Run black -l 79 against all source files

This is a straight reformat run using black as is, with no edits
applied at all.

The black run will format code consistently, however in
some cases that are prevalent in SQLAlchemy code it produces
too-long lines.   The too-long lines will be resolved in the
following commit that will resolve all remaining flake8 issues
including shadowed builtins, long lines, import order, unused
imports, duplicate imports, and docstring issues.

Change-Id: I7eda77fed3d8e73df84b3651fd6cfcfe858d4dc9

1 files changed, 471 insertions, 370 deletions

diff --git a/test/requirements.py b/test/requirements.py
index 6c9c5a760..cbe4a2be7 100644
--- a/test/requirements.py
+++ b/test/requirements.py
@@ -7,19 +7,20 @@ from sqlalchemy import util
 import sys
 from sqlalchemy.testing.requirements import SuiteRequirements
 from sqlalchemy.testing import exclusions
-from sqlalchemy.testing.exclusions import \
-     skip, \
-     skip_if,\
-     only_if,\
-     only_on,\
-     fails_on_everything_except,\
-     fails_on,\
-     fails_if,\
-     succeeds_if,\
-     SpecPredicate,\
-     against,\
-     LambdaPredicate,\
-     requires_tag
+from sqlalchemy.testing.exclusions import (
+    skip,
+    skip_if,
+    only_if,
+    only_on,
+    fails_on_everything_except,
+    fails_on,
+    fails_if,
+    succeeds_if,
+    SpecPredicate,
+    against,
+    LambdaPredicate,
+    requires_tag,
+)
 
 
 def no_support(db, reason):
@@ -35,11 +36,13 @@ class DefaultRequirements(SuiteRequirements):
     def deferrable_or_no_constraints(self):
         """Target database must support deferrable constraints."""
 
-        return skip_if([
-            no_support('firebird', 'not supported by database'),
-            no_support('mysql', 'not supported by database'),
-            no_support('mssql', 'not supported by database'),
-            ])
+        return skip_if(
+            [
+                no_support("firebird", "not supported by database"),
+                no_support("mysql", "not supported by database"),
+                no_support("mssql", "not supported by database"),
+            ]
+        )
 
     @property
     def check_constraints(self):
@@ -53,7 +56,7 @@ class DefaultRequirements(SuiteRequirements):
 
         return self.check_constraints + fails_on(
             self._mysql_not_mariadb_102,
-            "check constraints don't enforce on MySQL, MariaDB<10.2"
+            "check constraints don't enforce on MySQL, MariaDB<10.2",
         )
 
     @property
@@ -66,17 +69,13 @@ class DefaultRequirements(SuiteRequirements):
     def implicitly_named_constraints(self):
         """target database must apply names to unnamed constraints."""
 
-        return skip_if([
-            no_support('sqlite', 'not supported by database'),
-            ])
+        return skip_if([no_support("sqlite", "not supported by database")])
 
     @property
     def foreign_keys(self):
         """Target database must support foreign keys."""
 
-        return skip_if(
-                no_support('sqlite', 'not supported by database')
-            )
+        return skip_if(no_support("sqlite", "not supported by database"))
 
     @property
     def on_update_cascade(self):
@@ -84,17 +83,18 @@ class DefaultRequirements(SuiteRequirements):
         foreign keys."""
 
         return skip_if(
-                    ['sqlite', 'oracle'],
-                    'target backend %(doesnt_support)s ON UPDATE CASCADE'
-                )
+            ["sqlite", "oracle"],
+            "target backend %(doesnt_support)s ON UPDATE CASCADE",
+        )
 
     @property
     def non_updating_cascade(self):
         """target database must *not* support ON UPDATE..CASCADE behavior in
         foreign keys."""
 
-        return fails_on_everything_except('sqlite', 'oracle', '+zxjdbc') + \
-            skip_if('mssql')
+        return fails_on_everything_except(
+            "sqlite", "oracle", "+zxjdbc"
+        ) + skip_if("mssql")
 
     @property
     def recursive_fk_cascade(self):
@@ -107,54 +107,57 @@ class DefaultRequirements(SuiteRequirements):
     def deferrable_fks(self):
         """target database must support deferrable fks"""
 
-        return only_on(['oracle'])
+        return only_on(["oracle"])
 
     @property
     def foreign_key_constraint_option_reflection_ondelete(self):
-        return only_on(['postgresql', 'mysql', 'sqlite', 'oracle'])
+        return only_on(["postgresql", "mysql", "sqlite", "oracle"])
 
     @property
     def foreign_key_constraint_option_reflection_onupdate(self):
-        return only_on(['postgresql', 'mysql', 'sqlite'])
+        return only_on(["postgresql", "mysql", "sqlite"])
 
     @property
     def comment_reflection(self):
-        return only_on(['postgresql', 'mysql', 'oracle'])
+        return only_on(["postgresql", "mysql", "oracle"])
 
     @property
     def unbounded_varchar(self):
         """Target database must support VARCHAR with no length"""
 
-        return skip_if([
-                "firebird", "oracle", "mysql"
-            ], "not supported by database"
-            )
+        return skip_if(
+            ["firebird", "oracle", "mysql"], "not supported by database"
+        )
 
     @property
     def boolean_col_expressions(self):
         """Target database must support boolean expressions as columns"""
-        return skip_if([
-            no_support('firebird', 'not supported by database'),
-            no_support('oracle', 'not supported by database'),
-            no_support('mssql', 'not supported by database'),
-            no_support('sybase', 'not supported by database'),
-        ])
+        return skip_if(
+            [
+                no_support("firebird", "not supported by database"),
+                no_support("oracle", "not supported by database"),
+                no_support("mssql", "not supported by database"),
+                no_support("sybase", "not supported by database"),
+            ]
+        )
 
     @property
     def non_native_boolean_unconstrained(self):
         """target database is not native boolean and allows arbitrary integers
         in it's "bool" column"""
 
