- fully flake8 this file

1 files changed, 233 insertions, 234 deletions

diff --git a/lib/sqlalchemy/orm/strategies.py b/lib/sqlalchemy/orm/strategies.py
index b9de68f4b..3aed2b1ee 100644
--- a/lib/sqlalchemy/orm/strategies.py
+++ b/lib/sqlalchemy/orm/strategies.py
@@ -13,9 +13,9 @@ from .. import util, log, event
 from ..sql import util as sql_util, visitors
 from .. import sql
 from . import (
-        attributes, interfaces, exc as orm_exc, loading,
-        unitofwork, util as orm_util
-    )
+    attributes, interfaces, exc as orm_exc, loading,
+    unitofwork, util as orm_util
+)
 from .state import InstanceState
 from .util import _none_set
 from . import properties
@@ -25,15 +25,17 @@ from .interfaces import (
 from .session import _state_session
 import itertools
 
-def _register_attribute(strategy, mapper, useobject,
-        compare_function=None,
-        typecallable=None,
-        uselist=False,
-        callable_=None,
-        proxy_property=None,
-        active_history=False,
-        impl_class=None,
-        **kw
+
+def _register_attribute(
+    strategy, mapper, useobject,
+    compare_function=None,
+    typecallable=None,
+    uselist=False,
+    callable_=None,
+    proxy_property=None,
+    active_history=False,
+    impl_class=None,
+    **kw
 ):
 
     prop = strategy.parent_property
@@ -90,6 +92,7 @@ def _register_attribute(strategy, mapper, useobject,
             for hook in listen_hooks:
                 hook(desc, prop)
 
+
 @properties.ColumnProperty.strategy_for(instrument=False, deferred=False)
 class UninstrumentedColumnLoader(LoaderStrategy):
     """Represent the a non-instrumented MapperProperty.
@@ -103,13 +106,14 @@ class UninstrumentedColumnLoader(LoaderStrategy):
         self.columns = self.parent_property.columns
 
     def setup_query(self, context, entity, path, loadopt, adapter,
-                            column_collection=None, **kwargs):
+        column_collection=None, **kwargs):
         for c in self.columns:
             if adapter:
                 c = adapter.columns[c]
             column_collection.append(c)
 
-    def create_row_processor(self, context, path, loadopt, mapper, row, adapter):
+    def create_row_processor(self, context, path, loadopt,
+        mapper, row, adapter):
         return None, None, None
 
 
@@ -124,7 +128,7 @@ class ColumnLoader(LoaderStrategy):
         self.is_composite = hasattr(self.parent_property, 'composite_class')
 
     def setup_query(self, context, entity, path, loadopt,
-                            adapter, column_collection, **kwargs):
+        adapter, column_collection, **kwargs):
         for c in self.columns:
             if adapter:
                 c = adapter.columns[c]
@@ -135,16 +139,17 @@ class ColumnLoader(LoaderStrategy):
         coltype = self.columns[0].type
         # TODO: check all columns ?  check for foreign key as well?
         active_history = self.parent_property.active_history or \
-                            self.columns[0].primary_key or \
-                            mapper.version_id_col in set(self.columns)
+            self.columns[0].primary_key or \
+            mapper.version_id_col in set(self.columns)
 
-        _register_attribute(self, mapper, useobject=False,
+        _register_attribute(
+            self, mapper, useobject=False,
             compare_function=coltype.compare_values,
             active_history=active_history
-       )
+        )
 
     def create_row_processor(self, context, path,
-                                            loadopt, mapper, row, adapter):
+        loadopt, mapper, row, adapter):
         key = self.key
         # look through list of columns represented here
         # to see which, if any, is present in the row.
@@ -161,7 +166,6 @@ class ColumnLoader(LoaderStrategy):
             return expire_for_non_present_col, None, None
 
 
-
 @log.class_logger
 @properties.ColumnProperty.strategy_for(deferred=True, instrument=True)
 class DeferredColumnLoader(LoaderStrategy):
@@ -175,7 +179,8 @@ class DeferredColumnLoader(LoaderStrategy):
         self.columns = self.parent_property.columns
         self.group = self.parent_property.group
 
-    def create_row_processor(self, context, path, loadopt, mapper, row, adapter):
+    def create_row_processor(self, context, path, loadopt,
+        mapper, row, adapter):
         col = self.columns[0]
         if adapter:
             col = adapter.columns[col]
@@ -183,13 +188,13 @@ class DeferredColumnLoader(LoaderStrategy):
         key = self.key
         if col in row:
             return self.parent_property._get_strategy_by_cls(ColumnLoader).\
-                        create_row_processor(
-                                context, path, loadopt, mapper, row, adapter)
+                create_row_processor(
+                    context, path, loadopt, mapper, row, adapter)
 
         elif not self.is_class_level:
             set_deferred_for_local_state = InstanceState._row_processor(
-                                                mapper.class_manager,
-                                                LoadDeferredColumns(key), key)
+                mapper.class_manager,
+                LoadDeferredColumns(key), key)
             return set_deferred_for_local_state, None, None
         else:
             def reset_col_for_deferred(state, dict_, row):
@@ -201,14 +206,15 @@ class DeferredColumnLoader(LoaderStrategy):
     def init_class_attribute(self, mapper):
         self.is_class_level = True
 
-        _register_attribute(self, mapper, useobject=False,
-             compare_function=self.columns[0].type.compare_values,
-             callable_=self._load_for_state,
-             expire_missing=False
+        _register_attribute(
+            self, mapper, useobject=False,
+            compare_function=self.columns[0].type.compare_values,
+            callable_=self._load_for_state,
+            expire_missing=False
         )
 
     def setup_query(self, context, entity, path, loadopt, adapter,
-                                only_load_props=None, **kwargs):
+        only_load_props=None, **kwargs):
 
         if (
             (
@@ -228,8 +234,8 @@ class DeferredColumnLoader(LoaderStrategy):
             )
         ):
             self.parent_property._get_strategy_by_cls(ColumnLoader).\
-                            setup_query(context, entity,
-                                        path, loadopt, adapter, **kwargs)
+                setup_query(context, entity,
+                            path, loadopt, adapter, **kwargs)
 
     def _load_for_state(self, state, passive):
         if not state.key:
@@ -242,12 +248,12 @@ class DeferredColumnLoader(LoaderStrategy):
 
         if self.group:
             toload = [
-                    p.key for p in
-                    localparent.iterate_properties
-                    if isinstance(p, StrategizedProperty) and
-                      isinstance(p.strategy, DeferredColumnLoader) and
-                      p.group == self.group
-                    ]
+                p.key for p in
+                localparent.iterate_properties
+                if isinstance(p, StrategizedProperty) and
+                isinstance(p.strategy, DeferredColumnLoader) and
+                p.group == self.group
+            ]
         else:
             toload = [self.key]
 
@@ -270,7 +276,6 @@ class DeferredColumnLoader(LoaderStrategy):
         return attributes.ATTR_WAS_SET
 
 
-
 class LoadDeferredColumns(object):
     """serializable loader object used by DeferredColumnLoader"""
 
@@ -286,7 +291,6 @@ class LoadDeferredColumns(object):
         return strategy._load_for_state(state, passive)
 
 
-
 class AbstractRelationshipLoader(LoaderStrategy):
     """LoaderStratgies which deal with related objects."""
 
@@ -297,7 +301,6 @@ class AbstractRelationshipLoader(LoaderStrategy):
         self.uselist = self.parent_property.uselist
 
 
-
 @log.class_logger
 @properties.RelationshipProperty.strategy_for(lazy="noload")
 @properties.RelationshipProperty.strategy_for(lazy=None)
@@ -310,19 +313,20 @@ class NoLoader(AbstractRelationshipLoader):
     def init_class_attribute(self, mapper):
         self.is_class_level = True
 
-        _register_attribute(self, mapper,
+        _register_attribute(
+            self, mapper,
             useobject=True,
             uselist=self.parent_property.uselist,
             typecallable=self.parent_property.collection_class,
         )
 
-    def create_row_processor(self, context, path, loadopt, mapper, row, adapter):
+    def create_row_processor(self, context, path, loadopt, mapper,
+        row, adapter):
         def invoke_no_load(state, dict_, row):
             state._initialize(self.key)
         return invoke_no_load, None, None
 
 
-
 @log.class_logger
 @properties.RelationshipProperty.strategy_for(lazy=True)
 @properties.RelationshipProperty.strategy_for(lazy="select")
@@ -336,24 +340,24 @@ class LazyLoader(AbstractRelationshipLoader):
         super(LazyLoader, self).__init__(parent)
         join_condition = self.parent_property._join_condition
         self._lazywhere, \
-        self._bind_to_col, \
-        self._equated_columns = join_condition.create_lazy_clause()
+            self._bind_to_col, \
+            self._equated_columns = join_condition.create_lazy_clause()
 
         self._rev_lazywhere, \
-        self._rev_bind_to_col, \
-        self._rev_equated_columns = join_condition.create_lazy_clause(
-                                                reverse_direction=True)
+            self._rev_bind_to_col, \
+            self._rev_equated_columns = join_condition.create_lazy_clause(
+                reverse_direction=True)
 
         self.logger.info("%s lazy loading clause %s", self, self._lazywhere)
 
         # determine if our "lazywhere" clause is the same as the mapper's
         # get() clause.  then we can just use mapper.get()
         self.use_get = not self.uselist and \
-                        self.mapper._get_clause[0].compare(
-                            self._lazywhere,
-                            use_proxies=True,
-                            equivalents=self.mapper._equivalent_columns
-                        )
+            self.mapper._get_clause[0].compare(
+                self._lazywhere,
+                use_proxies=True,
+                equivalents=self.mapper._equivalent_columns
+            )
 
         if self.use_get:
             for col in list(self._equated_columns):
@@ -362,7 +366,7 @@ class LazyLoader(AbstractRelationshipLoader):
                         self._equated_columns[c] = self._equated_columns[col]
 
             self.logger.info("%s will use query.get() to "
-                                    "optimize instance loads" % self)
+                "optimize instance loads" % self)
 
     def init_class_attribute(self, mapper):
         self.is_class_level = True
@@ -379,7 +383,8 @@ class LazyLoader(AbstractRelationshipLoader):
         # will enable active_history
         # in that case.  otherwise we don't need the
         # "old" value during backref operations.
-        _register_attribute(self,
+        _register_attribute(
+            self,
             mapper,
             useobject=True,
             callable_=self._load_for_state,
@@ -390,24 +395,22 @@ class LazyLoader(AbstractRelationshipLoader):
         )
 
     def lazy_clause(self, state, reverse_direction=False,
-                                alias_secondary=False,
-                                adapt_source=None,
-                                passive=None):
+        alias_secondary=False,
+        adapt_source=None,
+        passive=None):
         if state is None:
             return self._lazy_none_clause(
-                                        reverse_direction,
-                                        adapt_source=adapt_source)
+                reverse_direction,
+                adapt_source=adapt_source)
 
         if not reverse_direction:
-            criterion, bind_to_col, rev = \
-                                            self._lazywhere, \
-                                            self._bind_to_col, \
-                                            self._equated_columns
+            criterion, bind_to_col = \
+                self._lazywhere, \
+                self._bind_to_col
         else:
-            criterion, bind_to_col, rev = \
-                                            self._rev_lazywhere, \
-                                            self._rev_bind_to_col, \
-                                            self._rev_equated_columns
+            criterion, bind_to_col = \
+                self._rev_lazywhere, \
+                self._rev_bind_to_col
 
         if reverse_direction:
             mapper = self.parent_property.mapper
@@ -431,17 +434,17 @@ class LazyLoader(AbstractRelationshipLoader):
             def visit_bindparam(bindparam):
                 if bindparam._identifying_key in bind_to_col:
                     bindparam.callable = \
-                            lambda: mapper._get_state_attr_by_column(
-                                    state, dict_,
-                                    bind_to_col[bindparam._identifying_key])
+                        lambda: mapper._get_state_attr_by_column(
+                            state, dict_,
+                            bind_to_col[bindparam._identifying_key])
 
         if self.parent_property.secondary is not None and alias_secondary:
             criterion = sql_util.ClauseAdapter(
-                                self.parent_property.secondary.alias()).\
-                                traverse(criterion)
+                self.parent_property.secondary.alias()).\
+                traverse(criterion)
 
         criterion = visitors.cloned_traverse(
-                                criterion, {}, {'bindparam': visit_bindparam})
+            criterion, {}, {'bindparam': visit_bindparam})
 
         if adapt_source:
             criterion = adapt_source(criterion)
@@ -449,15 +452,13 @@ class LazyLoader(AbstractRelationshipLoader):
 
     def _lazy_none_clause(self, reverse_direction=False, adapt_source=None):
         if not reverse_direction:
-            criterion, bind_to_col, rev = \
-                                        self._lazywhere, \
-                                        self._bind_to_col,\
-                                        self._equated_columns
+            criterion, bind_to_col = \
+                self._lazywhere, \
+                self._bind_to_col
         else:
-            criterion, bind_to_col, rev = \
-                                            self._rev_lazywhere, \
-                                            self._rev_bind_to_col, \
-                                            self._rev_equated_columns
+            criterion, bind_to_col = \
+                self._rev_lazywhere, \
+                self._rev_bind_to_col
 
         criterion = sql_util.adapt_criterion_to_null(criterion, bind_to_col)
 
@@ -532,15 +533,16 @@ class LazyLoader(AbstractRelationshipLoader):
 
         return [
             get_attr(
-                    state,
-                    dict_,
-                    self._equated_columns[pk],
-                    passive=passive)
+                state,
+                dict_,
+                self._equated_columns[pk],
+                passive=passive)
             for pk in self.mapper.primary_key
         ]
 
     @util.dependencies("sqlalchemy.orm.strategy_options")
-    def _emit_lazyload(self, strategy_options, session, state, ident_key, passive):
+    def _emit_lazyload(self, strategy_options, session, state,
+        ident_key, passive):
         q = session.query(self.mapper)._adapt_all_clauses()
 
         if self.parent_property.secondary is not None:
@@ -554,7 +556,6 @@ class LazyLoader(AbstractRelationshipLoader):
         if pending or passive & attributes.NO_AUTOFLUSH:
             q = q.autoflush(False)
 
-
         if state.load_path:
             q = q._with_current_path(state.load_path[self.parent_property])
 
@@ -571,9 +572,10 @@ class LazyLoader(AbstractRelationshipLoader):
             # reverse props that are MANYTOONE are loading *this*
             # object from get(), so don't need to eager out to those.
             if rev.direction is interfaces.MANYTOONE and \
-                        rev._use_get and \
-                        not isinstance(rev.strategy, LazyLoader):
-                q = q.options(strategy_options.Load(rev.parent).lazyload(rev.key))
+                rev._use_get and \
+                not isinstance(rev.strategy, LazyLoader):
+                q = q.options(strategy_options.Load(rev.parent).
+                    lazyload(rev.key))
 
         lazy_clause = self.lazy_clause(state, passive=passive)
 
@@ -584,7 +586,6 @@ class LazyLoader(AbstractRelationshipLoader):
 
         q = q.filter(lazy_clause)
 
-
         result = q.all()
         if self.uselist:
             return result
@@ -602,7 +603,7 @@ class LazyLoader(AbstractRelationshipLoader):
                 return None
 
     def create_row_processor(self, context, path, loadopt,
-                                    mapper, row, adapter):
+            mapper, row, adapter):
         key = self.key
         if not self.is_class_level:
             # we are not the primary manager for this attribute
@@ -614,8 +615,8 @@ class LazyLoader(AbstractRelationshipLoader):
             # attribute - "eager" attributes always have a
             # class-level lazyloader installed.
             set_lazy_callable = InstanceState._row_processor(
-                                        mapper.class_manager,
-                                        LoadLazyAttribute(key), key)
+                mapper.class_manager,
+                LoadLazyAttribute(key), key)
 
             return set_lazy_callable, None, None
         else:
@@ -633,7 +634,6 @@ class LazyLoader(AbstractRelationshipLoader):
             return reset_for_lazy_callable, None, None
 
 
-
 class LoadLazyAttribute(object):
     """serializable loader object used by LazyLoader"""
 
@@ -653,16 +653,16 @@ class LoadLazyAttribute(object):
 class ImmediateLoader(AbstractRelationshipLoader):
     def init_class_attribute(self, mapper):
         self.parent_property.\
-                _get_strategy_by_cls(LazyLoader).\
-                init_class_attribute(mapper)
+            _get_strategy_by_cls(LazyLoader).\
+            init_class_attribute(mapper)
 
     def setup_query(self, context, entity,
-                        path, loadopt, adapter, column_collection=None,
-                        parentmapper=None, **kwargs):
+        path, loadopt, adapter, column_collection=None,
+        parentmapper=None, **kwargs):
         pass
 
     def create_row_processor(self, context, path, loadopt,
-                                mapper, row, adapter):
+            mapper, row, adapter):
         def load_immediate(state, dict_, row):
             state.get_impl(self.key).get(state, dict_)
 
@@ -678,13 +678,13 @@ class SubqueryLoader(AbstractRelationshipLoader):
 
     def init_class_attribute(self, mapper):
         self.parent_property.\
-                _get_strategy_by_cls(LazyLoader).\
-                init_class_attribute(mapper)
+            _get_strategy_by_cls(LazyLoader).\
+            init_class_attribute(mapper)
 
     def setup_query(self, context, entity,
-                        path, loadopt, adapter,
-                        column_collection=None,
-                        parentmapper=None, **kwargs):
+        path, loadopt, adapter,
+        column_collection=None,
+        parentmapper=None, **kwargs):
 
         if not context.query._enable_eagerloads:
             return
@@ -715,18 +715,18 @@ class SubqueryLoader(AbstractRelationshipLoader):
                 return
 
         leftmost_mapper, leftmost_attr, leftmost_relationship = \
-                self._get_leftmost(subq_path)
+            self._get_leftmost(subq_path)
 
         orig_query = context.attributes.get(
-                                ("orig_query", SubqueryLoader),
-                                context.query)
+            ("orig_query", SubqueryLoader),
+            context.query)
 
         # generate a new Query from the original, then
         # produce a subquery from it.
         left_alias = self._generate_from_original_query(
-                            orig_query, leftmost_mapper,
-                            leftmost_attr, leftmost_relationship,
-                            entity.entity_zero
+            orig_query, leftmost_mapper,
+            leftmost_attr, leftmost_relationship,
+            entity.entity_zero
         )
 
         # generate another Query that will join the
@@ -742,7 +742,7 @@ class SubqueryLoader(AbstractRelationshipLoader):
 
         q = q._set_enable_single_crit(False)
         to_join, local_attr, parent_alias = \
-                    self._prep_for_joins(left_alias, subq_path)
+            self._prep_for_joins(left_alias, subq_path)
         q = q.order_by(*local_attr)
         q = q.add_columns(*local_attr)
         q = self._apply_joins(q, to_join, left_alias,
@@ -760,13 +760,14 @@ class SubqueryLoader(AbstractRelationshipLoader):
         subq_mapper = orm_util._class_to_mapper(subq_path[0])
 
         # determine attributes of the leftmost mapper
-        if self.parent.isa(subq_mapper) and self.parent_property is subq_path[1]:
+        if self.parent.isa(subq_mapper) and \
+            self.parent_property is subq_path[1]:
             leftmost_mapper, leftmost_prop = \
-                                    self.parent, self.parent_property
+                self.parent, self.parent_property
         else:
             leftmost_mapper, leftmost_prop = \
-                                    subq_mapper, \
-                                    subq_path[1]
+                subq_mapper, \
+                subq_path[1]
 
         leftmost_cols = leftmost_prop.local_columns
 
@@ -778,10 +779,10 @@ class SubqueryLoader(AbstractRelationshipLoader):
 
         return leftmost_mapper, leftmost_attr, leftmost_prop
 
-    def _generate_from_original_query(self,
-            orig_query, leftmost_mapper,
-            leftmost_attr, leftmost_relationship,
-            orig_entity
+    def _generate_from_original_query(
+        self,
+        orig_query, leftmost_mapper,
+        leftmost_attr, leftmost_relationship, orig_entity
     ):
         # reformat the original query
         # to look only for significant columns
@@ -898,7 +899,7 @@ class SubqueryLoader(AbstractRelationshipLoader):
             else:
                 if last and effective_entity is not self.mapper:
                     attr = getattr(parent_alias, key).\
-                                    of_type(effective_entity)
+                        of_type(effective_entity)
                 else:
                     attr = getattr(mapper.entity, key)
 
@@ -927,12 +928,12 @@ class SubqueryLoader(AbstractRelationshipLoader):
             # right now.
             eagerjoin = q._from_obj[0]
             eager_order_by = \
-                            eagerjoin._target_adapter.\
-                                copy_and_process(
-                                    util.to_list(
-                                        self.parent_property.order_by
-                                    )
-                                )
+                eagerjoin._target_adapter.\
+                copy_and_process(
+                    util.to_list(
+                        self.parent_property.order_by
+                    )
+                )
             q = q.order_by(*eager_order_by)
         return q
 
@@ -966,12 +967,12 @@ class SubqueryLoader(AbstractRelationshipLoader):
                 self._load()
 
     def create_row_processor(self, context, path, loadopt,
-                                    mapper, row, adapter):
+            mapper, row, adapter):
         if not self.parent.class_manager[self.key].impl.supports_population:
             raise sa_exc.InvalidRequestError(
-                        "'%s' does not support object "
-                        "population - eager loading cannot be applied." %
-                        self)
+                "'%s' does not support object "
+                "population - eager loading cannot be applied." %
+                self)
 
         path = path[self.parent_property]
 
@@ -1005,7 +1006,7 @@ class SubqueryLoader(AbstractRelationshipLoader):
                 ()
             )
             state.get_impl(self.key).\
-                    set_committed_value(state, dict_, collection)
+                set_committed_value(state, dict_, collection)
 
         return load_collection_from_subq, None, None, collections.loader
 
@@ -1023,12 +1024,11 @@ class SubqueryLoader(AbstractRelationshipLoader):
 
             scalar = collection[0]
             state.get_impl(self.key).\
-                    set_committed_value(state, dict_, scalar)
+                set_committed_value(state, dict_, scalar)
 
         return load_scalar_from_subq, None, None, collections.loader
 
 
-
 @log.class_logger
 @properties.RelationshipProperty.strategy_for(lazy="joined")
 @properties.RelationshipProperty.strategy_for(lazy=False)
@@ -1045,10 +1045,10 @@ class JoinedLoader(AbstractRelationshipLoader):
         self.parent_property.\
             _get_strategy_by_cls(LazyLoader).init_class_attribute(mapper)
 
-    def setup_query(self, context, entity, path, loadopt, adapter, \
-                                column_collection=None, parentmapper=None,
-                                chained_from_outerjoin=False,
-                                **kwargs):
+    def setup_query(self, context, entity, path, loadopt, adapter,
+        column_collection=None, parentmapper=None,
+        chained_from_outerjoin=False,
+        **kwargs):
         """Add a left outer join to the statement that's being constructed."""
 
         if not context.query._enable_eagerloads:
@@ -1059,7 +1059,7 @@ class JoinedLoader(AbstractRelationshipLoader):
         with_polymorphic = None
 
         user_defined_adapter = self._init_user_defined_eager_proc(
-                                        loadopt, context) if loadopt else False
+            loadopt, context) if loadopt else False
 
         if user_defined_adapter is not False:
             clauses, adapter, add_to_collection = \
@@ -1079,9 +1079,9 @@ class JoinedLoader(AbstractRelationshipLoader):
 
             clauses, adapter, add_to_collection, chained_from_outerjoin = \
                 self._generate_row_adapter(
-                        context, entity, path, loadopt, adapter,
-                        column_collection, parentmapper, chained_from_outerjoin
-                    )
+                    context, entity, path, loadopt, adapter,
+                    column_collection, parentmapper, chained_from_outerjoin
+                )
 
         with_poly_info = path.get(
             context.attributes,
@@ -1096,7 +1096,7 @@ class JoinedLoader(AbstractRelationshipLoader):
         path = path[self.mapper]
 
         for value in self.mapper._iterate_polymorphic_properties(
-                                mappers=with_polymorphic):
+            mappers=with_polymorphic):
             value.setup(
                 context,
                 entity,
@@ -1109,10 +1109,10 @@ class JoinedLoader(AbstractRelationshipLoader):
         if with_poly_info is not None and \
             None in set(context.secondary_columns):
             raise sa_exc.InvalidRequestError(
-                    "Detected unaliased columns when generating joined "
-                    "load.  Make sure to use aliased=True or flat=True "
-                    "when using joined loading with with_polymorphic()."
-                )
+                "Detected unaliased columns when generating joined "
+                "load.  Make sure to use aliased=True or flat=True "
+                "when using joined loading with with_polymorphic()."
+            )
 
     def _init_user_defined_eager_proc(self, loadopt, context):
 
@@ -1126,7 +1126,7 @@ class JoinedLoader(AbstractRelationshipLoader):
         # the option applies.  check if the "user_defined_eager_row_processor"
         # has been built up.
         adapter = path.get(context.attributes,
-                            "user_defined_eager_row_processor", False)
+            "user_defined_eager_row_processor", False)
         if adapter is not False:
             # just return it
             return adapter
