Post black reformatting

Applied on top of a pure run of black -l 79 in
I7eda77fed3d8e73df84b3651fd6cfcfe858d4dc9,  this set of changes
resolves all remaining flake8 conditions for those codes
we have enabled in setup.cfg.

Included are resolutions for all remaining flake8 issues
including shadowed builtins, long lines, import order, unused
imports, duplicate imports, and docstring issues.

Change-Id: I4f72d3ba1380dd601610ff80b8fb06a2aff8b0fe

10 files changed, 130 insertions, 106 deletions

diff --git a/lib/sqlalchemy/engine/__init__.py b/lib/sqlalchemy/engine/__init__.py
index 590359c38..fadc10ad7 100644
--- a/lib/sqlalchemy/engine/__init__.py
+++ b/lib/sqlalchemy/engine/__init__.py
@@ -51,43 +51,33 @@ url.py
     within a URL.
 """
 
-from .interfaces import (
-    Connectable,
-    CreateEnginePlugin,
-    Dialect,
-    ExecutionContext,
-    ExceptionContext,
-    # backwards compat
-    Compiled,
-    TypeCompiler,
-)
-
-from .base import (
-    Connection,
-    Engine,
-    NestedTransaction,
-    RootTransaction,
-    Transaction,
-    TwoPhaseTransaction,
-)
-
-from .result import (
-    BaseRowProxy,
-    BufferedColumnResultProxy,
-    BufferedColumnRow,
-    BufferedRowResultProxy,
-    FullyBufferedResultProxy,
-    ResultProxy,
-    RowProxy,
-)
-
-from .util import connection_memoize
-
-
-from . import util, strategies
+from . import strategies
+from . import util  # noqa
+from .base import Connection  # noqa
+from .base import Engine  # noqa
+from .base import NestedTransaction  # noqa
+from .base import RootTransaction  # noqa
+from .base import Transaction  # noqa
+from .base import TwoPhaseTransaction  # noqa
+from .interfaces import Compiled  # noqa
+from .interfaces import Connectable  # noqa
+from .interfaces import CreateEnginePlugin  # noqa
+from .interfaces import Dialect  # noqa
+from .interfaces import ExceptionContext  # noqa
+from .interfaces import ExecutionContext  # noqa
+from .interfaces import TypeCompiler  # noqa
+from .result import BaseRowProxy  # noqa
+from .result import BufferedColumnResultProxy  # noqa
+from .result import BufferedColumnRow  # noqa
+from .result import BufferedRowResultProxy  # noqa
+from .result import FullyBufferedResultProxy  # noqa
+from .result import ResultProxy  # noqa
+from .result import RowProxy  # noqa
+from .util import connection_memoize  # noqa
+from ..sql import ddl  # noqa
+
 
 # backwards compat
-from ..sql import ddl
 
 default_strategy = "plain"
 
@@ -298,8 +288,8 @@ def create_engine(*args, **kwargs):
         Behavior here varies per backend, and
         individual dialects should be consulted directly.
 
-        Note that the isolation level can also be set on a per-:class:`.Connection`
-        basis as well, using the
+        Note that the isolation level can also be set on a
+        per-:class:`.Connection` basis as well, using the
         :paramref:`.Connection.execution_options.isolation_level`
         feature.
 
@@ -455,7 +445,7 @@ def create_engine(*args, **kwargs):
         ``(sql, *multiparams, **params)``, to which the ``mock`` strategy will
         dispatch all statement execution. Used only by ``strategy='mock'``.
 
-    """
+    """  # noqa
 
     strategy = kwargs.pop("strategy", default_strategy)
     strategy = strategies.strategies[strategy]
diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py
index 75d03b744..c0979ecac 100644
--- a/lib/sqlalchemy/engine/base.py
+++ b/lib/sqlalchemy/engine/base.py
@@ -6,18 +6,23 @@
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 from __future__ import with_statement
 
-"""Defines :class:`.Connection` and :class:`.Engine`.
+import contextlib
+import sys
 
