Changeset 3519

Show
Ignore:
Timestamp:
09/06/07 12:34:17 (1 year ago)
Author:
mscott
Message:

Merge and close #62.

You can now specify initial/sample data for EntityList and EntitySet field types. Just specify a list or set of tuples, where the tuples contained in the list or set are the same format as you would specify for initial/sample data for an Entity field.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/Schevo/schevo/test/test_field_entitylist.py

    r3513 r3519  
    6565 
    6666            _key(name) 
     67 
     68 
     69        class FooFoo(E.Entity): 
     70 
     71            name = f.unicode() 
     72 
     73            _key(name) 
     74 
     75            _initial = [ 
     76                ('foofoo1', ), 
     77                ('foofoo2', ), 
     78                ] 
     79 
     80            _initial_priority = 1 
     81 
     82 
     83        class BarBar(E.Entity): 
     84 
     85            name = f.unicode() 
     86            foo_foos = f.entity_list('FooFoo') 
     87 
     88            _key(name) 
     89 
     90            _initial = [ 
     91                ('barbar1', [('foofoo1',), ('foofoo2',)]), 
     92                ('barbar2', [('foofoo2',), ('foofoo1',)]), 
     93                ] 
     94 
     95 
     96        class BazBaz(E.Entity): 
     97 
     98            name = f.unicode() 
     99 
     100            _key(name) 
     101 
     102            _initial = [ 
     103                ('bazbaz1', ), 
     104                ('bazbaz2', ), 
     105                ] 
     106 
     107            _initial_priority = 1 
     108 
     109 
     110        class BofBof(E.Entity): 
     111 
     112            name = f.unicode() 
     113            foo_foos_or_bar_bars = f.entity_list('FooFoo', 'BazBaz') 
     114 
     115            _key(name) 
     116 
     117            _initial = [ 
     118                ('bofbof1', [('FooFoo', ('foofoo1',)), 
     119                             ('BazBaz', ('bazbaz2',)), 
     120                             ]), 
     121                ('bofbof2', [('FooFoo', ('foofoo2',)), 
     122                             ('BazBaz', ('bazbaz1',)), 
     123                             ]), 
     124                ] 
    67125        ''' 
    68126 
    …… 
    158216        assert list(boo.foo_list) == [foo, UNASSIGNED] 
    159217 
     218    def test_initial_values(self): 
     219        barbar1 = db.BarBar.findone(name='barbar1') 
     220        expected = [ 
     221            db.FooFoo.findone(name='foofoo1'), 
     222            db.FooFoo.findone(name='foofoo2'), 
     223            ] 
     224        assert list(barbar1.foo_foos) == expected 
     225        barbar2 = db.BarBar.findone(name='barbar2') 
     226        expected = [ 
     227            db.FooFoo.findone(name='foofoo2'), 
     228            db.FooFoo.findone(name='foofoo1'), 
     229            ] 
     230        assert list(barbar2.foo_foos) == expected 
     231        bofbof1 = db.BofBof.findone(name='bofbof1') 
     232        expected = [ 
     233            db.FooFoo.findone(name='foofoo1'), 
     234            db.BazBaz.findone(name='bazbaz2'), 
     235            ] 
     236        assert list(bofbof1.foo_foos_or_bar_bars) == expected 
     237        bofbof2 = db.BofBof.findone(name='bofbof2') 
     238        expected = [ 
     239            db.FooFoo.findone(name='foofoo2'), 
     240            db.BazBaz.findone(name='bazbaz1'), 
     241            ] 
     242        assert list(bofbof2.foo_foos_or_bar_bars) == expected 
     243 
    160244 
    161245class TestFieldEntityList2(BaseFieldEntityList): 

  • trunk/Schevo/schevo/test/test_field_entityset.py

    r3513 r3519  
    4646 
    4747            _key(name) 
     48 
     49 
     50        class FooFoo(E.Entity): 
     51 
     52            name = f.unicode() 
     53 
     54            _key(name) 
     55 
     56            _initial = [ 
     57                ('foofoo1', ), 
     58                ('foofoo2', ), 
     59                ] 
     60 
     61            _initial_priority = 1 
     62 
     63 
     64        class BarBar(E.Entity): 
     65 
     66            name = f.unicode() 
     67            foo_foos = f.entity_set('FooFoo') 
     68 
     69            _key(name) 
     70 
     71            _initial = [ 
     72                ('barbar1', set([('foofoo1',), ('foofoo2',)])), 
     73                ('barbar2', set([('foofoo2',), ('foofoo1',)])), 
     74                ] 
     75 
     76 
     77        class BazBaz(E.Entity): 
     78 
     79            name = f.unicode() 
     80 
     81            _key(name) 
     82 
     83            _initial = [ 
     84                ('bazbaz1', ), 
     85                ('bazbaz2', ), 
     86                ] 
     87 
     88            _initial_priority = 1 
     89 
     90 
     91        class BofBof(E.Entity): 
     92 
     93            name = f.unicode() 
     94            foo_foos_or_bar_bars = f.entity_set('FooFoo', 'BazBaz') 
     95 
     96            _key(name) 
     97 
     98            _initial = [ 
     99                ('bofbof1', set([('FooFoo', ('foofoo1',)), 
     100                                 ('BazBaz', ('bazbaz2',)), 
     101                                 ])), 
     102                ('bofbof2', set([('FooFoo', ('foofoo2',)), 
     103                                 ('BazBaz', ('bazbaz1',)), 
     104                                 ])), 
     105                ] 
    48106        ''' 
    49107 
    …… 
    121179        assert raises(ValueError, *call) 
    122180 
     181    def test_initial_values(self): 
     182        barbar1 = db.BarBar.findone(name='barbar1') 
     183        expected = set([ 
     184            db.FooFoo.findone(name='foofoo1'), 
     185            db.FooFoo.findone(name='foofoo2'), 
     186            ]) 
     187        assert barbar1.foo_foos == expected 
     188        barbar2 = db.BarBar.findone(name='barbar2') 
     189        expected = set([ 
     190            db.FooFoo.findone(name='foofoo2'), 
     191            db.FooFoo.findone(name='foofoo1'), 
     192            ]) 
     193        assert barbar2.foo_foos == expected 
     194        bofbof1 = db.BofBof.findone(name='bofbof1') 
     195        expected = set([ 
     196            db.FooFoo.findone(name='foofoo1'), 
     197            db.BazBaz.findone(name='bazbaz2'), 
     198            ]) 
     199        assert bofbof1.foo_foos_or_bar_bars == expected 
     200        bofbof2 = db.BofBof.findone(name='bofbof2') 
     201        expected = set([ 
     202            db.FooFoo.findone(name='foofoo2'), 
     203            db.BazBaz.findone(name='bazbaz1'), 
     204            ]) 
     205        assert bofbof2.foo_foos_or_bar_bars == expected 
     206 
    123207 
    124208class TestFieldEntitySet2(BaseFieldEntitySet): 

  • trunk/Schevo/schevo/transaction.py

    r3451 r3519  
    681681            # itself, we only do a lookup here if the value supplied 
    682682            # is not an Entity instance. 
    683             if (issubclass(FieldClass, field.Entity) 
     683            if (issubclass(FieldClass, field._EntityBase) 
    684684                and not isinstance(value, base.Entity) 
    685                 and value is not UNASSIGNED): 
    686                 allow = FieldClass.allow 
    687                 if len(allow) > 1: 
    688                     # With more than one allow we need to have been 
    689                     # told which extent to use. 
    690                     extent_name, value = value 
     685                and value is not UNASSIGNED 
     686                ): 
     687                if isinstance(value, list): 
     688                    value = [ 
     689                        resolve(field_name, v, FieldClass, field_names) 
     690                        for v in value 
     691                        ] 
     692                elif isinstance(value, set): 
     693                    value = set([ 
     694                        resolve(field_name, v, FieldClass, field_names) 
     695                        for v in value 
     696                        ]) 
    691697                else: 
    692                     # Only one Entity is allowed so we do not expect 
    693                     # the extent name in the data. 
    694                     extent_name = set(allow).pop() 
    695                 lookup_extent = db.extent(extent_name) 
    696                 default_key = lookup_extent.default_key 
    697                 if isinstance(value, dict): 
    698                     kw = value 
    699                 elif isinstance(value, tuple): 
    700                     if len(default_key) != len(value): 
    701                         msg = 'mismatch between default key %r and value %r' 
    702                         raise ValueError, msg % (default_key, value) 
    703                     kw = dict(zip(default_key, value)) 
    704                     for key_field_name in default_key: 
    705                         FClass = lookup_extent.field_spec[key_field_name] 
    706                         v = resolve(key_field_name, kw[key_field_name], FClass, 
    707                                     default_key) 
    708                         kw[key_field_name] = v 
    709                 else: 
    710                     msg = 'value %r is not valid for field %r in %r' % ( 
    711                         value, field_name, field_names) 
    712                     raise TypeError(msg) 
    713                 value = lookup_extent.findone(**kw) 
     698                    allow = FieldClass.allow 
     699                    if len(allow) > 1: 
     700                        # With more than one allow we need to have been 
     701                        # told which extent to use. 
     702                        extent_name, value = value 
     703                    else: 
     704                        # Only one Entity is allowed so we do not expect 
     705                        # the extent name in the data. 
     706                        extent_name = set(allow).pop() 
     707                    lookup_extent = db.extent(extent_name) 
     708                    default_key = lookup_extent.default_key 
     709                    if isinstance(value, dict): 
     710                        kw = value 
     711                    elif isinstance(value, tuple): 
     712                        if len(default_key) != len(value): 
     713                            msg = 'mismatch between default key %r and value %r' 
     714                            raise ValueError, msg % (default_key, value) 
     715                        kw = dict(zip(default_key, value)) 
     716                        for key_field_name in default_key: 
     717                            FClass = lookup_extent.field_spec[key_field_name] 
     718                            v = resolve(key_field_name, kw[key_field_name], 
     719                                        FClass, default_key) 
     720                            kw[key_field_name] = v 
     721                    else: 
     722                        msg = 'value %r is not valid for field %r in %r' % ( 
     723                            value, field_name, field_names) 
     724                        raise TypeError(msg) 
     725                    value = lookup_extent.findone(**kw) 
    714726            return value 
    715727        # Main processing loop.  Process extents by highest priority first.