Use tagged version of src/persistent

lib/python/persistent/DEPENDENCIES.cfg

+zope.interface
+# the following are needed by the tests
+transaction
+ZODB

lib/python/persistent/README.txt

+===================
+Persistence support
+===================
+
+(This document is under construction. More basic documentation will
+ eventually appear here.)
+
+
+Overriding __getattr__, __getattribute__, __setattr__, and __delattr__
+-----------------------------------------------------------------------  
+
+Subclasses can override the attribute-management methods.  For the
+__getattr__ method, the behavior is like that for regular Python
+classes and for earlier versions of ZODB 3.
+
+For __getattribute__, __setattr__, and __delattr__, it is necessary to
+cal certain methods defined by persistent.Persistent.  Detailed
+examples and documentation is provided in the test module,
+persistent.tests.test_overriding_attrs.
+
+
+
+
+  

lib/python/persistent/SETUP.cfg

+# Extension information for zpkg.
+
+# Mark an "exported" header for use from other packages.
+# This is not needed for headers only used within the package.
+#
+header  cPersistence.h
+
+
+# This is included by cPersistence.h, so all users of cPersistence.h
+# have to be able to include this indirectly.
+#
+header  ring.h
+
+
+<extension cPersistence>
+  source     cPersistence.c
+  source     ring.c
+
+  depends-on cPersistence.h
+  depends-on ring.h
+</extension>
+
+<extension cPickleCache>
+  source     cPickleCache.c
+  source     ring.c
+
+  depends-on cPersistence.h
+  depends-on ring.h
+</extension>
+
+<extension TimeStamp>
+  source     TimeStamp.c
+</extension>

lib/python/persistent/__init__.py

