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

sqlalchemy/orm, sqlalchemy/event, sqlalchemy/testing

1 files changed, 64 insertions, 62 deletions

diff --git a/lib/sqlalchemy/orm/unitofwork.py b/lib/sqlalchemy/orm/unitofwork.py
index b7f739ec5..71e61827b 100644
--- a/lib/sqlalchemy/orm/unitofwork.py
+++ b/lib/sqlalchemy/orm/unitofwork.py
@@ -56,16 +56,16 @@ def track_cascade_events(descriptor, prop):
 
             if sess._warn_on_events:
                 sess._flush_warning(
-                        "collection remove"
-                        if prop.uselist
-                        else "related attribute delete")
+                    "collection remove"
+                    if prop.uselist
+                    else "related attribute delete")
 
             # expunge pending orphans
             item_state = attributes.instance_state(item)
             if prop._cascade.delete_orphan and \
                 item_state in sess._new and \
                     prop.mapper._is_orphan(item_state):
-                    sess.expunge(item)
+                sess.expunge(item)
 
     def set_(state, newvalue, oldvalue, initiator):
         # process "save_update" cascade rules for when an instance
@@ -83,8 +83,8 @@ def track_cascade_events(descriptor, prop):
             if newvalue is not None:
                 newvalue_state = attributes.instance_state(newvalue)
                 if prop._cascade.save_update and \
-                    (prop.cascade_backrefs or key == initiator.key) and \
-                    not sess._contains_state(newvalue_state):
+                        (prop.cascade_backrefs or key == initiator.key) and \
+                        not sess._contains_state(newvalue_state):
                     sess._save_or_update_state(newvalue_state)
 
             if oldvalue is not None and \
@@ -95,7 +95,7 @@ def track_cascade_events(descriptor, prop):
                 oldvalue_state = attributes.instance_state(oldvalue)
 
                 if oldvalue_state in sess._new and \
-                    prop.mapper._is_orphan(oldvalue_state):
+                        prop.mapper._is_orphan(oldvalue_state):
                     sess.expunge(oldvalue)
         return newvalue
 
@@ -175,7 +175,7 @@ class UOWTransaction(object):
         self.states[state] = (isdelete, True)
 
     def get_attribute_history(self, state, key,
-                            passive=attributes.PASSIVE_NO_INITIALIZE):
+                              passive=attributes.PASSIVE_NO_INITIALIZE):
         """facade to attributes.get_state_history(), including
         caching of results."""
 
@@ -191,11 +191,11 @@ class UOWTransaction(object):
             # we want non-passive, do a non-passive lookup and re-cache
 
             if not cached_passive & attributes.SQL_OK \
-                and passive & attributes.SQL_OK:
+                    and passive & attributes.SQL_OK:
                 impl = state.manager[key].impl
                 history = impl.get_history(state, state.dict,
-                                    attributes.PASSIVE_OFF |
-                                    attributes.LOAD_AGAINST_COMMITTED)
+                                           attributes.PASSIVE_OFF |
+                                           attributes.LOAD_AGAINST_COMMITTED)
                 if history and impl.uses_objects:
                     state_history = history.as_state()
                 else:
@@ -206,13 +206,13 @@ class UOWTransaction(object):
             # TODO: store the history as (state, object) tuples
             # so we don't have to keep converting here
             history = impl.get_history(state, state.dict, passive |
-                                attributes.LOAD_AGAINST_COMMITTED)
+                                       attributes.LOAD_AGAINST_COMMITTED)
             if history and impl.uses_objects:
                 state_history = history.as_state()
             else:
                 state_history = history
             self.attributes[hashkey] = (history, state_history,
-                    passive)
+                                        passive)
 
         return state_history
 