-        return skip_if([
-            LambdaPredicate(
-                lambda config: against(config, "mssql"),
-                "SQL Server drivers / odbc seem to change their mind on this"
-            ),
-            LambdaPredicate(
-                lambda config: config.db.dialect.supports_native_boolean,
-                "native boolean dialect"
-            )
-        ])
+        return skip_if(
+            [
+                LambdaPredicate(
+                    lambda config: against(config, "mssql"),
+                    "SQL Server drivers / odbc seem to change their mind on this",
+                ),
+                LambdaPredicate(
+                    lambda config: config.db.dialect.supports_native_boolean,
+                    "native boolean dialect",
+                ),
+            ]
+        )
 
     @property
     def standalone_binds(self):
@@ -181,15 +184,15 @@ class DefaultRequirements(SuiteRequirements):
         artifact.
 
         """
-        return skip_if(["firebird", "oracle", "postgresql", "sybase"],
-                       "not supported by database")
+        return skip_if(
+            ["firebird", "oracle", "postgresql", "sybase"],
+            "not supported by database",
+        )
 
     @property
     def temporary_tables(self):
         """target database supports temporary tables"""
-        return skip_if(
-                    ["mssql", "firebird"], "not supported (?)"
-                )
+        return skip_if(["mssql", "firebird"], "not supported (?)")
 
     @property
     def temp_table_reflection(self):
@@ -204,20 +207,17 @@ class DefaultRequirements(SuiteRequirements):
         has SERIAL support.  FB and Oracle (and sybase?) require the Sequence
         to be explicitly added, including if the table was reflected.
         """
-        return skip_if(["firebird", "oracle", "sybase"],
-                       "not supported by database")
+        return skip_if(
+            ["firebird", "oracle", "sybase"], "not supported by database"
+        )
 
     @property
     def insert_from_select(self):
-        return skip_if(
-                    ["firebird"], "crashes for unknown reason"
-                )
+        return skip_if(["firebird"], "crashes for unknown reason")
 
     @property
     def fetch_rows_post_commit(self):
-        return skip_if(
-                    ["firebird"], "not supported"
-                )
+        return skip_if(["firebird"], "not supported")
 
     @property
     def non_broken_binary(self):
@@ -260,11 +260,7 @@ class DefaultRequirements(SuiteRequirements):
         """Target must support simultaneous, independent database cursors
         on a single connection."""
 
-        return skip_if(
-            [
-                "mssql",
-                "mysql"], "no driver support"
-        )
+        return skip_if(["mssql", "mysql"], "no driver support")
 
     @property
     def independent_connections(self):
@@ -274,13 +270,22 @@ class DefaultRequirements(SuiteRequirements):
 
         # This is also true of some configurations of UnixODBC and probably
         # win32 ODBC as well.
-        return skip_if([
-            no_support("sqlite",
-                       "independent connections disabled "
-                       "when :memory: connections are used"),
-            exclude("mssql", "<", (9, 0, 0),
+        return skip_if(
+            [
+                no_support(
+                    "sqlite",
+                    "independent connections disabled "
+                    "when :memory: connections are used",
+                ),
+                exclude(
+                    "mssql",
+                    "<",
+                    (9, 0, 0),
                     "SQL Server 2005+ is required for "
-                    "independent connections")])
+                    "independent connections",
+                ),
+            ]
+        )
 
     @property
     def memory_process_intensive(self):