+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Provide access to Persistent and PersistentMapping.
+
+$Id: __init__.py,v 1.8 2004/02/24 13:54:05 srichter Exp $
+"""
+
+from cPersistence import Persistent, GHOST, UPTODATE, CHANGED, STICKY
+from cPickleCache import PickleCache
+
+from cPersistence import simple_new
+import copy_reg
+copy_reg.constructor(simple_new)
+
+# Make an interface declaration for Persistent,
+# if zope.interface is available.
+try:
+    from zope.interface import classImplements
+except ImportError:
+    pass
+else:
+    from persistent.interfaces import IPersistent
+    classImplements(Persistent, IPersistent)

lib/python/persistent/cPersistence.h

+/*****************************************************************************
+
+  Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+  All Rights Reserved.
+
+  This software is subject to the provisions of the Zope Public License,
+  Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+  WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+  FOR A PARTICULAR PURPOSE
+
+ ****************************************************************************/
+
+#ifndef CPERSISTENCE_H
+#define CPERSISTENCE_H
+
+#include "Python.h"
+#include "ring.h"
+
+#define CACHE_HEAD \
+    PyObject_HEAD \
+    CPersistentRing ring_home; \
+    int non_ghost_count;
+
+struct ccobject_head_struct;
+
+typedef struct ccobject_head_struct PerCache;
+
+/* How big is a persistent object?
+
+   12  PyGC_Head is two pointers and an int
+    8  PyObject_HEAD is an int and a pointer
+ 
+   12  jar, oid, cache pointers
+    8  ring struct
+    8  serialno
+    4  state + extra
+
+  (52) so far
+
+    4  dict ptr
+    4  weaklist ptr
+  -------------------------
+   64  only need 62, but obmalloc rounds up to multiple of eight
+
+  Even a ghost requires 64 bytes.  It's possible to make a persistent
+  instance with slots and no dict, which changes the storage needed.
+
+*/
+
+#define cPersistent_HEAD \
+    PyObject_HEAD \
+    PyObject *jar; \
+    PyObject *oid; \
+    PerCache *cache; \
+    CPersistentRing ring; \
+    char serial[8]; \
+    signed char state; \
+    unsigned char reserved[3];
+
+#define cPersistent_GHOST_STATE -1
+#define cPersistent_UPTODATE_STATE 0
+#define cPersistent_CHANGED_STATE 1
+#define cPersistent_STICKY_STATE 2
+
+typedef struct {
+    cPersistent_HEAD
+} cPersistentObject;
+
+typedef void (*percachedelfunc)(PerCache *, PyObject *);
+
+typedef struct {
+    PyTypeObject *pertype;
+    getattrofunc getattro;
+    setattrofunc setattro;
+    int (*changed)(cPersistentObject*);
+    void (*accessed)(cPersistentObject*);
+    void (*ghostify)(cPersistentObject*);
+    int (*setstate)(PyObject*);
+    percachedelfunc percachedel;
+} cPersistenceCAPIstruct;
+
+#define cPersistenceType cPersistenceCAPI->pertype
+
+#ifndef DONT_USE_CPERSISTENCECAPI
+static cPersistenceCAPIstruct *cPersistenceCAPI;
+#endif
+
+#define cPersistanceModuleName "cPersistence"
+
+#define PER_TypeCheck(O) PyObject_TypeCheck((O), cPersistenceCAPI->pertype)
+
+#define PER_USE_OR_RETURN(O,R) {if((O)->state==cPersistent_GHOST_STATE && cPersistenceCAPI->setstate((PyObject*)(O)) < 0) return (R); else if ((O)->state==cPersistent_UPTODATE_STATE) (O)->state=cPersistent_STICKY_STATE;}
+
+#define PER_CHANGED(O) (cPersistenceCAPI->changed((cPersistentObject*)(O)))
+
+#define PER_GHOSTIFY(O) (cPersistenceCAPI->ghostify((cPersistentObject*)(O)))
+
+/* If the object is sticky, make it non-sticky, so that it can be ghostified.
+   The value is not meaningful
+ */
+#define PER_ALLOW_DEACTIVATION(O) ((O)->state==cPersistent_STICKY_STATE && ((O)->state=cPersistent_UPTODATE_STATE))
+
+#define PER_PREVENT_DEACTIVATION(O)  ((O)->state==cPersistent_UPTODATE_STATE && ((O)->state=cPersistent_STICKY_STATE))
+
+/* 
+   Make a persistent object usable from C by:
+
+   - Making sure it is not a ghost
+
+   - Making it sticky.
+
+   IMPORTANT: If you call this and don't call PER_ALLOW_DEACTIVATION, 
+              your object will not be ghostified.
+
+   PER_USE returns a 1 on success and 0 failure, where failure means
+   error.
+ */
+#define PER_USE(O) \
+(((O)->state != cPersistent_GHOST_STATE \
+  || (cPersistenceCAPI->setstate((PyObject*)(O)) >= 0)) \
+ ? (((O)->state==cPersistent_UPTODATE_STATE) \
+    ? ((O)->state=cPersistent_STICKY_STATE) : 1) : 0)
+
+#define PER_ACCESSED(O)  (cPersistenceCAPI->accessed((cPersistentObject*)(O)))
+
+#endif

lib/python/persistent/dict.py

+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Python implementation of persistent container type
+
+$Id: dict.py,v 1.2 2004/02/19 02:59:30 jeremy Exp $
+"""
+
+import persistent
+from UserDict import IterableUserDict
+
+__metaclass__ = type
+
+class PersistentDict(persistent.Persistent, IterableUserDict):
+    """A persistent wrapper for mapping objects.
+
+    This class allows wrapping of mapping objects so that object
+    changes are registered.  As a side effect, mapping objects may be
+    subclassed.
+    """
+
+    # IterableUserDict provides all of the mapping behavior.  The
+    # PersistentDict class is responsible marking the persistent
+    # state as changed when a method actually changes the state.  At
+    # the mapping API evolves, we may need to add more methods here.
+
+    __super_delitem = IterableUserDict.__delitem__
+    __super_setitem = IterableUserDict.__setitem__
+    __super_clear = IterableUserDict.clear
+    __super_update = IterableUserDict.update
+    __super_setdefault = IterableUserDict.setdefault
+    __super_popitem = IterableUserDict.popitem
+
+    __super_p_init = persistent.Persistent.__init__
+    __super_init = IterableUserDict.__init__
+
+    def __init__(self, dict=None):
+        self.__super_init(dict)
+        self.__super_p_init()
+
+    def __delitem__(self, key):
+        self.__super_delitem(key)
+        self._p_changed = True
+
+    def __setitem__(self, key, v):
+        self.__super_setitem(key, v)
+        self._p_changed = True
+
+    def clear(self):
+        self.__super_clear()
+        self._p_changed = True
+
+    def update(self, b):
+        self.__super_update(b)
+        self._p_changed = True
+
+    def setdefault(self, key, failobj=None):
+        # We could inline all of UserDict's implementation into the
+        # method here, but I'd rather not depend at all on the
+        # implementation in UserDict (simple as it is).
+        if not self.has_key(key):
+            self._p_changed = True
+        return self.__super_setdefault(key, failobj)
+
+    def popitem(self):
+        self._p_changed = True
+        return self.__super_popitem()

lib/python/persistent/list.py

