Changeset 199

Timestamp:

09/06/07 15:55:47 (6 years ago)

Author:

ged

Message:

• Added test for the case when you refer to a remotely-defined class by its
  named after importing it into the local namespace.
  
• Implemented a new syntax to declare fields and relationships, much closer to
  what is found in other Python ORM's. The with_fields syntax is now
  deprecated in favor of a that new syntax. The old statement-based (has_field et
  al.) syntax stays the default for now. This was done with help from a patch
  by Adam Gomaa.
  
• Relationships to other classes can now also be defined using the classes
  themselves in addition to the class names. Obviously, this doesn't work for
  forward references.
  

Location:

elixir/trunk

Files:

• CHANGES (modified) (1 diff)
• docs/tutorial.rst (modified) (5 diffs)
• elixir/__init__.py (modified) (2 diffs)
• elixir/entity.py (modified) (16 diffs)
• elixir/ext/associable.py (modified) (3 diffs)
• elixir/fields.py (modified) (2 diffs)
• elixir/relationships.py (modified) (12 diffs)
• tests/b.py (modified) (1 diff)
• tests/test_oo_syntax.py (added)
• tests/test_packages.py (modified) (2 diffs)

elixir/trunk/CHANGES

@@ -3 +3 @@
   non-polymorphic multi-table (aka joined table) inheritance.
 - Made the statement system more powerfull.
+- Implemented a new syntax to declare fiels and relationships, much closer to
+  what is found in other Python ORM's. The with_fields syntax is now
+  deprecated in favor of a that new syntax. The old statement based (has_field et
+  al.) syntax stays the default for now. This was done with help from a patch
+  by Adam Gomaa.
+- Relationships to other classes can now also be defined using the classes
+  themselves in addition to the class namees. Obviously, this doesn't work for
+  forward references.
 - Autodelay and init order changed => order_by + belongs_to, belongs_to + pk, 
   ...

elixir/trunk/docs/tutorial.rst

@@ -38 +38 @@
 
     class Movie(Entity):
-        with_fields(
-            title = Field(Unicode(30)),
-            year = Field(Integer),
-            description = Field(Unicode)
-        )
+        title = Field(Unicode(30))
+        year = Field(Integer)
+        description = Field(Unicode)
         
         def __repr__(self):
@@ -62 +60 @@
 easily trace what is happening in an interactive python interpreter.
 
-Also, please note that elixir currently provide two different ways to declare
-the fields on your entities. We have not decided yet on which one we like best,
-or if we will always keep both. The other way to declare your fields is using
-the ``has_field`` statement, rather than the ``with_fields`` statement.  The
-``Movie`` example above can be declared using the ``has_field`` statement like
-so:
+Also, please note that elixir currently provide two different ways to
+declare the fields on your entities. We have not decided yet on which
+one we like best, or if we will always keep both. The other way to
+declare your fields is using the ``has_field`` statement, rather than
+assigning directly to the class attributes.  The ``Movie`` example
+above could be declared using the ``has_field`` statement like so:
 
 ::
@@ -151 +149 @@
 
     class Genre(Entity):
-        with_fields(
-            name = Field(Unicode(15), unique=True)
-        )
+        name = Field(Unicode(15), unique=True)
+
         
         def __repr__(self):
@@ -169 +166 @@
 
     class Movie(Entity):
-        with_fields(
-            title = Field(Unicode(30)),
-            year = Field(Integer),
-            description = Field(Unicode)
-        )
+        title = Field(Unicode(30)),
+        year = Field(Integer),
+        description = Field(Unicode)
         
         belongs_to('genre', of_kind='Genre')                # add this line
@@ -182 +177 @@
     
     class Genre(Entity):
-        with_fields(
-            name = Field(Unicode(15))
-        )
+        name = Field(Unicode(15))
         
         has_many('movies', of_kind='Movie')                 # and this one

elixir/trunk/elixir/__init__.py

@@ -28 +28 @@
 from elixir.relationships import belongs_to, has_one, has_many, \
                                  has_and_belongs_to_many
