Changeset 51

Timestamp:

01/12/05 07:48:53

Author:

fumanchu

Message:

1. Changed arena.roster to ._registered_classes. Dropped containers.Prism and .Index
2. First attempt at arena.migrate (migrate class data from one store to another).
3. Fixed weakref bug in db pooling.
4. db.SM.reserve() now writes all data, not just ID.
5. Various store bugs (adapters, mostly).

Files:

• trunk/__init__.py (modified) (4 diffs)
• trunk/containers.py (modified) (2 diffs)
• trunk/doc/intro.html (modified) (2 diffs)
• trunk/doc/modeling.html (modified) (2 diffs)
• trunk/engines.py (modified) (2 diffs)
• trunk/storage/__init__.py (modified) (1 diff)
• trunk/storage/db.py (modified) (14 diffs)
• trunk/storage/sockets.py (modified) (3 diffs)
• trunk/storage/storeado.py (modified) (11 diffs)
• trunk/storage/storemysql.py (modified) (5 diffs)
• trunk/storage/storepypgsql.py (modified) (2 diffs)
• trunk/storage/zoo_fixture.py (modified) (10 diffs)
• trunk/test_containers.py (modified) (1 diff)
• trunk/test_dejavu.py (modified) (1 diff)
• trunk/zoo.py (modified) (2 diffs)

trunk/__init__.py

@@ -500 +500 @@
-        self.defaultStore = None
-        self.stores = {}
-roster = Prism('name', 'cls', 'store')
+_registered_classes = {}
-        self.associations = Graph()
-        self.engine_functions = {}
@@ -517 +517 @@
-        stores.sort()
-        
-        import xray
-        for order, name, options in stores:
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        self.stores[name] = store
-
-
-
-
-
-
-
+
-            self.defaultStore = store
-    
@@ -559 +553 @@
-    def register(self, cls):
-        """register(cls) -> Assert that Units of class 'cls' will be handled."""
-
-
-
-
-
-
-
+
+
+
+
-        
-        # Register any association(s) in an undirected graph.
@@ -577 +568 @@
-    
-    def class_by_name(self, classname):
-
+
+
+
+
-    
-    def storage(self, cls):
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    def create_storage(self, cls):
+        """create_storage(cls). Create storage space for cls."""
-        self.storage(cls).create_storage(cls)
+    
+    def migrate_class(self, cls, new_store):
+        """migrate_class(cls, new_store). Copy all units of cls to new store."""
+        new_store.create_storage(cls)
+        box = self.new_sandbox()
+        for unit in box.recall(cls):
+            new_store.reserve(unit)
+        self._registered_classes[cls] = new_store
+        box.flush(cls)
+    
+    def migrate(self, new_store, old_store=None):
+        """migrate(new_store, old_store=None). Copy all units (of old_store) to new store."""
+        for cls in self._registered_classes:
+            store = self.storage(cls)
+            if old_store is None or old_store is store:
+                self.migrate_class(cls, new_store)
-
-

trunk/containers.py