@@ -288,75 +293,91 @@ class DefaultRequirements(SuiteRequirements):
         and iterate through hundreds of connections
 
         """
-        return skip_if([
-            no_support("oracle", "Oracle XE usually can't handle these"),
-            no_support("mssql+pyodbc", "MS ODBC drivers struggle")
-        ])
+        return skip_if(
+            [
+                no_support("oracle", "Oracle XE usually can't handle these"),
+                no_support("mssql+pyodbc", "MS ODBC drivers struggle"),
+            ]
+        )
 
     @property
     def updateable_autoincrement_pks(self):
         """Target must support UPDATE on autoincrement/integer primary key."""
 
-        return skip_if(["mssql", "sybase"],
-                       "IDENTITY columns can't be updated")
+        return skip_if(
+            ["mssql", "sybase"], "IDENTITY columns can't be updated"
+        )
 
     @property
     def isolation_level(self):
         return only_on(
-            ('postgresql', 'sqlite', 'mysql', 'mssql'),
-            "DBAPI has no isolation level support") \
-            + fails_on('postgresql+pypostgresql',
-                       'pypostgresql bombs on multiple isolation level calls')
+            ("postgresql", "sqlite", "mysql", "mssql"),
+            "DBAPI has no isolation level support",
+        ) + fails_on(
+            "postgresql+pypostgresql",
+            "pypostgresql bombs on multiple isolation level calls",
+        )
 
     @property
     def autocommit(self):
         """target dialect supports 'AUTOCOMMIT' as an isolation_level"""
         return only_on(
-            ('postgresql', 'mysql', 'mssql+pyodbc', 'mssql+pymssql'),
-            "dialect does not support AUTOCOMMIT isolation mode")
+            ("postgresql", "mysql", "mssql+pyodbc", "mssql+pymssql"),
+            "dialect does not support AUTOCOMMIT isolation mode",
+        )
 
     @property
     def row_triggers(self):
         """Target must support standard statement-running EACH ROW triggers."""
 
-        return skip_if([
-            # no access to same table
-            no_support('mysql', 'requires SUPER priv'),
-            exclude('mysql', '<', (5, 0, 10), 'not supported by database'),
-
-            # huh?  TODO: implement triggers for PG tests, remove this
-            no_support('postgresql',
-                       'PG triggers need to be implemented for tests'),
-        ])
+        return skip_if(
+            [
+                # no access to same table
+                no_support("mysql", "requires SUPER priv"),
+                exclude("mysql", "<", (5, 0, 10), "not supported by database"),
+                # huh?  TODO: implement triggers for PG tests, remove this
+                no_support(
+                    "postgresql",
+                    "PG triggers need to be implemented for tests",
+                ),
+            ]
+        )
 
     @property
     def sequences_as_server_defaults(self):
         """Target database must support SEQUENCE as a server side default."""
 
         return only_on(
-            'postgresql',
-            "doesn't support sequences as a server side default.")
+            "postgresql", "doesn't support sequences as a server side default."
+        )
 
     @property
     def correlated_outer_joins(self):
         """Target must support an outer join to a subquery which
         correlates to the parent."""
 
-        return skip_if("oracle", 'Raises "ORA-01799: a column may not be '
-                       'outer-joined to a subquery"')
+        return skip_if(
+            "oracle",
+            'Raises "ORA-01799: a column may not be '
+            'outer-joined to a subquery"',
+        )
 
     @property
     def update_from(self):
         """Target must support UPDATE..FROM syntax"""
 
-        return only_on(['postgresql', 'mssql', 'mysql'],
-                       "Backend does not support UPDATE..FROM")
+        return only_on(
+            ["postgresql", "mssql", "mysql"],
+            "Backend does not support UPDATE..FROM",
+        )
 
     @property
     def delete_from(self):
         """Target must support DELETE FROM..FROM or DELETE..USING syntax"""
-        return only_on(['postgresql', 'mssql', 'mysql', 'sybase'],
-                       "Backend does not support DELETE..FROM")
+        return only_on(
+            ["postgresql", "mssql", "mysql", "sybase"],
+            "Backend does not support DELETE..FROM",
+        )
 
     @property
     def update_where_target_in_subquery(self):
@@ -374,44 +395,37 @@ class DefaultRequirements(SuiteRequirements):
         return fails_if(
             self._mysql_not_mariadb_103,
             'MySQL error 1093 "Cant specify target table '
-            'for update in FROM clause", resolved by MariaDB 10.3')
+            'for update in FROM clause", resolved by MariaDB 10.3',
+        )
 
     @property
     def savepoints(self):
         """Target database must support savepoints."""
 
-        return skip_if([
-                    "sqlite",
-                    "sybase",
-                    ("mysql", "<", (5, 0, 3)),
-                    ], "savepoints not supported")
+        return skip_if(
+            ["sqlite", "sybase", ("mysql", "<", (5, 0, 3))],
+            "savepoints not supported",
+        )
 
     @property
     def savepoints_w_release(self):
         return self.savepoints + skip_if(
             ["oracle", "mssql"],
-            "database doesn't support release of savepoint"
+            "database doesn't support release of savepoint",
         )
 
-
     @property
     def schemas(self):
         """Target database must support external schemas, and have one
         named 'test_schema'."""
 
-        return skip_if([
-                    "firebird"
-                ], "no schema support")
+        return skip_if(["firebird"], "no schema support")
 
     @property
     def cross_schema_fk_reflection(self):
         """target system must support reflection of inter-schema foreign keys
         """
-        return only_on([
-                    "postgresql",
-                    "mysql",
-                    "mssql",
-                ])
+        return only_on(["postgresql", "mysql", "mssql"])
 
     @property
     def implicit_default_schema(self):
@@ -421,70 +435,70 @@ class DefaultRequirements(SuiteRequirements):
            basically, PostgreSQL.
 
         """
-        return only_on([
-                    "postgresql",
-                ])
-
+        return only_on(["postgresql"])
 
     @property
     def unique_constraint_reflection(self):
         return fails_on_everything_except(
-                    "postgresql",
-                    "mysql",
-                    "sqlite",
-                    "oracle"
-                )
+            "postgresql", "mysql", "sqlite", "oracle"
+        )
 
     @property
     def unique_constraint_reflection_no_index_overlap(self):
-        return self.unique_constraint_reflection + \
-            skip_if("mysql")  + skip_if("oracle")
-
+        return (
+            self.unique_constraint_reflection
+            + skip_if("mysql")
+            + skip_if("oracle")
+        )
 
     @property
     def check_constraint_reflection(self):
         return fails_on_everything_except(
-            "postgresql", "sqlite", "oracle",
-            self._mariadb_102
+            "postgresql", "sqlite", "oracle", self._mariadb_102
         )
 
     @property
     def temp_table_names(self):
         """target dialect supports listing of temporary table names"""
 
-        return only_on(['sqlite', 'oracle'])
+        return only_on(["sqlite", "oracle"])
 
     @property
     def temporary_views(self):
         """target database supports temporary views"""
-        return only_on(['sqlite', 'postgresql'])
+        return only_on(["sqlite", "postgresql"])
 
     @property
     def update_nowait(self):
         """Target database must support SELECT...FOR UPDATE NOWAIT"""
-        return skip_if(["firebird", "mssql", "mysql", "sqlite", "sybase"],
-                       "no FOR UPDATE NOWAIT support")
+        return skip_if(
+            ["firebird", "mssql", "mysql", "sqlite", "sybase"],
+            "no FOR UPDATE NOWAIT support",
+        )
 
     @property
     def subqueries(self):
         """Target database must support subqueries."""
 
-        return skip_if(exclude('mysql', '<', (4, 1, 1)), 'no subquery support')
+        return skip_if(exclude("mysql", "<", (4, 1, 1)), "no subquery support")
 
     @property
     def ctes(self):
         """Target database supports CTEs"""
 
-        return only_on([
-            lambda config: against(config, "mysql") and (
-                config.db.dialect._is_mariadb and
-                config.db.dialect._mariadb_normalized_version_info >=
-                (10, 2)
-            ),
-            "postgresql",
-            "mssql",
-            "oracle"
-        ])
+        return only_on(
+            [
+                lambda config: against(config, "mysql")
+                and (
+                    config.db.dialect._is_mariadb
+                    and config.db.dialect._mariadb_normalized_version_info
+                    >= (10, 2)
+                ),
+                "postgresql",
+                "mssql",
+                "oracle",
+            ]
+        )
 
     @property
     def ctes_with_update_delete(self):