+from elixir.relationships import ManyToOne, OneToOne, OneToMany, ManyToMany
 from elixir.properties import has_property
 from elixir.statements import Statement
@@ -41 +42 @@
            'has_property', 
            'belongs_to', 'has_one', 'has_many', 'has_and_belongs_to_many',
+           'ManyToOne', 'OneToOne', 'OneToMany', 'ManyToMany',
            'using_options', 'using_table_options', 'using_mapper_options',
            'options_defaults', 'metadata', 'objectstore',

elixir/trunk/elixir/entity.py

@@ -2 +2 @@
 Entity baseclass, metaclass and descriptor
 '''
+
+import sqlalchemy
 
 from sqlalchemy                     import Table, Integer, String, desc,\
@@ -9 +11 @@
 from sqlalchemy.ext.sessioncontext  import SessionContext
 from sqlalchemy.util                import OrderedDict
-import sqlalchemy
+
 from elixir.statements              import Statement
 from elixir.fields                  import Field
@@ -62 +64 @@
 
         self.fields = OrderedDict()
-        self.relationships = OrderedDict()
+        self.relationships = list()
         self.delayed_properties = dict()
         self.constraints = list()
@@ -120 +122 @@
         since a loop of primary_keys is not a valid situation.
         """
-        for rel in self.relationships.itervalues():
+        for rel in self.relationships:
             rel.create_keys(True)
 
@@ -153 +155 @@
 
     def setup_relkeys(self):
-        for rel in self.relationships.itervalues():
+        for rel in self.relationships:
             rel.create_keys(False)
 
@@ -217 +219 @@
 
     def setup_reltables(self):
-        for rel in self.relationships.itervalues():
+        for rel in self.relationships:
             rel.create_tables()
 
@@ -367 +369 @@
 
     def setup_properties(self):
-        for rel in self.relationships.itervalues():
+        for rel in self.relationships:
             rel.create_properties()
 
@@ -417 +419 @@
 
         matching_rel = None
-        for other_rel in self.relationships.itervalues():
+        for other_rel in self.relationships:
             if other_rel.is_inverse(rel):
                 if matching_rel is None:
@@ -437 +439 @@
         return matching_rel
 
+    def find_relationship(self, name):
+        for rel in self.relationships:
+            if rel.name == name:
+                return rel
+        if self.parent:
+            return self.parent.find_relationship(name)
+        else:
+            return None
+
     def primary_keys(self):
         if self.autoload:
@@ -448 +459 @@
     primary_keys = property(primary_keys)
 
-    def all_relationships(self):
-        if self.parent:
-            res = self.parent._descriptor.all_relationships
-        else:
-            res = dict()
-        res.update(self.relationships)
-        return res
-    all_relationships = property(all_relationships)
-
 
 class TriggerProxy(object):
+    """A class that serves as a "trigger" ; accessing its attributes runs
+    the function that is set at initialization.
+
+    Primarily used for setup_all().
+
+    Note that the `setupfunc` parameter is called on each access of
+    the attribute.
+
+    """
     def __init__(self, class_, attrname, setupfunc):
         self.class_ = class_
@@ -472 +483 @@
         proxied_attr = getattr(self.class_, self.attrname)
         return "<TriggerProxy (%s)>" % (self.class_.__name__)
+
+def _is_entity(class_):
+    return isinstance(class_, EntityMeta)
 
 class EntityMeta(type):
@@ -495 +509 @@
 
         # 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.
+        # 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 e.__class__.__name__ == 'EntityMeta']:
+                         if _is_entity(e)]:
             caller_entities[entity.__name__] = entity
 
@@ -506 +520 @@
         # process statements. Needed before the proxy for metadata
         Statement.process(cls)
+
+        # Process attributes, for the assignment syntax.
+        cls._process_attrs(dict_)
 
         # setup misc options here (like tablename etc.)
@@ -513 +530 @@
         # TODO: support entity_name... or maybe not. I'm not sure it makes 
         # sense in Elixir.
-        cls.setup_proxy()
-
-    def setup_proxy(cls, entity_name=None):
+        cls._setup_proxy()
+
+    def _setup_proxy(cls, entity_name=None):
         #TODO: move as much as possible of those "_private" values to the
         # descriptor, so that we don't mess the initial class.
@@ -555 +572 @@
         cls._ready = True
 
+    def _process_attrs(cls, attr_dict):
+        """Process class attributes, looking for Elixir `Field`s or
+        `Relationship`.
+        """
+
+        for name, attr in attr_dict.iteritems():
+            # Check if it's Elixir related. 
+            if isinstance(attr, Field):
+                # If no colname was defined (through the 'colname' kwarg), set
+                # it to the name of the attr.
+                if attr.colname is None:
+                    attr.colname = name
+                cls._descriptor.add_field(attr)
+            elif isinstance(attr, elixir.relationships.Relationship):
+                attr.name = name 
+                attr.entity = cls
+                cls._descriptor.relationships.append(attr)
+            else:
+                # Not an Elixir field, let it be. 
+                pass
+        return
+
     def __getattribute__(cls, name):
         if type.__getattribute__(cls, "_ready"):
@@ -593 +632 @@
     tutorial.
     '''