@@ -9 +9 @@
-and map.
-
-, Graph, Index, and Prism
+ and Graph
-
-This work, including the source code, documentation
@@ -171 +171 @@
-        return shortest
-
-
-missing=object()
-
-class Index(dict):
-    """Index(*indices) -> A container of objects, indexed by attribute.
-    
-    Sometimes, we want to store objects in an associative array,
-    but need lookup tools which are faster than simply iterating
-    through each object in the array. For example, given a set of
-    1,000,000 Artwork objects, it might be too expensive to find
-    all works by Picasso by examining each Artwork, accessing its
-    'Artist' attribute, and comparing that to 'Picasso'.
-    
-    One solution to this issue is to build multiple asociative arrays,
-    where each keyset represents an index of attributes (such as 'Artist').
-    Databases are the most common implementers of this technique.
-    Perhaps a more complex diagram will help:
-    
-        'Name'          'Artist'            'Rate'          Attributes
-        /     \             |               /     \
-      Guer  Frenzy       Picasso         125.99   300       "Handles"
-       |       |            |              |       |
-       |       |           / \             |       |
-      obj1    obj2      obj1 obj2         obj1    obj2
-       ^       ^          ^    ^           ^       ^
-       |       |          |    |           |       |
-       |       +----------|----+-----------|-------+- obj2
-       |                  |                |
-       +------------------+----------------+- obj1
-    
-    Notice that each of the two objects is referenced exactly three
-    times; that is, once for each attribute which we have declared
-    to be an indexed attribute. Also notice that these are references,
-    not copies.
-    
-    Our implementation of such an Index looks like this:
-        {'Name': {'Guernica': [obj1], 'Frenzy': [obj2]},
-         'Artist': {'Picasso': [obj1, obj2]},
-         'Rate': {300.00: [obj2], 125.99: [obj1]},
-         }
-    
-    A note about naming: nested dictionaries are somewhat difficult to keep
-    in your head, because one level's "key" is another level's "value".
-    In the Index class, the names are:
-        Index =
-            {attribute: {handle: bucket,
-                         handle: bucket,
-                         ...,
-                         },
-             attribute: {handle: bucket,
-                         handle: bucket,
-                         ...,
-                         },
-             }
-    ...where each 'bucket' is a list of objects. In the example above,
-    'Artist' is an attribute, 'Picasso' is a handle (one of the existing
-    values of obj.Artist), and [obj1, obj2] is a bucket.
-    
-    store(obj): add obj to each index based on attributes of obj.
-    
-    retrieve(attr, cmpfunc, *args): match objects based on indexed attributes.
-        attr = the indexed attribute to look up.
-        cmpfunc = a callable to which we will pass each instance attribute,
-            expecting a true or false result. For example, to retrieve all
-            objects with a 'Rate' attribute greater than 200, call:
-                retrieve('Rate', lambda x: x > 200)
-            --OR--
-                retrieve('Rate', operator.gt, 200)
-        *args: any extra arguments to be passed to cmpfunc.
-    """
-    
-    def __init__(self, *indices):
-        for attr in indices:
-            self[attr] = {}
-    
-    def store(self, obj):
-        """Add obj to self, one reference per index."""
-        for attr, index in self.iteritems():
-            bucket = index.setdefault(getattr(obj, attr), [])
-            if obj not in bucket:
-                bucket.append(obj)
-    
-    def reindex(self, obj, attr, oldhandle=missing):
-        """The attr of obj has changed. Move it to the correct index."""
-        index = self[attr]
-        if oldhandle is missing:
-            for handle, bucket in index.iteritems():
-                if obj in bucket:
-                    bucket.remove(obj)
-                    if len(bucket) == 0:
-                        del index[handle]
-                    break
-        else:
-            self._deindex(obj, attr, oldhandle)
-        bucket = index.setdefault(getattr(obj, attr), [])
-        if obj not in bucket:
-            bucket.append(obj)
-    
-    def _deindex(self, obj, attr, handle):
-        index = self[attr]
-        try:
-            bucket = index[handle]
-        except KeyError:
-            pass
-        else:
-            try:
-                bucket.remove(obj)
-            except ValueError:
-                pass
-            if len(bucket) == 0:
-                del index[handle]
-    
-    def remove(self, obj):
-        """Delete obj from each index."""
-        for attr in self.iterkeys():
-            handle = getattr(obj, attr)
-            self._deindex(obj, attr, handle)
-    
-    def handles(self, attr):
-        """Generator for all handles for the attribute."""
-        # Just let KeyErrors propagate outward.
-        for handle in self[attr].iterkeys():
-            yield handle
-    
-    def bucket(self, attr, handle):
-        """Obtain a list of all objects in a given bucket."""
-        # Just let KeyErrors propagate outward.
-        return self[attr][handle]
-    
-    def exists(self, attr, handle):
-        """Return True if the handle exists in attr, False otherwise."""
-        return self[attr].has_key(handle)
-    
-    def retrieve(self, attr, cmpfunc=None, *args):
-        """Obtain stored objects based on the value of an attribute.
-        
-        If cmpfunc is None, return all objects. Otherwise, we include
-        each bucket's objects if cmpfunc(handle, *args) is True.
-        """
-        product = []
-        if cmpfunc is None:
-            for bucket in self[attr].itervalues():
-                product.extend(bucket)
-        else:
-            for handle, bucket in self[attr].iteritems():
-                if cmpfunc(handle, *args):
-                    product.extend(bucket)
-        return product
-
-
-class Prism(object):
-    """Prism(*indices) -> A colection which simplifies attribute retrieval.
-    
-    For many homogeneous collections, it is common to index the contained
-    objects by an attribute of those objects. For example, if all of your
-    objects have an 'id' attribute, you might collect them in a dictionary
-    where each key is the id, and each value is the corresponding object.
-    
-    Some collections, however, benefit from lookups in multiple directions,
-    which we might call 'facets' of the contained objects. The Prism class
-    provides the ability to specify multiple indices/facets (all indices
-    must be unique).
-    
-    In addition, multi-facet lookups are most commonly used to retrieve,
-    not the contained object, but one of the other facets of that object.
-    The Prism class provides this behavior via 'function refraction'; if
-    you call Prism.far_facet_name(facet_name=value), this is equivalent to
-    the dict-style call: indexes[facet_name].get(value).far_facet_name.
-    For example, if you have the 'id' attribute of an object, and want to
-    retrieve the 'color' attribute, call Prism.color(id=392).
-    
-    However, rather than store objects, the Prism stores values; you can
-    think of it as a table instead of a set of objects. The issue with this
-    is that, if one of your facets isn't a unique index, you'll get back
-    the first match, not all matches. But sometimes that's what you want.
-    
-    Finally, there aren't any convenience methods yet for modifying entries;
-    you can add and retrieve pretty well, but not mutate or remove without
-    mucking about with internals. row_number() should help a bit.
-    """
-    
-    def __init__(self, *facets):
-        self.facets = {}
-        for name in facets:
-            self.facets[name] = []
-            self._add_refractor(name)
-    
-    def _add_refractor(self, name):
-        """Add an instancemethod to self which looks up far facets."""
-        def refractor(self, **facet):
-            """Return the '%s' value associated with the specified facet.""" % name
-            if len(facet) != 1:
-                raise TypeError(u'%s() takes exactly one keyword argument '
-                                u'(%s given).' % (name, len(facet)))
-            return self.facets[name][self.row_number(**facet)]
-        setattr(self, name, new.instancemethod(refractor, self, Prism))
-    
-    def add(self, **facets):
-        """add(**facets) -> add a row to the Prism."""
-        for name, row in self.facets.iteritems():
-            row.append(facets.get(name))
-    
-    def row_number(self, **facet):
-        """row_number(**facet) -> row number, given one facet's key+value."""
-        k, v = facet.popitem()
-        f = self.facets[k]
-        try:
-            return f.index(v)
-        except ValueError:
-            raise ValueError("'%s' is not a known %s" % (v, k))
-    
-    def row(self, **facet):
-        """row(**facet) -> all facets of a row given one facet's key+value."""
-        number = self.row_number(**facet)
-        return dict([(k, v[number]) for k, v in self.facets.iteritems()])
-