@@ -492,47 +506,45 @@ class DefaultRequirements(SuiteRequirements):
         or DELETE statement which refers to the CTE in a correlated subquery.
 
         """
-        return only_on([
-            "postgresql",
-            "mssql",
-            # "oracle" - oracle can do this but SQLAlchemy doesn't support
-            # their syntax yet
-        ])
+        return only_on(
+            [
+                "postgresql",
+                "mssql",
+                # "oracle" - oracle can do this but SQLAlchemy doesn't support
+                # their syntax yet
+            ]
+        )
 
     @property
     def ctes_on_dml(self):
         """target database supports CTES which consist of INSERT, UPDATE
         or DELETE *within* the CTE, e.g. WITH x AS (UPDATE....)"""
 
-        return only_if(
-            ['postgresql']
-        )
+        return only_if(["postgresql"])
 
     @property
     def mod_operator_as_percent_sign(self):
         """target database must use a plain percent '%' as the 'modulus'
         operator."""
 
-        return only_if(
-                    ['mysql', 'sqlite', 'postgresql+psycopg2', 'mssql']
-                )
+        return only_if(["mysql", "sqlite", "postgresql+psycopg2", "mssql"])
 
     @property
     def intersect(self):
         """Target database must support INTERSECT or equivalent."""
 
-        return fails_if([
-            "firebird", self._mysql_not_mariadb_103,
-            "sybase",
-        ], 'no support for INTERSECT')
+        return fails_if(
+            ["firebird", self._mysql_not_mariadb_103, "sybase"],
+            "no support for INTERSECT",
+        )
 
     @property
     def except_(self):
         """Target database must support EXCEPT or equivalent (i.e. MINUS)."""
-        return fails_if([
-            "firebird", self._mysql_not_mariadb_103,
-            "sybase",
-        ], 'no support for EXCEPT')
+        return fails_if(
+            ["firebird", self._mysql_not_mariadb_103, "sybase"],
+            "no support for EXCEPT",
+        )
 
     @property
     def order_by_col_from_union(self):
@@ -544,7 +556,7 @@ class DefaultRequirements(SuiteRequirements):
         Fails on SQL Server
 
         """
-        return fails_if('mssql')
+        return fails_if("mssql")
 
     @property
     def parens_in_union_contained_select_w_limit_offset(self):
@@ -556,7 +568,7 @@ class DefaultRequirements(SuiteRequirements):
         This is known to fail on SQLite.
 
         """
-        return fails_if('sqlite')
+        return fails_if("sqlite")
 
     @property
     def parens_in_union_contained_select_wo_limit_offset(self):
@@ -570,49 +582,58 @@ class DefaultRequirements(SuiteRequirements):
         creates an additional subquery.
 
         """
-        return fails_if(['sqlite', 'oracle'])
+        return fails_if(["sqlite", "oracle"])
 
     @property
     def offset(self):
         """Target database must support some method of adding OFFSET or
         equivalent to a result set."""
-        return fails_if([
-                "sybase"
-            ], 'no support for OFFSET or equivalent')
+        return fails_if(["sybase"], "no support for OFFSET or equivalent")
 
     @property
     def window_functions(self):
-        return only_if([
-                    "postgresql>=8.4", "mssql", "oracle"
-                ], "Backend does not support window functions")
+        return only_if(
+            ["postgresql>=8.4", "mssql", "oracle"],
+            "Backend does not support window functions",
+        )
 
     @property
     def two_phase_transactions(self):
         """Target database must support two-phase transactions."""
 
-        return skip_if([
-            no_support('firebird', 'no SA implementation'),
-            no_support('mssql', 'two-phase xact not supported by drivers'),
-            no_support('oracle',
-                       'two-phase xact not implemented in SQLA/oracle'),
-            no_support('drizzle', 'two-phase xact not supported by database'),
-            no_support('sqlite', 'two-phase xact not supported by database'),
-            no_support('sybase',
-                       'two-phase xact not supported by drivers/SQLA'),
-            no_support('postgresql+zxjdbc',
-                       'FIXME: JDBC driver confuses the transaction state, '
-                       'may need separate XA implementation'),
-            no_support('mysql',
-                       'recent MySQL communiity editions have too many issues '
-                       '(late 2016), disabling for now')])
+        return skip_if(
+            [
+                no_support("firebird", "no SA implementation"),
+                no_support("mssql", "two-phase xact not supported by drivers"),
+                no_support(
+                    "oracle", "two-phase xact not implemented in SQLA/oracle"
+                ),
+                no_support(
+                    "drizzle", "two-phase xact not supported by database"
+                ),
+                no_support(
+                    "sqlite", "two-phase xact not supported by database"
+                ),
+                no_support(
+                    "sybase", "two-phase xact not supported by drivers/SQLA"
+                ),
+                no_support(
+                    "postgresql+zxjdbc",
+                    "FIXME: JDBC driver confuses the transaction state, "
+                    "may need separate XA implementation",
+                ),
+                no_support(
+                    "mysql",
+                    "recent MySQL communiity editions have too many issues "
+                    "(late 2016), disabling for now",
+                ),
+            ]
+        )
 
     @property
     def two_phase_recovery(self):
         return self.two_phase_transactions + (
-            skip_if(
-               "mysql",
-               "crashes on most mariadb and mysql versions"
-            )
+            skip_if("mysql", "crashes on most mariadb and mysql versions")
         )
 
     @property
@@ -627,8 +648,9 @@ class DefaultRequirements(SuiteRequirements):
         target database can persist/return an empty string with a varchar.
         """
 
-        return fails_if(["oracle"],
-                        'oracle converts empty strings to a blank space')
+        return fails_if(
+            ["oracle"], "oracle converts empty strings to a blank space"
+        )
 
     @property
     def empty_strings_text(self):
@@ -640,9 +662,7 @@ class DefaultRequirements(SuiteRequirements):
     @property
     def unicode_data(self):
         """target drive must support unicode data stored in columns."""
-        return skip_if([
-            no_support("sybase", "no unicode driver support")
-            ])
+        return skip_if([no_support("sybase", "no unicode driver support")])
 
     @property
     def unicode_connections(self):
@@ -650,44 +670,44 @@ class DefaultRequirements(SuiteRequirements):
         Target driver must support some encoding of Unicode across the wire.
         """
         # TODO: expand to exclude MySQLdb versions w/ broken unicode
