From: Diana Clarke Date: Mon, 19 Nov 2012 19:56:11 +0000 (-0500) Subject: just a pep8 pass of lib/sqlalchemy/orm/ X-Git-Tag: rel_0_8_0b2~33^2~13 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=655e0b4de28841339a8aae5491225e5473e3ef8a;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git just a pep8 pass of lib/sqlalchemy/orm/ --- diff --git a/lib/sqlalchemy/orm/strategies.py b/lib/sqlalchemy/orm/strategies.py index 35ef7667b1..8c0700f744 100644 --- a/lib/sqlalchemy/orm/strategies.py +++ b/lib/sqlalchemy/orm/strategies.py @@ -22,6 +22,7 @@ from .interfaces import ( from .session import _state_session import itertools + def _register_attribute(strategy, mapper, useobject, compare_function=None, typecallable=None, @@ -86,6 +87,7 @@ def _register_attribute(strategy, mapper, useobject, for hook in listen_hooks: hook(desc, prop) + class UninstrumentedColumnLoader(LoaderStrategy): """Represent the a non-instrumented MapperProperty. @@ -107,6 +109,7 @@ class UninstrumentedColumnLoader(LoaderStrategy): def create_row_processor(self, context, path, mapper, row, adapter): return None, None, None + class ColumnLoader(LoaderStrategy): """Provide loading behavior for a :class:`.ColumnProperty`.""" @@ -131,7 +134,7 @@ class ColumnLoader(LoaderStrategy): _register_attribute(self, mapper, useobject=False, compare_function=coltype.compare_values, - active_history = active_history + active_history=active_history ) def create_row_processor(self, context, path, @@ -151,8 +154,10 @@ class ColumnLoader(LoaderStrategy): state._expire_attribute_pre_commit(dict_, key) return expire_for_non_present_col, None, None + log.class_logger(ColumnLoader) + class DeferredColumnLoader(LoaderStrategy): """Provide loading behavior for a deferred :class:`.ColumnProperty`.""" @@ -177,7 +182,8 @@ class DeferredColumnLoader(LoaderStrategy): elif not self.is_class_level: def set_deferred_for_local_state(state, dict_, row): - state._set_callable(dict_, key, LoadDeferredColumns(state, key)) + state._set_callable( + dict_, key, LoadDeferredColumns(state, key)) return set_deferred_for_local_state, None, None else: def reset_col_for_deferred(state, dict_, row): @@ -220,7 +226,7 @@ class DeferredColumnLoader(LoaderStrategy): localparent.iterate_properties if isinstance(p, StrategizedProperty) and isinstance(p.strategy, DeferredColumnLoader) and - p.group==self.group + p.group == self.group ] else: toload = [self.key] @@ -243,8 +249,10 @@ class DeferredColumnLoader(LoaderStrategy): return attributes.ATTR_WAS_SET + log.class_logger(DeferredColumnLoader) + class LoadDeferredColumns(object): """serializable loader object used by DeferredColumnLoader""" @@ -260,6 +268,7 @@ class LoadDeferredColumns(object): strategy = prop._strategies[DeferredColumnLoader] return strategy._load_for_state(state, passive) + class DeferredOption(StrategizedOption): propagate_to_loaders = True @@ -273,6 +282,7 @@ class DeferredOption(StrategizedOption): else: return ColumnLoader + class UndeferGroupOption(MapperOption): propagate_to_loaders = True @@ -282,6 +292,7 @@ class UndeferGroupOption(MapperOption): def process_query(self, query): query._attributes[("undefer", self.group)] = True + class AbstractRelationshipLoader(LoaderStrategy): """LoaderStratgies which deal with related objects.""" @@ -291,6 +302,7 @@ class AbstractRelationshipLoader(LoaderStrategy): self.target = self.parent_property.target self.uselist = self.parent_property.uselist + class NoLoader(AbstractRelationshipLoader): """Provide loading behavior for a :class:`.RelationshipProperty` with "lazy=None". @@ -303,7 +315,7 @@ class NoLoader(AbstractRelationshipLoader): _register_attribute(self, mapper, useobject=True, uselist=self.parent_property.uselist, - typecallable = self.parent_property.collection_class, + typecallable=self.parent_property.collection_class, ) def create_row_processor(self, context, path, mapper, row, adapter): @@ -311,8 +323,10 @@ class NoLoader(AbstractRelationshipLoader): state._initialize(self.key) return invoke_no_load, None, None + log.class_logger(NoLoader) + class LazyLoader(AbstractRelationshipLoader): """Provide loading behavior for a :class:`.RelationshipProperty` with "lazy=True", that is loads when first accessed. @@ -355,6 +369,12 @@ class LazyLoader(AbstractRelationshipLoader): def init_class_attribute(self, mapper): self.is_class_level = True + active_history = ( + self.parent_property.active_history or + self.parent_property.direction is not interfaces.MANYTOONE or + not self.use_get + ) + # MANYTOONE currently only needs the # "old" value for delete-orphan # cascades. the required _SingleParentValidator @@ -365,15 +385,11 @@ class LazyLoader(AbstractRelationshipLoader): mapper, useobject=True, callable_=self._load_for_state, - uselist = self.parent_property.uselist, - backref = self.parent_property.back_populates, - typecallable = self.parent_property.collection_class, - active_history = \ - self.parent_property.active_history or \ - self.parent_property.direction is not \ - interfaces.MANYTOONE or \ - not self.use_get, - ) + uselist=self.parent_property.uselist, + backref=self.parent_property.back_populates, + typecallable=self.parent_property.collection_class, + active_history=active_history + ) def lazy_clause(self, state, reverse_direction=False, alias_secondary=False, @@ -421,7 +437,6 @@ class LazyLoader(AbstractRelationshipLoader): 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()).\ @@ -582,7 +597,6 @@ class LazyLoader(AbstractRelationshipLoader): else: return None - def create_row_processor(self, context, path, mapper, row, adapter): key = self.key @@ -615,6 +629,7 @@ class LazyLoader(AbstractRelationshipLoader): log.class_logger(LazyLoader) + class LoadLazyAttribute(object): """serializable loader object used by LazyLoader""" @@ -649,6 +664,7 @@ class ImmediateLoader(AbstractRelationshipLoader): return None, None, load_immediate + class SubqueryLoader(AbstractRelationshipLoader): def __init__(self, parent): super(SubqueryLoader, self).__init__(parent) @@ -713,7 +729,7 @@ class SubqueryLoader(AbstractRelationshipLoader): q = orig_query.session.query(effective_entity) q._attributes = { ("orig_query", SubqueryLoader): orig_query, - ('subquery_path', None) : subq_path + ('subquery_path', None): subq_path } q = q._enable_single_crit(False) @@ -779,13 +795,12 @@ class SubqueryLoader(AbstractRelationshipLoader): left_alias = orm_util.AliasedClass(leftmost_mapper, embed_q) return left_alias - def _prep_for_joins(self, left_alias, subq_path): subq_path = subq_path.path # figure out what's being joined. a.k.a. the fun part to_join = [ - (subq_path[i], subq_path[i+1]) + (subq_path[i], subq_path[i + 1]) for i in xrange(0, len(subq_path), 2) ] @@ -905,7 +920,7 @@ class SubqueryLoader(AbstractRelationshipLoader): (k, [v[0] for v in v]) for k, v in itertools.groupby( subq, - lambda x:x[1:] + lambda x: x[1:] )) path.set(context, 'collections', collections) @@ -946,8 +961,10 @@ class SubqueryLoader(AbstractRelationshipLoader): return load_scalar_from_subq, None, None + log.class_logger(SubqueryLoader) + class JoinedLoader(AbstractRelationshipLoader): """Provide loading behavior for a :class:`.RelationshipProperty` using joined eager loading. @@ -1173,7 +1190,6 @@ class JoinedLoader(AbstractRelationshipLoader): ) ) - def _create_eager_adapter(self, context, row, adapter, path): user_defined_adapter = path.get(context, "user_defined_eager_row_processor", @@ -1291,8 +1307,10 @@ class JoinedLoader(AbstractRelationshipLoader): load_scalar_from_joined_existing_row, \ None, load_scalar_from_joined_exec + log.class_logger(JoinedLoader) + class EagerLazyOption(StrategizedOption): def __init__(self, key, lazy=True, chained=False, propagate_to_loaders=True @@ -1314,18 +1332,21 @@ class EagerLazyOption(StrategizedOption): return self.strategy_cls _factory = { - False:JoinedLoader, - "joined":JoinedLoader, - None:NoLoader, - "noload":NoLoader, - "select":LazyLoader, - True:LazyLoader, - "subquery":SubqueryLoader, - "immediate":ImmediateLoader + False: JoinedLoader, + "joined": JoinedLoader, + None: NoLoader, + "noload": NoLoader, + "select": LazyLoader, + True: LazyLoader, + "subquery": SubqueryLoader, + "immediate": ImmediateLoader } + + def factory(identifier): return _factory.get(identifier, LazyLoader) + class EagerJoinOption(PropertyOption): def __init__(self, key, innerjoin, chained=False): @@ -1340,6 +1361,7 @@ class EagerJoinOption(PropertyOption): else: paths[-1].set(query, "eager_join_type", self.innerjoin) + class LoadEagerFromAliasOption(PropertyOption): def __init__(self, key, alias=None, chained=False): @@ -1382,6 +1404,7 @@ class LoadEagerFromAliasOption(PropertyOption): paths[-1].set(query, "user_defined_eager_row_processor", adapter) + def single_parent_validator(desc, prop): def _do_check(state, value, oldvalue, initiator): if value is not None and initiator.key == prop.key: @@ -1405,4 +1428,3 @@ def single_parent_validator(desc, prop): active_history=True) event.listen(desc, 'set', set_, raw=True, retval=True, active_history=True) - diff --git a/lib/sqlalchemy/orm/sync.py b/lib/sqlalchemy/orm/sync.py index 2b2f6d0922..847bce30e7 100644 --- a/lib/sqlalchemy/orm/sync.py +++ b/lib/sqlalchemy/orm/sync.py @@ -11,6 +11,7 @@ between instances based on join conditions. from . import exc, util as orm_util, attributes + def populate(source, source_mapper, dest, dest_mapper, synchronize_pairs, uowcommit, flag_cascaded_pks): source_dict = source.dict @@ -42,38 +43,45 @@ def populate(source, source_mapper, dest, dest_mapper, r.references(l): uowcommit.attributes[("pk_cascaded", dest, r)] = True + def clear(dest, dest_mapper, synchronize_pairs): for l, r in synchronize_pairs: if r.primary_key: raise AssertionError( - "Dependency rule tried to blank-out primary key " - "column '%s' on instance '%s'" % - (r, orm_util.state_str(dest)) - ) + "Dependency rule tried to blank-out primary key " + "column '%s' on instance '%s'" % + (r, orm_util.state_str(dest)) + ) try: dest_mapper._set_state_attr_by_column(dest, dest.dict, r, None) except exc.UnmappedColumnError: _raise_col_to_prop(True, None, l, dest_mapper, r) + def update(source, source_mapper, dest, old_prefix, synchronize_pairs): for l, r in synchronize_pairs: try: - oldvalue = source_mapper._get_committed_attr_by_column(source.obj(), l) - value = source_mapper._get_state_attr_by_column(source, source.dict, l) + oldvalue = source_mapper._get_committed_attr_by_column( + source.obj(), l) + value = source_mapper._get_state_attr_by_column( + source, source.dict, l) except exc.UnmappedColumnError: _raise_col_to_prop(False, source_mapper, l, None, r) dest[r.key] = value dest[old_prefix + r.key] = oldvalue + def populate_dict(source, source_mapper, dict_, synchronize_pairs): for l, r in synchronize_pairs: try: - value = source_mapper._get_state_attr_by_column(source, source.dict, l) + value = source_mapper._get_state_attr_by_column( + source, source.dict, l) except exc.UnmappedColumnError: _raise_col_to_prop(False, source_mapper, l, None, r) dict_[r.key] = value + def source_modified(uowcommit, source, source_mapper, synchronize_pairs): """return true if the source object has changes from an old to a new value on the given synchronize pairs @@ -90,6 +98,7 @@ def source_modified(uowcommit, source, source_mapper, synchronize_pairs): else: return False + def _raise_col_to_prop(isdest, source_mapper, source_column, dest_mapper, dest_column): if isdest: diff --git a/lib/sqlalchemy/orm/unitofwork.py b/lib/sqlalchemy/orm/unitofwork.py index 1cba58321c..4d0c70ea34 100644 --- a/lib/sqlalchemy/orm/unitofwork.py +++ b/lib/sqlalchemy/orm/unitofwork.py @@ -18,6 +18,7 @@ from . import attributes, persistence, util as orm_util sessionlib = util.importlater("sqlalchemy.orm", "session") + def track_cascade_events(descriptor, prop): """Establish event listeners on object attributes which handle cascade-on-set/append. @@ -370,7 +371,6 @@ class UOWTransaction(object): postsort_actions): rec.execute(self) - def finalize_flush_changes(self): """mark processed objects as clean / deleted after a successful flush(). @@ -388,6 +388,7 @@ class UOWTransaction(object): self.session._remove_newly_deleted(isdel) self.session._register_newly_persistent(other) + class IterateMappersMixin(object): def _mappers(self, uow): if self.fromparent: @@ -399,6 +400,7 @@ class IterateMappersMixin(object): else: return self.dependency_processor.mapper.self_and_descendants + class Preprocess(IterateMappersMixin): def __init__(self, dependency_processor, fromparent): self.dependency_processor = dependency_processor @@ -439,6 +441,7 @@ class Preprocess(IterateMappersMixin): else: return False + class PostSortRec(object): disabled = False @@ -461,6 +464,7 @@ class PostSortRec(object): ",".join(str(x) for x in self.__dict__.values()) ) + class ProcessAll(IterateMappersMixin, PostSortRec): def __init__(self, uow, dependency_processor, delete, fromparent): self.dependency_processor = dependency_processor @@ -497,6 +501,7 @@ class ProcessAll(IterateMappersMixin, PostSortRec): if isdelete == self.delete and not listonly: yield state + class IssuePostUpdate(PostSortRec): def __init__(self, uow, mapper, isdelete): self.mapper = mapper @@ -508,6 +513,7 @@ class IssuePostUpdate(PostSortRec): persistence.post_update(self.mapper, states, uow, cols) + class SaveUpdateAll(PostSortRec): def __init__(self, uow, mapper): self.mapper = mapper @@ -519,7 +525,6 @@ class SaveUpdateAll(PostSortRec): uow ) - def per_state_flush_actions(self, uow): states = list(uow.states_for_mapper_hierarchy( self.mapper, False, False)) @@ -536,6 +541,7 @@ class SaveUpdateAll(PostSortRec): states_for_prop = uow.filter_states_for_dep(dep, states) dep.per_state_flush_actions(uow, states_for_prop, False) + class DeleteAll(PostSortRec): def __init__(self, uow, mapper): self.mapper = mapper @@ -563,6 +569,7 @@ class DeleteAll(PostSortRec): states_for_prop = uow.filter_states_for_dep(dep, states) dep.per_state_flush_actions(uow, states_for_prop, True) + class ProcessState(PostSortRec): def __init__(self, uow, dependency_processor, delete, state): self.dependency_processor = dependency_processor @@ -592,6 +599,7 @@ class ProcessState(PostSortRec): self.delete ) + class SaveUpdateState(PostSortRec): def __init__(self, uow, state, mapper): self.state = state @@ -615,6 +623,7 @@ class SaveUpdateState(PostSortRec): orm_util.state_str(self.state) ) + class DeleteState(PostSortRec): def __init__(self, uow, state, mapper): self.state = state @@ -637,4 +646,3 @@ class DeleteState(PostSortRec): self.__class__.__name__, orm_util.state_str(self.state) ) - diff --git a/lib/sqlalchemy/orm/util.py b/lib/sqlalchemy/orm/util.py index 43632ff134..97baffc9aa 100644 --- a/lib/sqlalchemy/orm/util.py +++ b/lib/sqlalchemy/orm/util.py @@ -22,6 +22,7 @@ _INSTRUMENTOR = ('mapper', 'instrumentor') _none_set = frozenset([None]) + class CascadeOptions(frozenset): """Keeps track of the options sent to relationship().cascade""" @@ -69,6 +70,7 @@ class CascadeOptions(frozenset): ",".join([x for x in sorted(self)]) ) + def _validator_events(desc, key, validator, include_removes): """Runs a validation method on an attribute value to be set or appended.""" @@ -93,6 +95,7 @@ def _validator_events(desc, key, validator, include_removes): if include_removes: event.listen(desc, "remove", remove, raw=True, retval=True) + def polymorphic_union(table_map, typecolname, aliasname='p_union', cast_nulls=True): """Create a ``UNION`` statement used by a polymorphic mapper. @@ -155,6 +158,7 @@ def polymorphic_union(table_map, typecolname, from_obj=[table])) return sql.union_all(*result).alias(aliasname) + def identity_key(*args, **kwargs): """Get an identity key. @@ -211,6 +215,7 @@ def identity_key(*args, **kwargs): mapper = object_mapper(instance) return mapper.identity_key_from_instance(instance) + class ORMAdapter(sql_util.ColumnAdapter): """Extends ColumnAdapter to accept ORM entities. @@ -240,6 +245,7 @@ class ORMAdapter(sql_util.ColumnAdapter): else: return None + class PathRegistry(object): """Represent query load paths and registry functions. @@ -335,6 +341,7 @@ class PathRegistry(object): def __repr__(self): return "%s(%r)" % (self.__class__.__name__, self.path, ) + class RootRegistry(PathRegistry): """Root registry, defers to mappers so that paths are maintained per-root-mapper. @@ -347,6 +354,7 @@ class RootRegistry(PathRegistry): return mapper._sa_path_registry PathRegistry.root = RootRegistry() + class KeyRegistry(PathRegistry): def __init__(self, parent, key): self.key = key @@ -362,6 +370,7 @@ class KeyRegistry(PathRegistry): self, entity ) + class EntityRegistry(PathRegistry, dict): is_aliased_class = False @@ -542,6 +551,7 @@ class AliasedClass(object): return '' % ( id(self), self.__target.__name__) + AliasedInsp = util.namedtuple("AliasedInsp", [ "entity", "mapper", @@ -551,6 +561,7 @@ AliasedInsp = util.namedtuple("AliasedInsp", [ "polymorphic_on" ]) + class AliasedInsp(_InspectionAttr, AliasedInsp): """Provide an inspection interface for an :class:`.AliasedClass` object. @@ -596,8 +607,10 @@ class AliasedInsp(_InspectionAttr, AliasedInsp): :class:`.AliasedInsp`.""" return self.mapper.class_ + inspection._inspects(AliasedClass)(lambda target: target._aliased_insp) + def aliased(element, alias=None, name=None, adapt_on_names=False): """Produce an alias of the given element, usually an :class:`.AliasedClass` instance. @@ -677,6 +690,7 @@ def aliased(element, alias=None, name=None, adapt_on_names=False): return AliasedClass(element, alias=alias, name=name, adapt_on_names=adapt_on_names) + def with_polymorphic(base, classes, selectable=False, polymorphic_on=None, aliased=False, innerjoin=False): @@ -750,6 +764,7 @@ def _orm_annotate(element, exclude=None): """ return sql_util._deep_annotate(element, {'_orm_adapt': True}, exclude) + def _orm_deannotate(element): """Remove annotations that link a column to a particular mapping. @@ -763,9 +778,11 @@ def _orm_deannotate(element): values=("_orm_adapt", "parententity") ) + def _orm_full_deannotate(element): return sql_util._deep_deannotate(element) + class _ORMJoin(expression.Join): """Extend Join to support ORM constructs as input.""" @@ -836,6 +853,7 @@ class _ORMJoin(expression.Join): def outerjoin(self, right, onclause=None, join_to_left=True): return _ORMJoin(self, right, onclause, True, join_to_left) + def join(left, right, onclause=None, isouter=False, join_to_left=True): """Produce an inner join between left and right clauses. @@ -878,6 +896,7 @@ def join(left, right, onclause=None, isouter=False, join_to_left=True): """ return _ORMJoin(left, right, onclause, isouter, join_to_left) + def outerjoin(left, right, onclause=None, join_to_left=True): """Produce a left outer join between left and right clauses. @@ -888,6 +907,7 @@ def outerjoin(left, right, onclause=None, join_to_left=True): """ return _ORMJoin(left, right, onclause, True, join_to_left) + def with_parent(instance, prop): """Create filtering criterion that relates this query's primary entity to the given related instance, using established :func:`.relationship()` @@ -932,8 +952,10 @@ def _attr_as_key(attr): else: return expression._column_as_key(attr) + _state_mapper = util.dottedgetter('manager.mapper') + @inspection._inspects(object) def _inspect_mapped_object(instance): try: @@ -945,6 +967,7 @@ def _inspect_mapped_object(instance): except exc.NO_STATE: return None + @inspection._inspects(type) def _inspect_mapped_class(class_, configure=False): try: @@ -978,6 +1001,7 @@ def object_mapper(instance): """ return object_state(instance).mapper + def object_state(instance): """Given an object, return the :class:`.InstanceState` associated with the object. @@ -1001,6 +1025,7 @@ def object_state(instance): else: return state + def class_mapper(class_, configure=True): """Given a class, return the primary :class:`.Mapper` associated with the key. @@ -1027,6 +1052,7 @@ def class_mapper(class_, configure=True): else: return mapper + def _class_to_mapper(class_or_mapper): insp = inspection.inspect(class_or_mapper, False) if insp is not None: @@ -1034,6 +1060,7 @@ def _class_to_mapper(class_or_mapper): else: raise exc.UnmappedClassError(class_or_mapper) + def _mapper_or_none(entity): """Return the :class:`.Mapper` for the given class or None if the class is not mapped.""" @@ -1044,6 +1071,7 @@ def _mapper_or_none(entity): else: return None + def _is_mapped_class(entity): """Return True if the given object is a mapped class, :class:`.Mapper`, or :class:`.AliasedClass`.""" @@ -1089,6 +1117,7 @@ def _entity_descriptor(entity, key): (description, key) ) + def _orm_columns(entity): insp = inspection.inspect(entity, False) if hasattr(insp, 'selectable'): @@ -1096,15 +1125,18 @@ def _orm_columns(entity): else: return [entity] + def has_identity(object): state = attributes.instance_state(object) return state.has_identity + def instance_str(instance): """Return a string describing an instance.""" return state_str(attributes.instance_state(instance)) + def state_str(state): """Return a string describing an instance via its InstanceState.""" @@ -1113,6 +1145,7 @@ def state_str(state): else: return '<%s at 0x%x>' % (state.class_.__name__, id(state.obj())) + def state_class_str(state): """Return a string describing an instance's class via its InstanceState.""" @@ -1121,9 +1154,10 @@ def state_class_str(state): else: return '<%s>' % (state.class_.__name__, ) + def attribute_str(instance, attribute): return instance_str(instance) + "." + attribute + def state_attribute_str(state, attribute): return state_str(state) + "." + attribute -