@@ -1149,15 +1149,16 @@ class JoinedLoader(AbstractRelationshipLoader):
         else:
             if path.contains(context.attributes, "path_with_polymorphic"):
                 with_poly_info = path.get(context.attributes,
-                                                "path_with_polymorphic")
+                    "path_with_polymorphic")
                 adapter = orm_util.ORMAdapter(
-                            with_poly_info.entity,
-                            equivalents=prop.mapper._equivalent_columns)
+                    with_poly_info.entity,
+                    equivalents=prop.mapper._equivalent_columns)
             else:
-                adapter = context.query._polymorphic_adapters.get(prop.mapper, None)
+                adapter = context.query._polymorphic_adapters.get(
+                    prop.mapper, None)
         path.set(context.attributes,
-                            "user_defined_eager_row_processor",
-                            adapter)
+            "user_defined_eager_row_processor",
+            adapter)
 
         return adapter
 
@@ -1171,19 +1172,18 @@ class JoinedLoader(AbstractRelationshipLoader):
         if adapter and user_defined_adapter:
             user_defined_adapter = user_defined_adapter.wrap(adapter)
             path.set(context.attributes, "user_defined_eager_row_processor",
-                                    user_defined_adapter)
+                user_defined_adapter)
         elif adapter:
             user_defined_adapter = adapter
             path.set(context.attributes, "user_defined_eager_row_processor",
-                                    user_defined_adapter)
+                user_defined_adapter)
 
         add_to_collection = context.primary_columns
         return user_defined_adapter, adapter, add_to_collection
 
     def _generate_row_adapter(self,
         context, entity, path, loadopt, adapter,
-        column_collection, parentmapper, chained_from_outerjoin
-    ):
+        column_collection, parentmapper, chained_from_outerjoin):
         with_poly_info = path.get(
             context.attributes,
             "path_with_polymorphic",
@@ -1196,20 +1196,20 @@ class JoinedLoader(AbstractRelationshipLoader):
                                 flat=True,
                                 use_mapper_path=True)
         clauses = orm_util.ORMAdapter(
-                    to_adapt,
-                    equivalents=self.mapper._equivalent_columns,
-                    adapt_required=True)
+            to_adapt,
+            equivalents=self.mapper._equivalent_columns,
+            adapt_required=True)
         assert clauses.aliased_class is not None
 
         if self.parent_property.direction != interfaces.MANYTOONE:
             context.multi_row_eager_loaders = True
 
         innerjoin = (
-                            loadopt.local_opts.get(
-                                'innerjoin', self.parent_property.innerjoin)
-                            if loadopt is not None
-                            else self.parent_property.innerjoin
-                        )
+            loadopt.local_opts.get(
+                'innerjoin', self.parent_property.innerjoin)
+            if loadopt is not None
+            else self.parent_property.innerjoin
+        )
 
         if not innerjoin:
             # if this is an outer join, all non-nested eager joins from