-        return skip_if([
-            exclude('mysql', '<', (4, 1, 1), 'no unicode connection support'),
-            ])
+        return skip_if(
+            [exclude("mysql", "<", (4, 1, 1), "no unicode connection support")]
+        )
 
     @property
     def unicode_ddl(self):
         """Target driver must support some degree of non-ascii symbol names."""
         # TODO: expand to exclude MySQLdb versions w/ broken unicode
 
-        return skip_if([
-            no_support('oracle', 'FIXME: no support in database?'),
-            no_support('sybase', 'FIXME: guessing, needs confirmation'),
-            no_support('mssql+pymssql', 'no FreeTDS support'),
-            LambdaPredicate(
-                lambda config: against(config, "mysql+mysqlconnector") and
-                config.db.dialect._mysqlconnector_version_info > (2, 0) and
-                util.py2k,
-                "bug in mysqlconnector 2.0"
-            ),
-            exclude('mysql', '<', (4, 1, 1), 'no unicode connection support'),
-        ])
+        return skip_if(
+            [
+                no_support("oracle", "FIXME: no support in database?"),
+                no_support("sybase", "FIXME: guessing, needs confirmation"),
+                no_support("mssql+pymssql", "no FreeTDS support"),
+                LambdaPredicate(
+                    lambda config: against(config, "mysql+mysqlconnector")
+                    and config.db.dialect._mysqlconnector_version_info > (2, 0)
+                    and util.py2k,
+                    "bug in mysqlconnector 2.0",
+                ),
+                exclude(
+                    "mysql", "<", (4, 1, 1), "no unicode connection support"
+                ),
+            ]
+        )
 
     @property
     def emulated_lastrowid(self):
         """"target dialect retrieves cursor.lastrowid or an equivalent
         after an insert() construct executes.
         """
-        return fails_on_everything_except('mysql',
-                                          'sqlite+pysqlite',
-                                          'sqlite+pysqlcipher',
-                                          'sybase',
-                                          'mssql')
+        return fails_on_everything_except(
+            "mysql", "sqlite+pysqlite", "sqlite+pysqlcipher", "sybase", "mssql"
+        )
 
     @property
     def implements_get_lastrowid(self):
-        return skip_if([
-            no_support('sybase', 'not supported by database'),
-            ])
+        return skip_if([no_support("sybase", "not supported by database")])
 
     @property
     def dbapi_lastrowid(self):
@@ -695,22 +715,24 @@ class DefaultRequirements(SuiteRequirements):
         cursor object.
 
         """
-        return skip_if('mssql+pymssql', 'crashes on pymssql') + \
-            fails_on_everything_except('mysql',
-                                       'sqlite+pysqlite',
-                                       'sqlite+pysqlcipher')
+        return skip_if(
+            "mssql+pymssql", "crashes on pymssql"
+        ) + fails_on_everything_except(
+            "mysql", "sqlite+pysqlite", "sqlite+pysqlcipher"
+        )
 
     @property
     def nullsordering(self):
         """Target backends that support nulls ordering."""
-        return fails_on_everything_except('postgresql', 'oracle', 'firebird')
+        return fails_on_everything_except("postgresql", "oracle", "firebird")
 
     @property
     def reflects_pk_names(self):
         """Target driver reflects the name of primary key constraints."""
 
-        return fails_on_everything_except('postgresql', 'oracle', 'mssql',
-                                          'sybase', 'sqlite')
+        return fails_on_everything_except(
+            "postgresql", "oracle", "mssql", "sybase", "sqlite"
+        )
 
     @property
     def nested_aggregates(self):
@@ -721,37 +743,44 @@ class DefaultRequirements(SuiteRequirements):
 
     @property
     def array_type(self):
-        return only_on([
-            lambda config: against(config, "postgresql") and
-            not against(config, "+pg8000") and not against(config, "+zxjdbc")
-        ])
+        return only_on(
+            [
+                lambda config: against(config, "postgresql")
+                and not against(config, "+pg8000")
+                and not against(config, "+zxjdbc")
+            ]
+        )
 
     @property
     def json_type(self):
-        return only_on([
-            lambda config:
-                against(config, "mysql") and (
+        return only_on(
+            [
+                lambda config: against(config, "mysql")
+                and (
                     (
-                        not config.db.dialect._is_mariadb and
-                        against(config, "mysql >= 5.7")
+                        not config.db.dialect._is_mariadb
+                        and against(config, "mysql >= 5.7")
                     )
                     or (
-                        config.db.dialect._mariadb_normalized_version_info >=
-                        (10, 2, 7)
+                        config.db.dialect._mariadb_normalized_version_info
+                        >= (10, 2, 7)
                     )
                 ),
-            "postgresql >= 9.3",
-            "sqlite >= 3.9"
-        ])
+                "postgresql >= 9.3",
+                "sqlite >= 3.9",
+            ]
+        )
 
     @property
     def reflects_json_type(self):
-        return only_on([
-            lambda config: against(config, "mysql >= 5.7") and
-            not config.db.dialect._is_mariadb,
-            "postgresql >= 9.3",
-            "sqlite >= 3.9"
-        ])
+        return only_on(
+            [
+                lambda config: against(config, "mysql >= 5.7")
+                and not config.db.dialect._is_mariadb,
+                "postgresql >= 9.3",
+                "sqlite >= 3.9",
+            ]
+        )
 
     @property
     def json_array_indexes(self):
@@ -778,8 +807,9 @@ class DefaultRequirements(SuiteRequirements):
         """target dialect supports representation of Python
         datetime.datetime() with microsecond objects."""
 
-        return skip_if(['mssql', 'mysql', 'firebird', '+zxjdbc',
-                        'oracle', 'sybase'])
+        return skip_if(
+            ["mssql", "mysql", "firebird", "+zxjdbc", "oracle", "sybase"]
+        )
 
     @property
     def timestamp_microseconds(self):
@@ -787,14 +817,14 @@ class DefaultRequirements(SuiteRequirements):
         datetime.datetime() with microsecond objects but only
         if TIMESTAMP is used."""
 
