- idle 78-char adjustments

2 files changed, 82 insertions, 44 deletions

diff --git a/lib/sqlalchemy/dialects/firebird/base.py b/lib/sqlalchemy/dialects/firebird/base.py
index d6e0f95bd..da8bef8c0 100644
--- a/lib/sqlalchemy/dialects/firebird/base.py
+++ b/lib/sqlalchemy/dialects/firebird/base.py
@@ -164,8 +164,8 @@ ischema_names = {
     }
 
 
-# TODO: date conversion types (should be implemented as _FBDateTime, _FBDate, etc.
-# as bind/result functionality is required)
+# TODO: date conversion types (should be implemented as _FBDateTime, 
+# _FBDate, etc. as bind/result functionality is required)
 
 class FBTypeCompiler(compiler.GenericTypeCompiler):
     def visit_boolean(self, type_):
@@ -203,18 +203,25 @@ class FBCompiler(sql.compiler.SQLCompiler):
     def visit_mod(self, binary, **kw):
         # Firebird lacks a builtin modulo operator, but there is
         # an equivalent function in the ib_udf library.
-        return "mod(%s, %s)" % (self.process(binary.left), self.process(binary.right))
+        return "mod(%s, %s)" % (
+                                self.process(binary.left),
+                                self.process(binary.right))
 
     def visit_alias(self, alias, asfrom=False, **kwargs):
         if self.dialect._version_two:
-            return super(FBCompiler, self).visit_alias(alias, asfrom=asfrom, **kwargs)
+            return super(FBCompiler, self).\
+                        visit_alias(alias, asfrom=asfrom, **kwargs)
         else:
             # Override to not use the AS keyword which FB 1.5 does not like
             if asfrom:
-                alias_name = isinstance(alias.name, expression._generated_label) and \
-                                self._truncated_identifier("alias", alias.name) or alias.name
-
-                return self.process(alias.original, asfrom=asfrom, **kwargs) + " " + \
+                alias_name = isinstance(alias.name,
+                                expression._generated_label) and \
+                                self._truncated_identifier("alias",
+                                alias.name) or alias.name
+
+                return self.process(
+                            alias.original, asfrom=asfrom, **kwargs) + \
+                            " " + \
                             self.preparer.format_alias(alias, alias_name)
             else:
                 return self.process(alias.original, **kwargs)
@@ -290,22 +297,28 @@ class FBDDLCompiler(sql.compiler.DDLCompiler):
         # no syntax for these
         # http://www.firebirdsql.org/manual/generatorguide-sqlsyntax.html
         if create.element.start is not None:
-            raise NotImplemented("Firebird SEQUENCE doesn't support START WITH")
+            raise NotImplemented(
+                        "Firebird SEQUENCE doesn't support START WITH")
         if create.element.increment is not None:
-            raise NotImplemented("Firebird SEQUENCE doesn't support INCREMENT BY")
+            raise NotImplemented(
+                        "Firebird SEQUENCE doesn't support INCREMENT BY")
 
         if self.dialect._version_two:
-            return "CREATE SEQUENCE %s" % self.preparer.format_sequence(create.element)
+            return "CREATE SEQUENCE %s" % \
+                        self.preparer.format_sequence(create.element)
         else:
-            return "CREATE GENERATOR %s" % self.preparer.format_sequence(create.element)
+            return "CREATE GENERATOR %s" % \
+                        self.preparer.format_sequence(create.element)
 
     def visit_drop_sequence(self, drop):
         """Generate a ``DROP GENERATOR`` statement for the sequence."""
 
         if self.dialect._version_two:
-            return "DROP SEQUENCE %s" % self.preparer.format_sequence(drop.element)
+            return "DROP SEQUENCE %s" % \
+                        self.preparer.format_sequence(drop.element)
         else:
-            return "DROP GENERATOR %s" % self.preparer.format_sequence(drop.element)
+            return "DROP GENERATOR %s" % \
+                        self.preparer.format_sequence(drop.element)
 
 
 class FBIdentifierPreparer(sql.compiler.IdentifierPreparer):