@@ -1228,8 +1228,8 @@ class JoinedLoader(AbstractRelationshipLoader):
         return clauses, adapter, add_to_collection, chained_from_outerjoin
 
     def _create_eager_join(self, context, entity,
-                            path, adapter, parentmapper,
-                            clauses, innerjoin, chained_from_outerjoin):
+        path, adapter, parentmapper,
+        clauses, innerjoin, chained_from_outerjoin):
 
         if parentmapper is None:
             localparent = entity.mapper
@@ -1247,9 +1247,8 @@ class JoinedLoader(AbstractRelationshipLoader):
         if entity not in context.eager_joins and \
             not should_nest_selectable and \
             context.from_clause:
-            index, clause = \
-                sql_util.find_join_source(
-                                context.from_clause, entity.selectable)
+            index, clause = sql_util.find_join_source(
+                context.from_clause, entity.selectable)
             if clause is not None:
                 # join to an existing FROM clause on the query.
                 # key it to its list index in the eager_joins dict.
@@ -1265,49 +1264,50 @@ class JoinedLoader(AbstractRelationshipLoader):
         if adapter:
             if getattr(adapter, 'aliased_class', None):
                 onclause = getattr(
-                                adapter.aliased_class, self.key,
-                                self.parent_property)
+                    adapter.aliased_class, self.key,
+                    self.parent_property)
             else:
                 onclause = getattr(
-                                orm_util.AliasedClass(
-                                        self.parent,
-                                        adapter.selectable,
-                                        use_mapper_path=True
-                                ),
-                                self.key, self.parent_property
-                            )
+                    orm_util.AliasedClass(
+                        self.parent,
+                        adapter.selectable,
+                        use_mapper_path=True
+                    ),
+                    self.key, self.parent_property
+                )
 
         else:
             onclause = self.parent_property
 
         assert clauses.aliased_class is not None
 