-        return only_on(['oracle'])
+        return only_on(["oracle"])
 
     @property
     def datetime_historic(self):
         """target dialect supports representation of Python
         datetime.datetime() objects with historic (pre 1900) values."""
 
-        return succeeds_if(['sqlite', 'postgresql', 'firebird'])
+        return succeeds_if(["sqlite", "postgresql", "firebird"])
 
     @property
     def date(self):
@@ -809,29 +839,30 @@ class DefaultRequirements(SuiteRequirements):
         of a date column."""
 
         # does not work as of pyodbc 4.0.22
-        return fails_on('mysql+mysqlconnector') + skip_if("mssql+pyodbc")
+        return fails_on("mysql+mysqlconnector") + skip_if("mssql+pyodbc")
 
     @property
     def date_historic(self):
         """target dialect supports representation of Python
         datetime.datetime() objects with historic (pre 1900) values."""
 
-        return succeeds_if(['sqlite', 'postgresql', 'firebird'])
+        return succeeds_if(["sqlite", "postgresql", "firebird"])
 
     @property
     def time(self):
         """target dialect supports representation of Python
         datetime.time() objects."""
 
-        return skip_if(['oracle'])
+        return skip_if(["oracle"])
 
     @property
     def time_microseconds(self):
         """target dialect supports representation of Python
         datetime.time() with microsecond objects."""
 
-        return skip_if(['mssql', 'mysql', 'firebird', '+zxjdbc',
-                        'oracle', 'sybase'])
+        return skip_if(
+            ["mssql", "mysql", "firebird", "+zxjdbc", "oracle", "sybase"]
+        )
 
     @property
     def precision_numerics_general(self):
@@ -853,10 +884,13 @@ class DefaultRequirements(SuiteRequirements):
 
         return fails_if(
             [
-                ("sybase+pyodbc", None, None,
-                 "Don't know how do get these values through FreeTDS + Sybase"
-                 ),
-                ("firebird", None, None, "Precision must be from 1 to 18")
+                (
+                    "sybase+pyodbc",
+                    None,
+                    None,
+                    "Don't know how do get these values through FreeTDS + Sybase",
+                ),
+                ("firebird", None, None, "Precision must be from 1 to 18"),
             ]
         )
 
@@ -868,13 +902,15 @@ class DefaultRequirements(SuiteRequirements):
         """
 
         def broken_cx_oracle(config):
-            return against(config, 'oracle+cx_oracle') and \
-                config.db.dialect.cx_oracle_ver <= (6, 0, 2) and \
-                config.db.dialect.cx_oracle_ver > (6, )
+            return (
+                against(config, "oracle+cx_oracle")
+                and config.db.dialect.cx_oracle_ver <= (6, 0, 2)
+                and config.db.dialect.cx_oracle_ver > (6,)
+            )
 
         return fails_if(
             [
-                ('sqlite', None, None, 'TODO'),
+                ("sqlite", None, None, "TODO"),
                 ("firebird", None, None, "Precision must be from 1 to 18"),
                 ("sybase+pysybase", None, None, "TODO"),
             ]
@@ -889,8 +925,12 @@ class DefaultRequirements(SuiteRequirements):
         return fails_if(
             [
                 ("oracle", None, None, "driver doesn't do this automatically"),
-                ("firebird", None, None,
-                 "database and/or driver truncates decimal places.")
+                (
+                    "firebird",
+                    None,
+                    None,
+                    "database and/or driver truncates decimal places.",
+                ),
             ]
         )
 
@@ -899,32 +939,65 @@ class DefaultRequirements(SuiteRequirements):
         """target backend will return native floating point numbers with at
         least seven decimal places when using the generic Float type."""
 
-        return fails_if([
-            ('mysql', None, None,
-             'mysql FLOAT type only returns 4 decimals'),
-            ('firebird', None, None,
-             "firebird FLOAT type isn't high precision"),
-        ])
+        return fails_if(
+            [
+                (
+                    "mysql",
+                    None,
+                    None,
+                    "mysql FLOAT type only returns 4 decimals",
+                ),
+                (
+                    "firebird",
+                    None,
+                    None,
+                    "firebird FLOAT type isn't high precision",
+                ),
+            ]
+        )
 
     @property
     def floats_to_four_decimals(self):
-        return fails_if([
-            ("mysql+oursql", None, None, "Floating point error"),
-            ("firebird", None, None,
-             "Firebird still has FP inaccuracy even "
-             "with only four decimal places"),
-            ('mssql+pyodbc', None, None,
-             'mssql+pyodbc has FP inaccuracy even with '
-             'only four decimal places '),
-            ('mssql+pymssql', None, None,
-             'mssql+pymssql has FP inaccuracy even with '
-             'only four decimal places '),
-            ('postgresql+pg8000', None, None,
-             'postgresql+pg8000 has FP inaccuracy even with '
-             'only four decimal places '),
-            ('postgresql+psycopg2cffi', None, None,
-             'postgresql+psycopg2cffi has FP inaccuracy even with '
-             'only four decimal places ')])
+        return fails_if(
+            [
+                ("mysql+oursql", None, None, "Floating point error"),
+                (
+                    "firebird",
+                    None,
+                    None,
+                    "Firebird still has FP inaccuracy even "
+                    "with only four decimal places",
+                ),
+                (
+                    "mssql+pyodbc",
+                    None,
+                    None,
+                    "mssql+pyodbc has FP inaccuracy even with "
+                    "only four decimal places ",
+                ),
+                (
+                    "mssql+pymssql",
+                    None,
+                    None,
+                    "mssql+pymssql has FP inaccuracy even with "
+                    "only four decimal places ",
+                ),
+                (
+                    "postgresql+pg8000",
+                    None,
+                    None,
+                    "postgresql+pg8000 has FP inaccuracy even with "
+                    "only four decimal places ",
+                ),
+                (
+                    "postgresql+psycopg2cffi",
+                    None,
+                    None,
+                    "postgresql+psycopg2cffi has FP inaccuracy even with "
+                    "only four decimal places ",
+                ),
+            ]
+        )
 
     @property
     def implicit_decimal_binds(self):
@@ -953,19 +1026,20 @@ class DefaultRequirements(SuiteRequirements):
                 try:
                     from MySQLdb import converters
                     from decimal import Decimal
+
                     return Decimal not in converters.conversions
                 except:
                     return True
 
-            return against(config, "mysql+mysqldb") and \
-                config.db.dialect._mysql_dbapi_version <= (1, 3, 13)
+            return against(
+                config, "mysql+mysqldb"
+            ) and config.db.dialect._mysql_dbapi_version <= (1, 3, 13)
+
         return exclusions.fails_on(check, "fixed for mysqlclient post 1.3.13")
 
     @property
     def fetch_null_from_numeric(self):
-        return skip_if(
-                    ("mssql+pyodbc", None, None, "crashes due to bug #351"),
-                )
+        return skip_if(("mssql+pyodbc", None, None, "crashes due to bug #351"))
 
     @property
     def duplicate_key_raises_integrity_error(self):
@@ -977,8 +1051,10 @@ class DefaultRequirements(SuiteRequirements):
                 return False
             count = config.db.scalar(
                 "SELECT count(*) FROM pg_extension "
-                "WHERE extname='%s'" % name)
+                "WHERE extname='%s'" % name
+            )
             return bool(count)
