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, 226 insertions, 133 deletions

diff --git a/lib/sqlalchemy/testing/plugin/plugin_base.py b/lib/sqlalchemy/testing/plugin/plugin_base.py
index 0ffcae093..5d6bf2975 100644
--- a/lib/sqlalchemy/testing/plugin/plugin_base.py
+++ b/lib/sqlalchemy/testing/plugin/plugin_base.py
@@ -46,58 +46,130 @@ options = None
 
 
 def setup_options(make_option):
-    make_option("--log-info", action="callback", type="string", callback=_log,
-                help="turn on info logging for <LOG> (multiple OK)")
-    make_option("--log-debug", action="callback",
-                type="string", callback=_log,
-                help="turn on debug logging for <LOG> (multiple OK)")
-    make_option("--db", action="append", type="string", dest="db",
-                help="Use prefab database uri. Multiple OK, "
-                "first one is run by default.")
-    make_option('--dbs', action='callback', zeroarg_callback=_list_dbs,
-                help="List available prefab dbs")
-    make_option("--dburi", action="append", type="string", dest="dburi",
-                help="Database uri.  Multiple OK, "
-                "first one is run by default.")
-    make_option("--dropfirst", action="store_true", dest="dropfirst",
-                help="Drop all tables in the target database first")
-    make_option("--backend-only", action="store_true", dest="backend_only",
-                help="Run only tests marked with __backend__")
-    make_option("--nomemory", action="store_true", dest="nomemory",
-                help="Don't run memory profiling tests")
-    make_option("--postgresql-templatedb", type="string",
-                help="name of template database to use for PostgreSQL "
-                     "CREATE DATABASE (defaults to current database)")
-    make_option("--low-connections", action="store_true",
-                dest="low_connections",
-                help="Use a low number of distinct connections - "
-                "i.e. for Oracle TNS")
-    make_option("--write-idents", type="string", dest="write_idents",
-                help="write out generated follower idents to <file>, "
-                "when -n<num> is used")
-    make_option("--reversetop", action="store_true",
-                dest="reversetop", default=False,
-                help="Use a random-ordering set implementation in the ORM "
-                "(helps reveal dependency issues)")
-    make_option("--requirements", action="callback", type="string",
-                callback=_requirements_opt,
-                help="requirements class for testing, overrides setup.cfg")
-    make_option("--with-cdecimal", action="store_true",
-                dest="cdecimal", default=False,
-                help="Monkeypatch the cdecimal library into Python 'decimal' "
-                "for all tests")
-    make_option("--include-tag", action="callback", callback=_include_tag,
-                type="string",
-                help="Include tests with tag <tag>")
-    make_option("--exclude-tag", action="callback", callback=_exclude_tag,
-                type="string",
-                help="Exclude tests with tag <tag>")
-    make_option("--write-profiles", action="store_true",
-                dest="write_profiles", default=False,
-                help="Write/update failing profiling data.")
-    make_option("--force-write-profiles", action="store_true",
-                dest="force_write_profiles", default=False,
-                help="Unconditionally write/update profiling data.")
+    make_option(
+        "--log-info",
+        action="callback",
+        type="string",
+        callback=_log,
+        help="turn on info logging for <LOG> (multiple OK)",
+    )
+    make_option(
+        "--log-debug",
+        action="callback",
+        type="string",
+        callback=_log,
+        help="turn on debug logging for <LOG> (multiple OK)",
+    )
+    make_option(
+        "--db",
+        action="append",
+        type="string",
+        dest="db",
+        help="Use prefab database uri. Multiple OK, "
+        "first one is run by default.",
+    )
+    make_option(
+        "--dbs",
+        action="callback",
+        zeroarg_callback=_list_dbs,
+        help="List available prefab dbs",
+    )
+    make_option(
+        "--dburi",
+        action="append",
+        type="string",
+        dest="dburi",
+        help="Database uri.  Multiple OK, " "first one is run by default.",
+    )
+    make_option(
+        "--dropfirst",
+        action="store_true",
+        dest="dropfirst",
+        help="Drop all tables in the target database first",
+    )
+    make_option(
+        "--backend-only",
+        action="store_true",
+        dest="backend_only",
+        help="Run only tests marked with __backend__",
+    )
+    make_option(
+        "--nomemory",
+        action="store_true",
+        dest="nomemory",
+        help="Don't run memory profiling tests",
+    )
+    make_option(
+        "--postgresql-templatedb",
+        type="string",
+        help="name of template database to use for PostgreSQL "
+        "CREATE DATABASE (defaults to current database)",
+    )
+    make_option(
+        "--low-connections",
+        action="store_true",
+        dest="low_connections",
+        help="Use a low number of distinct connections - "
+        "i.e. for Oracle TNS",
+    )
+    make_option(
+        "--write-idents",
+        type="string",
+        dest="write_idents",
+        help="write out generated follower idents to <file>, "
+        "when -n<num> is used",
+    )
+    make_option(
+        "--reversetop",
+        action="store_true",
+        dest="reversetop",
+        default=False,
+        help="Use a random-ordering set implementation in the ORM "
+        "(helps reveal dependency issues)",
+    )
+    make_option(
+        "--requirements",
+        action="callback",
+        type="string",
+        callback=_requirements_opt,
+        help="requirements class for testing, overrides setup.cfg",
+    )
+    make_option(
+        "--with-cdecimal",
+        action="store_true",
+        dest="cdecimal",
+        default=False,
+        help="Monkeypatch the cdecimal library into Python 'decimal' "
+        "for all tests",
+    )
+    make_option(
+        "--include-tag",
+        action="callback",
+        callback=_include_tag,
+        type="string",
+        help="Include tests with tag <tag>",
+    )
+    make_option(
+        "--exclude-tag",
+        action="callback",
+        callback=_exclude_tag,
+        type="string",
+        help="Exclude tests with tag <tag>",
+    )
+    make_option(
+        "--write-profiles",
+        action="store_true",
+        dest="write_profiles",
+        default=False,
+        help="Write/update failing profiling data.",
+    )
+    make_option(
+        "--force-write-profiles",
+        action="store_true",
+        dest="force_write_profiles",
+        default=False,
+        help="Unconditionally write/update profiling data.",
+    )
 
 
 def configure_follower(follower_ident):
