def replicate_attributes(source, target, cache=None):
    '''Replicates common SQLAlchemy attributes from the `source` object to the
    `target` object.'''
    target_manager = manager_of_class(type(target))
    column_attrs = set()
    relationship_attrs = set()
    relationship_columns = set()
    for attr in manager_of_class(type(source)).attributes:
        if attr.key not in target_manager:
            # It's not common attribute
            continue
        target_attr = target_manager[attr.key]
        if isinstance(attr.property, ColumnProperty):
            assert isinstance(target_attr.property, ColumnProperty)
            column_attrs.add(attr)
        elif isinstance(attr.property, RelationshipProperty):
            assert isinstance(target_attr.property, RelationshipProperty)
            relationship_attrs.add(attr)
            if attr.property.direction is MANYTOONE:
                relationship_columns.update(attr.property.local_columns)
    for attr in column_attrs:
        if _column_property_in_registry(attr.property, _excluded):
            continue
        elif (not _column_property_in_registry(attr.property, _included) and
                 all(column in relationship_columns
                     for column in attr.property.columns)):
            continue
        setattr(target, attr.key, getattr(source, attr.key))
    for attr in relationship_attrs:
        target_attr_model = target_manager[attr.key].property.argument
        if not is_relation_replicatable(attr):
            continue
        replicate_relation(source, target, attr, target_manager[attr.key],
                           cache=cache)

    def test_uninstrument(self):
        class A(object):pass

        manager = attributes.register_class(A)

        assert attributes.manager_of_class(A) is manager
        attributes.unregister_class(A)
        assert attributes.manager_of_class(A) is None

    def test_null_instrumentation(self):
        class Foo(MyBaseClass):
            pass
        attributes.register_class(Foo)
        attributes.register_attribute(Foo, "name", uselist=False, useobject=False)
        attributes.register_attribute(Foo, "bars", uselist=True, trackparent=True, useobject=True)

        assert Foo.name == attributes.manager_of_class(Foo)['name']
        assert Foo.bars == attributes.manager_of_class(Foo)['bars']

    def test_rebuild_state(self):
        """not much of a 'test', but illustrate how to 
        remove instance-level state before pickling.
        
        """
        mapper(User, users)

        u1 = User()
        attributes.manager_of_class(User).teardown_instance(u1)
        assert not u1.__dict__
        u2 = pickle.loads(pickle.dumps(u1))
        attributes.manager_of_class(User).setup_instance(u2)
        assert attributes.instance_state(u2)

        def __new__(cls, schema, id_fields=None, **fields):
            if isinstance(schema, basestring):
                table = metadata.tables.get(schema, None)
                if table is None:
                    raise ValueError("%s is not defined in the metadata" % schema)
                managed_class = managed_class_of_table(table)
            elif isinstance(schema, Table):
                table = schema
                managed_class = managed_class_of_table(table)
            elif isinstance(schema, Mapper):
                table = schema.local_table
                managed_class = schema.class_
            else:
                manager = manager_of_class(schema)
                if manager is not None:
                    managed_class = manager
                    table = manager.mapper.local_table
                else:
                    raise TypeError("schema must be either a table name or a %s instance" % Table.__name__)

            if managed_class is not None:
                assert not issubclass(managed_class, DatumBase)
                _cls = lookup_mixin_class(managed_class)
            else:
                _cls = cls
            newinstance = object.__new__(_cls)
            newinstance._tableau_table = table
            return newinstance

