Changeset 512 for elixir/trunk/elixir

Timestamp:

11/09/09 16:21:19 (3 years ago)

Author:

ged

Message:

- allows abstract classes to set default options
- allow mixed type inheritance (classes can inherit from a concrete class and

abstract classes at the same time).

- cleaned up slightly the abstract patch

Files:

• elixir/trunk/elixir/entity.py (modified) (8 diffs)

elixir/trunk/elixir/entity.py

@@ -47 +47 @@
 
     def __init__(self, entity):
-
         self.entity = entity
         # entity.__module__ is not always reliable (eg in mod_python)
         self.module = sys.modules.get(entity.__module__)
 
-        # used for multi-table inheritance
-        self.join_condition = None
-        self.has_pk = False
-        self._pk_col_done = False
-
         self.builders = []
 
@@ -63 +57 @@
         self.children = []
 
+        bases = []
         for base in entity.__bases__:
             if isinstance(base, EntityMeta):
-                if (
-                    is_entity(base) and
-                    (not is_abstract_entity(base))
-                ):
+                if is_entity(base) and not is_abstract_entity(base):
                     if self.parent:
                         raise Exception(
@@ -76 +68 @@
                     else:
                         self.parent = base
-                        self.base = base._descriptor.base
+                        bases.extend(base._descriptor.bases)
                         self.parent._descriptor.children.append(entity)
                 else:
-                    self.base = base
+                    bases.append(base)
+        self.bases = bases
+
+        if not is_entity(entity):
+            return
+
+        # used for multi-table inheritance
+        self.join_condition = None
+        self.has_pk = False
+        self._pk_col_done = False
 
         # columns and constraints waiting for a table to exist
@@ -96 +97 @@
         self.table_args = []
 
-        # base class options_defaults
-        base_defaults = getattr(self.base, 'options_defaults', {})
+        # base class(es) options_defaults
+        base_defaults = {}
+        for base in self.bases:
+            base_defaults.update(getattr(base, 'options_defaults', {}))
+
         complete_defaults = options.options_defaults.copy()
         complete_defaults.update({
@@ -697 +701 @@
 
 def is_abstract_entity(dict_or_cls):
-    if isinstance(dict_or_cls, dict):
-        mutators = dict_or_cls.get(MUTATORS, [])
-    else:
-        mutators = getattr(dict_or_cls, MUTATORS, [])
-        
-    for m in mutators:
-        if 'abstract' in m[2]:
-            return m[2]['abstract']
+    if not isinstance(dict_or_cls, dict):
+        dict_or_cls = dict_or_cls.__dict__
+    for mutator, args, kwargs in dict_or_cls.get(MUTATORS, []):
+        if 'abstract' in kwargs:
+            return kwargs['abstract']
 
     return False
@@ -713 +714 @@
     the EntityMeta metaclass.
     """
+    # Create the entity descriptor
+    #XXX: we might want to use a simplified descriptor for bases and abstract
+    # classes which only need "bases", "options_defaults" and "abstract"
+    desc = cls._descriptor = EntityDescriptor(cls)
+
+    # Process mutators
+    # We *do* want mutators to be processed for base/abstract classes
+    # (so that statements like using_options_defaults work).
+    process_mutators(cls)
+
+    # We do not want to do any more processing for base/abstract classes
+    # (Entity et al.).
+    if not is_entity(cls) or is_abstract_entity(cls):
+        return
+
     cls.table = None
     cls.mapper = None
 
-    # create the entity descriptor
-    desc = cls._descriptor = EntityDescriptor(cls)
-
-    # Determine whether this entity is a *direct* subclass of its base entity
-    entity_bases = []
+    # Copy the properties ('Property' instances) of the entity base class(es).
+    # We use getmembers (instead of __dict__) so that we also get the
+    # properties from the parents of the base class if any.
+    base_props = []
     for base in cls.__bases__:
-        if isinstance(base, EntityMeta):
-            if not is_entity(base) or is_abstract_entity(base):
-                entity_bases.append(base)
- 
-    base_props = []
-    if entity_bases:
-        # If so, copy the base entity properties ('Property' instances).
-        # We use inspect.getmembers (instead of __dict__) so that we also
-        # get the properties from the parents of the base_class if any.
-        for base in entity_bases:
-            base_props += [(name, deepcopy(attr)) for name, attr in 
+        if isinstance(base, EntityMeta) and \
+           (not is_entity(base) or is_abstract_entity(base)):
+            base_props += [(name, deepcopy(attr)) for name, attr in
                            getmembers(base, lambda a: isinstance(a, Property))]
 
@@ -744 +751 @@
         prop.attach(cls, name)
 
-    # Process mutators
-    process_mutators(cls)
-
     # setup misc options here (like tablename etc.)
     desc.setup_options()
@@ -759 +763 @@
 
     def __init__(cls, name, bases, dict_):
-        # Only process further subclasses of the base classes (Entity et al.),
-        # not the base classes themselves. We don't want the base entities to
-        # be registered in an entity collection, nor to have a table name and
-        # so on.
-
-        if is_abstract_entity(dict_):
-            return
-
-        if not is_entity(cls):
-            if isinstance(cls, EntityMeta):
-                process_mutators(cls)
-            return
-
         instrument_class(cls)