-"""
+from .interfaces import Connectable
+from .interfaces import ExceptionContext
+from .util import _distill_params
+from .. import exc
+from .. import interfaces
+from .. import log
+from .. import util
+from ..sql import schema
+from ..sql import util as sql_util
 
 
-import sys
-from .. import exc, util, log, interfaces
-from ..sql import util as sql_util
-from ..sql import schema
-from .interfaces import Connectable, ExceptionContext
-from .util import _distill_params
-import contextlib
+"""Defines :class:`.Connection` and :class:`.Engine`.
+
+"""
 
 
 class Connection(Connectable):
@@ -172,7 +177,7 @@ class Connection(Connectable):
     def __enter__(self):
         return self
 
-    def __exit__(self, type, value, traceback):
+    def __exit__(self, type_, value, traceback):
         self.close()
 
     def execution_options(self, **opt):
@@ -321,7 +326,7 @@ class Connection(Connectable):
 
             :ref:`schema_translating`
 
-        """
+        """  # noqa
         c = self._clone()
         c._execution_options = c._execution_options.union(opt)
         if self._has_events or self.engine._has_events:
@@ -892,15 +897,15 @@ class Connection(Connectable):
         self.__can_reconnect = False
         self.__transaction = None
 
-    def scalar(self, object, *multiparams, **params):
+    def scalar(self, object_, *multiparams, **params):
         """Executes and returns the first column of the first row.
 
         The underlying result/cursor is closed after execution.
         """
 
-        return self.execute(object, *multiparams, **params).scalar()
+        return self.execute(object_, *multiparams, **params).scalar()
 
-    def execute(self, object, *multiparams, **params):
+    def execute(self, object_, *multiparams, **params):
         r"""Executes a SQL statement construct and returns a
         :class:`.ResultProxy`.
 
@@ -959,12 +964,12 @@ class Connection(Connectable):
          DBAPI-agnostic way, use the :func:`~.expression.text` construct.
 
         """
-        if isinstance(object, util.string_types[0]):
-            return self._execute_text(object, multiparams, params)
+        if isinstance(object_, util.string_types[0]):
+            return self._execute_text(object_, multiparams, params)
         try:
-            meth = object._execute_on_connection
+            meth = object_._execute_on_connection
         except AttributeError:
-            raise exc.ObjectNotExecutableError(object)
+            raise exc.ObjectNotExecutableError(object_)
         else:
             return meth(self, multiparams, params)
 
@@ -1698,8 +1703,8 @@ class Transaction(object):
     def __enter__(self):
         return self
 
-    def __exit__(self, type, value, traceback):
-        if type is None and self.is_active:
+    def __exit__(self, type_, value, traceback):
+        if type_ is None and self.is_active:
             try:
                 self.commit()
             except:
@@ -2005,8 +2010,8 @@ class Engine(Connectable, log.Identified):
         def __enter__(self):
             return self.conn
 
-        def __exit__(self, type, value, traceback):
-            if type is not None:
+        def __exit__(self, type_, value, traceback):
+            if type_ is not None:
                 self.transaction.rollback()
             else:
                 self.transaction.commit()
diff --git a/lib/sqlalchemy/engine/default.py b/lib/sqlalchemy/engine/default.py
index d7c2518fe..cceae74e8 100644
--- a/lib/sqlalchemy/engine/default.py
+++ b/lib/sqlalchemy/engine/default.py
@@ -13,15 +13,24 @@ as the base class for their own corresponding classes.
 
 """
 
-import re
-import random
-from . import reflection, interfaces, result
-from ..sql import compiler, expression, schema
-from .. import types as sqltypes
-from .. import exc, util, pool, processors
 import codecs
+import random
+import re
 import weakref
+
+from . import interfaces
+from . import reflection
+from . import result
 from .. import event
