- apply pep8 formatting to sqlalchemy/sql, sqlalchemy/util, sqlalchemy/dialects,

sqlalchemy/orm, sqlalchemy/event, sqlalchemy/testing

5 files changed, 119 insertions, 98 deletions

diff --git a/lib/sqlalchemy/event/api.py b/lib/sqlalchemy/event/api.py
index ddbf05cfe..270e95c9c 100644
--- a/lib/sqlalchemy/event/api.py
+++ b/lib/sqlalchemy/event/api.py
@@ -25,7 +25,8 @@ def _event_key(target, identifier, fn):
             return _EventKey(target, identifier, fn, tgt)
     else:
         raise exc.InvalidRequestError("No such event '%s' for target '%s'" %
-                                (identifier, target))
+                                      (identifier, target))
+
 
 def listen(target, identifier, fn, *args, **kw):
     """Register a listener function for the given target.
@@ -114,14 +115,15 @@ def remove(target, identifier, fn):
         event.remove(SomeMappedClass, "before_insert", my_listener_function)
 
     Above, the listener function associated with ``SomeMappedClass`` was also
-    propagated to subclasses of ``SomeMappedClass``; the :func:`.remove` function
-    will revert all of these operations.
+    propagated to subclasses of ``SomeMappedClass``; the :func:`.remove`
+    function will revert all of these operations.
 
     .. versionadded:: 0.9.0
 
     """
     _event_key(target, identifier, fn).remove()
 
+
 def contains(target, identifier, fn):
     """Return True if the given target/ident/fn is set up to listen.
 
diff --git a/lib/sqlalchemy/event/attr.py b/lib/sqlalchemy/event/attr.py
index 57adc4208..7641b595a 100644
--- a/lib/sqlalchemy/event/attr.py
+++ b/lib/sqlalchemy/event/attr.py
@@ -44,6 +44,7 @@ class RefCollection(object):
     def ref(self):
         return weakref.ref(self, registry._collection_gced)
 
+
 class _DispatchDescriptor(RefCollection):
     """Class-level attributes on :class:`._Dispatch` classes."""
 
@@ -53,13 +54,13 @@ class _DispatchDescriptor(RefCollection):
         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]
-                        )
-                    ))
+            sorted(
+                getattr(fn, '_legacy_signatures', []),
+                key=lambda s: s[0]
+            )
+        ))
         self.__doc__ = fn.__doc__ = legacy._augment_fn_docs(
-                                        self, parent_dispatch_cls, fn)
+            self, parent_dispatch_cls, fn)
 
         self._clslevel = weakref.WeakKeyDictionary()
         self._empty_listeners = weakref.WeakKeyDictionary()
@@ -83,11 +84,10 @@ class _DispatchDescriptor(RefCollection):
             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."
+            "Class-level Event targets must be classes."
         stack = [target]
         while stack:
             cls = stack.pop(0)
@@ -103,7 +103,7 @@ class _DispatchDescriptor(RefCollection):
     def append(self, event_key, propagate):
         target = event_key.dispatch_target
         assert isinstance(target, type), \
-                "Class-level Event targets must be classes."
+            "Class-level Event targets must be classes."
 
         stack = [target]
         while stack:
@@ -170,10 +170,12 @@ class _DispatchDescriptor(RefCollection):
         obj.__dict__[self.__name__] = ret
         return ret
 
+
 class _HasParentDispatchDescriptor(object):
     def _adjust_fn_spec(self, fn, named):
         return self.parent._adjust_fn_spec(fn, named)
 
+
 class _EmptyListener(_HasParentDispatchDescriptor):
     """Serves as a class-level interface to the events
     served by a _DispatchDescriptor, when there are no
@@ -183,6 +185,7 @@ class _EmptyListener(_HasParentDispatchDescriptor):
     events are added.
 
     """
+
     def __init__(self, parent, target_cls):
         if target_cls not in parent._clslevel:
             parent.update_subclass(target_cls)
@@ -192,7 +195,6 @@ class _EmptyListener(_HasParentDispatchDescriptor):
         self.propagate = frozenset()
         self.listeners = ()
 
-
     def for_modify(self, obj):
         """Return an event collection which can be modified.
 
@@ -268,6 +270,7 @@ class _CompoundListener(_HasParentDispatchDescriptor):
 
     __nonzero__ = __bool__
 