+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+"""Python implementation of persistent list.
+
+$Id: list.py,v 1.7 2004/02/19 18:13:35 jeremy Exp $"""
+
+__version__='$Revision: 1.7 $'[11:-2]
+
+import persistent
+from UserList import UserList
+
+class PersistentList(UserList, persistent.Persistent):
+    __super_setitem = UserList.__setitem__
+    __super_delitem = UserList.__delitem__
+    __super_setslice = UserList.__setslice__
+    __super_delslice = UserList.__delslice__
+    __super_iadd = UserList.__iadd__
+    __super_imul = UserList.__imul__
+    __super_append = UserList.append
+    __super_insert = UserList.insert
+    __super_pop = UserList.pop
+    __super_remove = UserList.remove
+    __super_reverse = UserList.reverse
+    __super_sort = UserList.sort
+    __super_extend = UserList.extend
+
+    def __setitem__(self, i, item):
+        self.__super_setitem(i, item)
+        self._p_changed = 1
+
+    def __delitem__(self, i):
+        self.__super_delitem(i)
+        self._p_changed = 1
+
+    def __setslice__(self, i, j, other):
+        self.__super_setslice(i, j, other)
+        self._p_changed = 1
+
+    def __delslice__(self, i, j):
+        self.__super_delslice(i, j)
+        self._p_changed = 1
+
+    def __iadd__(self, other):
+        L = self.__super_iadd(other)
+        self._p_changed = 1
+        return L
+
+    def __imul__(self, n):
+        L = self.__super_imul(n)
+        self._p_changed = 1
+        return L
+
+    def append(self, item):
+        self.__super_append(item)
+        self._p_changed = 1
+
+    def insert(self, i, item):
+        self.__super_insert(i, item)
+        self._p_changed = 1
+
+    def pop(self, i=-1):
+        rtn = self.__super_pop(i)
+        self._p_changed = 1
+        return rtn
+
+    def remove(self, item):
+        self.__super_remove(item)
+        self._p_changed = 1
+
+    def reverse(self):
+        self.__super_reverse()
+        self._p_changed = 1
+
+    def sort(self, *args):
+        self.__super_sort(*args)
+        self._p_changed = 1
+
+    def extend(self, other):
+        self.__super_extend(other)
+        self._p_changed = 1
+
+    # This works around a bug in Python 2.1.x (up to 2.1.2 at least) where the
+    # __cmp__ bogusly raises a RuntimeError, and because this is an extension
+    # class, none of the rich comparison stuff works anyway.
+    def __cmp__(self, other):
+        return cmp(self.data, self._UserList__cast(other))

lib/python/persistent/mapping.py

+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+"""Python implementation of persistent base types
+
+$Id: mapping.py,v 1.22 2003/11/28 16:44:55 jim Exp $"""
+
+__version__='$Revision: 1.22 $'[11:-2]
+
+import persistent
+from UserDict import UserDict
+
+class PersistentMapping(UserDict, persistent.Persistent):
+    """A persistent wrapper for mapping objects.
+
+    This class allows wrapping of mapping objects so that object
+    changes are registered.  As a side effect, mapping objects may be
+    subclassed.
+
+    A subclass of PersistentMapping or any code that adds new
+    attributes should not create an attribute named _container.  This
+    is reserved for backwards compatibility reasons.
+    """
+
+    # UserDict provides all of the mapping behavior.  The
+    # PersistentMapping class is responsible marking the persistent
+    # state as changed when a method actually changes the state.  At
+    # the mapping API evolves, we may need to add more methods here.
+
+    __super_delitem = UserDict.__delitem__
+    __super_setitem = UserDict.__setitem__
+    __super_clear = UserDict.clear
+    __super_update = UserDict.update
+    __super_setdefault = UserDict.setdefault
+
+    def __delitem__(self, key):
+        self.__super_delitem(key)
+        self._p_changed = 1
+
+    def __setitem__(self, key, v):
+        self.__super_setitem(key, v)
+        self._p_changed = 1
+
+    def clear(self):
+        self.__super_clear()
+        self._p_changed = 1
+
+    def update(self, b):
+        self.__super_update(b)
+        self._p_changed = 1
+
+    def setdefault(self, key, failobj=None):
+        # We could inline all of UserDict's implementation into the
+        # method here, but I'd rather not depend at all on the
+        # implementation in UserDict (simple as it is).
+        if not self.has_key(key):
+            self._p_changed = 1
+        return self.__super_setdefault(key, failobj)
+
+    try:
+        __super_popitem = UserDict.popitem
+    except AttributeError:
+        pass
+    else:
+        def popitem(self):
+            self._p_changed = 1
+            return self.__super_popitem()
+
+    # If the internal representation of PersistentMapping changes,
+    # it causes compatibility problems for pickles generated by
+    # different versions of the code.  Compatibility works in both
+    # directions, because an application may want to share a database
+    # between applications using different versions of the code.
+
+    # Effectively, the original rep is part of the "API."  To provide
+    # full compatibility, the getstate and setstate must read and
+    # right objects using the old rep.
+
+    # As a result, the PersistentMapping must save and restore the
+    # actual internal dictionary using the name _container.
+
+    def __getstate__(self):
+        state = {}
+        state.update(self.__dict__)
+        state['_container'] = state['data']
+        del state['data']
+        return state
+
+    def __setstate__(self, state):
+        if state.has_key('_container'):
+            self.data = state['_container']
+            del state['_container']
+        elif not state.has_key('data'):
+            self.data = {}
+        self.__dict__.update(state)

lib/python/persistent/ring.c

