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

5 files changed, 153 insertions, 108 deletions

diff --git a/lib/sqlalchemy/event/api.py b/lib/sqlalchemy/event/api.py
index acfacc233..f9e04503c 100644
--- a/lib/sqlalchemy/event/api.py
+++ b/lib/sqlalchemy/event/api.py
@@ -14,8 +14,8 @@ from .. import util, exc
 from .base import _registrars
 from .registry import _EventKey
 
-CANCEL = util.symbol('CANCEL')
-NO_RETVAL = util.symbol('NO_RETVAL')
+CANCEL = util.symbol("CANCEL")
+NO_RETVAL = util.symbol("NO_RETVAL")
 
 
 def _event_key(target, identifier, fn):
@@ -24,8 +24,9 @@ def _event_key(target, identifier, fn):
         if tgt is not None:
             return _EventKey(target, identifier, fn, tgt)
     else:
-        raise exc.InvalidRequestError("No such event '%s' for target '%s'" %
-                                      (identifier, target))
+        raise exc.InvalidRequestError(
+            "No such event '%s' for target '%s'" % (identifier, target)
+        )
 
 
 def listen(target, identifier, fn, *args, **kw):
@@ -120,9 +121,11 @@ def listens_for(target, identifier, *args, **kw):
         :func:`.listen` - general description of event listening
 
     """
+
     def decorate(fn):
         listen(target, identifier, fn, *args, **kw)
         return fn
+
     return decorate
 
 
diff --git a/lib/sqlalchemy/event/attr.py b/lib/sqlalchemy/event/attr.py
index c33ec82ff..31a9f28ca 100644
--- a/lib/sqlalchemy/event/attr.py
+++ b/lib/sqlalchemy/event/attr.py
@@ -41,7 +41,7 @@ import collections
 
 
 class RefCollection(util.MemoizedSlots):
-    __slots__ = 'ref',
+    __slots__ = ("ref",)
 
     def _memoized_attr_ref(self):
         return weakref.ref(self, registry._collection_gced)
@@ -67,20 +67,27 @@ class _empty_collection(object):
 class _ClsLevelDispatch(RefCollection):
     """Class-level events on :class:`._Dispatch` classes."""
 
-    __slots__ = ('name', 'arg_names', 'has_kw',
-                 'legacy_signatures', '_clslevel', '__weakref__')
+    __slots__ = (
+        "name",
+        "arg_names",
+        "has_kw",
+        "legacy_signatures",
+        "_clslevel",
+        "__weakref__",
+    )
 
     def __init__(self, parent_dispatch_cls, fn):
         self.name = fn.__name__
         argspec = util.inspect_getargspec(fn)
         self.arg_names = argspec.args[1:]
         self.has_kw = bool(argspec.keywords)
-        self.legacy_signatures = list(reversed(
-            sorted(
-                getattr(fn, '_legacy_signatures', []),
-                key=lambda s: s[0]
+        self.legacy_signatures = list(
+            reversed(
+                sorted(
+                    getattr(fn, "_legacy_signatures", []), key=lambda s: s[0]
+                )
             )
-        ))
+        )
         fn.__doc__ = legacy._augment_fn_docs(self, parent_dispatch_cls, fn)
 
         self._clslevel = weakref.WeakKeyDictionary()
@@ -102,15 +109,18 @@ class _ClsLevelDispatch(RefCollection):
             argdict = dict(zip(self.arg_names, args))
             argdict.update(kw)
             return fn(**argdict)
+
         return wrap_kw
 
     def insert(self, event_key, propagate):
         target = event_key.dispatch_target
-        assert isinstance(target, type), \
-            "Class-level Event targets must be classes."
-        if not getattr(target, '_sa_propagate_class_events', True):
+        assert isinstance(
+            target, type
+        ), "Class-level Event targets must be classes."
+        if not getattr(target, "_sa_propagate_class_events", True):
             raise exc.InvalidRequestError(
-                "Can't assign an event directly to the %s class" % target)
+                "Can't assign an event directly to the %s class" % target
+            )
         stack = [target]
         while stack:
             cls = stack.pop(0)
@@ -125,11 +135,13 @@ class _ClsLevelDispatch(RefCollection):
 
     def append(self, event_key, propagate):
         target = event_key.dispatch_target
-        assert isinstance(target, type), \
-            "Class-level Event targets must be classes."
-        if not getattr(target, '_sa_propagate_class_events', True):
+        assert isinstance(
+            target, type
+        ), "Class-level Event targets must be classes."
+        if not getattr(target, "_sa_propagate_class_events", True):
             raise exc.InvalidRequestError(
-                "Can't assign an event directly to the %s class" % target)
+                "Can't assign an event directly to the %s class" % target
+            )
         stack = [target]
         while stack:
             cls = stack.pop(0)
@@ -143,7 +155,7 @@ class _ClsLevelDispatch(RefCollection):
         registry._stored_in_collection(event_key, self)
 
     def _assign_cls_collection(self, target):
-        if getattr(target, '_sa_propagate_class_events', True):
+        if getattr(target, "_sa_propagate_class_events", True):
             self._clslevel[target] = collections.deque()
         else:
             self._clslevel[target] = _empty_collection()
@@ -154,11 +166,9 @@ class _ClsLevelDispatch(RefCollection):
         clslevel = self._clslevel[target]
         for cls in target.__mro__[1:]:
             if cls in self._clslevel:
-                clslevel.extend([
-                    fn for fn
-                    in self._clslevel[cls]
-                    if fn not in clslevel
-                ])
+                clslevel.extend(
+                    [fn for fn in self._clslevel[cls] if fn not in clslevel]
+                )
 
     def remove(self, event_key):
         target = event_key.dispatch_target
@@ -209,7 +219,7 @@ class _EmptyListener(_InstanceLevelDispatch):
     propagate = frozenset()
     listeners = ()
 
-    __slots__ = 'parent', 'parent_listeners', 'name'
+    __slots__ = "parent", "parent_listeners", "name"
 
     def __init__(self, parent, target_cls):
         if target_cls not in parent._clslevel:
@@ -258,7 +268,7 @@ class _EmptyListener(_InstanceLevelDispatch):
 
 
 class _CompoundListener(_InstanceLevelDispatch):
-    __slots__ = '_exec_once_mutex', '_exec_once'
+    __slots__ = "_exec_once_mutex", "_exec_once"
 
     def _memoized_attr__exec_once_mutex(self):
         return threading.Lock()
@@ -306,8 +316,13 @@ class _ListenerCollection(_CompoundListener):
     """
 
     __slots__ = (
-        'parent_listeners', 'parent', 'name', 'listeners',
-        'propagate', '__weakref__')
+        "parent_listeners",
+        "parent",
+        "name",
+        "listeners",
+        "propagate",
+        "__weakref__",
+    )
 
     def __init__(self, parent, target_cls):
         if target_cls not in parent._clslevel:
@@ -335,11 +350,13 @@ class _ListenerCollection(_CompoundListener):
         existing_listeners = self.listeners
         existing_listener_set = set(existing_listeners)
         self.propagate.update(other.propagate)
-        other_listeners = [l for l
-                           in other.listeners
-                           if l not in existing_listener_set
-                           and not only_propagate or l in self.propagate
-                           ]
+        other_listeners = [
+            l
+            for l in other.listeners
+            if l not in existing_listener_set
+            and not only_propagate
+            or l in self.propagate
+        ]
 
         existing_listeners.extend(other_listeners)
 
@@ -368,7 +385,7 @@ class _ListenerCollection(_CompoundListener):
 
 
 class _JoinedListener(_CompoundListener):
-    __slots__ = 'parent', 'name', 'local', 'parent_listeners'
+    __slots__ = "parent", "name", "local", "parent_listeners"
 
     def __init__(self, parent, name, local):
         self._exec_once = False
diff --git a/lib/sqlalchemy/event/base.py b/lib/sqlalchemy/event/base.py
index 137aec258..c750be70a 100644
--- a/lib/sqlalchemy/event/base.py
+++ b/lib/sqlalchemy/event/base.py
@@ -26,7 +26,7 @@ _registrars = util.defaultdict(list)
 
 
 def _is_event_name(name):