@@ -321,8 +334,10 @@ class FBExecutionContext(default.DefaultExecutionContext):
     def fire_sequence(self, seq):
         """Get the next value from the sequence using ``gen_id()``."""
 
-        return self._execute_scalar("SELECT gen_id(%s, 1) FROM rdb$database" % \
-            self.dialect.identifier_preparer.format_sequence(seq))
+        return self._execute_scalar(
+                "SELECT gen_id(%s, 1) FROM rdb$database" % 
+                self.dialect.identifier_preparer.format_sequence(seq)
+                )
 
 
 class FBDialect(default.DefaultDialect):
@@ -392,7 +407,8 @@ class FBDialect(default.DefaultDialect):
             return name
 
     def has_table(self, connection, table_name, schema=None):
-        """Return ``True`` if the given table exists, ignoring the `schema`."""
+        """Return ``True`` if the given table exists, ignoring 
+        the `schema`."""
 
         tblqry = """
         SELECT 1 AS has_table FROM rdb$database
@@ -462,7 +478,9 @@ class FBDialect(default.DefaultDialect):
         return pkfields
 
     @reflection.cache
-    def get_column_sequence(self, connection, table_name, column_name, schema=None, **kw):
+    def get_column_sequence(self, connection, 
+                                table_name, column_name, 
+                                schema=None, **kw):
         tablename = self.denormalize_name(table_name)
         colname = self.denormalize_name(column_name)
         # Heuristic-query to determine the generator associated to a PK field
@@ -473,14 +491,15 @@ class FBDialect(default.DefaultDialect):
                   ON tabdep.rdb$dependent_name=trigdep.rdb$dependent_name
                      AND trigdep.rdb$depended_on_type=14
                      AND trigdep.rdb$dependent_type=2
-             JOIN rdb$triggers trig ON trig.rdb$trigger_name=tabdep.rdb$dependent_name
+             JOIN rdb$triggers trig ON
+                    trig.rdb$trigger_name=tabdep.rdb$dependent_name
         WHERE tabdep.rdb$depended_on_name=?
           AND tabdep.rdb$depended_on_type=0
           AND trig.rdb$trigger_type=1
           AND tabdep.rdb$field_name=?
           AND (SELECT count(*)
-               FROM rdb$dependencies trigdep2
-               WHERE trigdep2.rdb$dependent_name = trigdep.rdb$dependent_name) = 2
+           FROM rdb$dependencies trigdep2
+           WHERE trigdep2.rdb$dependent_name = trigdep.rdb$dependent_name) = 2
         """
         genr = connection.execute(genqry, [tablename, colname]).first()
         if genr is not None:
@@ -494,15 +513,19 @@ class FBDialect(default.DefaultDialect):
                         r.rdb$null_flag AS null_flag,
                         t.rdb$type_name AS ftype,
                         f.rdb$field_sub_type AS stype,
-                        f.rdb$field_length/COALESCE(cs.rdb$bytes_per_character,1) AS flen,
+                        f.rdb$field_length/
+                            COALESCE(cs.rdb$bytes_per_character,1) AS flen,
                         f.rdb$field_precision AS fprec,
                         f.rdb$field_scale AS fscale,
-                        COALESCE(r.rdb$default_source, f.rdb$default_source) AS fdefault
+                        COALESCE(r.rdb$default_source, 
+                                f.rdb$default_source) AS fdefault
         FROM rdb$relation_fields r
              JOIN rdb$fields f ON r.rdb$field_source=f.rdb$field_name
              JOIN rdb$types t