-
     __metaclass__ = EntityMeta
 

elixir/trunk/elixir/ext/associable.py

@@ -131 +131 @@
             self.type = tablename
    
-    class Associable(el.relationships.Relationship):
+    class Associable(object):
         """An associable Elixir Statement object"""
         def __init__(self, entity, name=None, uselist=True, lazy=True):
@@ -142 +142 @@
             else:
                 self.name = name
-            self.entity._descriptor.relationships[able_name] = self
-
-        def create_keys(self, pk):
-            if pk:
-                return
+
+        def after_table(self):
             field = el.Field(sa.Integer, sa.ForeignKey('%s.id' % able_name),
                              colname='%s_assoc_id' % interface_name)
             self.entity._descriptor.add_field(field)
 
-        def create_tables(self):
             if not hasattr(assoc_entity, '_assoc_table'):
                 association_table = sa.Table("%s" % able_name, assoc_entity._descriptor.metadata,
@@ -178 +174 @@
                 })
         
-        def create_properties(self):
             entity = self.entity
             entity.mapper.add_property(

elixir/trunk/elixir/fields.py

@@ -8 +8 @@
 This module contains DSL statements which allow you to declare which 
 fields (columns) your Elixir entities have.  There are currently two
-different statements that you can use to declare fields:
+different ways to declare your entities fields: through the has_field_
+statement, and by using the `Object-oriented syntax`_. Note that the 
+with_fields_ statement is currently deprecated in favor of the 
+`Object-oriented syntax`_.
 
 
-`has_field`
------------
+has_field
+---------
 The `has_field` statement allows you to define fields one at a time.
 
@@ -65 +68 @@
         has_field('name', String(50))
 
+Object-oriented syntax
+----------------------
 
-`with_fields`
--------------
-The `with_fields` statement allows you to define fields all at once.
+Here is a quick example of how to use the object-oriented syntax.
 
+::
+
+    class Person(Entity):
+        id = Field(Integer, primary_key=True)
+        name = Field(String(50))
+
+with_fields
+-----------
+The `with_fields` statement is **deprecated** in favor of the `Object-oriented
+syntax`_. It allows you to define all fields of an entity at once. 
 Each keyword argument to this statement represents one field, which should
 be a `Field` object. The first argument to a Field object is its type. 

elixir/trunk/elixir/relationships.py

@@ -239 +239 @@
     '''
     
-    def __init__(self, entity, name, *args, **kwargs):
-        self.entity = entity
-        self.name = name
+    def __init__(self, of_kind, *args, **kwargs):
+        self.entity = None
+        self.name = None
         self.inverse_name = kwargs.pop('inverse', None)
 
-        if 'through' in kwargs and 'via' in kwargs:
-            setattr(entity, name, 
-                    association_proxy(kwargs.pop('through'), kwargs.pop('via'),
-                                      **kwargs))
-            return
-        elif 'through' in kwargs or 'via' in kwargs:
-            raise Exception("'through' and 'via' relationship keyword "
-                            "arguments should be used in combination.")
-
-        self.of_kind = kwargs.pop('of_kind')
+        self.of_kind = of_kind
 
         self._target = None
@@ -265 +256 @@
         self.kwargs = kwargs
 
-        self.entity._descriptor.relationships[self.name] = self
     
     def create_keys(self, pk):
@@ -310 +300 @@
     def target(self):
         if not self._target:
-            path = self.of_kind.rsplit('.', 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)
+            if isinstance(self.of_kind, EntityMeta):
+                self._target = self.of_kind
             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]
+                path = self.of_kind.rsplit('.', 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]
         return self._target
     target = property(target)
@@ -331 +324 @@
             if self.inverse_name:
                 desc = self.target._descriptor
-                # we use all_relationships so that relationships from parent
-                # entities are included too
-                inverse = desc.all_relationships.get(self.inverse_name, None)
+                inverse = desc.find_relationship(self.inverse_name)
                 if inverse is None:
                     raise Exception(
@@ -362 +353 @@
 
 
-class BelongsTo(Relationship):
+class ManyToOne(Relationship):
     '''
     
     '''
     
-    def __init__(self, entity, name, *args, **kwargs):
+    def __init__(self, *args, **kwargs):
         self.colname = kwargs.pop('colname', [])
         if self.colname and not isinstance(self.colname, list):
@@ -389 +380 @@
         self.foreign_key = list()
         self.primaryjoin_clauses = list()
-        super(BelongsTo, self).__init__(entity, name, *args, **kwargs)
+        super(ManyToOne, self).__init__(*args, **kwargs)
     
     def match_type_of(self, other):
-        return isinstance(other, (HasMany, HasOne))
+        return isinstance(other, (OneToMany, OneToOne))
 
     def create_keys(self, pk):
@@ -497 +488 @@
 
 
-class HasOne(Relationship):
+class OneToOne(Relationship):
     uselist = False
 
     def match_type_of(self, other):
-        return isinstance(other, BelongsTo)
+        return isinstance(other, ManyToOne)
 
     def create_keys(self, pk):
@@ -537 +528 @@
 
 
-class HasMany(HasOne):
+class OneToMany(OneToOne):
     uselist = True
     
     def get_prop_kwargs(self):
-        kwargs = super(HasMany, self).get_prop_kwargs()
+        kwargs = super(OneToMany, self).get_prop_kwargs()
 
         if 'order_by' in kwargs:
@@ -551 +542 @@
 
 
-class HasAndBelongsToMany(Relationship):
+class ManyToMany(Relationship):
     uselist = True
 
-    def __init__(self, entity, name, *args, **kwargs):
+    def __init__(self, *args, **kwargs):
         self.user_tablename = kwargs.pop('tablename', None)
         self.local_side = kwargs.pop('local_side', [])
@@ -565 +556 @@
         self.primaryjoin_clauses = list()
         self.secondaryjoin_clauses = list()
-        super(HasAndBelongsToMany, self).__init__(entity, name, 
-                                                  *args, **kwargs)
+        super(ManyToMany, self).__init__(*args, **kwargs)
 
     def match_type_of(self, other):
-        return isinstance(other, HasAndBelongsToMany)
+        return isinstance(other, ManyToMany)
 
     def create_tables(self):
@@ -718 +708 @@
 
     def is_inverse(self, other):
-        return super(HasAndBelongsToMany, self).is_inverse(other) and \
+        return super(ManyToMany, self).is_inverse(other) and \
                (self.user_tablename == other.user_tablename or 
                 (not self.user_tablename and not other.user_tablename))
@@ -776 +766 @@
 
 
-belongs_to = Statement(BelongsTo)
-has_one = Statement(HasOne)
-has_many = Statement(HasMany)
-has_and_belongs_to_many = Statement(HasAndBelongsToMany)
+def rel_statement_handler(target):
+    class Handler(object):
+        def __init__(self, entity, name, *args, **kwargs):
+            if 'through' in kwargs and 'via' in kwargs:
+                setattr(entity, name, 
+                        association_proxy(kwargs.pop('through'), 
+                                          kwargs.pop('via'),
+                                          **kwargs))
+                return
+            elif 'through' in kwargs or 'via' in kwargs:
+                raise Exception("'through' and 'via' relationship keyword "
+                                "arguments should be used in combination.")
+            rel = target(kwargs.pop('of_kind'), *args, **kwargs)
+            rel.name = name
+            rel.entity = entity
+            entity._descriptor.relationships.append(rel)
+    return Handler
+
+
+belongs_to = Statement(rel_statement_handler(ManyToOne))
+has_one = Statement(rel_statement_handler(OneToOne))
+has_many = Statement(rel_statement_handler(OneToMany))
+has_and_belongs_to_many = Statement(rel_statement_handler(ManyToMany))

elixir/trunk/tests/b.py

@@ -3 +3 @@
 class B(Entity):
     has_field('name', String(30))
-    has_many('a', of_kind='tests.a.A')
+    has_many('as_', of_kind='tests.a.A')
 

elixir/trunk/tests/test_packages.py

@@ -4 +4 @@
 
 from elixir import *
-import elixir
+import sys
 
-def teardown():
-    cleanup_all()
+def setup(self):
+    metadata.bind = 'sqlite:///'
 
 class TestPackages(object):
-    def setup(self):
-        metadata.bind = 'sqlite:///'
-    
     def teardown(self):
-        drop_all()
-        objectstore.clear()
+        cleanup_all(True)
     
     def test_packages(self):
         # This is an ugly workaround because when nosetest is run globally (ie
         # either on the tests directory or in the "trunk" directory, it imports
-        # all modules, including a and b and thus their entities are
-        # immediately setup but then the other tests clear all mappers, and 
-        # when we get here, this tests doesn't reinit those because the modules
-        # are not reimported. 
-        # In short, one more reason to use delay_setup by default. 
-        # Note that even if we set delay setup in this particular test, before
-        # the module imports, it'll fail because we'd need to set delay_setup
-        # before the a and b modules are imported by nosetests.
-        import sys
+        # all modules, including a and b. Then when any other test calls
+        # setup_all(), A and B are also setup, but then the other test also
+        # calls cleanup_all(), so when we get here, A and B are already dead and
+        # reimporting their modules does nothing because they were already
+        # imported.
         sys.modules.pop('tests.a', None)
         sys.modules.pop('tests.b', None)
@@ -34 +26 @@
         from tests.a import A
         from tests.b import B
-        create_all()
 
-        a = A(name='a1')
-        b = B(name='b1')
+        setup_all(True)
 
-        b.a.append(a)
+        b1 = B(name='b1', as_=[A(name='a1')])
 
         objectstore.flush()
+        objectstore.clear()
 
+        a = A.query().one()
+
+        assert a in a.b.as_
+
+    def test_ref_to_imported_entity_using_class(self):
+        sys.modules.pop('tests.a', None)
+        sys.modules.pop('tests.b', None)
+
+        from tests.a import A
+        from tests.b import B
+
+        class C(Entity):
+            has_field('name', String(30))
+            belongs_to('a', of_kind=A)
+
+        setup_all(True)
+
+        # 'a_id' in ... is not supported before SA 0.4
+        assert C.table.columns.has_key('a_id')
+
+    def test_ref_to_imported_entity_using_name(self):
+        sys.modules.pop('tests.a', None)
+        sys.modules.pop('tests.b', None)
+
+        from tests.a import A
+        from tests.b import B
+
+        class C(Entity):
+            has_field('name', String(30))
+            belongs_to('a', of_kind='A')
+
+        setup_all(True)
+
+        assert C.table.columns.has_key('a_id')
+