+from .. import exc
+from .. import pool
+from .. import processors
+from .. import types as sqltypes
+from .. import util
+from ..sql import compiler
+from ..sql import expression
+from ..sql import schema
+
 
 AUTOCOMMIT_REGEXP = re.compile(
     r"\s*(?:UPDATE|INSERT|CREATE|DELETE|DROP|ALTER)", re.I | re.UNICODE
@@ -239,13 +248,13 @@ class DefaultDialect(interfaces.Dialect):
         self.label_length = label_length
 
         if self.description_encoding == "use_encoding":
-            self._description_decoder = processors.to_unicode_processor_factory(
-                encoding
-            )
+            self._description_decoder = (
+                processors.to_unicode_processor_factory
+            )(encoding)
         elif self.description_encoding is not None:
-            self._description_decoder = processors.to_unicode_processor_factory(
-                self.description_encoding
-            )
+            self._description_decoder = (
+                processors.to_unicode_processor_factory
+            )(self.description_encoding)
         self._encoder = codecs.getencoder(self.encoding)
         self._decoder = processors.to_unicode_processor_factory(self.encoding)
 
diff --git a/lib/sqlalchemy/engine/interfaces.py b/lib/sqlalchemy/engine/interfaces.py
index e10e6e884..f738b5caf 100644
--- a/lib/sqlalchemy/engine/interfaces.py
+++ b/lib/sqlalchemy/engine/interfaces.py
@@ -8,9 +8,8 @@
 """Define core interfaces used by the engine system."""
 
 from .. import util
-
-# backwards compat
-from ..sql.compiler import Compiled, TypeCompiler
+from ..sql.compiler import Compiled  # noqa
+from ..sql.compiler import TypeCompiler  # noqa
 
 
 class Dialect(object):
@@ -1157,11 +1156,11 @@ class Connectable(object):
 
         raise NotImplementedError()
 
-    def execute(self, object, *multiparams, **params):
+    def execute(self, object_, *multiparams, **params):
         """Executes the given construct and returns a :class:`.ResultProxy`."""
         raise NotImplementedError()
 
-    def scalar(self, object, *multiparams, **params):
+    def scalar(self, object_, *multiparams, **params):
         """Executes and returns the first column of the first row.
 
         The underlying cursor is closed after execution.
diff --git a/lib/sqlalchemy/engine/reflection.py b/lib/sqlalchemy/engine/reflection.py
index 9b5fa2459..c822ff820 100644
--- a/lib/sqlalchemy/engine/reflection.py
+++ b/lib/sqlalchemy/engine/reflection.py
@@ -25,14 +25,15 @@ methods such as get_table_names, get_columns, etc.
    'name' attribute..
 """
 
-from .. import exc, sql
-from ..sql import schema as sa_schema
+from .base import Connectable
+from .. import exc
+from .. import inspection
+from .. import sql
 from .. import util
+from ..sql import schema as sa_schema
 from ..sql.type_api import TypeEngine
 from ..util import deprecated
 from ..util import topological
-from .. import inspection
-from .base import Connectable
 
 
 @util.decorator
diff --git a/lib/sqlalchemy/engine/result.py b/lib/sqlalchemy/engine/result.py
index 5ad0d2909..d672ffefe 100644
--- a/lib/sqlalchemy/engine/result.py
+++ b/lib/sqlalchemy/engine/result.py
@@ -9,11 +9,16 @@
 and :class:`.RowProxy."""
 
 
-from .. import exc, util
-from ..sql import expression, sqltypes, util as sql_util
 import collections
 import operator
 
+from .. import exc
+from .. import util
+from ..sql import expression
+from ..sql import sqltypes
+from ..sql import util as sql_util
+
+
 # This reconstructor is necessary so that pickles with the C extension or
 # without use the same Binary format.
 try:
@@ -443,7 +448,14 @@ class ResultMetaData(object):
                     obj,
                     untranslated,
                 )
-                for idx, colname, mapped_type, coltype, obj, untranslated in raw_iterator
+                for (
+                    idx,
+                    colname,
+                    mapped_type,
+                    coltype,
+                    obj,
+                    untranslated,
+                ) in raw_iterator
             ]
 
     def _colnames_from_description(self, context, cursor_description):
@@ -575,10 +587,10 @@ class ResultMetaData(object):
         return d
 
     def _key_fallback(self, key, raiseerr=True):
-        map = self._keymap
+        map_ = self._keymap
         result = None
         if isinstance(key, util.string_types):
-            result = map.get(key if self.case_sensitive else key.lower())
+            result = map_.get(key if self.case_sensitive else key.lower())
         # fallback for targeting a ColumnElement to a textual expression
         # this is a rare use case which only occurs when matching text()
         # or colummn('name') constructs to ColumnElements, or after a
@@ -587,18 +599,18 @@ class ResultMetaData(object):
             if (
                 key._label
                 and (key._label if self.case_sensitive else key._label.lower())
-                in map
+                in map_
             ):
-                result = map[
+                result = map_[
                     key._label if self.case_sensitive else key._label.lower()
                 ]
             elif (
                 hasattr(key, "name")
                 and (key.name if self.case_sensitive else key.name.lower())
-                in map
+                in map_
             ):
                 # match is only on name.
-                result = map[
+                result = map_[
                     key.name if self.case_sensitive else key.name.lower()
                 ]
             # search extra hard to make sure this
@@ -620,7 +632,7 @@ class ResultMetaData(object):
             else:
                 return None
         else:
-            map[key] = result
+            map_[key] = result
         return result
 
     def _has_key(self, key):
diff --git a/lib/sqlalchemy/engine/strategies.py b/lib/sqlalchemy/engine/strategies.py
index 4aecb9537..e16460d86 100644
--- a/lib/sqlalchemy/engine/strategies.py
+++ b/lib/sqlalchemy/engine/strategies.py
@@ -17,10 +17,14 @@ New strategies can be added via new ``EngineStrategy`` classes.
 
 from operator import attrgetter
 
-from sqlalchemy.engine import base, threadlocal, url
-from sqlalchemy import util, event
-from sqlalchemy import pool as poollib
-from sqlalchemy.sql import schema
+from . import base
+from . import threadlocal
+from . import url
+from .. import event
+from .. import pool as poollib
+from .. import util
+from ..sql import schema
+
 
 strategies = {}
 
@@ -299,7 +303,7 @@ class MockEngineStrategy(EngineStrategy):
                 element
             )
 
-        def execute(self, object, *multiparams, **params):
+        def execute(self, object_, *multiparams, **params):
             raise NotImplementedError()
 
 
diff --git a/lib/sqlalchemy/engine/threadlocal.py b/lib/sqlalchemy/engine/threadlocal.py
index 5b2bdabc0..b34d510f7 100644
--- a/lib/sqlalchemy/engine/threadlocal.py
+++ b/lib/sqlalchemy/engine/threadlocal.py
@@ -13,10 +13,11 @@ This module is semi-private and is invoked automatically when the threadlocal
 engine strategy is used.
 """
 
-from .. import util
-from . import base
 import weakref
 
+from . import base
+from .. import util
+
 
 class TLConnection(base.Connection):
     def __init__(self, *arg, **kw):
@@ -92,8 +93,8 @@ class TLEngine(base.Engine):
     def __enter__(self):
         return self
 
-    def __exit__(self, type, value, traceback):
-        if type is None:
+    def __exit__(self, type_, value, traceback):
+        if type_ is None:
             self.commit()
         else:
             self.rollback()
diff --git a/lib/sqlalchemy/engine/url.py b/lib/sqlalchemy/engine/url.py
index e92e57b8e..f7019d74e 100644
--- a/lib/sqlalchemy/engine/url.py
+++ b/lib/sqlalchemy/engine/url.py
@@ -15,9 +15,12 @@ be used directly and is also accepted directly by ``create_engine()``.
 """
 
 import re
-from .. import exc, util
-from . import Dialect
-from ..dialects import registry, plugins
+
+from .interfaces import Dialect
+from .. import exc
+from .. import util
+from ..dialects import plugins
+from ..dialects import registry
 
 
 class URL(object):
diff --git a/lib/sqlalchemy/engine/util.py b/lib/sqlalchemy/engine/util.py
index 76bb8f4b5..bf8ec13b9 100644
--- a/lib/sqlalchemy/engine/util.py
+++ b/lib/sqlalchemy/engine/util.py
@@ -28,8 +28,8 @@ def connection_memoize(key):
 
 
 def py_fallback():
-    def _distill_params(multiparams, params):
-        """Given arguments from the calling form *multiparams, **params,
+    def _distill_params(multiparams, params):  # noqa
+        r"""Given arguments from the calling form \*multiparams, \**params,
         return a list of bind parameter structures, usually a list of
         dictionaries.
 
@@ -75,6 +75,6 @@ def py_fallback():
 
 
 try:
-    from sqlalchemy.cutils import _distill_params
+    from sqlalchemy.cutils import _distill_params  # noqa
 except ImportError:
     globals().update(py_fallback())