+
         return only_if(check, "needs %s extension" % name)
 
     @property
@@ -993,8 +1069,8 @@ class DefaultRequirements(SuiteRequirements):
     def range_types(self):
         def check_range_types(config):
             if not against(
-                    config,
-                    ["postgresql+psycopg2", "postgresql+psycopg2cffi"]):
+                config, ["postgresql+psycopg2", "postgresql+psycopg2cffi"]
+            ):
                 return False
             try:
                 config.db.scalar("select '[1,2)'::int4range;")
@@ -1007,25 +1083,26 @@ class DefaultRequirements(SuiteRequirements):
     @property
     def oracle_test_dblink(self):
         return skip_if(
-                    lambda config: not config.file_config.has_option(
-                        'sqla_testing', 'oracle_db_link'),
-                    "oracle_db_link option not specified in config"
-                )
+            lambda config: not config.file_config.has_option(
+                "sqla_testing", "oracle_db_link"
+            ),
+            "oracle_db_link option not specified in config",
+        )
 
     @property
     def postgresql_test_dblink(self):
         return skip_if(
-                    lambda config: not config.file_config.has_option(
-                        'sqla_testing', 'postgres_test_db_link'),
-                    "postgres_test_db_link option not specified in config"
-                )
+            lambda config: not config.file_config.has_option(
+                "sqla_testing", "postgres_test_db_link"
+            ),
+            "postgres_test_db_link option not specified in config",
+        )
 
     @property
     def postgresql_jsonb(self):
         return only_on("postgresql >= 9.4") + skip_if(
-            lambda config:
-            config.db.dialect.driver == "pg8000" and
-            config.db.dialect._dbapi_version <= (1, 10, 1)
+            lambda config: config.db.dialect.driver == "pg8000"
+            and config.db.dialect._dbapi_version <= (1, 10, 1)
         )
 
     @property
@@ -1038,15 +1115,16 @@ class DefaultRequirements(SuiteRequirements):
 
     @property
     def psycopg2_compatibility(self):
-        return only_on(
-            ["postgresql+psycopg2", "postgresql+psycopg2cffi"]
-        )
+        return only_on(["postgresql+psycopg2", "postgresql+psycopg2cffi"])
 
     @property
     def psycopg2_or_pg8000_compatibility(self):
         return only_on(
-            ["postgresql+psycopg2", "postgresql+psycopg2cffi",
-             "postgresql+pg8000"]
+            [
+                "postgresql+psycopg2",
+                "postgresql+psycopg2cffi",
+                "postgresql+pg8000",
+            ]
         )
 
     @property
@@ -1054,40 +1132,49 @@ class DefaultRequirements(SuiteRequirements):
         return skip_if(
             [
                 (
-                    "+psycopg2", None, None,
+                    "+psycopg2",
+                    None,
+                    None,
                     "psycopg2 2.4 no longer accepts percent "
-                    "sign in bind placeholders"),
+                    "sign in bind placeholders",
+                ),
                 (
-                    "+psycopg2cffi", None, None,
+                    "+psycopg2cffi",
+                    None,
+                    None,
                     "psycopg2cffi does not accept percent signs in "
-                    "bind placeholders"),
-                ("mysql", None, None, "executemany() doesn't work here")
+                    "bind placeholders",
+                ),
+                ("mysql", None, None, "executemany() doesn't work here"),
             ]
         )
 
     @property
     def order_by_label_with_expression(self):
-        return fails_if([
-            ('firebird', None, None,
-             "kinterbasdb doesn't send full type information"),
-            ('postgresql', None, None, 'only simple labels allowed'),
-            ('sybase', None, None, 'only simple labels allowed'),
-            ('mssql', None, None, 'only simple labels allowed')
-        ])
+        return fails_if(
+            [
+                (
+                    "firebird",
+                    None,
+                    None,
+                    "kinterbasdb doesn't send full type information",
+                ),
+                ("postgresql", None, None, "only simple labels allowed"),
+                ("sybase", None, None, "only simple labels allowed"),
+                ("mssql", None, None, "only simple labels allowed"),
+            ]
+        )
 
     def get_order_by_collation(self, config):
         lookup = {
-
             # will raise without quoting
             "postgresql": "POSIX",
-
             # note MySQL databases need to be created w/ utf8mb3 charset
             # for the test suite
             "mysql": "utf8mb3_bin",
             "sqlite": "NOCASE",
-
             # will raise *with* quoting
-            "mssql": "Latin1_General_CI_AS"
+            "mssql": "Latin1_General_CI_AS",
         }
         try:
             return lookup[config.db.name]
@@ -1098,8 +1185,9 @@ class DefaultRequirements(SuiteRequirements):
     def skip_mysql_on_windows(self):
         """Catchall for a large variety of MySQL on Windows failures"""
 
