Changeset 342

Timestamp:

06/18/08 18:37:18 (5 years ago)

Author:

ged

Message:

- remove deprecated methods on Entity
- pulled entity mapping and target resolving code from EntityMeta and

Relationship so that people can provide their own registry with any behavior
they like.

Location:

elixir/trunk/elixir

Files:

• __init__.py (modified) (3 diffs)
• entity.py (modified) (8 diffs)
• relationships.py (modified) (2 diffs)

elixir/trunk/elixir/__init__.py

@@ -21 +21 @@
     from sets import Set as set
 
+import sys
 import warnings
+
+from py23compat import rsplit
+
 import sqlalchemy
 from sqlalchemy.types import *
@@ -93 +97 @@
 # default entity collection
 class AttributeEntityList(list):
+    _entities = {}
     
     def __init__(self):
@@ -101 +106 @@
         if key in self._entity_map:
             warnings.warn('An entity named `%s` is already registered!' % key)
+
+        # build a dict of entities for each frame where there are entities
+        # defined. 3 is because map_entity is called by:
+        # EntityDescriptor::setup_options (which is called by)
+        # EntityMeta::__init__
+        # which is called when the entity is defined
+        caller_frame = sys._getframe(3)
+        cid = entity._caller = id(caller_frame)
+        caller_entities = self._entities.setdefault(cid, {})
+        caller_entities[key] = entity
+
+        # Append all entities which are currently visible by the entity. This 
+        # will find more entities only if some of them where imported from 
+        # another module.
+        for ent in [e for e in caller_frame.f_locals.values() 
+                         if isinstance(e, EntityMeta)]:
+            caller_entities[ent.__name__] = ent
+        
         self._entity_map[key] = entity
     
+    def resolve(self, key, entity=None):
+        if isinstance(key, EntityMeta):
+            return key
+        else:
+            path = rsplit(key, '.', 1)
+            classname = path.pop()
+
+            if path:
+                # Do we have a fully qualified entity name?
+                module = sys.modules[path.pop()]
+                return getattr(module, classname, None)
+            else:
+                # If not, try the list of entities of the "caller" of the 
+                # source class. Most of the time, this will be the module 
+                # the class is defined in. But it could also be a method 
+                # (inner classes).
+                caller_entities = self._entities[entity._caller]
+                return caller_entities[classname]
+
     def __getattr__(self, key):        
         return self._entity_map.get(key)

elixir/trunk/elixir/entity.py

@@ -10 +10 @@
 
 import sqlalchemy
-from sqlalchemy                    import Table, Column, Integer, \
-                                          desc, ForeignKey, and_, \
-                                          ForeignKeyConstraint
-from sqlalchemy.orm                import Query, MapperExtension, \
-                                          mapper, object_session, \
-                                          EXT_CONTINUE, \
-                                          polymorphic_union
+from sqlalchemy     import Table, Column, Integer, desc, ForeignKey, and_, \
+                           ForeignKeyConstraint
+from sqlalchemy.orm import Query, MapperExtension, mapper, object_session, \
+                           EXT_CONTINUE, polymorphic_union
 try:
     from sqlalchemy.ext.sessioncontext import SessionContext
@@ -86 +83 @@
         self.builders = []
 
-        self.is_base = is_base(entity)
         self.parent = None
         self.children = []
 
         for base in entity.__bases__:
-            if isinstance(base, EntityMeta) and not is_base(base):
+            if isinstance(base, EntityMeta) and is_entity(base):
                 if self.parent:
                     raise Exception('%s entity inherits from several entities,'
@@ -278 +274 @@
                     self.entity.table = self.parent.table 
 
-                    # re-add the entity columns to the parent entity so that they
-                    # are added to the parent's table (whether the parent's table
-                    # is already setup or not).
+                    # re-add the entity columns to the parent entity so that 
+                    # they are added to the parent's table (whether the 
+                    # parent's table is already setup or not).
                     for col in self.columns:
                         self.parent._descriptor.add_column(col)
@@ -655 +651 @@
         return getattr(owner, self.attrname)
 
-def is_base(cls):
+def is_entity(cls):
     """
-    Scan bases classes to see if any is an instance of EntityMeta. If we
-    don't find any, it means the current entity is a base class (like 
-    the 'Entity' class).
+    Scan the bases classes of `cls` to see if any is an instance of 
+    EntityMeta. If we don't find any, it means it is either an unrelated class
+    or an entity base class (like the 'Entity' class).
     """
     for base in cls.__bases__:
         if isinstance(base, EntityMeta):
-            return False
-    return True
+            return True
+    return False
 
 class EntityMeta(type):
@@ -672 +668 @@
     for your entities (ie you don't want to use the provided 'Entity' class).
     """
-    _entities = {}
 
     def __init__(cls, name, bases, dict_):
@@ -679 +674 @@
         # be registered in an entity collection, nor to have a table name and 
         # so on. 
-        if is_base(cls):
+        if not is_entity(cls):
             return
-
-        # build a dict of entities for each frame where there are entities
-        # defined
-        caller_frame = sys._getframe(1)
-        cid = cls._caller = id(caller_frame)
-        caller_entities = EntityMeta._entities.setdefault(cid, {})
-        caller_entities[name] = cls
-
-        # Append all entities which are currently visible by the entity. This 
-        # will find more entities only if some of them where imported from 
-        # another module.
-        for entity in [e for e in caller_frame.f_locals.values() 
-                         if isinstance(e, EntityMeta)]:
-            caller_entities[entity.__name__] = entity
 
         # create the entity descriptor
@@ -772 +753 @@
     #TODO: we might want to add all columns that will be available as
     #attributes on the class itself (in SA 0.4). This would be a pretty
-    #rare usecase, as people will hit the query attribute before the
+    #rare usecase, as people will normally hit the query attribute before the
     #column attributes, but still...
     for name in ('c', 'table', 'mapper', 'query'):
@@ -1008 +989 @@
     get = classmethod(get)
 
-    #-----------------#
-    # DEPRECATED LAND #
-    #-----------------#
-
-    def filter(cls, *args, **kwargs):
-        warnings.warn("The filter method on the class is deprecated."
-                      "You should use cls.query.filter(...)", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter(*args, **kwargs)
-    filter = classmethod(filter)
-
-    def filter_by(cls, *args, **kwargs):
-        warnings.warn("The filter_by method on the class is deprecated."
-                      "You should use cls.query.filter_by(...)", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter_by(*args, **kwargs)
-    filter_by = classmethod(filter_by)
-
-    def select(cls, *args, **kwargs):
-        warnings.warn("The select method on the class is deprecated."
-                      "You should use cls.query.filter(...).all()", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter(*args, **kwargs).all()
-    select = classmethod(select)
-
-    def select_by(cls, *args, **kwargs):
-        warnings.warn("The select_by method on the class is deprecated."
-                      "You should use cls.query.filter_by(...).all()", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter_by(*args, **kwargs).all()
-    select_by = classmethod(select_by)
-
-    def selectfirst(cls, *args, **kwargs):
-        warnings.warn("The selectfirst method on the class is deprecated."
-                      "You should use cls.query.filter(...).first()", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter(*args, **kwargs).first()
-    selectfirst = classmethod(selectfirst)
-
-    def selectfirst_by(cls, *args, **kwargs):
-        warnings.warn("The selectfirst_by method on the class is deprecated."
-                      "You should use cls.query.filter_by(...).first()", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter_by(*args, **kwargs).first()
-    selectfirst_by = classmethod(selectfirst_by)
-
-    def selectone(cls, *args, **kwargs):
-        warnings.warn("The selectone method on the class is deprecated."
-                      "You should use cls.query.filter(...).one()", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter(*args, **kwargs).one()
-    selectone = classmethod(selectone)
-
-    def selectone_by(cls, *args, **kwargs):
-        warnings.warn("The selectone_by method on the class is deprecated."
-                      "You should use cls.query.filter_by(...).one()", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter_by(*args, **kwargs).one()
-    selectone_by = classmethod(selectone_by)
-
-    def join_to(cls, *args, **kwargs):
-        warnings.warn("The join_to method on the class is deprecated."
-                      "You should use cls.query.join(...)", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.join_to(*args, **kwargs).all()
-    join_to = classmethod(join_to)
-
-    def join_via(cls, *args, **kwargs):
-        warnings.warn("The join_via method on the class is deprecated."
-                      "You should use cls.query.join(...)", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.join_via(*args, **kwargs).all()
-    join_via = classmethod(join_via)
-
-    def count(cls, *args, **kwargs):
-        warnings.warn("The count method on the class is deprecated."
-                      "You should use cls.query.filter(...).count()", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter(*args, **kwargs).count()
-    count = classmethod(count)
-
-    def count_by(cls, *args, **kwargs):
-        warnings.warn("The count_by method on the class is deprecated."
-                      "You should use cls.query.filter_by(...).count()", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.filter_by(*args, **kwargs).count()
-    count_by = classmethod(count_by)
-
-    def options(cls, *args, **kwargs):
-        warnings.warn("The options method on the class is deprecated."
-                      "You should use cls.query.options(...)", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.options(*args, **kwargs)
-    options = classmethod(options)
-
-    def instances(cls, *args, **kwargs):
-        warnings.warn("The instances method on the class is deprecated."
-                      "You should use cls.query.instances(...)", 
-                      DeprecationWarning, stacklevel=2)
-        return cls.query.instances(*args, **kwargs)
-    instances = classmethod(instances)
-
-
-

elixir/trunk/elixir/relationships.py

@@ -327 +327 @@
 '''
 
+import sys
+
 from sqlalchemy         import ForeignKeyConstraint, Column, \
                                Table, and_
 from sqlalchemy.orm     import relation, backref
+from sqlalchemy.ext.associationproxy import association_proxy
+
+import options
 from elixir.statements  import ClassMutator
 from elixir.fields      import Field
 from elixir.properties  import Property
 from elixir.entity      import EntityDescriptor, EntityMeta
-from sqlalchemy.ext.associationproxy import association_proxy
-
-from py23compat import rsplit
-
-import sys
-import options
+
 
 __doc_all__ = []
@@ -415 +415 @@
         self.property = relation(self.target, **kwargs)
         self.entity._descriptor.add_property(self.name, self.property)
-    
+
     def target(self):
         if not self._target:
-            if isinstance(self.of_kind, EntityMeta):
-                self._target = self.of_kind
-            else:
-                path = rsplit(self.of_kind, '.', 1)
-                classname = path.pop()
-
-                if path:
-                    # do we have a fully qualified entity name?
-                    module = sys.modules[path.pop()]
-                    self._target = getattr(module, classname, None)
-                else:
-                    # If not, try the list of entities of the "caller" of the 
-                    # source class. Most of the time, this will be the module 
-                    # the class is defined in. But it could also be a method 
-                    # (inner classes).
-                    caller_entities = EntityMeta._entities[self.entity._caller]
-                    self._target = caller_entities[classname]
+            collection = self.entity._descriptor.collection
+            self._target = collection.resolve(self.of_kind, self.entity)
         return self._target
     target = property(target)