+/*****************************************************************************
+
+  Copyright (c) 2003 Zope Corporation and Contributors.
+  All Rights Reserved.
+
+  This software is subject to the provisions of the Zope Public License,
+  Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+  WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+  FOR A PARTICULAR PURPOSE
+
+ ****************************************************************************/
+
+#define RING_C "$Id: ring.c,v 1.3 2004/05/03 20:15:45 spascoe Exp $\n"
+
+/* Support routines for the doubly-linked list of cached objects.
+
+The cache stores a doubly-linked list of persistent objects, with
+space for the pointers allocated in the objects themselves.  The cache
+stores the distinguished head of the list, which is not a valid
+persistent object.
+
+The next pointers traverse the ring in order starting with the least
+recently used object.  The prev pointers traverse the ring in order
+starting with the most recently used object.
+
+*/
+
+#include "Python.h"
+#include "ring.h"
+
+void
+ring_add(CPersistentRing *ring, CPersistentRing *elt)
+{
+    assert(!elt->r_next);
+    elt->r_next = ring;
+    elt->r_prev = ring->r_prev;
+    ring->r_prev->r_next = elt;
+    ring->r_prev = elt;
+}
+
+void
+ring_del(CPersistentRing *elt)
+{
+    elt->r_next->r_prev = elt->r_prev;
+    elt->r_prev->r_next = elt->r_next;
+    elt->r_next = NULL;
+    elt->r_prev = NULL;
+}
+
+void
+ring_move_to_head(CPersistentRing *ring, CPersistentRing *elt)
+{
+    elt->r_prev->r_next = elt->r_next;
+    elt->r_next->r_prev = elt->r_prev;
+    elt->r_next = ring;
+    elt->r_prev = ring->r_prev;
+    ring->r_prev->r_next = elt;
+    ring->r_prev = elt;
+}

lib/python/persistent/ring.h

+/*****************************************************************************
+
+  Copyright (c) 2003 Zope Corporation and Contributors.
+  All Rights Reserved.
+
+  This software is subject to the provisions of the Zope Public License,
+  Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+  WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+  FOR A PARTICULAR PURPOSE
+
+ ****************************************************************************/
+
+/* Support routines for the doubly-linked list of cached objects.
+
+The cache stores a headed, doubly-linked, circular list of persistent
+objects, with space for the pointers allocated in the objects themselves.
+The cache stores the distinguished head of the list, which is not a valid
+persistent object.  The other list members are non-ghost persistent
+objects, linked in LRU (least-recently used) order.
+
+The r_next pointers traverse the ring starting with the least recently used
+object.  The r_prev pointers traverse the ring starting with the most
+recently used object.
+
+Obscure:  While each object is pointed at twice by list pointers (once by
+its predecessor's r_next, again by its successor's r_prev), the refcount
+on the object is bumped only by 1.  This leads to some possibly surprising
+sequences of incref and decref code.  Note that since the refcount is
+bumped at least once, the list does hold a strong reference to each
+object in it.
+*/
+
+typedef struct CPersistentRing_struct
+{
+    struct CPersistentRing_struct *r_prev;
+    struct CPersistentRing_struct *r_next;
+} CPersistentRing;
+
+/* The list operations here take constant time independent of the
+ * number of objects in the list:
+ */
+
+/* Add elt as the most recently used object.  elt must not already be
+ * in the list, although this isn't checked.
+ */
+void ring_add(CPersistentRing *ring, CPersistentRing *elt);
+
+/* Remove elt from the list.  elt must already be in the list, although
+ * this isn't checked.
+ */
+void ring_del(CPersistentRing *elt);
+
+/* elt must already be in the list, although this isn't checked.  It's
+ * unlinked from its current position, and relinked into the list as the
+ * most recently used object (which is arguably the tail of the list
+ * instead of the head -- but the name of this function could be argued
+ * either way).  This is equivalent to
+ *
+ *     ring_del(elt);
+ *     ring_add(ring, elt);
+ *
+ * but may be a little quicker.
+ */
+void ring_move_to_head(CPersistentRing *ring, CPersistentRing *elt);

lib/python/persistent/tests/__init__.py

+# package

lib/python/persistent/tests/persistent.txt