-    return not name.startswith('_') and name != 'dispatch'
+    return not name.startswith("_") and name != "dispatch"
 
 
 class _UnpickleDispatch(object):
@@ -37,8 +37,8 @@ class _UnpickleDispatch(object):
 
     def __call__(self, _instance_cls):
         for cls in _instance_cls.__mro__:
-            if 'dispatch' in cls.__dict__:
-                return cls.__dict__['dispatch'].dispatch._for_class(
+            if "dispatch" in cls.__dict__:
+                return cls.__dict__["dispatch"].dispatch._for_class(
                     _instance_cls
                 )
         else:
@@ -67,7 +67,7 @@ class _Dispatch(object):
 
     # In one ORM edge case, an attribute is added to _Dispatch,
     # so __dict__ is used in just that case and potentially others.
-    __slots__ = '_parent', '_instance_cls', '__dict__', '_empty_listeners'
+    __slots__ = "_parent", "_instance_cls", "__dict__", "_empty_listeners"
 
     _empty_listener_reg = weakref.WeakKeyDictionary()
 
@@ -79,7 +79,9 @@ class _Dispatch(object):
             try:
                 self._empty_listeners = self._empty_listener_reg[instance_cls]
             except KeyError:
-                self._empty_listeners = self._empty_listener_reg[instance_cls] = {
+                self._empty_listeners = self._empty_listener_reg[
+                    instance_cls
+                ] = {
                     ls.name: _EmptyListener(ls, instance_cls)
                     for ls in parent._event_descriptors
                 }
@@ -122,17 +124,18 @@ class _Dispatch(object):
         :class:`._Dispatch` objects.
 
         """
-        if '_joined_dispatch_cls' not in self.__class__.__dict__:
+        if "_joined_dispatch_cls" not in self.__class__.__dict__:
             cls = type(
                 "Joined%s" % self.__class__.__name__,
-                (_JoinedDispatcher, ), {'__slots__': self._event_names}
+                (_JoinedDispatcher,),
+                {"__slots__": self._event_names},
             )
 
             self.__class__._joined_dispatch_cls = cls
         return self._joined_dispatch_cls(self, other)
 
     def __reduce__(self):
-        return _UnpickleDispatch(), (self._instance_cls, )
+        return _UnpickleDispatch(), (self._instance_cls,)
 
     def _update(self, other, only_propagate=True):
         """Populate from the listeners in another :class:`_Dispatch`
@@ -140,8 +143,9 @@ class _Dispatch(object):
         for ls in other._event_descriptors:
             if isinstance(ls, _EmptyListener):
                 continue
-            getattr(self, ls.name).\
-                for_modify(self)._update(ls, only_propagate=only_propagate)
+            getattr(self, ls.name).for_modify(self)._update(
+                ls, only_propagate=only_propagate
+            )
 
     def _clear(self):
         for ls in self._event_descriptors:
@@ -164,14 +168,15 @@ def _create_dispatcher_class(cls, classname, bases, dict_):
     # there's all kinds of ways to do this,
     # i.e. make a Dispatch class that shares the '_listen' method
     # of the Event class, this is the straight monkeypatch.
-    if hasattr(cls, 'dispatch'):
+    if hasattr(cls, "dispatch"):
         dispatch_base = cls.dispatch.__class__
     else:
         dispatch_base = _Dispatch
 
     event_names = [k for k in dict_ if _is_event_name(k)]
-    dispatch_cls = type("%sDispatch" % classname,
-                        (dispatch_base, ), {'__slots__': event_names})
+    dispatch_cls = type(
+        "%sDispatch" % classname, (dispatch_base,), {"__slots__": event_names}
+    )
 
     dispatch_cls._event_names = event_names
 
@@ -186,7 +191,7 @@ def _create_dispatcher_class(cls, classname, bases, dict_):
                 setattr(dispatch_inst, ls.name, ls)
                 dispatch_cls._event_names.append(ls.name)
 
-    if getattr(cls, '_dispatch_target', None):
+    if getattr(cls, "_dispatch_target", None):
         cls._dispatch_target.dispatch = dispatcher(cls)
 
 
@@ -221,12 +226,14 @@ class Events(util.with_metaclass(_EventMeta, object)):
 
         # Mapper, ClassManager, Session override this to
         # also accept classes, scoped_sessions, sessionmakers, etc.
-        if hasattr(target, 'dispatch'):
+        if hasattr(target, "dispatch"):
             if (
                 dispatch_is(cls.dispatch.__class__)
                 or dispatch_is(type, cls.dispatch.__class__)
-                or (dispatch_is(_JoinedDispatcher)
-                    and dispatch_parent_is(cls.dispatch.__class__))
+                or (
+                    dispatch_is(_JoinedDispatcher)
+                    and dispatch_parent_is(cls.dispatch.__class__)
+                )
             ):
                 return target
 
@@ -246,7 +253,7 @@ class Events(util.with_metaclass(_EventMeta, object)):
 class _JoinedDispatcher(object):
     """Represent a connection between two _Dispatch objects."""
 
-    __slots__ = 'local', 'parent', '_instance_cls'
+    __slots__ = "local", "parent", "_instance_cls"
 
     def __init__(self, local, parent):
         self.local = local
@@ -281,5 +288,5 @@ class dispatcher(object):
     def __get__(self, obj, cls):
         if obj is None:
             return self.dispatch
-        obj.__dict__['dispatch'] = disp = self.dispatch._for_instance(obj)
+        obj.__dict__["dispatch"] = disp = self.dispatch._for_instance(obj)
         return disp
diff --git a/lib/sqlalchemy/event/legacy.py b/lib/sqlalchemy/event/legacy.py
index 1883070f4..c30b922fd 100644
--- a/lib/sqlalchemy/event/legacy.py
+++ b/lib/sqlalchemy/event/legacy.py
@@ -15,10 +15,11 @@ from .. import util
 
 def _legacy_signature(since, argnames, converter=None):
     def leg(fn):
-        if not hasattr(fn, '_legacy_signatures'):
+        if not hasattr(fn, "_legacy_signatures"):
             fn._legacy_signatures = []
         fn._legacy_signatures.append((since, argnames, converter))
         return fn
+
     return leg
 
 
@@ -30,15 +31,18 @@ def _wrap_fn_for_legacy(dispatch_collection, fn, argspec):
         else:
             has_kw = False
 
-        if len(argnames) == len(argspec.args) \
-                and has_kw is bool(argspec.keywords):
+        if len(argnames) == len(argspec.args) and has_kw is bool(
+            argspec.keywords
+        ):
 
             if conv:
                 assert not has_kw
 
                 def wrap_leg(*args):
                     return fn(*conv(*args))
+
             else:
+
                 def wrap_leg(*args, **kw):
                     argdict = dict(zip(dispatch_collection.arg_names, args))
                     args = [argdict[name] for name in argnames]
@@ -46,16 +50,14 @@ def _wrap_fn_for_legacy(dispatch_collection, fn, argspec):
                         return fn(*args, **kw)
                     else:
                         return fn(*args)
+
             return wrap_leg
     else:
         return fn
 
 
 def _indent(text, indent):
-    return "\n".join(
-        indent + line
-        for line in text.split("\n")
-    )
+    return "\n".join(indent + line for line in text.split("\n"))
 
 
 def _standard_listen_example(dispatch_collection, sample_target, fn):
@@ -64,10 +66,13 @@ def _standard_listen_example(dispatch_collection, sample_target, fn):
             "%(arg)s = kw['%(arg)s']" % {"arg": arg}
             for arg in dispatch_collection.arg_names[0:2]
         ),
-        "    ")
+        "    ",
+    )
     if dispatch_collection.legacy_signatures:
-        current_since = max(since for since, args, conv
-                            in dispatch_collection.legacy_signatures)
+        current_since = max(
+            since
+            for since, args, conv in dispatch_collection.legacy_signatures
+        )
     else:
         current_since = None
     text = (
@@ -82,7 +87,6 @@ def _standard_listen_example(dispatch_collection, sample_target, fn):
 
     if len(dispatch_collection.arg_names) > 3:
         text += (
-
             "\n# named argument style (new in 0.9)\n"
             "@event.listens_for("
             "%(sample_target)s, '%(event_name)s', named=True)\n"
@@ -93,13 +97,14 @@ def _standard_listen_example(dispatch_collection, sample_target, fn):
         )
 
     text %= {
-        "current_since": " (arguments as of %s)" %
-        current_since if current_since else "",
+        "current_since": " (arguments as of %s)" % current_since
+        if current_since
+        else "",
         "event_name": fn.__name__,
         "has_kw_arguments": ", **kw" if dispatch_collection.has_kw else "",
         "named_event_arguments": ", ".join(dispatch_collection.arg_names),
         "example_kw_arg": example_kw_arg,
-        "sample_target": sample_target
+        "sample_target": sample_target,
     }
     return text
 
@@ -113,13 +118,15 @@ def _legacy_listen_examples(dispatch_collection, sample_target, fn):
             "def receive_%(event_name)s("
             "%(named_event_arguments)s%(has_kw_arguments)s):\n"
             "    \"listen for the '%(event_name)s' event\"\n"
-            "\n    # ... (event handling logic) ...\n" % {
+            "\n    # ... (event handling logic) ...\n"
+            % {
                 "since": since,
                 "event_name": fn.__name__,
                 "has_kw_arguments": " **kw"
-                if dispatch_collection.has_kw else "",
+                if dispatch_collection.has_kw
+                else "",
                 "named_event_arguments": ", ".join(args),
-                "sample_target": sample_target
+                "sample_target": sample_target,
             }
         )
     return text
@@ -133,37 +140,34 @@ def _version_signature_changes(dispatch_collection):
         "    arguments ``%(named_event_arguments)s%(has_kw_arguments)s``.\n"
         "    Listener functions which accept the previous argument \n"
         "    signature(s) listed above will be automatically \n"
-        "    adapted to the new signature." % {
+        "    adapted to the new signature."
+        % {
             "since": since,
             "event_name": dispatch_collection.name,
             "named_event_arguments": ", ".join(dispatch_collection.arg_names),
-            "has_kw_arguments": ", **kw" if dispatch_collection.has_kw else ""
+            "has_kw_arguments": ", **kw" if dispatch_collection.has_kw else "",
         }
     )
 
 
 def _augment_fn_docs(dispatch_collection, parent_dispatch_cls, fn):
-    header = ".. container:: event_signatures\n\n"\
-        "     Example argument forms::\n"\
+    header = (
+        ".. container:: event_signatures\n\n"
+        "     Example argument forms::\n"
         "\n"
+    )
 
     sample_target = getattr(parent_dispatch_cls, "_target_class_doc", "obj")
-    text = (
-        header +
-        _indent(
-            _standard_listen_example(
-                dispatch_collection, sample_target, fn),
-            " " * 8)
+    text = header + _indent(
+        _standard_listen_example(dispatch_collection, sample_target, fn),
+        " " * 8,
     )
     if dispatch_collection.legacy_signatures:
         text += _indent(
-            _legacy_listen_examples(
-                dispatch_collection, sample_target, fn),
-            " " * 8)
+            _legacy_listen_examples(dispatch_collection, sample_target, fn),
+            " " * 8,
+        )
 
         text += _version_signature_changes(dispatch_collection)
 
-    return util.inject_docstring_text(fn.__doc__,
-                                      text,
-                                      1
-                                      )
+    return util.inject_docstring_text(fn.__doc__, text, 1)
diff --git a/lib/sqlalchemy/event/registry.py b/lib/sqlalchemy/event/registry.py
index 8d4bada0b..c862ae403 100644
--- a/lib/sqlalchemy/event/registry.py
+++ b/lib/sqlalchemy/event/registry.py
@@ -141,11 +141,15 @@ class _EventKey(object):
     """
 
     __slots__ = (
-        'target', 'identifier', 'fn', 'fn_key', 'fn_wrap', 'dispatch_target'
+        "target",
+        "identifier",
+        "fn",
+        "fn_key",
+        "fn_wrap",
+        "dispatch_target",
     )
 
-    def __init__(self, target, identifier,
-                 fn, dispatch_target, _fn_wrap=None):
+    def __init__(self, target, identifier, fn, dispatch_target, _fn_wrap=None):
         self.target = target
         self.identifier = identifier
         self.fn = fn
@@ -169,7 +173,7 @@ class _EventKey(object):
                 self.identifier,
                 self.fn,
                 self.dispatch_target,
-                _fn_wrap=fn_wrap
+                _fn_wrap=fn_wrap,
             )
 
     def with_dispatch_target(self, dispatch_target):
@@ -181,15 +185,18 @@ class _EventKey(object):
                 self.identifier,
                 self.fn,
                 dispatch_target,
-                _fn_wrap=self.fn_wrap
+                _fn_wrap=self.fn_wrap,
             )
 
     def listen(self, *args, **kw):
         once = kw.pop("once", False)
         named = kw.pop("named", False)
 
-        target, identifier, fn = \
-            self.dispatch_target, self.identifier, self._listen_fn
+        target, identifier, fn = (
+            self.dispatch_target,
+            self.identifier,
+            self._listen_fn,
+        )
 
         dispatch_collection = getattr(target.dispatch, identifier)
 
@@ -198,8 +205,9 @@ class _EventKey(object):
         self = self.with_wrapper(adjusted_fn)
 
         if once:
-            self.with_wrapper(
-                util.only_once(self._listen_fn)).listen(*args, **kw)
+            self.with_wrapper(util.only_once(self._listen_fn)).listen(
+                *args, **kw
+            )
         else:
             self.dispatch_target.dispatch._listen(self, *args, **kw)
 
@@ -208,8 +216,8 @@ class _EventKey(object):
 
         if key not in _key_to_collection:
             raise exc.InvalidRequestError(
-                "No listeners found for event %s / %r / %s " %
-                (self.target, self.identifier, self.fn)
+                "No listeners found for event %s / %r / %s "
+                % (self.target, self.identifier, self.fn)
             )
         dispatch_reg = _key_to_collection.pop(key)
 
@@ -224,20 +232,26 @@ class _EventKey(object):
         """
         return self._key in _key_to_collection
 
-    def base_listen(self, propagate=False, insert=False,
-                    named=False, retval=None):
+    def base_listen(
+        self, propagate=False, insert=False, named=False, retval=None
+    ):
 
-        target, identifier, fn = \
-            self.dispatch_target, self.identifier, self._listen_fn
+        target, identifier, fn = (
+            self.dispatch_target,
+            self.identifier,
+            self._listen_fn,
+        )
 
         dispatch_collection = getattr(target.dispatch, identifier)
 
         if insert:
-            dispatch_collection.\
-                for_modify(target.dispatch).insert(self, propagate)
+            dispatch_collection.for_modify(target.dispatch).insert(
+                self, propagate
+            )
         else:
-            dispatch_collection.\
-                for_modify(target.dispatch).append(self, propagate)
+            dispatch_collection.for_modify(target.dispatch).append(
+                self, propagate
+            )
 
     @property
     def _listen_fn(self):