-        join_to_outer = innerjoin and isinstance(towrap, sql.Join) and towrap.isouter
+        join_to_outer = innerjoin and isinstance(towrap, sql.Join) and \
+            towrap.isouter
 
         if chained_from_outerjoin and join_to_outer and innerjoin == 'nested':
             inner = orm_util.join(
-                                    towrap.right,
-                                    clauses.aliased_class,
-                                    onclause,
-                                    isouter=False
-                                )
+                towrap.right,
+                clauses.aliased_class,
+                onclause,
+                isouter=False
+            )
 
             eagerjoin = orm_util.join(
-                                towrap.left,
-                                inner,
-                                towrap.onclause,
-                                isouter=True
-                        )
+                towrap.left,
+                inner,
+                towrap.onclause,
+                isouter=True
+            )
             eagerjoin._target_adapter = inner._target_adapter
         else:
             if chained_from_outerjoin:
                 innerjoin = False
             eagerjoin = orm_util.join(
-                                        towrap,
-                                        clauses.aliased_class,
-                                        onclause,
-                                        isouter=not innerjoin
-                                        )
+                towrap,
+                clauses.aliased_class,
+                onclause,
+                isouter=not innerjoin
+            )
         context.eager_joins[entity_key] = eagerjoin
 
         # send a hint to the Query as to where it may "splice" this join
