Changeset 3550

Timestamp:

09/12/07 16:53:26 (1 year ago)

Author:

mscott

Message:

Merge #65 to trunk.

schevo.test.test_field_entity, schevo.test.test_field_entitylist, schevo.test.test_field_entityset

• Add tests for specifying default values for Entity, EntityList, and EntitySet fields.
  
  

schevo.transaction:resolve

• Add docstring.
  
• Move out of schevo.transaction:_Populate body.
  
• Add db argument.
  
• Raise a ValueError if value could not be found when attempting resolution.
  
• Make field_names optional, since it's only applicable for generating friendly error messages during initial/sample data population.
  
  

schevo.transaction:_Populate

• Short-circuit if no data is given to populate. This skips any sort of default-value resolution when it is not strictly necessary.
  
• Move process_data function to a private instancemethod, rather than an inline function defined within _execute.
  
  

SchevoSchemaDefinition

• better documentation for initial/sample data
  
• documentation for field default values
  

Files:

• trunk/Schevo/doc/SchevoSchemaDefinition.txt (modified) (5 diffs)
• trunk/Schevo/schevo/test/test_field_entity.py (modified) (3 diffs)
• trunk/Schevo/schevo/test/test_field_entitylist.py (modified) (3 diffs)
• trunk/Schevo/schevo/test/test_field_entityset.py (modified) (2 diffs)
• trunk/Schevo/schevo/transaction.py (modified) (6 diffs)

trunk/Schevo/doc/SchevoSchemaDefinition.txt