+
 class _ListenerCollection(RefCollection, _CompoundListener):
     """Instance-level attributes on instances of :class:`._Dispatch`.
 
@@ -304,10 +307,10 @@ class _ListenerCollection(RefCollection, _CompoundListener):
         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
-                ]
+                           in other.listeners
+                           if l not in existing_listener_set
+                           and not only_propagate or l in self.propagate
+                           ]
 
         existing_listeners.extend(other_listeners)
 
@@ -346,9 +349,9 @@ class _JoinedDispatchDescriptor(object):
             return self
         else:
             obj.__dict__[self.name] = ret = _JoinedListener(
-                        obj.parent, self.name,
-                        getattr(obj.local, self.name)
-                    )
+                obj.parent, self.name,
+                getattr(obj.local, self.name)
+            )
             return ret
 
 
@@ -383,5 +386,3 @@ class _JoinedListener(_CompoundListener):
 
     def clear(self):
         raise NotImplementedError()
-
-
diff --git a/lib/sqlalchemy/event/base.py b/lib/sqlalchemy/event/base.py
index 3aacee2eb..4925f6ffa 100644
--- a/lib/sqlalchemy/event/base.py
+++ b/lib/sqlalchemy/event/base.py
@@ -18,7 +18,8 @@ instances of ``_Dispatch``.
 from __future__ import absolute_import
 
 from .. import util
-from .attr import _JoinedDispatchDescriptor, _EmptyListener, _DispatchDescriptor
+from .attr import _JoinedDispatchDescriptor, \
+    _EmptyListener, _DispatchDescriptor
 
 _registrars = util.defaultdict(list)
 
@@ -32,6 +33,7 @@ class _UnpickleDispatch(object):
     :class:`_Dispatch` given a particular :class:`.Events` subclass.
 
     """
+
     def __call__(self, _parent_cls):
         for cls in _parent_cls.__mro__:
             if 'dispatch' in cls.__dict__:
@@ -80,9 +82,9 @@ class _Dispatch(object):
         """
         if '_joined_dispatch_cls' not in self.__class__.__dict__:
             cls = type(
-                    "Joined%s" % self.__class__.__name__,
-                    (_JoinedDispatcher, self.__class__), {}
-                )
+                "Joined%s" % self.__class__.__name__,
+                (_JoinedDispatcher, self.__class__), {}
+            )
             for ls in _event_descriptors(self):
                 setattr(cls, ls.name, _JoinedDispatchDescriptor(ls.name))
 
@@ -131,7 +133,7 @@ def _create_dispatcher_class(cls, classname, bases, dict_):
     # of the Event class, this is the straight monkeypatch.
     dispatch_base = getattr(cls, 'dispatch', _Dispatch)
     dispatch_cls = type("%sDispatch" % classname,
-                                        (dispatch_base, ), {})
+                        (dispatch_base, ), {})
     cls._set_dispatch(cls, dispatch_cls)
 
     for k in dict_:
@@ -150,6 +152,7 @@ def _remove_dispatcher(cls):
             if not _registrars[k]:
                 del _registrars[k]
 
+
 class Events(util.with_metaclass(_EventMeta, object)):
     """Define event listening functions for a particular target type."""
 
@@ -163,16 +166,15 @@ class Events(util.with_metaclass(_EventMeta, object)):
         cls.dispatch = dispatch_cls
         dispatch_cls._events = cls
 
-
     @classmethod
     def _accept_with(cls, target):
         # Mapper, ClassManager, Session override this to
         # also accept classes, scoped_sessions, sessionmakers, etc.
         if hasattr(target, 'dispatch') and (
-                    isinstance(target.dispatch, cls.dispatch) or \
-                    isinstance(target.dispatch, type) and \
-                    issubclass(target.dispatch, cls.dispatch)
-                ):
+            isinstance(target.dispatch, cls.dispatch) or
+            isinstance(target.dispatch, type) and
+            issubclass(target.dispatch, cls.dispatch)
+        ):
             return target
         else:
             return None
@@ -206,6 +208,7 @@ class dispatcher(object):
     instances.
 
     """
+
     def __init__(self, events):
         self.dispatch_cls = events.dispatch
         self.events = events
@@ -215,4 +218,3 @@ class dispatcher(object):
             return self.dispatch_cls
         obj.__dict__['dispatch'] = disp = self.dispatch_cls(cls)
         return disp
-
diff --git a/lib/sqlalchemy/event/legacy.py b/lib/sqlalchemy/event/legacy.py
index fc3aa288e..3b1519cb6 100644
--- a/lib/sqlalchemy/event/legacy.py
+++ b/lib/sqlalchemy/event/legacy.py
@@ -12,6 +12,7 @@ generation of deprecation notes and docstrings.
 
 from .. import util
 
+
 def _legacy_signature(since, argnames, converter=None):
     def leg(fn):
         if not hasattr(fn, '_legacy_signatures'):
@@ -20,6 +21,7 @@ def _legacy_signature(since, argnames, converter=None):
         return fn
     return leg
 
+
 def _wrap_fn_for_legacy(dispatch_descriptor, fn, argspec):
     for since, argnames, conv in dispatch_descriptor.legacy_signatures:
         if argnames[-1] == "**kw":