@@ -225,13 +225,13 @@ class UOWTransaction(object):
             self.presort_actions[key] = Preprocess(processor, fromparent)
 
     def register_object(self, state, isdelete=False,
-                            listonly=False, cancel_delete=False,
-                            operation=None, prop=None):
+                        listonly=False, cancel_delete=False,
+                        operation=None, prop=None):
         if not self.session._contains_state(state):
             if not state.deleted and operation is not None:
                 util.warn("Object of type %s not in session, %s operation "
-                            "along '%s' will not proceed" %
-                            (orm_util.state_class_str(state), operation, prop))
+                          "along '%s' will not proceed" %
+                          (orm_util.state_class_str(state), operation, prop))
             return False
 
         if state not in self.states:
@@ -278,8 +278,8 @@ class UOWTransaction(object):
 
         """
         return util.PopulateDict(
-                    lambda tup: tup[0]._props.get(tup[1].key) is tup[1].prop
-                )
+            lambda tup: tup[0]._props.get(tup[1].key) is tup[1].prop
+        )
 
     def filter_states_for_dep(self, dep, states):
         """Filter the given list of InstanceStates to those relevant to the
@@ -314,8 +314,8 @@ class UOWTransaction(object):
 
         # see if the graph of mapper dependencies has cycles.
         self.cycles = cycles = topological.find_cycles(
-                                        self.dependencies,
-                                        list(self.postsort_actions.values()))
+            self.dependencies,
+            list(self.postsort_actions.values()))
 
         if cycles:
             # if yes, break the per-mapper actions into
@@ -330,8 +330,8 @@ class UOWTransaction(object):
             # that were broken up.
             for edge in list(self.dependencies):
                 if None in edge or \
-                    edge[0].disabled or edge[1].disabled or \
-                    cycles.issuperset(edge):
+                        edge[0].disabled or edge[1].disabled or \
+                        cycles.issuperset(edge):
                     self.dependencies.remove(edge)
                 elif edge[0] in cycles:
                     self.dependencies.remove(edge)
@@ -345,30 +345,30 @@ class UOWTransaction(object):
         return set([a for a in self.postsort_actions.values()
                     if not a.disabled
                     ]
-                ).difference(cycles)
+                   ).difference(cycles)
 
     def execute(self):
         postsort_actions = self._generate_actions()
 
-        #sort = topological.sort(self.dependencies, postsort_actions)
-        #print "--------------"
-        #print "\ndependencies:", self.dependencies
-        #print "\ncycles:", self.cycles
-        #print "\nsort:", list(sort)
-        #print "\nCOUNT OF POSTSORT ACTIONS", len(postsort_actions)
+        # sort = topological.sort(self.dependencies, postsort_actions)
+        # print "--------------"
+        # print "\ndependencies:", self.dependencies
+        # print "\ncycles:", self.cycles
+        # print "\nsort:", list(sort)
+        # print "\nCOUNT OF POSTSORT ACTIONS", len(postsort_actions)
 
         # execute
         if self.cycles:
             for set_ in topological.sort_as_subsets(
-                                            self.dependencies,
-                                            postsort_actions):
+                    self.dependencies,
+                    postsort_actions):
                 while set_:
                     n = set_.pop()
                     n.execute_aggregate(self, set_)
         else:
             for rec in topological.sort(
-                                    self.dependencies,
-                                    postsort_actions):
+                    self.dependencies,
+                    postsort_actions):
                 rec.execute(self)
 
     def finalize_flush_changes(self):
@@ -430,11 +430,11 @@ class Preprocess(IterateMappersMixin):
 
         if (delete_states or save_states):
             if not self.setup_flush_actions and (
-                    self.dependency_processor.\
-                            prop_has_changes(uow, delete_states, True) or
-                    self.dependency_processor.\
-                            prop_has_changes(uow, save_states, False)
-                ):
+                    self.dependency_processor.
+                    prop_has_changes(uow, delete_states, True) or
+                    self.dependency_processor.
+                    prop_has_changes(uow, save_states, False)
+            ):
                 self.dependency_processor.per_property_flush_actions(uow)
                 self.setup_flush_actions = True
             return True