@@ -7 +7 @@
-
-.. contents::
+
+.. Quick reference: Order of section delineators is === --- ... ~~~
-
-
@@ -326 +328 @@
--------------------
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    class Foo(E.Entity):
-
-        name = f.string()
+        size = f.integer(default=5)
-
-        _key(name)
-
-        _initial = [
-One', 
-Two', 
-Buckle', 
-Shoe', 
+a', 1
+b', 2
+c', DEFAULT
+d', DEFAULT
-            ]
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-        foo = f.entity('Foo')
-r
+z
-
-        _key(foo, bar)
-
-        _initial = [
-
-
-
-
+ False
+ False
+ False
+ True
-            ]
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -380 +473 @@
-        birthdate = f.date(required=False)        # [2]
-        disposition = f.entity('Disposition', on_delete=UNASSIGN,
-
+
+
-
-1. The `name` field is a required `Unicode` field.  By default, all
@@ -388 +482 @@
-
-3. The `disposition` field is an optional `Entity` field that can
-
-
-
+
+
+
+
+
+
+
+
-
-
@@ -412 +511 @@
-safest operation, since it prevents accidental deletion of an entity
-if it is being referred to by another entity.
+
+
+Default field values
+....................
+
+Default field values are assigned to fields in `Create` transactions.
+
+Specify default field values in a field definition by giving either a
+default value in the same notation as you would for initial or sample
+data, or by specifying a callable that returns the actual value to be
+used as the default value.
+
+Default values are not assigned to a field if a value has been
+supplied for that field in the keyword arguments specified when
+creating the `Create` transaction.
-
-

trunk/Schevo/schevo/test/test_field_entity.py

@@ -18 +18 @@
-
-        thing = f.string()
+
+        _key(thing)
-
-        _sample_unittest = [
@@ -39 +41 @@
-    class Baz(E.Entity):
-
-
+, default=('a', )
-        bar = f.entity('Bar', default=default_bar)
-        foobar = f.entity('Foo', 'Bar', required=False)
@@ -55 +57 @@
-        assert f.convert('Foo-1', db) == db.Foo[1]
-        assert f.convert(u'Foo-1', db) == db.Foo[1]
+
+    def test_default(self):
+        tx = db.Baz.t.create()
+        assert tx.foo == db.Foo.findone(thing='a')
+        assert tx.bar == db.Bar.findone(stuff=1)
-
-    def test_reversible_valid_values(self):

trunk/Schevo/schevo/test/test_field_entitylist.py

@@ -1 @@
-
-"""EntityList field unit tests.
-
@@ -79 +78 @@
-
-            _initial_priority = 1
+
+
+        class BooBoo(E.Entity):
+
+            foo_foos = f.entity_list('FooFoo',
+                                     default=[('foofoo2', ), ('foofoo1', )])
-
-
@@ -124 +129 @@
-                ]
-        '''
+
+    def test_default(self):
+        tx = db.BooBoo.t.create()
+        assert tx.foo_foos == [db.FooFoo.findone(name='foofoo2'),
+                               db.FooFoo.findone(name='foofoo1')]
-
-    def test_store_and_retrieve_UNASSIGNED(self):

trunk/Schevo/schevo/test/test_field_entityset.py

@@ -60 +60 @@
-
-            _initial_priority = 1
+
+
+        class BooBoo(E.Entity):
+
+            foo_foos = f.entity_set('FooFoo',
+                                    default=set([('foofoo2', ), ('foofoo1', )]))
-
-
@@ -105 +111 @@
-                ]
-        '''
+
+    def test_default(self):
+        tx = db.BooBoo.t.create()
+        assert tx.foo_foos == set([db.FooFoo.findone(name='foofoo2'),
+                                   db.FooFoo.findone(name='foofoo1')])
-
-    def test_store_and_retrieve_UNASSIGNED(self):

trunk/Schevo/schevo/transaction.py

@@ -208 +208 @@
-            setattr(self, name, value)
-        # Look for matching field values in objects passed as args.
-ield
-ield.assigned and not field
+
+.assigned and not f
-                for arg in args:
-                    if hasattr(arg, field_name):
@@ -216 +216 @@
-        # Assign default values for fields that haven't yet been
-        # assigned a value.
-
-
-
+
+
+
+
+
+
+
+
-                while callable(default) and default is not UNASSIGNED:
-                    default = default()
-ield
+
-
-    def _setup(self):
@@ -615 +620 @@
-
-    def _execute(self, db):
-        execute = db.execute
-        processing = []
-        data_attr = self._data_attr
-        def process_data(extent):
-            """Recursively process data, parents before children."""
-            if extent in processing or extent not in self._extents:
-                return
-            processing.append(extent)
-            # Get the field spec from the extent's create transaction
-            # by instantiating a new create transaction.
-            create = extent.t.create
-            tx = create()
-            field_spec = tx._field_spec.copy()
-            # Remove readonly fields since we can't set them, and
-            # remove hidden fields since we can't "see" them.
-            for name in field_spec.keys():
-                delete = False
-                if not hasattr(tx.f, name):
-                    # The create transaction's _setup() might delete a
-                    # field without deleting the field_spec entry.
-                    delete = True
-                else:
-                    f = getattr(tx.f, name)
-                if delete or f.readonly or f.hidden:
-                    del field_spec[name]
-            field_names = field_spec.keys()
-            field_classes = field_spec.values()
-            has_entity_field = False
-            for FieldClass in field_classes:
-                if issubclass(FieldClass, field.Entity):
-                    has_entity_field = True
-                    allow = FieldClass.allow
-                    for extent_name in allow:
-                        parent_extent = db.extent(extent_name)
-                        process_data(parent_extent)
-            # Get the data we need to process.
-            data = []
-            if hasattr(extent._EntityClass, data_attr):
-                data = getattr(extent._EntityClass, data_attr)
-            if callable(data):
-                data = data(db)
-            if not data:
-                return
-            for values in data:
-                value_map = {}
-                for field_name, value, FieldClass in zip(
-                    field_names, values, field_classes
-                    ):
-                    if value is not DEFAULT:
-                        value = resolve(field_name, value, FieldClass,
-                                        field_names)
-                        value_map[field_name] = value
-                new = create(**value_map)
-                try:
-                    execute(new)
-                except:
-                    print '-' * 40
-                    print 'extent:', extent
-                    print 'data:', data
-                    print 'field_spec:', field_spec
-                    print 'value_map:', value_map
-                    raise
-        def resolve(field_name, value, FieldClass, field_names):
-            # Since a callable data might resolve entity fields
-            # itself, we only do a lookup here if the value supplied
-            # is not an Entity instance.
-            if (issubclass(FieldClass, field._EntityBase)
-                and not isinstance(value, base.Entity)
-                and value is not UNASSIGNED
-                ):
-                if isinstance(value, list):
-                    value = [
-                        resolve(field_name, v, FieldClass, field_names)
-                        for v in value
-                        ]
-                elif isinstance(value, set):
-                    value = set([
-                        resolve(field_name, v, FieldClass, field_names)
-                        for v in value
-                        ])
-                else:
-                    allow = FieldClass.allow
-                    if len(allow) > 1:
-                        # With more than one allow we need to have been
-                        # told which extent to use.
-                        extent_name, value = value
-                    else:
-                        # Only one Entity is allowed so we do not expect
-                        # the extent name in the data.
-                        extent_name = set(allow).pop()
-                    lookup_extent = db.extent(extent_name)
-                    default_key = lookup_extent.default_key
-                    if isinstance(value, dict):
-                        kw = value
-                    elif isinstance(value, tuple):
-                        if len(default_key) != len(value):
-                            msg = 'mismatch between default key %r and value %r'
-                            raise ValueError, msg % (default_key, value)
-                        kw = dict(zip(default_key, value))
-                        for key_field_name in default_key:
-                            FClass = lookup_extent.field_spec[key_field_name]
-                            v = resolve(key_field_name, kw[key_field_name],
-                                        FClass, default_key)
-                            kw[key_field_name] = v
-                    else:
-                        msg = 'value %r is not valid for field %r in %r' % (
-                            value, field_name, field_names)
-                        raise TypeError(msg)
-                    value = lookup_extent.findone(**kw)
-            return value
-        # Main processing loop.  Process extents by highest priority first.
-        priority_attr = self._data_attr + '_priority'
@@ -740 +636 @@
-            for extent in extents
-            ))
+        # Process data in order of priority.
+        processing = []
-        for priority, extent in priority_extents:
-process_data(extent
+self._process_data(db, extent, processing
-        # Call module-level handlers.
-        fn = getattr(db._schema_module, 'on' + data_attr, None)
@@ -747 +645 @@
-            fn(db)
-
+    def _process_data(self, db, extent, processing):
+        """Recursively process initial/sample data, parents before children.
+
+        - `db`: Database to work within.
+        - `extent`: Extent to process.
+        - `processing`: List of extents that are being processed higher up
+          in the call stack.
+        """
+        if extent in processing:
+            return
+        processing.append(extent)
+        # Get the data we need to process, and short-circuit if no
+        # data is specified.
+        data = []
+        data_attr = self._data_attr
+        if hasattr(extent._EntityClass, data_attr):
+            data = getattr(extent._EntityClass, data_attr)
+        if callable(data):
+            data = data(db)
+        if not data:
+            return
+        # Get the field spec from the extent's create transaction
+        # by instantiating a new create transaction.
+        create = extent.t.create
+        tx = create()
+        field_spec = tx._field_spec.copy()
+        # Remove readonly fields since we can't set them, and
+        # remove hidden fields since we can't "see" them.
+        for name in field_spec.keys():
+            delete = False
+            if not hasattr(tx.f, name):
+                # The create transaction's _setup() might delete a
+                # field without deleting the field_spec entry.
+                delete = True
+            else:
+                f = getattr(tx.f, name)
+            if delete or f.readonly or f.hidden:
+                del field_spec[name]
+        field_names = field_spec.keys()
+        field_classes = field_spec.values()
+        has_entity_field = False
+        for FieldClass in field_classes:
+            if issubclass(FieldClass, field.Entity):
+                has_entity_field = True
+                allow = FieldClass.allow
+                for extent_name in allow:
+                    parent_extent = db.extent(extent_name)
+                    self._process_data(db, parent_extent, processing)
+        # Process the data.
+        execute = db.execute
+        for values in data:
+            value_map = {}
+            for field_name, value, FieldClass in zip(
+                field_names, values, field_classes
+                ):
+                if value is not DEFAULT:
+                    value = resolve(db, field_name, value, FieldClass,
+                                    field_names)
+                    value_map[field_name] = value
+            new = create(**value_map)
+            try:
+                execute(new)
+            except:
+                print '-' * 40
+                print 'extent:', extent
+                print 'data:', data
+                print 'field_spec:', field_spec
+                print 'value_map:', value_map
+                raise
+
-
-class Initialize(_Populate):
@@ -789 +757 @@
-    def _execute(self, db):
-        return self._fn(db)
+
+
+# ---------------------------------------------------------------------
+
+
+def resolve(db, field_name, value, FieldClass, field_names=None):
+    """Resolve the entity reference(s) in `value` and return the
+    actual entity references.
+
+    - `db`: Database to search within.
+    - `field_name`: Field name for the field whose value we are
+      resolving.
+    - `value`: Value to resolve.
+    - `FieldClass`: Class of the field whose value we are
+      resolving.
+    - `field_names`: (optional) Full list of field names for each data
+      population record, if resolving within initial or sample data.
+      Used to make error messages more useful.
+    """
+    # Since a callable data might resolve entity fields
+    # itself, we only do a lookup here if the value supplied
+    # is not an Entity instance.
+    if (issubclass(FieldClass, field._EntityBase)
+        and not isinstance(value, base.Entity)
+        and value is not UNASSIGNED
+        ):
+        if isinstance(value, list):
+            value = [
+                resolve(db, field_name, v, FieldClass, field_names)
+                for v in value
+                ]
+        elif isinstance(value, set):
+            value = set([
+                resolve(db, field_name, v, FieldClass, field_names)
+                for v in value
+                ])
+        else:
+            allow = FieldClass.allow
+            if len(allow) > 1:
+                # With more than one allow we need to have been
+                # told which extent to use.
+                extent_name, value = value
+            else:
+                # Only one Entity is allowed so we do not expect
+                # the extent name in the data.
+                extent_name = set(allow).pop()
+            lookup_extent = db.extent(extent_name)
+            default_key = lookup_extent.default_key
+            if isinstance(value, dict):
+                kw = value
+            elif isinstance(value, tuple):
+                if len(default_key) != len(value):
+                    msg = 'mismatch between default key %r and value %r'
+                    raise ValueError, msg % (default_key, value)
+                kw = dict(zip(default_key, value))
+                for key_field_name in default_key:
+                    FClass = lookup_extent.field_spec[key_field_name]
+                    v = resolve(db, key_field_name, kw[key_field_name],
+                                FClass, default_key)
+                    kw[key_field_name] = v
+            else:
+                msg = 'value %r is not valid for field %r in %r' % (
+                    value, field_name, field_names)
+                raise TypeError(msg)
+            value = lookup_extent.findone(**kw)
+            if value is None:
+                raise ValueError('no entity %s found in %s' %
+                                 (kw, lookup_extent))
+    return value
-
-