@@ -1323,24 +1323,23 @@ class JoinedLoader(AbstractRelationshipLoader):
             # This has the effect
             # of "undefering" those columns.
             for col in sql_util._find_columns(
-                                self.parent_property.primaryjoin):
+                self.parent_property.primaryjoin):
                 if localparent.mapped_table.c.contains_column(col):
                     if adapter:
                         col = adapter.columns[col]
                     context.primary_columns.append(col)
 
         if self.parent_property.order_by:
-            context.eager_order_by += \
-                            eagerjoin._target_adapter.\
-                                copy_and_process(
-                                    util.to_list(
-                                        self.parent_property.order_by
-                                    )
-                                )
+            context.eager_order_by += eagerjoin._target_adapter.\
+                copy_and_process(
+                    util.to_list(
+                        self.parent_property.order_by
+                    )
+                )
 
     def _create_eager_adapter(self, context, row, adapter, path, loadopt):
         user_defined_adapter = self._init_user_defined_eager_proc(
-                                        loadopt, context) if loadopt else False
+            loadopt, context) if loadopt else False
 
         if user_defined_adapter is not False:
             decorator = user_defined_adapter
@@ -1364,44 +1363,45 @@ class JoinedLoader(AbstractRelationshipLoader):
             # processor, will cause a degrade to lazy
             return False
 