@@ -451,8 +451,8 @@ class PostSortRec(object):
             return uow.postsort_actions[key]
         else:
             uow.postsort_actions[key] = \
-                                    ret = \
-                                    object.__new__(cls)
+                ret = \
+                object.__new__(cls)
             return ret
 
     def execute_aggregate(self, uow, recs):
@@ -471,7 +471,7 @@ class ProcessAll(IterateMappersMixin, PostSortRec):
         self.delete = delete
         self.fromparent = fromparent
         uow.deps[dependency_processor.parent.base_mapper].\
-                    add(dependency_processor)
+            add(dependency_processor)
 
     def execute(self, uow):
         states = self._elements(uow)
@@ -521,13 +521,14 @@ class SaveUpdateAll(PostSortRec):
 
     def execute(self, uow):
         persistence.save_obj(self.mapper,
-            uow.states_for_mapper_hierarchy(self.mapper, False, False),
-            uow
-        )
+                             uow.states_for_mapper_hierarchy(
+                                 self.mapper, False, False),
+                             uow
+                             )
 
     def per_state_flush_actions(self, uow):
         states = list(uow.states_for_mapper_hierarchy(
-                                    self.mapper, False, False))
+            self.mapper, False, False))
         base_mapper = self.mapper.base_mapper
         delete_all = DeleteAll(uow, base_mapper)
         for state in states:
@@ -549,13 +550,14 @@ class DeleteAll(PostSortRec):
 
     def execute(self, uow):
         persistence.delete_obj(self.mapper,
-            uow.states_for_mapper_hierarchy(self.mapper, True, False),
-            uow
-        )
+                               uow.states_for_mapper_hierarchy(
+                                   self.mapper, True, False),
+                               uow
+                               )
 
     def per_state_flush_actions(self, uow):
         states = list(uow.states_for_mapper_hierarchy(
-                                    self.mapper, True, False))
+            self.mapper, True, False))
         base_mapper = self.mapper.base_mapper
         save_all = SaveUpdateAll(uow, base_mapper)
         for state in states:
@@ -581,9 +583,9 @@ class ProcessState(PostSortRec):
         dependency_processor = self.dependency_processor
         delete = self.delete
         our_recs = [r for r in recs
-                        if r.__class__ is cls_ and
-                        r.dependency_processor is dependency_processor and
-                        r.delete is delete]
+                    if r.__class__ is cls_ and
+                    r.dependency_processor is dependency_processor and
+                    r.delete is delete]
         recs.difference_update(our_recs)
         states = [self.state] + [r.state for r in our_recs]
         if delete:
@@ -609,13 +611,13 @@ class SaveUpdateState(PostSortRec):
         cls_ = self.__class__
         mapper = self.mapper
         our_recs = [r for r in recs
-                        if r.__class__ is cls_ and
-                        r.mapper is mapper]
+                    if r.__class__ is cls_ and
+                    r.mapper is mapper]
         recs.difference_update(our_recs)
         persistence.save_obj(mapper,
-                        [self.state] +
-                        [r.state for r in our_recs],
-                        uow)
+                             [self.state] +
+                             [r.state for r in our_recs],
+                             uow)
 
     def __repr__(self):
         return "%s(%s)" % (
@@ -633,13 +635,13 @@ class DeleteState(PostSortRec):
         cls_ = self.__class__
         mapper = self.mapper
         our_recs = [r for r in recs
-                        if r.__class__ is cls_ and
-                        r.mapper is mapper]
+                    if r.__class__ is cls_ and
+                    r.mapper is mapper]
         recs.difference_update(our_recs)
         states = [self.state] + [r.state for r in our_recs]
         persistence.delete_obj(mapper,
-                        [s for s in states if uow.states[s][0]],
-                        uow)
+                               [s for s in states if uow.states[s][0]],
+                               uow)
 
     def __repr__(self):
         return "%s(%s)" % (