def _entity_descriptor(entity, key):
    """Return attribute/property information given an entity and string name.

    Returns a 2-tuple representing InstrumentedAttribute/MapperProperty.

    """
    if isinstance(entity, AliasedClass):
        try:
            desc = getattr(entity, key)
            return desc, desc.property
        except AttributeError:
            raise sa_exc.InvalidRequestError("Entity '%s' has no property '%s'" % (entity, key))
            
    elif isinstance(entity, type):
        try:
            desc = attributes.manager_of_class(entity)[key]
            return desc, desc.property
        except KeyError:
            raise sa_exc.InvalidRequestError("Entity '%s' has no property '%s'" % (entity, key))
            
    else:
        try:
            desc = entity.class_manager[key]
            return desc, desc.property
        except KeyError:
            raise sa_exc.InvalidRequestError("Entity '%s' has no property '%s'" % (entity, key))

    def test_nativeext_submanager(self):
        class Mine(attributes.ClassManager): pass
        class A(object):
            __sa_instrumentation_manager__ = Mine

        attributes.register_class(A)
        eq_(type(attributes.manager_of_class(A)), Mine)

 def __build_operation_from_file(self, project, operation_file):
     """
     Create Operation entity from metadata file.
     """
     operation_dict = XMLReader(operation_file).read_metadata()
     operation_entity = manager_of_class(model.Operation).new_instance()
     return operation_entity.from_dict(operation_dict, dao, self.user_id, project.gid)

    def __setstate__(self, state):
        self.obj = weakref.ref(state["instance"], self._cleanup)
        self.class_ = state["instance"].__class__
        self.manager = manager = manager_of_class(self.class_)
        if manager is None:
            raise orm_exc.UnmappedInstanceError(
                state["instance"],
                "Cannot deserialize object of type %r - no mapper() has"
                " been configured for this class within the current Python process!" % self.class_,
            )
        elif manager.mapper and not manager.mapper.compiled:
            manager.mapper.compile()

        self.committed_state = state.get("committed_state", {})
        self.pending = state.get("pending", {})
        self.parents = state.get("parents", {})
        self.modified = state.get("modified", False)
        self.expired = state.get("expired", False)
        self.callables = state.get("callables", {})

        if self.modified:
            self._strong_obj = state["instance"]

        self.__dict__.update([(k, state[k]) for k in ("key", "load_options", "mutable_dict") if k in state])

        if "load_path" in state:
            self.load_path = interfaces.deserialize_path(state["load_path"])

def _entity_info(entity, compile=True):
    """Return mapping information given a class, mapper, or AliasedClass.

    Returns 3-tuple of: mapper, mapped selectable, boolean indicating if this
    is an aliased() construct.

    If the given entity is not a mapper, mapped class, or aliased construct,
    returns None, the entity, False.  This is typically used to allow
    unmapped selectables through.

    """
    if isinstance(entity, AliasedClass):
        return entity._AliasedClass__mapper, entity._AliasedClass__alias, True

    if isinstance(entity, mapperlib.Mapper):
        mapper = entity

    elif isinstance(entity, type):
        class_manager = attributes.manager_of_class(entity)

        if class_manager is None:
            return None, entity, False

        mapper = class_manager.mapper
    else:
        return None, entity, False

    if compile:
        mapper = mapper.compile()
    return mapper, mapper._with_polymorphic_selectable, False

    def __setstate__(self, state):
        self.obj = weakref.ref(state['instance'], self._cleanup)
        self.class_ = state['instance'].__class__
        self.manager = manager = manager_of_class(self.class_)
        if manager is None:
            raise orm_exc.UnmappedInstanceError(
                        state['instance'],
                        "Cannot deserialize object of type %r - no mapper() has"
                        " been configured for this class within the current Python process!" %
                        self.class_)
        elif manager.is_mapped and not manager.mapper.compiled:
            manager.mapper.compile()

        self.committed_state = state.get('committed_state', {})
        self.pending = state.get('pending', {})
        self.parents = state.get('parents', {})
        self.modified = state.get('modified', False)
        self.expired = state.get('expired', False)
        self.callables = state.get('callables', {})

        if self.modified:
            self._strong_obj = state['instance']

        self.__dict__.update([
            (k, state[k]) for k in (
                'key', 'load_options', 'mutable_dict'
            ) if k in state 
        ])

        if 'load_path' in state:
            self.load_path = interfaces.deserialize_path(state['load_path'])

 def register(self, cls, canary):
     original_init = cls.__init__
     attributes.register_class(cls)
     ne_(cls.__init__, original_init)
     manager = attributes.manager_of_class(cls)
     def on_init(state, instance, args, kwargs):
         canary.append((cls, 'on_init', type(instance)))
     manager.events.add_listener('on_init', on_init)

    def test_customfinder_pass(self):
        class A(object): pass
        def find(cls):
            return None

        attributes.instrumentation_finders.insert(0, find)
        attributes.register_class(A)
        eq_(type(attributes.manager_of_class(A)), attributes.ClassManager)

    def test_collectionclasses(self):

        class Foo(object):pass
        attributes.register_class(Foo)

        attributes.register_attribute(Foo, "collection", uselist=True, typecallable=set, useobject=True)
        assert attributes.manager_of_class(Foo).is_instrumented("collection")
        assert isinstance(Foo().collection, set)

        attributes.unregister_attribute(Foo, "collection")
        assert not attributes.manager_of_class(Foo).is_instrumented("collection")
        
        try:
            attributes.register_attribute(Foo, "collection", uselist=True, typecallable=dict, useobject=True)
            assert False
        except sa_exc.ArgumentError, e:
            assert str(e) == "Type InstrumentedDict must elect an appender method to be a collection class"