@@ -29,10 +31,11 @@ def _wrap_fn_for_legacy(dispatch_descriptor, fn, argspec):
             has_kw = False
 
         if len(argnames) == len(argspec.args) \
-            and has_kw is bool(argspec.keywords):
+                and has_kw is bool(argspec.keywords):
 
             if conv:
                 assert not has_kw
+
                 def wrap_leg(*args):
                     return fn(*conv(*args))
             else:
@@ -47,38 +50,42 @@ def _wrap_fn_for_legacy(dispatch_descriptor, fn, argspec):
     else:
         return fn
 
+
 def _indent(text, indent):
     return "\n".join(
-                indent + line
-                for line in text.split("\n")
-            )
+        indent + line
+        for line in text.split("\n")
+    )
+
 
 def _standard_listen_example(dispatch_descriptor, sample_target, fn):
     example_kw_arg = _indent(
-            "\n".join(
-                "%(arg)s = kw['%(arg)s']" % {"arg": arg}
-                for arg in dispatch_descriptor.arg_names[0:2]
-            ),
-            "    ")
+        "\n".join(
+            "%(arg)s = kw['%(arg)s']" % {"arg": arg}
+            for arg in dispatch_descriptor.arg_names[0:2]
+        ),
+        "    ")
     if dispatch_descriptor.legacy_signatures:
         current_since = max(since for since, args, conv
                             in dispatch_descriptor.legacy_signatures)
     else:
         current_since = None
     text = (
-            "from sqlalchemy import event\n\n"
-            "# standard decorator style%(current_since)s\n"
-            "@event.listens_for(%(sample_target)s, '%(event_name)s')\n"
-            "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"
+        "from sqlalchemy import event\n\n"
+        "# standard decorator style%(current_since)s\n"
+        "@event.listens_for(%(sample_target)s, '%(event_name)s')\n"
+        "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"
     )
 
     if len(dispatch_descriptor.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"
+            "@event.listens_for("
+            "%(sample_target)s, '%(event_name)s', named=True)\n"
             "def receive_%(event_name)s(**kw):\n"
             "    \"listen for the '%(event_name)s' event\"\n"
             "%(example_kw_arg)s\n"
@@ -86,72 +93,77 @@ def _standard_listen_example(dispatch_descriptor, sample_target, fn):
         )
 
     text %= {
-                "current_since": " (arguments as of %s)" %
-                                current_since if current_since else "",
-                "event_name": fn.__name__,
-                "has_kw_arguments": ", **kw" if dispatch_descriptor.has_kw else "",
-                "named_event_arguments": ", ".join(dispatch_descriptor.arg_names),
-                "example_kw_arg": example_kw_arg,
-                "sample_target": sample_target
-            }
+        "current_since": " (arguments as of %s)" %
+        current_since if current_since else "",
+        "event_name": fn.__name__,
+        "has_kw_arguments": ", **kw" if dispatch_descriptor.has_kw else "",
+        "named_event_arguments": ", ".join(dispatch_descriptor.arg_names),
+        "example_kw_arg": example_kw_arg,
+        "sample_target": sample_target
+    }
     return text
 
+
 def _legacy_listen_examples(dispatch_descriptor, sample_target, fn):
     text = ""
     for since, args, conv in dispatch_descriptor.legacy_signatures:
         text += (
             "\n# legacy calling style (pre-%(since)s)\n"
             "@event.listens_for(%(sample_target)s, '%(event_name)s')\n"
-            "def receive_%(event_name)s(%(named_event_arguments)s%(has_kw_arguments)s):\n"
+            "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" % {
                 "since": since,
                 "event_name": fn.__name__,
-                "has_kw_arguments": " **kw" if dispatch_descriptor.has_kw else "",
+                "has_kw_arguments": " **kw"
+                if dispatch_descriptor.has_kw else "",
                 "named_event_arguments": ", ".join(args),
                 "sample_target": sample_target
             }
         )
     return text
 
+
 def _version_signature_changes(dispatch_descriptor):
     since, args, conv = dispatch_descriptor.legacy_signatures[0]
     return (
-            "\n.. versionchanged:: %(since)s\n"
-            "    The ``%(event_name)s`` event now accepts the \n"
-            "    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." % {
-                "since": since,
-                "event_name": dispatch_descriptor.__name__,
-                "named_event_arguments": ", ".join(dispatch_descriptor.arg_names),
-                "has_kw_arguments": ", **kw" if dispatch_descriptor.has_kw else ""
-            }
-        )
+        "\n.. versionchanged:: %(since)s\n"
+        "    The ``%(event_name)s`` event now accepts the \n"
+        "    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." % {
+            "since": since,
+            "event_name": dispatch_descriptor.__name__,
+            "named_event_arguments": ", ".join(dispatch_descriptor.arg_names),
+            "has_kw_arguments": ", **kw" if dispatch_descriptor.has_kw else ""
+        }
+    )
+
 
 def _augment_fn_docs(dispatch_descriptor, parent_dispatch_cls, fn):
     header = ".. container:: event_signatures\n\n"\