trunk/doc/intro.html

@@ -70 +70 @@
-zookeeper.py
-<pre>import dejavu
-from dejavu.storage.storeado import StorageManagerADO_MSAccess as SM
-
-
-class Zoo(dejavu.Unit):
@@ -91 +89 @@
-conf = {u'Connect':
-        r"PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=C:\zookeeper.mdb;"}
-'main', SM("mySM", arena
+"main", "dejavu.storage.storeado.StorageManagerADO_MSAccess"
-arena.register_all(globals())</pre>
-

trunk/doc/modeling.html

@@ -511 +511 @@
-<h4>Loading Stores</h4>
-<p>You <b>may</b> manually set up Storage Managers by calling
-unitClasse
+option
-probably shouldn't. Instead, allow your deployers to decide for
-themselves which storage solution(s) to use. You can do this by calling
@@ -521 +521 @@
-
-<h4>Registering Unit Classes</h4>
-
-
-
-
-
+
+
+
+
-
-<p>The <tt>Arena</tt> object also manages the associations between Unit

trunk/engines.py

@@ -259 +259 @@
-        if self.Expiration is not None:
-            if self.Expiration <= datetime.datetime.now():
-                msg = ("Forgetting Engine %s. Exp = %s. Now = %s" %
-                       (self.ID, self.Expiration, datetime.datetime.now()))
-                self.sandbox.arena.application.logger.info(msg)
-                self.forget()
-                raise dejavu.UnrecallableError
@@ -462 +459 @@
-        expr = pickle.loads(operand)
-        expr.bind_args(**self.args)
+        
-        A = self.sets[setID]
-        A.acquire()

trunk/storage/__init__.py

@@ -21 +21 @@
-        self.name = name
-        self.arena = arena
+        self.classnames = [x.strip() for x
+                           in allOptions.get('Units', '').split(",")
+                           if x.strip()]
-        self.shutdownOrder = int(allOptions.get('Shutdown Order', '0'))
-    

trunk/storage/db.py

@@ -16 +16 @@
-"""
-
+import time
-import weakref
-import Queue
@@ -84 +85 @@
-            # actual precision depends on platform. PostgreSQL
-            # DOUBLE is 8 bytes (15 decimal-digit precision).
-
+ PRECISION
-    
-    def coerce_str(self, cls, key):
@@ -169 +170 @@
-##        elif bytes == 3:
-##            return "MEDIUMINT"
-if bytes == 4
+se
-            return u"INTEGER"
-    
-
-
@@ -238 +238 @@
-    coerce_decimal = tostr
-    coerce_decimal_Decimal = tostr
+    
+    def pickle(self, value):
+        return self.coerce_str(pickle.dumps(value))
+    
+    coerce_dict = pickle
+    
-    coerce_fixedpoint_FixedPoint = tostr
-    coerce_float = tostr
-    coerce_int = tostr
-    
-
-
+
-    
-    coerce_long = tostr
@@ -252 +257 @@
-        return "'" + value + "'"
-    
-coerce_list
+pickle
-    
-    coerce_unicode = coerce_str
@@ -423 +428 @@
-            # The entire expression could not be evaluated.
-            result = self.adapter.bool_true
+        if result == self.adapter.coerce_bool(True):
+            result = self.adapter.bool_true
+        if result == self.adapter.coerce_bool(False):
+            result = self.adapter.bool_false
-        return result
-    
@@ -429 +438 @@
-        comp = self.stack.pop()
-        trueval = self.adapter.bool_true
+        falseval = self.adapter.bool_false
-        while terms:
-            term, operation = terms.pop()
@@ -435 +445 @@
-            if comp is cannot_represent:
-                comp = trueval
+            
+            # Blurg. SQL Server is *so* picky.
+            if term == self.adapter.coerce_bool(True):
+                term = trueval
+            if term == self.adapter.coerce_bool(False):
+                term = falseval
+            if comp == self.adapter.coerce_bool(True):
+                comp = trueval
+            if comp == self.adapter.coerce_bool(False):
+                comp = falseval
+            
-            comp = "(%s) %s (%s)" % (term, operation.upper(), comp)
-        self.stack.append(comp)
@@ -647 +668 @@
-    toAdapter = AdapterToSQL()
-    fromAdapter = AdapterFromDB()
+    debug_connections = False
-    
-    def __init__(self, name, arena, allOptions={}):
@@ -659 +681 @@
-        else:
-            self.pool = None
+        self.retry = 5
+        self.threaded = True
-        
-        self.prefix = allOptions.get(u'Prefix', u"djv")
@@ -707 +731 @@
-    
-    def connection(self):
-self.pool is not None
+not self.threaded
-            try:
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    def release(self, ref):
-        conn = self.refs[ref]
-        del self.refs[ref]
+        
-        if self.pool is not None:
-            try:
-
+
+
+
+
-            except Queue.Full:
-
+
+
+
+
+
-    
-    def shutdown(self):
@@ -783 +843 @@
-    def execute(self, query, conn=None):
-        """execute(query, conn=None) -> result set."""
-
-    
-    
-    
-
-
-
-
-
+##
+
+
+
+##
+##
+##
+##
+##
-    
-    def fetch(self, query, conn=None):
@@ -850 +910 @@
-        The ID should be supplied by UnitSequencers via reserve().
-        """
+        cls = unit.__class__
-        tablename = self.tablename(unit)
-
-
-
+
-        self.reserve_lock.acquire()
-        try:
-            if unit.ID is None:
-
+
+
+
-                coltype = cols[0][1]
+                expectedType = cls.property_type("ID")
-                data = [coerce(row[0], coltype, expectedType) for row in data]
-                unit.ID = unit.sequencer.next(data)
+                del data
+                del cols
+            
+            fields = []
+            values = []
+            for key in cls.properties():
+                subtype = self.expanded_columns.get((cls.__name__, key))
+                if subtype:
+                    self.save_expanded(unit, key, subtype)
+                else:
+                    val = self.toAdapter.coerce(getattr(unit, key))
+                    fields.append(i(key))
+                    values.append(val)
-            
-            self.execute('INSERT INTO %s (%s) VALUES (%s);' %
-
+
+
+
-        finally:
-            self.reserve_lock.release()
@@ -1058 +1135 @@
-            if acceptable:
-                yield unitset
+
+
+class OutOfConnectionsError(dejavu.DejavuError):
+    """Exception raised when a database store has run out of connections."""
+    pass
+

trunk/storage/sockets.py

@@ -1 @@
-import fixedpoint
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
+
-import socket
-import select
+
+
+def _define_fixedpoint_states():
+    """Add methods to fixedpoint to support pickling."""
+    import fixedpoint
+    
+    if not hasattr(fixedpoint.FixedPoint, "__getstate__"):
+        def __getstate__(self):
+            return (self.n, self.p)
+        fixedpoint.FixedPoint.__getstate__ = __getstate__
+        
+        def __setstate__(self, v):
+            self.n, self.p = v
+        fixedpoint.FixedPoint.__setstate__ = __setstate__
-
-
@@ -12 +26 @@
-    if isinstance(unit, dict):
-        for key, value in unit.iteritems():
-
-
-
-
-
+
+
+
-    else:
-        # Assume it's a dejavu.Unit.
-        for key in unit.__class__.properties():
-            value = getattr(unit, key)
-
-
-
-
-
+
+
+
-    return pickle.dumps(data)
-
@@ -33 +43 @@
-    cls = unit.__class__
-    for key in cls.properties():
-        value = attrdict[key]
-        if cls.property_type(key) == fixedpoint.FixedPoint:
-            if value is not None:
-                n, p = value
-                value = fixedpoint.FixedPoint(0, 2)
-                value.n, value.p = n, p
-        # Set the attribute directly to avoid __set__ overhead.
-value
+attrdict[key]
-
-def dechunk(data):

trunk/storage/storeado.py

@@ -8 +8 @@
-import pywintypes
-import datetime
+
-try:
-    import cPickle as pickle
@@ -17 +18 @@
-except ImportError:
-    pass
+
+try:
+    # Builtin in Python 2.5?
+    decimal
+except NameError:
+    try:
+        # Module in Python 2.3, 2.4
+        import decimal
+    except ImportError:
+        pass
+
+import warnings
-
-import dejavu
@@ -330 +343 @@
-        # res.CursorLocation = adUseClient
-        try:
-
-
-
+
+
+
+
+
+
-        except pywintypes.com_error, x:
-            try:
@@ -339 +355 @@
-                pass
-            x.args += (query, )
+            conn = None
-            raise x
-        
@@ -351 +368 @@
-            data = zip(*data)
-        res.Close()
+        conn = None
-        
-        return data, columns
@@ -374 +392 @@
-    def coerce_bool(self, value):
-        if value:
-(1=1)
-(1=0)
+1
+0
-
-
@@ -381 +399 @@
-    
-    numeric_max_precision = 38
+    
+    def coerce_bool(self, cls, key): return u"BIT"
-    
-    def coerce_datetime_datetime(self, cls, key):
@@ -398 +418 @@
-            # Okay, what the @#$%& is wrong with Redmond??!?! We can't even
-            # compare TEXT or NTEXT fields??!? Fine. We'll deny such, and
-
+ and exclamation points
-            import warnings
-            warnings.warn("You have defined a string property without "
@@ -468 +488 @@
-class FieldTypeAdapter_MSAccess(db.FieldTypeAdapter):
-    
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    def coerce_str(self, cls, key):
@@ -478 +567 @@
-            return u"VARCHAR(%s)" % bytes
-        else:
-gigabyte
+GB max
-            # in Access UI). But then, 1 GB is the limit for the whole DB.
-            return u"MEMO"
@@ -517 +606 @@
-        self.cursorType = int(allOptions.get(u'CursorType', adOpenDynamic))
-        self.lockType = int(allOptions.get(u'LockType', adLockOptimistic))
+        # MS Access can't use a pool, because there doesn't seem
+        # to be a commit timeout.
-        self.pool = None
+        self.threaded = False
+        self.debug_connections = True
-    
-    def create_database(self):

trunk/storage/storemysql.py

@@ -26 +26 @@
-
-class AdapterFromMySQL(db.AdapterFromDB):
+    
+    def coerce_bool(self, value, coltype):
+        if isinstance(value, basestring):
+            # either '0' or '1'
+            value = (value == '1')
+        return bool(value)
-    
-    def coerce_unicode(self, value, coltype):
@@ -141 +147 @@
-            conn = _mysql.connect(**self.connargs)
-        except _mysql.OperationalError, x:
-
+
+
+
-                self.create_database()
-                conn = _mysql.connect(**self.connargs)
@@ -150 +158 @@
-    def _template_conn(self):
-        tmplconn = self.connargs.copy()
-
+mysql
-        return _mysql.connect(**tmplconn)
-    
@@ -165 +173 @@
-        self.execute(sql, conn)
-        conn.close()
+    
+    def create_storage(self, unitClass):
+        # MySQL won't allow indexes on a BLOB field without a specific length.
+        tablename = self.tablename(unitClass)
+        
+        coerce = self.typeAdapter.coerce
+        fields = []
+        for key in unitClass.properties():
+            fields.append(u'%s %s' % (self.identifier(key),
+                                      coerce(unitClass, key)))
+        self.execute(u'CREATE TABLE %s (%s);' % (tablename, ", ".join(fields)))
+        
+        for index in unitClass.indices():
+            i = self.identifier(self.prefix, "i", unitClass.__name__, index)
+            
+            dbtype = coerce(unitClass, index)
+            if dbtype.endswith('BLOB') or dbtype == 'TEXT':
+                self.execute(u'CREATE INDEX %s ON %s (%s(%s));' %
+                             (i, tablename, self.identifier(index), 255))
+            else:
+                self.execute(u'CREATE INDEX %s ON %s (%s);' %
+                             (i, tablename, self.identifier(index)))
-    
-    def fetch(self, query, conn=None):
@@ -180 +210 @@
-        res = conn.store_result()
-        return res.fetch_row(0, 0), res.describe()
-
+
+
+
+
+
+
+

trunk/storage/storepypgsql.py

@@ -1 +1 @@
-# Use libpq directly to avoid all of the DB-API overhead.
-from pyPgSQL import libpq
-import time
-import datetime
-import dejavu
@@ -50 +49 @@
-            k, v = atom.split("=", 1)
-            setattr(self, k, v)
-        
-        self.retry = 5
-    
-    def _get_conn(self):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-    
-    def _template_conn(self):

trunk/storage/zoo_fixture.py

@@ -11 +11 @@
-import dejavu
-from dejavu import logic, zoo
+
+try:
+    import fixedpoint
+except ImportError:
+    fixedpoint = None
-
-
@@ -46 +51 @@
-        box.memorize(Biodome)
-        
+        seaworld = zoo.Zoo(Name = 'Sea World',
+                           Admission = "60",
+                           )
+        box.memorize(seaworld)
+        
-        # Animals
-
+, Lifespan=73.5
-        self.assertEqual(leopard.PreviousZoos, None)
-        box.memorize(leopard)
@@ -53 +63 @@
-        leopard.LastEscape = datetime.datetime(2004, 12, 21, 8, 15, 0)
-        
-
-
+
+
+
-        box.memorize(zoo.Animal(Name='Lion', Legs=4))
-        box.memorize(zoo.Animal(Name='Bear', Legs=4))
-        # Notice that ostrich.PreviousZoos is [], whereas leopard is None.
-
+
+
-        box.memorize(zoo.Animal(Name='Centipede', Legs=100))
-        
@@ -66 +78 @@
-        box.memorize(adelie)
-        
+        seaworld.add(emp, adelie)
+        
-        millipede = zoo.Animal(Name='Millipede', Legs=1000000)
-        millipede.PreviousZoos = [WAP.ID]
-        box.memorize(millipede)
-        
-emp, adelie
+tiger
-        
-        # Exhibits
-        pe = zoo.Exhibit(Name = 'The Penguin Encounter',
-SDZ
+seaworld
-                         Animals = [emp.ID, adelie.ID],
+                         PettingAllowed = True,
-                         Acreage = "3.21",
-                         )
-        box.memorize(pe)
+        
+        tr = zoo.Exhibit(Name = 'Tiger River',
+                         ZooID = SDZ.ID,
+                         Animals = [tiger.ID],
+                         PettingAllowed = False,
+                         Acreage = "4",
+                         )
+        box.memorize(tr)
-        
-        box.flush_all()
@@ -110 +133 @@
-        self.assertEqual(float(Biodome.Admission), 11.75)
-        
+        if fixedpoint:
+            seaworld = box.unit(zoo.Zoo, Admission = fixedpoint.FixedPoint(60))
+        else:
+            seaworld = box.unit(zoo.Zoo, Admission = float(60))
+        self.assertNotEqual(seaworld, None)
+        
-        # Animals
-        leopard = box.unit(zoo.Animal, Name='Leopard')
-        self.assertEqual(leopard.Name, 'Leopard')
-        self.assertEqual(leopard.Legs, 4)
+        self.assertEqual(leopard.Lifespan, 73.5)
-        self.assertEqual(leopard.ZooID, WAP.ID)
-        self.assertEqual(leopard.PreviousZoos, None)
@@ -135 +165 @@
-        # Exhibits
-        exes = [x for x in box.recall(zoo.Exhibit)]
-
-
-
-
+
+
+
+
+
+
+
+
-        self.assertEqual(len(pe.Animals), 2)
-        self.assertEqual(float(pe.Acreage), 3.21)
+        self.assertEqual(pe.PettingAllowed, True)
+        
+        self.assertEqual(tr.ZooID, SDZ.ID)
+        self.assertEqual(len(tr.Animals), 1)
+        self.assertEqual(float(tr.Acreage), 4)
+        self.assertEqual(tr.PettingAllowed, False)
-        
-        box.flush_all()
@@ -155 +195 @@
-        zoos = [x for x in box.recall(zoo.Zoo)]
-        self.assertEqual(zoos[0].dirty(), False)
-3
+4
-        self.assertEqual(matches(lambda x: True), 10)
-        self.assertEqual(matches(lambda x: x.Legs == 4), 4)
@@ -161 +201 @@
-        self.assertEqual(matches(lambda x: x.Legs >= 2 and x.Legs < 20), 7)
-        self.assertEqual(matches(lambda x: x.Legs > 10), 2)
+        self.assertEqual(matches(lambda x: x.Lifespan > 70), 2)
-        self.assertEqual(matches(lambda x: x.Name.startswith('L')), 2)
-        self.assertEqual(matches(lambda x: x.Name.endswith('pede')), 2)
@@ -212 +253 @@
-                                         (zoo.Animal, None))]
-        SDZ = box.unit(zoo.Zoo, Name='San Diego Zoo')
-3
+2
-        aid = 0
-        for z, a in zooed_animals:
@@ -218 +259 @@
-            self.assertNotEqual(id(a), aid)
-            aid = id(a)
-##
-##
-##
-##
-##
-##
-##
-##
-##
-##
-##
-##
-##
-##
-##
-##
-##
-##
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-def setup_SM(SM_class, opts):
-
-
-
-
-
-
+
+
-    
-    for cls in (zoo.Animal, zoo.Zoo, zoo.Exhibit):

trunk/test_containers.py

@@ -160 +160 @@
-
-
-class Artwork(object):
-    def __init__(self, Name='', Artist='', Rate=''):
-        self.Name = Name
-        self.Artist = Artist
-        self.Rate = Rate
-
-
-class IndexTests(unittest.TestCase):
-    
-    def test_Index(self):
-        artworks = containers.Index('Name', 'Artist', 'Rate')
-        for index in artworks:
-            self.assertEqual(index in ['Name', 'Artist', 'Rate'], True)
-        
-        # Store a single object.
-        guernica = Artwork('Guernica', 'Pablo Picasso', 185.00)
-        artworks.store(guernica)
-        self.assertEqual(artworks.bucket('Name', 'Guernica'), [guernica])
-        
-        # Add another that should collide on an indexed attribute.
-        frenzy = Artwork('Frenzy', 'Pablo Picasso', 203.45)
-        artworks.store(frenzy)
-        self.assertEqual(artworks.bucket('Artist', 'Pablo Picasso'),
-                         [guernica, frenzy])
-        
-        # Add a bunch.
-        magrittes = [Artwork('Empire of Light', 'Rene Magritte', 512.13),
-                     Artwork('The Rape', 'Rene Magritte', 121.99),
-                     Artwork('The Son of Man', 'Rene Magritte', 1024.33),
-                     Artwork('The Difficult Crossing', 'Rene Magritte', 0.32),
-                     ]
-        for work in magrittes:
-            artworks.store(work)
-        
-        # Manually find all artworks rated under 200
-        cheapos = []
-        for rate in artworks.handles('Rate'):
-            if rate < 200:
-                cheapos.extend(artworks.bucket('Rate', rate))
-        expected = [magrittes[1], guernica, magrittes[3]]
-        self.assertEqual(len(cheapos), len(expected))
-        for work in expected:
-            self.assertEqual(work in cheapos, True)
-        
-        # Retrieve() all artworks rated over 200.
-        assets = artworks.retrieve('Rate', operator.gt, 200)
-        expected = [magrittes[2], frenzy, magrittes[0]]
-        self.assertEqual(len(assets), len(expected))
-        for work in expected:
-            self.assertEqual(work in assets, True)
-        
-        # Retrieve() all artworks. Use two different attributes
-        # and compare the results.
-        byrate = artworks.retrieve('Rate')
-        byartist = artworks.retrieve('Artist')
-        self.assertEqual(len(byrate), len(byartist))
-        for work in byrate:
-            self.assertEqual(work in byartist, True)
-        
-        # Delete a single artwork.
-        artworks.remove(guernica)
-        self.assertEqual(artworks.bucket('Artist', 'Pablo Picasso'), [frenzy])
-        self.assertRaises(KeyError, artworks.bucket, 'Name', 'Guernica')
-        
-        # Change an indexed value of an artwork.
-        guernica.Rate = 300.0
-        artworks.reindex(guernica, 'Rate')
-        self.assertEqual(artworks.retrieve('Rate', operator.eq, 300), [guernica])
-        
-        # Reindex with the known last value.
-        guernica.Rate = 135.0
-        artworks.reindex(guernica, 'Rate', 300.0)
-        self.assertEqual(artworks.retrieve('Rate', operator.eq, 135), [guernica])
-        self.assertEqual(artworks.retrieve('Rate', operator.eq, 300), [])
-        self.assertRaises(KeyError, artworks.bucket, 'Rate', 300.0)
-
-
-class PrismTests(unittest.TestCase):
-    
-    def test_Prism(self):
-        artworks = containers.Prism('Name', 'Artist', 'Rate')
-        for index in artworks.facets.keys():
-            self.assertEqual(index in ['Name', 'Artist', 'Rate'], True)
-        
-        # Store a single row.
-        artworks.add(Name='Guernica', Artist='Pablo Picasso', Rate=185.00)
-        self.assertEqual(artworks.Artist(Name='Guernica'), 'Pablo Picasso')
-        
-        # Add another that should collide on an indexed attribute.
-        artworks.add(Name='Frenzy', Artist='Pablo Picasso', Rate=203.45)
-        self.assertEqual(artworks.Name(Artist='Pablo Picasso'), 'Guernica')
-        self.assertEqual(artworks.Rate(Artist='Pablo Picasso'), 185.00)
-        
-        # Add a row with missing facets.
-        artworks.add(Name='Empire of Light', Artist='Rene Magritte')
-        self.assertEqual(artworks.Rate(Artist='Rene Magritte'), None)
-        # Fill in the missing value.
-        i = artworks.row_number(Name='Empire of Light')
-        artworks.facets['Rate'][i] = 512.13
-        self.assertEqual(artworks.Rate(Artist='Rene Magritte'), 512.13)
-
-
-def run_tests():
-    try:

trunk/test_dejavu.py

@@ -4 +4 @@
-import dejavu
-from dejavu import zoo, storage
-storage.CachingProxy("default", zoo.arena)
+"storage.CachingProxy"
-
-

trunk/zoo.py

@@ -38 +38 @@
-    PreviousZoos = UnitProperty(list)
-    LastEscape = EscapeProperty(datetime.datetime)
+    Lifespan = UnitProperty(float, hints={'bytes': 4})
-
-associate(Zoo, 'ID', Animal, 'ZooID')
@@ -47 +48 @@
-    ZooID = UnitProperty(int)
-    Animals = UnitProperty(list)
+    PettingAllowed = UnitProperty(bool)
-    if decimal:
-        Acreage = UnitProperty(decimal.Decimal)