+Tests for persistent.Persistent
+===============================
+
+This document is an extended doc test that covers the basics of the
+Persistent base class.  The test expects a class named 'P' to be
+provided in its globals.  The P class implements the Persistent
+interface.
+
+Test framework
+--------------
+
+The class P needs to behave like ExampleP.  (Note that the code below
+is *not* part of the tests.)
+
+class ExampleP(Persistent):
+    def __init__(self):
+        self.x = 0
+    def inc(self):
+        self.x += 1
+
+The tests use stub data managers.  A data manager is responsible for
+loading and storing the state of a persistent object.  It's stored in
+the _p_jar attribute of a persistent object.
+
+>>> class DM:
+...     def __init__(self):
+...         self.called = 0
+...     def register(self, ob):
+...         self.called += 1
+...     def setstate(self, ob):
+...         ob.__setstate__({'x': 42})
+
+>>> class BrokenDM(DM):
+...     def register(self,ob):
+...         self.called += 1
+...         raise NotImplementedError
+...     def setstate(self,ob):
+...         raise NotImplementedError
+
+>>> from persistent import Persistent
+
+Test Persistent without Data Manager
+------------------------------------
+
+First do some simple tests of a Persistent instance that does not have
+a data manager (_p_jar).
+
+>>> p = P()
+>>> p.x
+0
+>>> p._p_changed
+False
+>>> p._p_state
+0
+>>> p._p_jar
+>>> p._p_oid
+
+Verify that modifications have no effect on _p_state of _p_changed.
+
+>>> p.inc()
+>>> p.inc()
+>>> p.x
+2
+>>> p._p_changed
+False
+>>> p._p_state
+0
+
+Try all sorts of different ways to change the object's state.
+
+>>> p._p_deactivate()
+>>> p._p_state
+0
+>>> p._p_changed = True
+>>> p._p_state
+0
+>>> del p._p_changed
+>>> p._p_changed
+False
+>>> p._p_state
+0
+>>> p.x
+2
+
+Test Persistent with Data Manager
+---------------------------------
+
+Next try some tests of an object with a data manager.  The DM class is
+a simple testing stub.
+    
+>>> p = P()
+>>> dm = DM()
+>>> p._p_oid = "00000012"
+>>> p._p_jar = dm
+>>> p._p_changed
+0
+>>> dm.called
+0
+
+Modifying the object marks it as changed and registers it with the
+data manager.  Subsequent modifications don't have additional
+side-effects.
+
+>>> p.inc()
+>>> p._p_changed
+1
+>>> dm.called
+1
+>>> p.inc()
+>>> p._p_changed
+1
+>>> dm.called
+1
+
+It's not possible to deactivate a modified object.
+
+>>> p._p_deactivate()
+>>> p._p_changed
+1
+
+It is possible to invalidate it.  That's the key difference
+between deactivation and invalidation.
+
+>>> p._p_invalidate()
+>>> p._p_state
+-1
+
+Now that the object is a ghost, any attempt to modify it will
+require that it be unghosted first.  The test data manager
+has the odd property that it sets the object's 'x' attribute
+to 42 when it is unghosted.
+
+>>> p.inc()
+>>> p.x
+43
+>>> dm.called
+2
+
+You can manually reset the changed field to False, although
+it's not clear why you would want to do that.  The object
+changes to the UPTODATE state but retains its modifications.
+
+>>> p._p_changed = False
+>>> p._p_state
+0
+>>> p._p_changed
+False
+>>> p.x
+43
+
+>>> p.inc()
+>>> p._p_changed
+True
+>>> dm.called
+3
+
+__getstate__() and __setstate__()
+---------------------------------
+
+The next several tests cover the __getstate__() and __setstate__()
+implementations.
+
+>>> p = P()
+>>> state = p.__getstate__()
+>>> isinstance(state, dict)
+True
+>>> state['x']
+0
+>>> p._p_state
+0
+
+Calling setstate always leaves the object in the uptodate state?
+(I'm not entirely clear on this one.)
+
+>>> p.__setstate__({'x': 5})
+>>> p._p_state
+0
+
+Assigning to a volatile attribute has no effect on the object state.
+
+>>> p._v_foo = 2
+>>> p.__getstate__()
+{'x': 5}
+>>> p._p_state
+0
+
+The _p_serial attribute is not affected by calling setstate.
+
+>>> p._p_serial = "00000012"
+>>> p.__setstate__(p.__getstate__())
+>>> p._p_serial
+'00000012'
+
+Change Ghost test
+-----------------
+
+If an object is a ghost and it's _p_changed is set to True, it should
+have no effect.
+
+>>> p = P()
+>>> p._p_jar = DM()
+>>> p._p_oid = 1
+>>> p._p_deactivate()
+>>> p._p_changed
+>>> p._p_state
+-1
+>>> p._p_changed = True
+>>> p._p_changed
+>>> p._p_state
+-1
+
+Activate, deactivate, and invalidate
+------------------------------------
+
+Some of these tests are redundant, but are included to make sure there
+are explicit and simple tests of _p_activate(), _p_deactivate(), and
+_p_invalidate().
+
+>>> p = P()
+>>> p._p_oid = 1
+>>> p._p_jar = DM()
+>>> p._p_deactivate()
+>>> p._p_state
+-1
+>>> p._p_activate()
+>>> p._p_state
+0
+>>> p.x
+42
+>>> p.inc()
+>>> p.x
+43
+>>> p._p_state
+1
+>>> p._p_invalidate()
+>>> p._p_state
+-1
+>>> p.x
+42
+
+Test failures
+-------------
+
+The following tests cover various errors cases.
+
+When an object is modified, it registers with its data manager.  If
+that registration fails, the exception is propagated and the object
+stays in the up-to-date state.  It shouldn't change to the modified
+state, because it won't be saved when the transaction commits.
+
+>>> p = P()
+>>> p._p_oid = 1
+>>> p._p_jar = BrokenDM()
+>>> p._p_state
+0
+>>> p._p_jar.called
+0
+>>> p._p_changed = 1
+Traceback (most recent call last):
+  ...
+NotImplementedError
+>>> p._p_jar.called
+1
+>>> p._p_state
+0
+
+Make sure that exceptions that occur inside the data manager's
+setstate() method propagate out to the caller.
+
+>>> p = P()
+>>> p._p_oid = 1
+>>> p._p_jar = BrokenDM()
+>>> p._p_deactivate()
+>>> p._p_state
+-1
+>>> p._p_activate()
+Traceback (most recent call last):
+  ...
+NotImplementedError
+>>> p._p_state
+-1
+
+
+Special test to cover layout of __dict__
+----------------------------------------
+
+We once had a bug in the Persistent class that calculated an incorrect
+offset for the __dict__ attribute.  It assigned __dict__ and _p_jar to
+the same location in memory.  This is a simple test to make sure they
+have different locations.
+
+>>> p = P()
+>>> p.inc()
+>>> p.inc()
+>>> 'x' in p.__dict__
+True
+>>> p._p_jar
+
+
+Inheritance and metaclasses
+---------------------------
+
+Simple tests to make sure it's possible to inherit from the Persistent
+base class multiple times.  There used to be metaclasses involved in
+Persistent that probably made this a more interesting test.
+
+>>> class A(Persistent):
+...     pass
+>>> class B(Persistent):
+...     pass
+>>> class C(A, B):
+...     pass
+>>> class D(object):
+...     pass
+>>> class E(D, B):
+...     pass
+>>> a = A()
+>>> b = B()
+>>> c = C()
+>>> d = D()
+>>> e = E()
+
+Also make sure that it's possible to define Persistent classes that
+have a custom metaclass.
+
+>>> class alternateMeta(type):
+...     type
+>>> class alternate(object):
+...     __metaclass__ = alternateMeta
+>>> class mixedMeta(alternateMeta, type):
+...     pass
+>>> class mixed(alternate, Persistent):
+...     pass
+>>> class mixed(Persistent, alternate):
+...     pass
+
+
+Basic type structure
+--------------------
+
+>>> Persistent.__dictoffset__ 
+0
+>>> Persistent.__weakrefoffset__
+0
+>>> Persistent.__basicsize__ > object.__basicsize__
+True
+>>> P.__dictoffset__ > 0
+True
+>>> P.__weakrefoffset__ > 0
+True
+>>> P.__dictoffset__ < P.__weakrefoffset__
+True
+>>> P.__basicsize__ > Persistent.__basicsize__
+True
+
+
+Slots
+-----
+
+These are some simple tests of classes that have an __slots__
+attribute.  Some of the classes should have slots, others shouldn't.
+
+>>> class noDict(object):
+...     __slots__ = ['foo']
+>>> class p_noDict(Persistent):
+...     __slots__ = ['foo']
+>>> class p_shouldHaveDict(p_noDict):
+...     pass
+
+>>> p_noDict.__dictoffset__
+0
+>>> x = p_noDict()
+>>> x.foo = 1
+>>> x.foo
+1
+>>> x.bar = 1
+Traceback (most recent call last):
+  ...
+AttributeError: 'p_noDict' object has no attribute 'bar'
+>>> x._v_bar = 1
+Traceback (most recent call last):
+  ...
+AttributeError: 'p_noDict' object has no attribute '_v_bar'
+>>> x.__dict__
+Traceback (most recent call last):
+  ...
+AttributeError: 'p_noDict' object has no attribute '__dict__'
+
+The various _p_ attributes are unaffected by slots.
+>>> p._p_oid
+>>> p._p_jar
+>>> p._p_state
+0
+
+If the most-derived class does not specify 
+
+>>> p_shouldHaveDict.__dictoffset__ > 0
+True
+>>> x = p_shouldHaveDict()
+>>> isinstance(x.__dict__, dict)
+True
+
+
+Pickling
+--------
+
+There's actually a substantial effort involved in making subclasses of
+Persistent work with plain-old pickle.  The ZODB serialization layer
+never calls pickle on an object; it pickles the object's class
+description and its state as two separate pickles.
+
+>>> import pickle
+>>> p = P()
+>>> p.inc()
+>>> p2 = pickle.loads(pickle.dumps(p))
+>>> p2.__class__ is P
+True
+>>> p2.x == p.x
+True
+
+We should also test that pickle works with custom getstate and
+setstate.  Perhaps even reduce.  The problem is that pickling depends
+on finding the class in a particular module, and classes defined here
+won't appear in any module.  We could require each user of the tests
+to define a base class, but that might be tedious.
+
+Interfaces
+----------
+
+Some versions of Zope and ZODB have the zope.interfaces package
+available.  If it is available, then persistent will be associated
+with several interfaces.  It's hard to write a doctest test that runs
+the tests only if zope.interface is available, so this test looks a
+little unusual.  One problem is that the assert statements won't do
+anything if you run with -O.
+
+>>> try:
+...     import zope.interface
+... except ImportError:
+...     pass
+... else:
+...     from persistent.interfaces import IPersistent
+...     assert IPersistent.implementedBy(Persistent)
+...     p = Persistent()
+...     assert IPersistent.providedBy(p)
+...     assert IPersistent.implementedBy(P)
+...     p = P()
+...     assert IPersistent.providedBy(p)

lib/python/persistent/tests/testPersistent.py

+#############################################################################
+#
+# Copyright (c) 2003 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+import pickle
+import time
+import unittest
+
+from persistent import Persistent, GHOST, UPTODATE, CHANGED, STICKY
+from persistent.cPickleCache import PickleCache
+from persistent.TimeStamp import TimeStamp
+from ZODB.utils import p64
+
+class Jar(object):
+    """Testing stub for _p_jar attribute."""
+
+    def __init__(self):
+        self.cache = PickleCache(self)
+        self.oid = 1
+        self.registered = {}
+
+    def add(self, obj):
+        obj._p_oid = p64(self.oid)
+        self.oid += 1
+        obj._p_jar = self
+        self.cache[obj._p_oid] = obj
+
+    def close(self):
+        pass
+
+    # the following methods must be implemented to be a jar
+
+    def setklassstate(self):
+        # I don't know what this method does, but the pickle cache
+        # constructor calls it.
+        pass
+
+    def register(self, obj):
+        self.registered[obj] = 1
+
+    def setstate(self, obj):
+        # Trivial setstate() implementation that just re-initializes
+        # the object.  This isn't what setstate() is supposed to do,
+        # but it suffices for the tests.
+        obj.__class__.__init__(obj)
+
+class P(Persistent):
+    pass
+
+class H1(Persistent):
+
+    def __init__(self):
+        self.n = 0
+
+    def __getattr__(self, attr):
+        self.n += 1
+        return self.n
+
+class H2(Persistent):
+
+    def __init__(self):
+        self.n = 0
+
+    def __getattribute__(self, attr):
+        supergetattr = super(H2, self).__getattribute__
+        try:
+            return supergetattr(attr)
+        except AttributeError:
+            n = supergetattr("n")
+            self.n = n + 1
+            return n + 1
+
+class PersistenceTest(unittest.TestCase):
+
+    def setUp(self):
+        self.jar = Jar()
+
+    def tearDown(self):
+        self.jar.close()
+
+    def testOidAndJarAttrs(self):
+        obj = P()
+        self.assertEqual(obj._p_oid, None)
+        obj._p_oid = 12
+        self.assertEqual(obj._p_oid, 12)
+        del obj._p_oid
+
+        self.jar.add(obj)
+
+        # Can't change oid of cache object.
+        def deloid():
+            del obj._p_oid
+        self.assertRaises(ValueError, deloid)
+        def setoid():
+            obj._p_oid = 12
+        self.assertRaises(ValueError, setoid)
+
+        def deloid():
+            del obj._p_jar
+        self.assertRaises(ValueError, deloid)
+        def setoid():
+            obj._p_jar = 12
+        self.assertRaises(ValueError, setoid)
+
+    def testChangedAndState(self):
+        obj = P()
+        self.jar.add(obj)
+
+        # The value returned for _p_changed can be one of:
+        # 0 -- it is not changed
+        # 1 -- it is changed
+        # None -- it is a ghost
+
+        obj.x = 1
+        self.assertEqual(obj._p_changed, 1)
+        self.assertEqual(obj._p_state, CHANGED)
+        self.assert_(obj in self.jar.registered)
+
+        obj._p_changed = 0
+        self.assertEqual(obj._p_changed, 0)
+        self.assertEqual(obj._p_state, UPTODATE)
+        self.jar.registered.clear()
+
+        obj._p_changed = 1
+        self.assertEqual(obj._p_changed, 1)
+        self.assertEqual(obj._p_state, CHANGED)
+        self.assert_(obj in self.jar.registered)
+
+        # setting obj._p_changed to None ghostifies if the
+        # object is in the up-to-date state, but not otherwise.
+        obj._p_changed = None
+        self.assertEqual(obj._p_changed, 1)
+        self.assertEqual(obj._p_state, CHANGED)
+        obj._p_changed = 0
+        # Now it's a ghost.
+        obj._p_changed = None
+        self.assertEqual(obj._p_changed, None)
+        self.assertEqual(obj._p_state, GHOST)
+
+        obj = P()
+        self.jar.add(obj)
+        obj._p_changed = 1
+        # You can transition directly from modified to ghost if
+        # you delete the _p_changed attribute.
+        del obj._p_changed
+        self.assertEqual(obj._p_changed, None)
+        self.assertEqual(obj._p_state, GHOST)
+
+    def testStateReadonly(self):
+        # make sure we can't write to _p_state; we don't want yet
+        # another way to change state!
+        obj = P()
+        def setstate(value):
+            obj._p_state = value
+        self.assertRaises(TypeError, setstate, GHOST)
+        self.assertRaises(TypeError, setstate, UPTODATE)
+        self.assertRaises(TypeError, setstate, CHANGED)
+        self.assertRaises(TypeError, setstate, STICKY)
+
+    def testInvalidate(self):
+        obj = P()
+        self.jar.add(obj)
+
+        self.assertEqual(obj._p_changed, 0)
+        self.assertEqual(obj._p_state, UPTODATE)
+        obj._p_invalidate()
+        self.assertEqual(obj._p_changed, None)
+        self.assertEqual(obj._p_state, GHOST)
+
+        obj._p_activate()
+        obj.x = 1
+        obj._p_invalidate()
+        self.assertEqual(obj._p_changed, None)
+        self.assertEqual(obj._p_state, GHOST)
+
+    def testSerial(self):
+        noserial = "\000" * 8
+        obj = P()
+        self.assertEqual(obj._p_serial, noserial)
+
+        def set(val):
+            obj._p_serial = val
+        self.assertRaises(ValueError, set, 1)
+        self.assertRaises(ValueError, set, "0123")
+        self.assertRaises(ValueError, set, "012345678")
+        self.assertRaises(ValueError, set, u"01234567")
+
+        obj._p_serial = "01234567"
+        del obj._p_serial
+        self.assertEqual(obj._p_serial, noserial)
+
+    def testMTime(self):
+        obj = P()
+        self.assertEqual(obj._p_mtime, None)
+
+        t = int(time.time())
+        ts = TimeStamp(*time.gmtime(t)[:6])
+        obj._p_serial = repr(ts)
+        self.assertEqual(obj._p_mtime, t)
+        self.assert_(isinstance(obj._p_mtime, float))
+
+    def testPicklable(self):
+        obj = P()
+        obj.attr = "test"
+        s = pickle.dumps(obj)
+        obj2 = pickle.loads(s)
+        self.assertEqual(obj.attr, obj2.attr)
+
+    def testGetattr(self):
+        obj = H1()
+        self.assertEqual(obj.larry, 1)
+        self.assertEqual(obj.curly, 2)
+        self.assertEqual(obj.moe, 3)
+
+        self.jar.add(obj)
+        obj._p_deactivate()
+
+        # The simple Jar used for testing re-initializes the object.
+        self.assertEqual(obj.larry, 1)
+        # The getattr hook modified the object, so it should now be
+        # in the changed state.
+        self.assertEqual(obj._p_changed, 1)
+        self.assertEqual(obj._p_state, CHANGED)
+        self.assertEqual(obj.curly, 2)
+        self.assertEqual(obj.moe, 3)
+
+    def testGetattribute(self):
+        obj = H2()
+        self.assertEqual(obj.larry, 1)
+        self.assertEqual(obj.curly, 2)
+        self.assertEqual(obj.moe, 3)
+
+        self.jar.add(obj)
+        obj._p_deactivate()
+
+        # The simple Jar used for testing re-initializes the object.
+        self.assertEqual(obj.larry, 1)
+        # The getattr hook modified the object, so it should now be
+        # in the changed state.
+        self.assertEqual(obj._p_changed, 1)
+        self.assertEqual(obj._p_state, CHANGED)
+        self.assertEqual(obj.curly, 2)
+        self.assertEqual(obj.moe, 3)
+
+    # XXX Need to decide how __setattr__ and __delattr__ should work,
+    # then write tests.
+
+
+def test_suite():
+    return unittest.makeSuite(PersistenceTest)

lib/python/persistent/tests/test_PickleCache.py

+##############################################################################
+#
+# Copyright (c) 2003 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Unit tests for PickleCache
+
+$Id: test_PickleCache.py,v 1.2 2004/02/19 02:59:32 jeremy Exp $
+"""
+
+class DummyConnection:
+
+    def setklassstate(self, obj):
+        """Method used by PickleCache."""
+
+
+def test_delitem():
+    """
+    >>> from persistent import PickleCache
+    >>> conn = DummyConnection()
+    >>> cache = PickleCache(conn)
+    >>> del cache['']
+    Traceback (most recent call last):
+    ...
+    KeyError: ''
+    >>> from persistent import Persistent
+    >>> p = Persistent()
+    >>> p._p_oid = 'foo'
+    >>> p._p_jar = conn
+    >>> cache['foo'] = p
+    >>> del cache['foo']
+
+    """
+
+from doctest import DocTestSuite
+import unittest
+
+def test_suite():
+    return unittest.TestSuite((
+        DocTestSuite(),
+        ))
+
+if __name__ == '__main__':
+    unittest.main()

lib/python/persistent/tests/test_persistent.py

+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+import doctest
+import os
+import sys
+import unittest
+
+import persistent.tests
+from persistent import Persistent
+
+class P(Persistent):
+    def __init__(self):
+        self.x = 0
+    def inc(self):
+        self.x += 1
+
+def DocFileSuite(path, globs=None):
+    # It's not entirely obvious how to connection this single string
+    # with unittest.  For now, re-use the _utest() function that comes
+    # standard with doctest in Python 2.3.  One problem is that the
+    # error indicator doesn't point to the line of the doctest file
+    # that failed.
+    source = open(path).read()
+    if globs is None:
+        globs = sys._getframe(1).f_globals
+    t = doctest.Tester(globs=globs)
+    def runit():
+        doctest._utest(t, path, source, path, 0)
+    f = unittest.FunctionTestCase(runit, description="doctest from %s" % path)
+    suite = unittest.TestSuite()
+    suite.addTest(f)
+    return suite
+
+def test_suite():
+    path = os.path.join(persistent.tests.__path__[0], "persistent.txt")
+    return DocFileSuite(path, {"P": P})

lib/python/persistent/tests/test_wref.py

+##############################################################################
+#
+# Copyright (c) 2003 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""XXX short summary goes here.
+
+$Id: test_wref.py,v 1.2 2004/02/19 02:59:32 jeremy Exp $
+"""
+import unittest
+from doctest import DocTestSuite
+
+def test_suite():
+    return DocTestSuite('persistent.wref')
+
+if __name__ == '__main__':
+    unittest.main()