-    def create_row_processor(self, context, path, loadopt, mapper, row, adapter):
+    def create_row_processor(self, context, path, loadopt, mapper,
+        row, adapter):
         if not self.parent.class_manager[self.key].impl.supports_population:
             raise sa_exc.InvalidRequestError(
-                        "'%s' does not support object "
-                        "population - eager loading cannot be applied." %
-                        self)
+                "'%s' does not support object "
+                "population - eager loading cannot be applied." %
+                self
+            )
 
         our_path = path[self.parent_property]
 
         eager_adapter = self._create_eager_adapter(
-                                                context,
-                                                row,
-                                                adapter, our_path, loadopt)
+            context,
+            row,
+            adapter, our_path, loadopt)
 
         if eager_adapter is not False:
             key = self.key
 
             _instance = loading.instance_processor(
-                                self.mapper,
-                                context,
-                                our_path[self.mapper],
-                                eager_adapter)
+                self.mapper,
+                context,
+                our_path[self.mapper],
+                eager_adapter)
 
             if not self.uselist:
                 return self._create_scalar_loader(context, key, _instance)
             else:
                 return self._create_collection_loader(context, key, _instance)
         else:
-            return self.parent_property.\
-                            _get_strategy_by_cls(LazyLoader).\
-                            create_row_processor(
-                                            context, path, loadopt,
-                                            mapper, row, adapter)
+            return self.parent_property._get_strategy_by_cls(LazyLoader).\
+                create_row_processor(
+                    context, path, loadopt,
+                    mapper, row, adapter)
 
     def _create_collection_loader(self, context, key, _instance):
         def load_collection_from_joined_new_row(state, dict_, row):
             collection = attributes.init_state_collection(
-                                            state, dict_, key)
+                state, dict_, key)
             result_list = util.UniqueAppender(collection,
                                               'append_without_event')
             context.attributes[(state, key)] = result_list