def _is_mapped_class(cls):
    from sqlalchemy.orm import mapperlib as mapper
    if isinstance(cls, (AliasedClass, mapper.Mapper)):
        return True
    if isinstance(cls, expression.ClauseElement):
        return False
    manager = attributes.manager_of_class(cls)
    return manager and _INSTRUMENTOR in manager.info

def _mapper_or_none(cls):
    """Return the :class:`.Mapper` for the given class or None if the
    class is not mapped."""

    manager = attributes.manager_of_class(cls)
    if manager is not None and _INSTRUMENTOR in manager.info:
        return manager.info[_INSTRUMENTOR]
    else:
        return None

    def test_alternate_finders(self):
        """Ensure the generic finder front-end deals with edge cases."""

        class Unknown(object): pass
        class Known(MyBaseClass): pass

        attributes.register_class(Known)
        k, u = Known(), Unknown()

        assert attributes.manager_of_class(Unknown) is None
        assert attributes.manager_of_class(Known) is not None
        assert attributes.manager_of_class(None) is None

        assert attributes.instance_state(k) is not None
        assert_raises((AttributeError, KeyError),
                          attributes.instance_state, u)
        assert_raises((AttributeError, KeyError),
                          attributes.instance_state, None)

def _is_mapped_class(cls):
    if isinstance(cls, (AliasedClass, mapperlib.Mapper)):
        return True
    if isinstance(cls, expression.ClauseElement):
        return False
    if isinstance(cls, type):
        manager = attributes.manager_of_class(cls)
        return manager and _INSTRUMENTOR in manager.info
    return False

def get_state_dict(instance,name="Generic"):
    cls = type(instance)
    mgr = manager_of_class(cls)
    myDict = dict((key, sanitize(getattr(instance, key)))
                  for key, attr in mgr.iteritems()
                  if isinstance(attr.property, ColumnProperty))
    # next, we convert the dictionary to a 'namespace',
    # which allows us to use dot notation
    # XXX used named tuple instead?
    nameSpace = ap.Namespace(**myDict)
    return nameSpace

def _is_mapped_class(cls):
    """Return True if the given object is a mapped class,
    :class:`.Mapper`, or :class:`.AliasedClass`."""

    if isinstance(cls, (AliasedClass, mapperlib.Mapper)):
        return True
    if isinstance(cls, expression.ClauseElement):
        return False
    if isinstance(cls, type):
        manager = attributes.manager_of_class(cls)
        return manager and _INSTRUMENTOR in manager.info
    return False