module documentation

Support for collections of mapped entities.

The collections package supplies the machinery used to inform the ORM of collection membership changes. An instrumentation via decoration approach is used, allowing arbitrary types (including built-ins) to be used as entity collections without requiring inheritance from a base class.

Instrumentation decoration relays membership change events to the .CollectionAttributeImpl that is currently managing the collection. The decorators observe function call arguments and return values, tracking entities entering or leaving the collection. Two decorator approaches are provided. One is a bundle of generic decorators that map function arguments and return values to events:

from sqlalchemy.orm.collections import collection
class MyClass(object):
    # ...

    @collection.adds(1)
    def store(self, item):
        self.data.append(item)

    @collection.removes_return()
    def pop(self):
        return self.data.pop()

The second approach is a bundle of targeted decorators that wrap appropriate append and remove notifiers around the mutation methods present in the standard Python list, set and dict interfaces. These could be specified in terms of generic decorator recipes, but are instead hand-tooled for increased efficiency. The targeted decorators occasionally implement adapter-like behavior, such as mapping bulk-set methods (extend, update, __setslice__, etc.) into the series of atomic mutation events that the ORM requires.

The targeted decorators are used internally for automatic instrumentation of entity collection classes. Every collection class goes through a transformation process roughly like so:

  1. If the class is a built-in, substitute a trivial sub-class
  2. Is this class already instrumented?
  3. Add in generic decorators
  4. Sniff out the collection interface through duck-typing
  5. Add targeted decoration to any undecorated interface method

This process modifies the class at runtime, decorating methods and adding some bookkeeping properties. This isn't possible (or desirable) for built-in classes like list, so trivial sub-classes are substituted to hold decoration:

class InstrumentedList(list):
    pass

Collection classes can be specified in relationship(collection_class=) as types or a function that returns an instance. Collection classes are inspected and instrumented during the mapper compilation phase. The collection_class callable will be executed once to produce a specimen instance, and the type of that specimen will be instrumented. Functions that return built-in types like lists will be adapted to produce instrumented instances.

When extending a known type like list, additional decorations are not generally not needed. Odds are, the extension method will delegate to a method that's already instrumented. For example:

class QueueIsh(list):
   def push(self, item):
       self.append(item)
   def shift(self):
       return self.pop(0)

There's no need to decorate these methods. append and pop are already instrumented as part of the list interface. Decorating them would fire duplicate events, which should be avoided.

The targeted decoration tries not to rely on other methods in the underlying collection class, but some are unavoidable. Many depend on 'read' methods being present to properly instrument a 'write', for example, __setitem__ needs __getitem__. "Bulk" methods like update and extend may also reimplemented in terms of atomic appends and removes, so the extend decoration will actually perform many append operations and not call the underlying method at all.

Tight control over bulk operation and the firing of events is also possible by implementing the instrumentation internally in your methods. The basic instrumentation package works under the general assumption that collection mutation will not raise unusual exceptions. If you want to closely orchestrate append and remove events with exception management, internal instrumentation may be the answer. Within your method, collection_adapter(self) will retrieve an object that you can use for explicit control over triggering append and remove events.

The owning object and .CollectionAttributeImpl are also reachable through the adapter, allowing for some very sophisticated behavior.

Class collection Decorators for entity collection classes.
Class ​Collection​Adapter Bridges between the ORM and arbitrary Python collections.
Class ​Instrumented​Dict An instrumented version of the built-in dict.
Class ​Instrumented​List An instrumented version of the built-in list.
Class ​Instrumented​Set An instrumented version of the built-in set.
Class ​Mapped​Collection A basic dictionary-based collection class.
Function attribute​_mapped​_collection A dictionary-based collection type with attribute-based keying.
Function bulk​_replace Load a new collection, firing events based on prior like membership.
Function column​_mapped​_collection A dictionary-based collection type with column-based keying.
Function mapped​_collection A dictionary-based collection type with arbitrary keying.
Function prepare​_instrumentation Prepare a callable for future use as a collection class factory.
Variable collection​_adapter Fetch the .CollectionAdapter for a collection.
Class _​Plain​Column​Getter Plain column getter, stores collection of Column objects directly.
Class _​Serializable​Attr​Getter Undocumented
Class _​Serializable​Column​Getter Column-based getter used in version 0.7.6 only.
Class _​Serializable​Column​Getter​V2 Updated serializable getter which deals with multi-table mapped classes.
Function __before​_pop An event which occurs on a before a pop() operation occurs.
Function __converting​_factory Return a wrapper that converts a "canned" collection like set, dict, list into the Instrumented* version.
Function __del Run del events.
Function __set Run set events.
Function __set​_wo​_mutation Run set wo mutation events.
Function ​_assert​_required​_roles ensure all roles are present, and apply implicit instrumentation if needed
Function ​_dict​_decorators Tailored instrumentation wrappers for any dict-like mapping class.
Function ​_instrument​_class Modify methods in a class and install instrumentation.
Function ​_instrument​_membership​_mutator Route method args and/or return value through the collection adapter.
Function ​_list​_decorators Tailored instrumentation wrappers for any list-like class.
Function ​_locate​_roles​_and​_methods search for _sa_instrument_role-decorated methods in method resolution order, assign to roles.
Function ​_set​_binops​_check​_loose Allow anything set-like to participate in set binops.
Function ​_set​_binops​_check​_strict Allow only set, frozenset and self.__class__-derived objects in binops.
Function ​_set​_collection​_attributes apply ad-hoc instrumentation from decorators, class-level defaults and implicit role declarations
Function ​_set​_decorators Tailored instrumentation wrappers for any set-like class.
Function ​_setup​_canned​_roles No summary
Variable __canned​_instrumentation Undocumented
Variable __instrumentation​_mutex Undocumented
Variable __interfaces Undocumented
Variable ​_set​_binop​_bases Undocumented
def attribute_mapped_collection(attr_name):

A dictionary-based collection type with attribute-based keying.

Returns a .MappedCollection factory with a keying based on the 'attr_name' attribute of entities in the collection, where attr_name is the string name of the attribute.

Warning

the key value must be assigned to its final value before it is accessed by the attribute mapped collection. Additionally, changes to the key attribute are not tracked automatically, which means the key in the dictionary is not automatically synchronized with the key value on the target object itself. See the section :ref:`key_collections_mutations` for an example.

def bulk_replace(values, existing_adapter, new_adapter, initiator=None):

Load a new collection, firing events based on prior like membership.

Appends instances in values onto the new_adapter. Events will be fired for any instance not present in the existing_adapter. Any instances in existing_adapter not present in values will have remove events fired upon them.

Parameters
valuesAn iterable of collection member instances
existing​_adapterA .CollectionAdapter of instances to be replaced
new​_adapterAn empty .CollectionAdapter to load with values
initiatorUndocumented
def column_mapped_collection(mapping_spec):

A dictionary-based collection type with column-based keying.

Returns a .MappedCollection factory with a keying function generated from mapping_spec, which may be a Column or a sequence of Columns.

The key value must be immutable for the lifetime of the object. You can not, for example, map on foreign key values if those key values will change during the session, i.e. from None to a database-assigned integer after a session flush.

def mapped_collection(keyfunc):

A dictionary-based collection type with arbitrary keying.

Returns a .MappedCollection factory with a keying function generated from keyfunc, a callable that takes an entity and returns a key value.

The key value must be immutable for the lifetime of the object. You can not, for example, map on foreign key values if those key values will change during the session, i.e. from None to a database-assigned integer after a session flush.

def prepare_instrumentation(factory):

Prepare a callable for future use as a collection class factory.

Given a collection class factory (either a type or no-arg callable), return another factory that will produce compatible instances when called.

This function is responsible for converting collection_class=list into the run-time behavior of collection_class=InstrumentedList.

collection_adapter =
Fetch the .CollectionAdapter for a collection.
def __before_pop(collection, _sa_initiator=None):
An event which occurs on a before a pop() operation occurs.
def __converting_factory(specimen_cls, original_factory):
Return a wrapper that converts a "canned" collection like set, dict, list into the Instrumented* version.
def __del(collection, item, _sa_initiator=None):

Run del events.

This event occurs before the collection is actually mutated, except in the case of a pop operation, in which case it occurs afterwards. For pop operations, the __before_pop hook is called before the operation occurs.

def __set(collection, item, _sa_initiator=None):

Run set events.

This event always occurs before the collection is actually mutated.

def __set_wo_mutation(collection, item, _sa_initiator=None):

Run set wo mutation events.

The collection is not mutated.

def _assert_required_roles(cls, roles, methods):
ensure all roles are present, and apply implicit instrumentation if needed
def _dict_decorators():
Tailored instrumentation wrappers for any dict-like mapping class.
def _instrument_class(cls):
Modify methods in a class and install instrumentation.
def _instrument_membership_mutator(method, before, argument, after):
Route method args and/or return value through the collection adapter.
def _list_decorators():
Tailored instrumentation wrappers for any list-like class.
def _locate_roles_and_methods(cls):
search for _sa_instrument_role-decorated methods in method resolution order, assign to roles.
def _set_binops_check_loose(self, obj):
Allow anything set-like to participate in set binops.
def _set_binops_check_strict(self, obj):
Allow only set, frozenset and self.__class__-derived objects in binops.
def _set_collection_attributes(cls, roles, methods):
apply ad-hoc instrumentation from decorators, class-level defaults and implicit role declarations
def _set_decorators():
Tailored instrumentation wrappers for any set-like class.
def _setup_canned_roles(cls, roles, methods):
see if this class has "canned" roles based on a known collection type (dict, set, list). Apply those roles as needed to the "roles" dictionary, and also prepare "decorator" methods
__canned_instrumentation =

Undocumented

__instrumentation_mutex =

Undocumented

__interfaces =

Undocumented

_set_binop_bases =

Undocumented