-                  ON t.rdb$type=f.rdb$field_type AND t.rdb$field_name='RDB$FIELD_TYPE'
-             LEFT JOIN rdb$character_sets cs ON f.rdb$character_set_id=cs.rdb$character_set_id
+              ON t.rdb$type=f.rdb$field_type AND
+                    t.rdb$field_name='RDB$FIELD_TYPE'
+             LEFT JOIN rdb$character_sets cs ON
+                    f.rdb$character_set_id=cs.rdb$character_set_id
         WHERE f.rdb$system_flag=0 AND r.rdb$relation_name=?
         ORDER BY r.rdb$field_position
         """
@@ -528,7 +551,9 @@ class FBDialect(default.DefaultDialect):
                           (colspec, name))
                 coltype = sqltypes.NULLTYPE
             elif colspec == 'INT64':
-                coltype = coltype(precision=row['fprec'], scale=row['fscale'] * -1)
+                coltype = coltype(
+                                precision=row['fprec'], 
+                                scale=row['fscale'] * -1)
             elif colspec in ('VARYING', 'CSTRING'):
                 coltype = coltype(row['flen'])
             elif colspec == 'TEXT':
@@ -548,7 +573,9 @@ class FBDialect(default.DefaultDialect):
                 # more than one whitespace around the "DEFAULT" keyword
                 # (see also http://tracker.firebirdsql.org/browse/CORE-356)
                 defexpr = row['fdefault'].lstrip()
-                assert defexpr[:8].rstrip()=='DEFAULT', "Unrecognized default value: %s" % defexpr
+                assert defexpr[:8].rstrip() == \
+                            'DEFAULT', "Unrecognized default value: %s" % \
+                            defexpr
                 defvalue = defexpr[8:].strip()
                 if defvalue == 'NULL':
                     # Redundant
@@ -584,7 +611,8 @@ class FBDialect(default.DefaultDialect):
         FROM rdb$relation_constraints rc
              JOIN rdb$indices ix1 ON ix1.rdb$index_name=rc.rdb$index_name
              JOIN rdb$indices ix2 ON ix2.rdb$index_name=ix1.rdb$foreign_key
-             JOIN rdb$index_segments cse ON cse.rdb$index_name=ix1.rdb$index_name
+             JOIN rdb$index_segments cse ON
+                        cse.rdb$index_name=ix1.rdb$index_name
              JOIN rdb$index_segments se
                   ON se.rdb$index_name=ix2.rdb$index_name
                      AND se.rdb$field_position=cse.rdb$field_position
@@ -608,9 +636,10 @@ class FBDialect(default.DefaultDialect):
             if not fk['name']:
                 fk['name'] = cname
                 fk['referred_table'] = self.normalize_name(row['targetrname'])
-            fk['constrained_columns'].append(self.normalize_name(row['fname']))
+            fk['constrained_columns'].append(
+                                self.normalize_name(row['fname']))
             fk['referred_columns'].append(
-                            self.normalize_name(row['targetfname']))
+                                self.normalize_name(row['targetfname']))
         return fks.values()
 
     @reflection.cache
@@ -623,7 +652,8 @@ class FBDialect(default.DefaultDialect):
              JOIN rdb$index_segments ic
                   ON ix.rdb$index_name=ic.rdb$index_name
              LEFT OUTER JOIN rdb$relation_constraints
-                  ON rdb$relation_constraints.rdb$index_name = ic.rdb$index_name
+                  ON rdb$relation_constraints.rdb$index_name =
+                        ic.rdb$index_name
         WHERE ix.rdb$relation_name=? AND ix.rdb$foreign_key IS NULL
           AND rdb$relation_constraints.rdb$constraint_type IS NULL
         ORDER BY index_name, field_name
@@ -638,7 +668,8 @@ class FBDialect(default.DefaultDialect):
                 indexrec['column_names'] = []
                 indexrec['unique'] = bool(row['unique_flag'])
 
-            indexrec['column_names'].append(self.normalize_name(row['field_name']))
+            indexrec['column_names'].append(
+                                self.normalize_name(row['field_name']))
 
         return indexes.values()
 
diff --git a/lib/sqlalchemy/dialects/firebird/kinterbasdb.py b/lib/sqlalchemy/dialects/firebird/kinterbasdb.py
index fc7b57201..c43c100c4 100644
--- a/lib/sqlalchemy/dialects/firebird/kinterbasdb.py
+++ b/lib/sqlalchemy/dialects/firebird/kinterbasdb.py
@@ -13,11 +13,12 @@ The connection URL is of the form
 
 Kinterbasedb backend specific keyword arguments are:
 
-* type_conv - select the kind of mapping done on the types: by default SQLAlchemy
-  uses 200 with Unicode, datetime and decimal support (see details__).
+* type_conv - select the kind of mapping done on the types: by default  
+  SQLAlchemy uses 200 with Unicode, datetime and decimal support (see
+  details__).
 
-* concurrency_level - set the backend policy with regards to threading issues: by default
-  SQLAlchemy uses policy 1 (see details__).
+* concurrency_level - set the backend policy with regards to threading 
+  issues: by default SQLAlchemy uses policy 1 (see details__).
 
 * enable_rowcount - True by default, setting this to False disables 
   the usage of "cursor.rowcount" with the 
@@ -29,9 +30,10 @@ Kinterbasedb backend specific keyword arguments are:
   the cursor after a non-result-returning statement, rowcount must be 
   called, if at all, before the result object is returned.   Additionally,
   cursor.rowcount may not return correct results with older versions
-  of Firebird, and setting this flag to False will also cause the SQLAlchemy ORM
-  to ignore its usage. The behavior can also be controlled on a per-execution 
-  basis using the `enable_rowcount` option with :meth:`execution_options()`::
+  of Firebird, and setting this flag to False will also cause the 
+  SQLAlchemy ORM to ignore its usage. The behavior can also be controlled on a
+  per-execution basis using the `enable_rowcount` option with
+  :meth:`execution_options()`::
   
       conn = engine.connect().execution_options(enable_rowcount=True)
       r = conn.execute(stmt)
@@ -81,7 +83,8 @@ class FBDialect_kinterbasdb(FBDialect):
         
     )
     
-    def __init__(self, type_conv=200, concurrency_level=1, enable_rowcount=True, **kwargs):
+    def __init__(self, type_conv=200, concurrency_level=1,
+                            enable_rowcount=True, **kwargs):
         super(FBDialect_kinterbasdb, self).__init__(**kwargs)
         self.enable_rowcount = enable_rowcount
         self.type_conv = type_conv
@@ -104,7 +107,8 @@ class FBDialect_kinterbasdb(FBDialect):
         util.coerce_kw_type(opts, 'type_conv', int)
         
         type_conv = opts.pop('type_conv', self.type_conv)
-        concurrency_level = opts.pop('concurrency_level', self.concurrency_level)
+        concurrency_level = opts.pop('concurrency_level',
+                                    self.concurrency_level)
         
         if self.dbapi is not None:
             initialized = getattr(self.dbapi, 'initialized', None)
@@ -113,7 +117,8 @@ class FBDialect_kinterbasdb(FBDialect):
                 # http://kinterbasdb.cvs.sourceforge.net/viewvc/kinterbasdb/Kinterbasdb-3.0/__init__.py?r1=1.95&r2=1.96
                 initialized = getattr(self.dbapi, '_initialized', False)
             if not initialized:
-                self.dbapi.init(type_conv=type_conv, concurrency_level=concurrency_level)
+                self.dbapi.init(type_conv=type_conv,
+                                    concurrency_level=concurrency_level)
         return ([], opts)
 
     def _get_server_version_info(self, connection):
@@ -136,11 +141,13 @@ class FBDialect_kinterbasdb(FBDialect):
         version = fbconn.server_version
         m = match('\w+-V(\d+)\.(\d+)\.(\d+)\.(\d+) \w+ (\d+)\.(\d+)', version)
         if not m:
-            raise AssertionError("Could not determine version from string '%s'" % version)
+            raise AssertionError(
+                    "Could not determine version from string '%s'" % version)
         return tuple([int(x) for x in m.group(5, 6, 4)])
 
     def is_disconnect(self, e):
-        if isinstance(e, (self.dbapi.OperationalError, self.dbapi.ProgrammingError)):
+        if isinstance(e, (self.dbapi.OperationalError,
+                            self.dbapi.ProgrammingError)):
             msg = str(e)
             return ('Unable to complete network request to host' in msg or
                     'Invalid connection state' in msg or