-        return skip_if(self._has_mysql_on_windows,
-                       "Not supported on MySQL + Windows")
+        return skip_if(
+            self._has_mysql_on_windows, "Not supported on MySQL + Windows"
+        )
 
     @property
     def mssql_freetds(self):
@@ -1110,7 +1198,8 @@ class DefaultRequirements(SuiteRequirements):
         return exclusions.skip_if(
             ["oracle"],
             "works, but Oracle just gets tired with "
-            "this much connection activity")
+            "this much connection activity",
+        )
 
     @property
     def no_mssql_freetds(self):
@@ -1125,37 +1214,40 @@ class DefaultRequirements(SuiteRequirements):
                 return False
             with config.db.connect() as conn:
                 drivername = conn.connection.connection.getinfo(
-                    config.db.dialect.dbapi.SQL_DRIVER_NAME)
+                    config.db.dialect.dbapi.SQL_DRIVER_NAME
+                )
                 # on linux this is 'libmsodbcsql-13.1.so.9.2'.
                 # don't know what it is on windows
                 return "msodbc" in drivername
+
         return only_if(
-            has_fastexecutemany,
-            "only on pyodbc > 4.0.19 w/ msodbc driver")
+            has_fastexecutemany, "only on pyodbc > 4.0.19 w/ msodbc driver"
+        )
 
     @property
     def python_fixed_issue_8743(self):
         return exclusions.skip_if(
             lambda: sys.version_info < (2, 7, 8),
-            "Python issue 8743 fixed in Python 2.7.8"
+            "Python issue 8743 fixed in Python 2.7.8",
         )
 
     @property
     def selectone(self):
         """target driver must support the literal statement 'select 1'"""
-        return skip_if(["oracle", "firebird"],
-                       "non-standard SELECT scalar syntax")
+        return skip_if(
+            ["oracle", "firebird"], "non-standard SELECT scalar syntax"
+        )
 
     @property
     def mysql_for_update(self):
         return skip_if(
             "mysql+mysqlconnector",
-           "lock-sensitive operations crash on mysqlconnector"
+            "lock-sensitive operations crash on mysqlconnector",
         )
 
     @property
     def mysql_fsp(self):
-        return only_if('mysql >= 5.6.4')
+        return only_if("mysql >= 5.6.4")
 
     @property
     def mysql_fully_case_sensitive(self):
@@ -1164,7 +1256,7 @@ class DefaultRequirements(SuiteRequirements):
     @property
     def mysql_zero_date(self):
         def check(config):
-            if not against(config, 'mysql'):
+            if not against(config, "mysql"):
                 return False
 
             row = config.db.execute("show variables like 'sql_mode'").first()
@@ -1175,7 +1267,7 @@ class DefaultRequirements(SuiteRequirements):
     @property
     def mysql_non_strict(self):
         def check(config):
-            if not against(config, 'mysql'):
+            if not against(config, "mysql"):
                 return False
 
             row = config.db.execute("show variables like 'sql_mode'").first()
@@ -1186,53 +1278,62 @@ class DefaultRequirements(SuiteRequirements):
     @property
     def mysql_ngram_fulltext(self):
         def check(config):
-            return against(config, "mysql") and \
-                not config.db.dialect._is_mariadb and \
-                config.db.dialect.server_version_info >= (5, 7)
+            return (
+                against(config, "mysql")
+                and not config.db.dialect._is_mariadb
+                and config.db.dialect.server_version_info >= (5, 7)
+            )
+
         return only_if(check)
 
     def _mariadb_102(self, config):
-        return against(config, "mysql") and \
-                config.db.dialect._is_mariadb and \
-                config.db.dialect._mariadb_normalized_version_info > (10, 2)
+        return (
+            against(config, "mysql")
+            and config.db.dialect._is_mariadb
+            and config.db.dialect._mariadb_normalized_version_info > (10, 2)
+        )
 
     def _mysql_not_mariadb_102(self, config):
         return against(config, "mysql") and (
-            not config.db.dialect._is_mariadb or
-            config.db.dialect._mariadb_normalized_version_info < (10, 2)
+            not config.db.dialect._is_mariadb
+            or config.db.dialect._mariadb_normalized_version_info < (10, 2)
         )
 
     def _mysql_not_mariadb_103(self, config):
         return against(config, "mysql") and (
-            not config.db.dialect._is_mariadb or
-            config.db.dialect._mariadb_normalized_version_info < (10, 3)
+            not config.db.dialect._is_mariadb
+            or config.db.dialect._mariadb_normalized_version_info < (10, 3)
         )
 
     def _has_mysql_on_windows(self, config):
-        return against(config, 'mysql') and \
-                config.db.dialect._detect_casing(config.db) == 1
+        return (
+            against(config, "mysql")
+            and config.db.dialect._detect_casing(config.db) == 1
+        )
 
     def _has_mysql_fully_case_sensitive(self, config):
-        return against(config, 'mysql') and \
-                config.db.dialect._detect_casing(config.db) == 0
+        return (
+            against(config, "mysql")
+            and config.db.dialect._detect_casing(config.db) == 0
+        )
 
     @property
     def postgresql_utf8_server_encoding(self):
         return only_if(
-            lambda config: against(config, 'postgresql') and
-            config.db.scalar("show server_encoding").lower() == "utf8"
+            lambda config: against(config, "postgresql")
+            and config.db.scalar("show server_encoding").lower() == "utf8"
         )
 
     @property
     def cxoracle6_or_greater(self):
         return only_if(
-            lambda config: against(config, "oracle+cx_oracle") and
-            config.db.dialect.cx_oracle_ver >= (6, )
+            lambda config: against(config, "oracle+cx_oracle")
+            and config.db.dialect.cx_oracle_ver >= (6,)
         )
 
     @property
     def oracle5x(self):
         return only_if(
-            lambda config: against(config, "oracle+cx_oracle") and
-            config.db.dialect.cx_oracle_ver < (6, )
+            lambda config: against(config, "oracle+cx_oracle")
+            and config.db.dialect.cx_oracle_ver < (6,)
         )