@@ -108,6 +180,7 @@ def configure_follower(follower_ident):
 
     """
     from sqlalchemy.testing import provision
+
     provision.FOLLOWER_IDENT = follower_ident
 
 
@@ -121,9 +194,9 @@ def memoize_important_follower_config(dict_):
     callables, so we have to just copy all of that over.
 
     """
-    dict_['memoized_config'] = {
-        'include_tags': include_tags,
-        'exclude_tags': exclude_tags
+    dict_["memoized_config"] = {
+        "include_tags": include_tags,
+        "exclude_tags": exclude_tags,
     }
 
 
@@ -134,14 +207,14 @@ def restore_important_follower_config(dict_):
 
     """
     global include_tags, exclude_tags
-    include_tags.update(dict_['memoized_config']['include_tags'])
-    exclude_tags.update(dict_['memoized_config']['exclude_tags'])
+    include_tags.update(dict_["memoized_config"]["include_tags"])
+    exclude_tags.update(dict_["memoized_config"]["exclude_tags"])
 
 
 def read_config():
     global file_config
     file_config = configparser.ConfigParser()
-    file_config.read(['setup.cfg', 'test.cfg'])
+    file_config.read(["setup.cfg", "test.cfg"])
 
 
 def pre_begin(opt):
@@ -155,6 +228,7 @@ def pre_begin(opt):
 def set_coverage_flag(value):
     options.has_coverage = value
 
+
 _skip_test_exception = None
 
 
@@ -171,34 +245,33 @@ def post_begin():
 
     # late imports, has to happen after config as well
     # as nose plugins like coverage
-    global util, fixtures, engines, exclusions, \
-        assertions, warnings, profiling,\
-        config, testing
-    from sqlalchemy import testing # noqa
+    global util, fixtures, engines, exclusions, assertions, warnings, profiling, config, testing
+    from sqlalchemy import testing  # noqa
     from sqlalchemy.testing import fixtures, engines, exclusions  # noqa
-    from sqlalchemy.testing import assertions, warnings, profiling # noqa
+    from sqlalchemy.testing import assertions, warnings, profiling  # noqa
     from sqlalchemy.testing import config  # noqa
     from sqlalchemy import util  # noqa
-    warnings.setup_filters()
 
+    warnings.setup_filters()
 
 
 def _log(opt_str, value, parser):
     global logging
     if not logging:
         import logging
+
         logging.basicConfig()
 
-    if opt_str.endswith('-info'):
+    if opt_str.endswith("-info"):
         logging.getLogger(value).setLevel(logging.INFO)
-    elif opt_str.endswith('-debug'):
+    elif opt_str.endswith("-debug"):
         logging.getLogger(value).setLevel(logging.DEBUG)
 
 
 def _list_dbs(*args):
     print("Available --db options (use --dburi to override)")
-    for macro in sorted(file_config.options('db')):
-        print("%20s\t%s" % (macro, file_config.get('db', macro)))
+    for macro in sorted(file_config.options("db")):
+        print("%20s\t%s" % (macro, file_config.get("db", macro)))
     sys.exit(0)
 
 
@@ -207,11 +280,12 @@ def _requirements_opt(opt_str, value, parser):
 
 
 def _exclude_tag(opt_str, value, parser):
-    exclude_tags.add(value.replace('-', '_'))
+    exclude_tags.add(value.replace("-", "_"))
 
 
 def _include_tag(opt_str, value, parser):
-    include_tags.add(value.replace('-', '_'))
+    include_tags.add(value.replace("-", "_"))
+
 
 pre_configure = []
 post_configure = []
@@ -243,7 +317,8 @@ def _set_nomemory(opt, file_config):
 def _monkeypatch_cdecimal(options, file_config):
     if options.cdecimal:
         import cdecimal
-        sys.modules['decimal'] = cdecimal
+
+        sys.modules["decimal"] = cdecimal
 
 
 @post
@@ -266,27 +341,28 @@ def _engine_uri(options, file_config):
 
     if options.db:
         for db_token in options.db:
-            for db in re.split(r'[,\s]+', db_token):
-                if db not in file_config.options('db'):
+            for db in re.split(r"[,\s]+", db_token):
+                if db not in file_config.options("db"):
                     raise RuntimeError(
                         "Unknown URI specifier '%s'.  "
-                        "Specify --dbs for known uris."
-                        % db)
+                        "Specify --dbs for known uris." % db
+                    )
                 else:
-                    db_urls.append(file_config.get('db', db))
+                    db_urls.append(file_config.get("db", db))
 
     if not db_urls:
-        db_urls.append(file_config.get('db', 'default'))
+        db_urls.append(file_config.get("db", "default"))
 
     config._current = None
     for db_url in db_urls:
 
-        if options.write_idents and provision.FOLLOWER_IDENT: # != 'master':
+        if options.write_idents and provision.FOLLOWER_IDENT:  # != 'master':
             with open(options.write_idents, "a") as file_:
                 file_.write(provision.FOLLOWER_IDENT + " " + db_url + "\n")
 
         cfg = provision.setup_config(
-            db_url, options, file_config, provision.FOLLOWER_IDENT)
+            db_url, options, file_config, provision.FOLLOWER_IDENT
+        )
 
         if not config._current:
             cfg.set_as_current(cfg, testing)
@@ -295,7 +371,7 @@ def _engine_uri(options, file_config):
 @post
 def _requirements(options, file_config):
 
-    requirement_cls = file_config.get('sqla_testing', "requirement_cls")
+    requirement_cls = file_config.get("sqla_testing", "requirement_cls")
     _setup_requirements(requirement_cls)
 
 
@@ -334,22 +410,28 @@ def _prep_testing_database(options, file_config):
                 pass
             else:
                 for vname in view_names:
-                    e.execute(schema._DropView(
-                        schema.Table(vname, schema.MetaData())
-                    ))
+                    e.execute(
+                        schema._DropView(
+                            schema.Table(vname, schema.MetaData())
+                        )
+                    )
 
             if config.requirements.schemas.enabled_for_config(cfg):
                 try:
-                    view_names = inspector.get_view_names(
-                        schema="test_schema")
+                    view_names = inspector.get_view_names(schema="test_schema")
                 except NotImplementedError:
                     pass
                 else:
                     for vname in view_names:
-                        e.execute(schema._DropView(
-                            schema.Table(vname, schema.MetaData(),
-                                         schema="test_schema")
-                        ))
+                        e.execute(
+                            schema._DropView(
+                                schema.Table(
+                                    vname,
+                                    schema.MetaData(),
+                                    schema="test_schema",
+                                )
+                            )
+                        )
 
             util.drop_all_tables(e, inspector)
 
@@ -358,23 +440,29 @@ def _prep_testing_database(options, file_config):
 
             if against(cfg, "postgresql"):
                 from sqlalchemy.dialects import postgresql
+
                 for enum in inspector.get_enums("*"):
-                    e.execute(postgresql.DropEnumType(
-                        postgresql.ENUM(
-                            name=enum['name'],
-                            schema=enum['schema'])))
+                    e.execute(
+                        postgresql.DropEnumType(
+                            postgresql.ENUM(
+                                name=enum["name"], schema=enum["schema"]
+                            )
+                        )
+                    )
 
 
 @post
 def _reverse_topological(options, file_config):
     if options.reversetop:
         from sqlalchemy.orm.util import randomize_unitofwork
+
         randomize_unitofwork()
 
 
 @post
 def _post_setup_options(opt, file_config):
     from sqlalchemy.testing import config
+
     config.options = options
     config.file_config = file_config
 
@@ -382,17 +470,20 @@ def _post_setup_options(opt, file_config):
 @post
 def _setup_profiling(options, file_config):
     from sqlalchemy.testing import profiling
+
     profiling._profile_stats = profiling.ProfileStatsFile(
-        file_config.get('sqla_testing', 'profile_file'))
+        file_config.get("sqla_testing", "profile_file")
+    )
 
 
 def want_class(cls):
     if not issubclass(cls, fixtures.TestBase):
         return False
-    elif cls.__name__.startswith('_'):
+    elif cls.__name__.startswith("_"):
         return False
-    elif config.options.backend_only and not getattr(cls, '__backend__',
-                                                     False):
+    elif config.options.backend_only and not getattr(
+        cls, "__backend__", False
+    ):
         return False
     else:
         return True
@@ -405,25 +496,28 @@ def want_method(cls, fn):
         return False
     elif include_tags:
         return (
-            hasattr(cls, '__tags__') and
-            exclusions.tags(cls.__tags__).include_test(
-                include_tags, exclude_tags)
+            hasattr(cls, "__tags__")
+            and exclusions.tags(cls.__tags__).include_test(
+                include_tags, exclude_tags
+            )
         ) or (
-            hasattr(fn, '_sa_exclusion_extend') and
-            fn._sa_exclusion_extend.include_test(
-                include_tags, exclude_tags)
+            hasattr(fn, "_sa_exclusion_extend")
+            and fn._sa_exclusion_extend.include_test(
+                include_tags, exclude_tags
+            )
         )
-    elif exclude_tags and hasattr(cls, '__tags__'):
+    elif exclude_tags and hasattr(cls, "__tags__"):
         return exclusions.tags(cls.__tags__).include_test(
-            include_tags, exclude_tags)
-    elif exclude_tags and hasattr(fn, '_sa_exclusion_extend'):
+            include_tags, exclude_tags
+        )
+    elif exclude_tags and hasattr(fn, "_sa_exclusion_extend"):
         return fn._sa_exclusion_extend.include_test(include_tags, exclude_tags)
     else:
         return True
 
 
 def generate_sub_tests(cls, module):
-    if getattr(cls, '__backend__', False):
+    if getattr(cls, "__backend__", False):
         for cfg in _possible_configs_for_cls(cls):
             orig_name = cls.__name__
 
@@ -431,16 +525,13 @@ def generate_sub_tests(cls, module):
             # pytest junit plugin, which is tripped up by the brackets
             # and periods, so sanitize
 
-            alpha_name = re.sub('[_\[\]\.]+', '_', cfg.name)
-            alpha_name = re.sub('_+$', '', alpha_name)
+            alpha_name = re.sub("[_\[\]\.]+", "_", cfg.name)
+            alpha_name = re.sub("_+$", "", alpha_name)
             name = "%s_%s" % (cls.__name__, alpha_name)
             subcls = type(
                 name,
-                (cls, ),
-                {
-                    "_sa_orig_cls_name": orig_name,
-                    "__only_on_config__": cfg
-                }
+                (cls,),
+                {"_sa_orig_cls_name": orig_name, "__only_on_config__": cfg},
             )
             setattr(module, name, subcls)
             yield subcls
@@ -454,8 +545,8 @@ def start_test_class(cls):
 
 
 def stop_test_class(cls):
-    #from sqlalchemy import inspect
-    #assert not inspect(testing.db).get_table_names()
+    # from sqlalchemy import inspect
+    # assert not inspect(testing.db).get_table_names()
     engines.testing_reaper._stop_test_ctx()
     try:
         if not options.low_connections:
@@ -475,7 +566,7 @@ def final_process_cleanup():
 
 
 def _setup_engine(cls):
-    if getattr(cls, '__engine_options__', None):
+    if getattr(cls, "__engine_options__", None):
         eng = engines.testing_engine(options=cls.__engine_options__)
         config._current.push_engine(eng, testing)
 
@@ -485,7 +576,7 @@ def before_test(test, test_module_name, test_class, test_name):
     # like a nose id, e.g.:
     # "test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause"
 
-    name = getattr(test_class, '_sa_orig_cls_name', test_class.__name__)
+    name = getattr(test_class, "_sa_orig_cls_name", test_class.__name__)
 
     id_ = "%s.%s.%s" % (test_module_name, name, test_name)
 
@@ -505,16 +596,16 @@ def _possible_configs_for_cls(cls, reasons=None):
             if spec(config_obj):
                 all_configs.remove(config_obj)
 
-    if getattr(cls, '__only_on__', None):
+    if getattr(cls, "__only_on__", None):
         spec = exclusions.db_spec(*util.to_list(cls.__only_on__))
         for config_obj in list(all_configs):
             if not spec(config_obj):
                 all_configs.remove(config_obj)
 
-    if getattr(cls, '__only_on_config__', None):
+    if getattr(cls, "__only_on_config__", None):
         all_configs.intersection_update([cls.__only_on_config__])
 
-    if hasattr(cls, '__requires__'):
+    if hasattr(cls, "__requires__"):
         requirements = config.requirements
         for config_obj in list(all_configs):
             for requirement in cls.__requires__:
@@ -527,7 +618,7 @@ def _possible_configs_for_cls(cls, reasons=None):
                         reasons.extend(skip_reasons)
                     break
 
-    if hasattr(cls, '__prefer_requires__'):
+    if hasattr(cls, "__prefer_requires__"):
         non_preferred = set()
         requirements = config.requirements
         for config_obj in list(all_configs):
@@ -546,30 +637,32 @@ def _do_skips(cls):
     reasons = []
     all_configs = _possible_configs_for_cls(cls, reasons)
 
-    if getattr(cls, '__skip_if__', False):
-        for c in getattr(cls, '__skip_if__'):
+    if getattr(cls, "__skip_if__", False):
+        for c in getattr(cls, "__skip_if__"):
             if c():
-                config.skip_test("'%s' skipped by %s" % (
-                    cls.__name__, c.__name__)
+                config.skip_test(
+                    "'%s' skipped by %s" % (cls.__name__, c.__name__)
                 )
 
     if not all_configs:
         msg = "'%s' unsupported on any DB implementation %s%s" % (
             cls.__name__,
             ", ".join(
-                "'%s(%s)+%s'" % (
+                "'%s(%s)+%s'"
+                % (
                     config_obj.db.name,
                     ".".join(
-                        str(dig) for dig in
-                        exclusions._server_version(config_obj.db)),
-                    config_obj.db.driver
+                        str(dig)
+                        for dig in exclusions._server_version(config_obj.db)
+                    ),
+                    config_obj.db.driver,
                 )
-              for config_obj in config.Config.all_configs()
+                for config_obj in config.Config.all_configs()
             ),
-            ", ".join(reasons)
+            ", ".join(reasons),
         )
         config.skip_test(msg)
-    elif hasattr(cls, '__prefer_backends__'):
+    elif hasattr(cls, "__prefer_backends__"):
         non_preferred = set()
         spec = exclusions.db_spec(*util.to_list(cls.__prefer_backends__))
         for config_obj in all_configs: