# interfaces.py# Copyright (C) 2005, 2006, 2007, 2008 Michael Bayer mike_mp@zzzcomputing.com## This module is part of SQLAlchemy and is released under# the MIT License: http://www.opensource.org/licenses/mit-license.php"""Semi-private implementation objects which form the basisof ORM-mapped attributes, query options and mapper extension.Defines the [sqlalchemy.orm.interfaces#MapperExtension] class,which can be end-user subclassed to add event-based functionalityto mappers.  The remainder of this module is generally private to theORM."""from itertools import chainfrom sqlalchemy import exceptions, loggingfrom sqlalchemy.sql import expressionclass_mapper = None__all__ = ['EXT_CONTINUE', 'EXT_STOP', 'EXT_PASS', 'MapperExtension',           'MapperProperty', 'PropComparator', 'StrategizedProperty',           'build_path', 'MapperOption',           'ExtensionOption', 'PropertyOption',           'AttributeExtension', 'StrategizedOption', 'LoaderStrategy' ]EXT_CONTINUE = EXT_PASS = object()EXT_STOP = object()class MapperExtension(object):    """Base implementation for customizing Mapper behavior.    For each method in MapperExtension, returning a result of EXT_CONTINUE    will allow processing to continue to the next MapperExtension in line or    use the default functionality if there are no other extensions.    Returning EXT_STOP will halt processing of further extensions handling    that method.  Some methods such as ``load`` have other return    requirements, see the individual documentation for details.  Other than    these exception cases, any return value other than EXT_CONTINUE or    EXT_STOP will be interpreted as equivalent to EXT_STOP.    EXT_PASS is a synonym for EXT_CONTINUE and is provided for backward    compatibility.    """    def instrument_class(self, mapper, class_):        return EXT_CONTINUE    def init_instance(self, mapper, class_, oldinit, instance, args, kwargs):        return EXT_CONTINUE    def init_failed(self, mapper, class_, oldinit, instance, args, kwargs):        return EXT_CONTINUE    def get_session(self):        """Retrieve a contextual Session instance with which to        register a new object.        Note: this is not called if a session is provided with the        `__init__` params (i.e. `_sa_session`).        """        return EXT_CONTINUE    def load(self, query, *args, **kwargs):        """Override the `load` method of the Query object.        The return value of this method is used as the result of        ``query.load()`` if the value is anything other than EXT_CONTINUE.        """        return EXT_CONTINUE    def get(self, query, *args, **kwargs):        """Override the `get` method of the Query object.        The return value of this method is used as the result of        ``query.get()`` if the value is anything other than EXT_CONTINUE.        """        return EXT_CONTINUE    def get_by(self, query, *args, **kwargs):        """Override the `get_by` method of the Query object.        The return value of this method is used as the result of        ``query.get_by()`` if the value is anything other than        EXT_CONTINUE.        DEPRECATED.        """        return EXT_CONTINUE    def select_by(self, query, *args, **kwargs):        """Override the `select_by` method of the Query object.        The return value of this method is used as the result of        ``query.select_by()`` if the value is anything other than        EXT_CONTINUE.        DEPRECATED.        """        return EXT_CONTINUE    def select(self, query, *args, **kwargs):        """Override the `select` method of the Query object.        The return value of this method is used as the result of        ``query.select()`` if the value is anything other than        EXT_CONTINUE.        DEPRECATED.        """        return EXT_CONTINUE    def translate_row(self, mapper, context, row):        """Perform pre-processing on the given result row and return a        new row instance.        This is called as the very first step in the ``_instance()``        method.        """        return EXT_CONTINUE    def create_instance(self, mapper, selectcontext, row, class_):        """Receive a row when a new object instance is about to be        created from that row.        The method can choose to create the instance itself, or it can return        EXT_CONTINUE to indicate normal object creation should take place.        mapper          The mapper doing the operation        selectcontext          SelectionContext corresponding to the instances() call        row          The result row from the database        class\_          The class we are mapping.        return value          A new object instance, or EXT_CONTINUE        """        return EXT_CONTINUE    def append_result(self, mapper, selectcontext, row, instance, result, **flags):        """Receive an object instance before that instance is appended        to a result list.        If this method returns EXT_CONTINUE, result appending will proceed        normally.  if this method returns any other value or None,        result appending will not proceed for this instance, giving        this extension an opportunity to do the appending itself, if        desired.        mapper          The mapper doing the operation.        selectcontext          SelectionContext corresponding to the instances() call.        row          The result row from the database.        instance          The object instance to be appended to the result.        result          List to which results are being appended.        \**flags          extra information about the row, same as criterion in          `create_row_processor()` method of [sqlalchemy.orm.interfaces#MapperProperty]        """        return EXT_CONTINUE    def populate_instance(self, mapper, selectcontext, row, instance, **flags):        """Receive a newly-created instance before that instance has        its attributes populated.        The normal population of attributes is according to each        attribute's corresponding MapperProperty (which includes        column-based attributes as well as relationships to other        classes).  If this method returns EXT_CONTINUE, instance        population will proceed normally.  If any other value or None        is returned, instance population will not proceed, giving this        extension an opportunity to populate the instance itself, if        desired.        """        return EXT_CONTINUE    def before_insert(self, mapper, connection, instance):        """Receive an object instance before that instance is INSERTed        into its table.        This is a good place to set up primary key values and such        that aren't handled otherwise.        Column-based attributes can be modified within this method which will        result in the new value being inserted.  However *no* changes to the overall        flush plan can be made; this means any collection modification or        save() operations which occur within this method will not take effect        until the next flush call.        """        return EXT_CONTINUE    def after_insert(self, mapper, connection, instance):        """Receive an object instance after that instance is INSERTed."""        return EXT_CONTINUE    def before_update(self, mapper, connection, instance):        """Receive an object instance before that instance is UPDATEed.        Note that this method is called for all instances that are marked as        "dirty", even those which have no net changes to their column-based        attributes.  An object is marked as dirty when any of its column-based        attributes have a "set attribute" operation called or when any of its        collections are modified.  If, at update time, no column-based attributes        have any net changes, no UPDATE statement will be issued.  This means        that an instance being sent to before_update is *not* a guarantee that        an UPDATE statement will be issued (although you can affect the outcome        here).        To detect if the column-based attributes on the object have net changes,        and will therefore generate an UPDATE statement, use        ``object_session(instance).is_modified(instance, include_collections=False)``.        Column-based attributes can be modified within this method which will        result in their being updated.  However *no* changes to the overall        flush plan can be made; this means any collection modification or        save() operations which occur within this method will not take effect        until the next flush call.        """        return EXT_CONTINUE    def after_update(self, mapper, connection, instance):        """Receive an object instance after that instance is UPDATEed."""        return EXT_CONTINUE    def before_delete(self, mapper, connection, instance):        """Receive an object instance before that instance is DELETEed.        Note that *no* changes to the overall        flush plan can be made here; this means any collection modification,        save() or delete() operations which occur within this method will        not take effect until the next flush call.        """        return EXT_CONTINUE    def after_delete(self, mapper, connection, instance):        """Receive an object instance after that instance is DELETEed."""        return EXT_CONTINUEclass MapperProperty(object):    """Manage the relationship of a ``Mapper`` to a single class    attribute, as well as that attribute as it appears on individual    instances of the class, including attribute instrumentation,    attribute access, loading behavior, and dependency calculations.    """    def setup(self, querycontext, **kwargs):        """Called by Query for the purposes of constructing a SQL statement.        Each MapperProperty associated with the target mapper processes the        statement referenced by the query context, adding columns and/or        criterion as appropriate.        """        pass    def create_row_processor(self, selectcontext, mapper, row):        """Return a 3-tuple consiting of two row processing functions and an instance post-processing function.        Input arguments are the query.SelectionContext and the *first*        applicable row of a result set obtained within        query.Query.instances(), called only the first time a particular        mapper's populate_instance() method is invoked for the overall result.        The settings contained within the SelectionContext as well as the        columns present in the row (which will be the same columns present in        all rows) are used to determine the presence and behavior of the        returned callables.  The callables will then be used to process all        rows and to post-process all instances, respectively.        Callables are of the following form::            def new_execute(instance, row, **flags):                # process incoming instance and given row.  the instance is                # "new" and was just created upon receipt of this row.                # flags is a dictionary containing at least the following                # attributes:                #   isnew - indicates if the instance was newly created as a                #           result of reading this row                #   instancekey - identity key of the instance                # optional attribute:                #   ispostselect - indicates if this row resulted from a                #                  'post' select of additional tables/columns            def existing_execute(instance, row, **flags):                # process incoming instance and given row.  the instance is                # "existing" and was created based on a previous row.            def post_execute(instance, **flags):                # process instance after all result rows have been processed.                # this function should be used to issue additional selections                # in order to eagerly load additional properties.            return (new_execute, existing_execute, post_execute)        Either of the three tuples can be ``None`` in which case no function        is called.        """        raise NotImplementedError()    def cascade_iterator(self, type, object, recursive=None, halt_on=None):        """Iterate through instances related to the given instance along        a particular 'cascade' path, starting with this MapperProperty.        See PropertyLoader for the related instance implementation.        """        return iter([])    def get_criterion(self, query, key, value):        """Return a ``WHERE`` clause suitable for this        ``MapperProperty`` corresponding to the given key/value pair,        where the key is a column or object property name, and value        is a value to be matched.  This is only picked up by