-            "     Example argument forms::\n"\
-            "\n"
+        "     Example argument forms::\n"\
+        "\n"
 
     sample_target = getattr(parent_dispatch_cls, "_target_class_doc", "obj")
     text = (
-            header +
-            _indent(
-                        _standard_listen_example(
-                                    dispatch_descriptor, sample_target, fn),
-                        " " * 8)
-        )
+        header +
+        _indent(
+            _standard_listen_example(
+                dispatch_descriptor, sample_target, fn),
+            " " * 8)
+    )
     if dispatch_descriptor.legacy_signatures:
         text += _indent(
-                        _legacy_listen_examples(
-                                    dispatch_descriptor, sample_target, fn),
-                        " " * 8)
+            _legacy_listen_examples(
+                dispatch_descriptor, sample_target, fn),
+            " " * 8)
 
         text += _version_signature_changes(dispatch_descriptor)
 
     return util.inject_docstring_text(fn.__doc__,
-            text,
-            1
-        )
+                                      text,
+                                      1
+                                      )
diff --git a/lib/sqlalchemy/event/registry.py b/lib/sqlalchemy/event/registry.py
index 11f5cb579..a34de3cd7 100644
--- a/lib/sqlalchemy/event/registry.py
+++ b/lib/sqlalchemy/event/registry.py
@@ -47,6 +47,7 @@ ref(listenercollection) -> {
                         }
 """
 
+
 def _collection_gced(ref):
     # defaultdict, so can't get a KeyError
     if not _collection_to_key or ref not in _collection_to_key:
@@ -60,6 +61,7 @@ def _collection_gced(ref):
             if not dispatch_reg:
                 _key_to_collection.pop(key)
 
+
 def _stored_in_collection(event_key, owner):
     key = event_key._key
 
@@ -76,6 +78,7 @@ def _stored_in_collection(event_key, owner):
     listener_to_key = _collection_to_key[owner_ref]
     listener_to_key[listen_ref] = key
 
+
 def _removed_from_collection(event_key, owner):
     key = event_key._key
 
@@ -92,6 +95,7 @@ def _removed_from_collection(event_key, owner):
         listener_to_key = _collection_to_key[owner_ref]
         listener_to_key.pop(listen_ref)
 
+
 def _stored_in_collection_multi(newowner, oldowner, elements):
     if not elements:
         return
@@ -113,6 +117,7 @@ def _stored_in_collection_multi(newowner, oldowner, elements):
 
         new_listener_to_key[listen_ref] = key
 
+
 def _clear(owner, elements):
     if not elements:
         return
@@ -133,8 +138,8 @@ class _EventKey(object):
     """Represent :func:`.listen` arguments.
     """
 
-
-    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
@@ -159,7 +164,7 @@ class _EventKey(object):
                 self.fn,
                 self.dispatch_target,
                 _fn_wrap=fn_wrap
-                )
+            )
 
     def with_dispatch_target(self, dispatch_target):
         if dispatch_target is self.dispatch_target:
@@ -171,12 +176,13 @@ class _EventKey(object):
                 self.fn,
                 dispatch_target,
                 _fn_wrap=self.fn_wrap
-                )
+            )
 
     def listen(self, *args, **kw):
         once = kw.pop("once", False)
         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)
 
@@ -185,9 +191,9 @@ 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)
 
         for collection_ref, listener_ref in dispatch_reg.items():
@@ -202,7 +208,7 @@ class _EventKey(object):
         return self._key in _key_to_collection
 
     def base_listen(self, propagate=False, insert=False,
-                            named=False):
+                    named=False):
 
         target, identifier, fn = \
             self.dispatch_target, self.identifier, self._listen_fn
@@ -214,10 +220,10 @@ class _EventKey(object):
 
         if insert:
             dispatch_descriptor.\
-                    for_modify(target.dispatch).insert(self, propagate)
+                for_modify(target.dispatch).insert(self, propagate)
         else:
             dispatch_descriptor.\
-                    for_modify(target.dispatch).append(self, propagate)
+                for_modify(target.dispatch).append(self, propagate)
 
     @property
     def _listen_fn(self):
@@ -238,5 +244,3 @@ class _EventKey(object):
     def prepend_to_list(self, owner, list_):
         _stored_in_collection(self, owner)
         list_.insert(0, self._listen_fn)
-
-