@@ -1418,8 +1418,8 @@ class JoinedLoader(AbstractRelationshipLoader):
                 collection = attributes.init_state_collection(state,
                                 dict_, key)
                 result_list = util.UniqueAppender(
-                                        collection,
-                                        'append_without_event')
+                    collection,
+                    'append_without_event')
                 context.attributes[(state, key)] = result_list
             _instance(row, result_list)
 
@@ -1427,8 +1427,8 @@ class JoinedLoader(AbstractRelationshipLoader):
             _instance(row, None)
 
         return load_collection_from_joined_new_row, \
-                load_collection_from_joined_existing_row, \
-                None, load_collection_from_joined_exec
+            load_collection_from_joined_existing_row, \
+            None, load_collection_from_joined_exec
 
     def _create_scalar_loader(self, context, key, _instance):
         def load_scalar_from_joined_new_row(state, dict_, row):
@@ -1452,9 +1452,8 @@ class JoinedLoader(AbstractRelationshipLoader):
             _instance(row, None)
 
         return load_scalar_from_joined_new_row, \
-                load_scalar_from_joined_existing_row, \
-                None, load_scalar_from_joined_exec
-
+            load_scalar_from_joined_existing_row, \
+            None, load_scalar_from_joined_exec
 
 
 def single_parent_validator(desc, prop):
@@ -1477,6 +1476,6 @@ def single_parent_validator(desc, prop):
         return _do_check(state, value, oldvalue, initiator)
 
     event.listen(desc, 'append', append, raw=True, retval=True,
-                            active_history=True)
+        active_history=True)
     event.listen(desc, 'set', set_, raw=True, retval=True,
-                            active_history=True)
+        active_history=True)