Original implementation

CHANGES.txt

+Changelog
+=========
+
+2.13.2 (2010-06-16)
+-------------------
+
+- LP #587760: Handle tp_basicsize correctly.
+
+2.13.1 (2010-04-30)
+-------------------
+
+- Removed undeclared testing dependency on zope.testing.
+
+2.13.0 (2010-02-23)
+-------------------
+
+- Update to include ExtensionClass 2.13.0.
+
+2.12.0 (2010-02-14)
+-------------------
+
+- Added support for method cache in Persistence. Patch contributed by
+  Yoshinori K. Okuji. See https://bugs.launchpad.net/zope2/+bug/486193.
+
+- Updated C includes to ExtensionClass 2.12.0.
+
+- Updated package metadata and remove old build artifacts.
+
+2.11.1 (2009-02-19)
+-------------------
+
+- First egg release.

COPYRIGHT.txt

+Zope Foundation and Contributors
\ No newline at end of file

LICENSE.txt

+Zope Public License (ZPL) Version 2.1
+
+A copyright notice accompanies this license document that identifies the
+copyright holders.
+
+This license has been certified as open source. It has also been designated as
+GPL compatible by the Free Software Foundation (FSF).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions in source code must retain the accompanying copyright
+notice, this list of conditions, and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the accompanying copyright
+notice, this list of conditions, and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Names of the copyright holders must not be used to endorse or promote
+products derived from this software without prior written permission from the
+copyright holders.
+
+4. The right to distribute this software or to use it for any purpose does not
+give you the right to use Servicemarks (sm) or Trademarks (tm) of the
+copyright
+holders. Use of them is covered by separate agreement with the copyright
+holders.
+
+5. If any files are modified, you must cause the modified files to carry
+prominent notices stating that you changed the files and the date of any
+change.
+
+Disclaimer
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

PKG-INFO

+Metadata-Version: 1.0
+Name: Persistence
+Version: 2.13.2
+Summary: Persistent ExtensionClass
+Home-page: http://pypi.python.org/pypi/Persistence
+Author: Zope Foundation and Contributors
+Author-email: zope-dev@zope.org
+License: ZPL 2.1
+Description: Overview
+        ========
+        
+        This package provides a variant of the persistent base class that's an
+        ExtensionClass. Unless you need ExtensionClass semantics, you probably want to
+        use persistent.Persistent from ZODB3.
+        
+        
+        Changelog
+        =========
+        
+        2.13.2 (2010-06-16)
+        -------------------
+        
+        - LP #587760: Handle tp_basicsize correctly.
+        
+        2.13.1 (2010-04-30)
+        -------------------
+        
+        - Removed undeclared testing dependency on zope.testing.
+        
+        2.13.0 (2010-02-23)
+        -------------------
+        
+        - Update to include ExtensionClass 2.13.0.
+        
+        2.12.0 (2010-02-14)
+        -------------------
+        
+        - Added support for method cache in Persistence. Patch contributed by
+          Yoshinori K. Okuji. See https://bugs.launchpad.net/zope2/+bug/486193.
+        
+        - Updated C includes to ExtensionClass 2.12.0.
+        
+        - Updated package metadata and remove old build artifacts.
+        
+        2.11.1 (2009-02-19)
+        -------------------
+        
+        - First egg release.
+        
+Platform: UNKNOWN

README.txt

+Overview
+========
+
+This package provides a variant of the persistent base class that's an
+ExtensionClass. Unless you need ExtensionClass semantics, you probably want to
+use persistent.Persistent from ZODB3.

bootstrap.py

+##############################################################################
+#
+# Copyright (c) 2006 Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (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.
+#
+##############################################################################
+"""Bootstrap a buildout-based project
+
+Simply run this script in a directory containing a buildout.cfg.
+The script accepts buildout command-line options, so you can
+use the -c option to specify an alternate configuration file.
+
+$Id$
+"""
+
+import os, shutil, sys, tempfile, urllib2
+from optparse import OptionParser
+
+tmpeggs = tempfile.mkdtemp()
+
+is_jython = sys.platform.startswith('java')
+
+# parsing arguments
+parser = OptionParser()
+parser.add_option("-v", "--version", dest="version",
+                          help="use a specific zc.buildout version")
+parser.add_option("-d", "--distribute",
+                   action="store_true", dest="distribute", default=False,
+                   help="Use Disribute rather than Setuptools.")
+
+parser.add_option("-c", None, action="store", dest="config_file",
+                   help=("Specify the path to the buildout configuration "
+                         "file to be used."))
+
+options, args = parser.parse_args()
+
+# if -c was provided, we push it back into args for buildout' main function
+if options.config_file is not None:
+    args += ['-c', options.config_file]
+
+if options.version is not None:
+    VERSION = '==%s' % options.version
+else:
+    VERSION = ''
+
+USE_DISTRIBUTE = options.distribute
+args = args + ['bootstrap']
+
+to_reload = False
+try:
+    import pkg_resources
+    if not hasattr(pkg_resources, '_distribute'):
+        to_reload = True
+        raise ImportError
+except ImportError:
+    ez = {}
+    if USE_DISTRIBUTE:
+        exec urllib2.urlopen('http://python-distribute.org/distribute_setup.py'
+                         ).read() in ez
+        ez['use_setuptools'](to_dir=tmpeggs, download_delay=0, no_fake=True)
+    else:
+        exec urllib2.urlopen('http://peak.telecommunity.com/dist/ez_setup.py'
+                             ).read() in ez
+        ez['use_setuptools'](to_dir=tmpeggs, download_delay=0)
+
+    if to_reload:
+        reload(pkg_resources)
+    else:
+        import pkg_resources
+
+if sys.platform == 'win32':
+    def quote(c):
+        if ' ' in c:
+            return '"%s"' % c # work around spawn lamosity on windows
+        else:
+            return c
+else:
+    def quote (c):
+        return c
+
+cmd = 'from setuptools.command.easy_install import main; main()'
+ws  = pkg_resources.working_set
+
+if USE_DISTRIBUTE:
+    requirement = 'distribute'
+else:
+    requirement = 'setuptools'
+
+if is_jython:
+    import subprocess
+
+    assert subprocess.Popen([sys.executable] + ['-c', quote(cmd), '-mqNxd',
+           quote(tmpeggs), 'zc.buildout' + VERSION],
+           env=dict(os.environ,
+               PYTHONPATH=
+               ws.find(pkg_resources.Requirement.parse(requirement)).location
+               ),
+           ).wait() == 0
+
+else:
+    assert os.spawnle(
+        os.P_WAIT, sys.executable, quote (sys.executable),
+        '-c', quote (cmd), '-mqNxd', quote (tmpeggs), 'zc.buildout' + VERSION,
+        dict(os.environ,
+            PYTHONPATH=
+            ws.find(pkg_resources.Requirement.parse(requirement)).location
+            ),
+        ) == 0
+
+ws.add_entry(tmpeggs)
+ws.require('zc.buildout' + VERSION)
+import zc.buildout.buildout
+zc.buildout.buildout.main(args)
+shutil.rmtree(tmpeggs)

buildout.cfg

+[buildout]
+develop = .
+parts = test
+
+versions = versions
+
+[test]
+recipe = zc.recipe.testrunner
+eggs = Persistence
+
+[versions]
+zc.buildout = 1.4.3
+zc.recipe.egg = 1.2.2

include/ExtensionClass/__init__.py

+##############################################################################
+#
+# Copyright (c) 2003 Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (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.
+#
+##############################################################################
+"""ExtensionClass
+
+Extension Class exists to support types derived from the old ExtensionType
+meta-class that preceeded Python 2.2 and new-style classes.
+
+As a meta-class, ExtensionClass provides the following features:
+
+- Support for a class initialiser:
+
+  >>> from ExtensionClass import ExtensionClass, Base
+
+  >>> class C(Base):
+  ...   def __class_init__(self):
+  ...      print 'class init called'
+  ...      print self.__name__
+  ...   def bar(self):
+  ...      return 'bar called'
+  class init called
+  C
+  >>> c = C()
+  >>> int(c.__class__ is C)
+  1
+  >>> int(c.__class__ is type(c))
+  1
+
+- Making sure that every instance of the meta-class has Base as a base class:
+
+  >>> class X:
+  ...     __metaclass__ = ExtensionClass
+
+  >>> Base in X.__mro__
+  1
+
+- Provide an inheritedAttribute method for looking up attributes in
+  base classes:
+
+  >>> class C2(C):
+  ...   def bar(*a):
+  ...      return C2.inheritedAttribute('bar')(*a), 42
+  class init called
+  C2
+  >>> o = C2()
+  >>> o.bar()
+  ('bar called', 42)
+
+  This is for compatability with old code. New code should use super
+  instead.   
+
+The base class, Base, exists mainly to support the __of__ protocol.
+The __of__ protocol is similar to __get__ except that __of__ is called
+when an implementor is retrieved from an instance as well as from a
+class:
+
+>>> class O(Base):
+...   def __of__(*a):
+...      return a
+ 
+>>> o1 = O()
+>>> o2 = O()
+>>> C.o1 = o1
+>>> c.o2 = o2
+>>> c.o1 == (o1, c)
+1
+>>> C.o1 == o1
+1
+>>> int(c.o2 == (o2, c))
+1
+
+We accomplish this by making a class that implements __of__ a
+descriptor and treating all descriptor ExtensionClasses this way. That
+is, if an extension class is a descriptor, it's __get__ method will be
+called even when it is retrieved from an instance.
+
+>>> class O(Base):
+...   def __get__(*a):
+...      return a
+... 
+>>> o1 = O()
+>>> o2 = O()
+>>> C.o1 = o1
+>>> c.o2 = o2
+>>> int(c.o1 == (o1, c, type(c)))
+1
+>>> int(C.o1 == (o1, None, type(c)))
+1
+>>> int(c.o2 == (o2, c, type(c)))
+1
+  
+$Id: __init__.py 110581 2010-04-07 15:04:20Z tseaver $
+"""
+
+from _ExtensionClass import *

include/ExtensionClass/pickle/pickle.c

+/*
+
+ Copyright (c) 2003 Zope Foundation and Contributors.
+ All Rights Reserved.
+
+ This software is subject to the provisions of the Zope Public License,
+ Version 2.1 (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.
+
+*/
+/* 
+
+ Reusable pickle support code
+
+ This is "includeware", meant to be used through a C include
+
+ */
+
+/* It's a dang shame we can't inherit __get/setstate__ from object :( */
+
+static PyObject *str__slotnames__, *copy_reg_slotnames, *__newobj__;
+static PyObject *str__getnewargs__, *str__getstate__;
+
+#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
+typedef int Py_ssize_t;
+#define PY_SSIZE_T_MAX INT_MAX
+#define PY_SSIZE_T_MIN INT_MIN
+#endif
+
+static int
+pickle_setup(void)
+{
+  PyObject *copy_reg;
+  int r = -1;
+
+#define DEFINE_STRING(S) \
+  if(! (str ## S = PyString_FromString(# S))) return -1
+  DEFINE_STRING(__slotnames__);
+  DEFINE_STRING(__getnewargs__);
+  DEFINE_STRING(__getstate__);
+#undef DEFINE_STRING
+
+  copy_reg = PyImport_ImportModule("copy_reg");
+  if (copy_reg == NULL)
+    return -1;
+
+  copy_reg_slotnames = PyObject_GetAttrString(copy_reg, "_slotnames");
+  if (copy_reg_slotnames == NULL)
+    goto end;
+
+  __newobj__ = PyObject_GetAttrString(copy_reg, "__newobj__");
+  if (__newobj__ == NULL)
+    goto end;
+
+  r = 0;
+ end:
+  Py_DECREF(copy_reg);
+  return r;
+}
+
+static PyObject *
+pickle_slotnames(PyTypeObject *cls)
+{
+  PyObject *slotnames;
+
+  slotnames = PyDict_GetItem(cls->tp_dict, str__slotnames__);
+  if (slotnames != NULL) 
+    {
+      Py_INCREF(slotnames);
+      return slotnames;
+    }
+
+  slotnames = PyObject_CallFunctionObjArgs(copy_reg_slotnames, (PyObject*)cls, 
+                                           NULL);
+  if (slotnames != NULL &&
+      slotnames != Py_None &&
+      ! PyList_Check(slotnames))
+    {
+      PyErr_SetString(PyExc_TypeError,
+                      "copy_reg._slotnames didn't return a list or None");
+      Py_DECREF(slotnames);
+      slotnames = NULL;
+    }
+  
+  return slotnames;
+}
+
+static PyObject *
+pickle_copy_dict(PyObject *state)
+{
+  PyObject *copy, *key, *value;
+  char *ckey;
+  Py_ssize_t pos = 0;
+  Py_ssize_t nr;
+
+  copy = PyDict_New();
+  if (copy == NULL)
+    return NULL;
+
+  if (state == NULL)
+    return copy;
+
+  while ((nr = PyDict_Next(state, &pos, &key, &value))) 
+    {
+      if (nr < 0)
+        goto err;
+
+      if (key && PyString_Check(key))
+        {
+          ckey = PyString_AS_STRING(key);
+          if (*ckey == '_' &&
+              (ckey[1] == 'v' || ckey[1] == 'p') &&
+              ckey[2] == '_')
+            /* skip volatile and persistent */
+            continue;
+        }
+
+      if (key != NULL && value != NULL &&
+          (PyObject_SetItem(copy, key, value) < 0)
+          )
+        goto err;
+    }
+  
+  return copy;
+ err:
+  Py_DECREF(copy);
+  return NULL;
+}
+
+
+static char pickle___getstate__doc[] =
+"Get the object serialization state\n"
+"\n"
+"If the object has no assigned slots and has no instance dictionary, then \n"
+"None is returned.\n"
+"\n"
+"If the object has no assigned slots and has an instance dictionary, then \n"
+"the a copy of the instance dictionary is returned. The copy has any items \n"
+"with names starting with '_v_' or '_p_' ommitted.\n"
+"\n"
+"If the object has assigned slots, then a two-element tuple is returned.  \n"
+"The first element is either None or a copy of the instance dictionary, \n"
+"as described above. The second element is a dictionary with items \n"
+"for each of the assigned slots.\n"
+;
+
+static PyObject *
+pickle___getstate__(PyObject *self)
+{
+  PyObject *slotnames=NULL, *slots=NULL, *state=NULL;
+  PyObject **dictp;
+  int n=0;
+
+  slotnames = pickle_slotnames(self->ob_type);
+  if (slotnames == NULL)
+    return NULL;
+
+  dictp = _PyObject_GetDictPtr(self);
+  if (dictp)
+    state = pickle_copy_dict(*dictp);
+  else 
+    {
+      state = Py_None;
+      Py_INCREF(state);
+    }
+
+  if (slotnames != Py_None)
+    {
+      int i;
+
+      slots = PyDict_New();
+      if (slots == NULL)
+        goto end;
+
+      for (i = 0; i < PyList_GET_SIZE(slotnames); i++) 
+        {
+          PyObject *name, *value;
+          char *cname;
+
+          name = PyList_GET_ITEM(slotnames, i);
+          if (PyString_Check(name))
+            {
+              cname = PyString_AS_STRING(name);
+              if (*cname == '_' &&
+                  (cname[1] == 'v' || cname[1] == 'p') &&
+                  cname[2] == '_')
+                /* skip volatile and persistent */
+                continue;
+            }
+
+          value = PyObject_GetAttr(self, name);
+          if (value == NULL)
+            PyErr_Clear();
+          else 
+            {
+              int err = PyDict_SetItem(slots, name, value);
+              Py_DECREF(value);
+              if (err)
+                goto end;
+              n++;
+            }
+        }
+    }
+
+  if (n) 
+    state = Py_BuildValue("(NO)", state, slots);
+
+ end:
+  Py_XDECREF(slotnames);
+  Py_XDECREF(slots);
+  
+  return state;
+}
+
+static int
+pickle_setattrs_from_dict(PyObject *self, PyObject *dict)
+{
+  PyObject *key, *value;
+  Py_ssize_t pos = 0;
+  
+  if (! PyDict_Check(dict))
+    {
+      PyErr_SetString(PyExc_TypeError, "Expected dictionary");
+      return -1;
+    }
+  
+  while (PyDict_Next(dict, &pos, &key, &value)) 
+    {
+      if (key != NULL && value != NULL &&
+          (PyObject_SetAttr(self, key, value) < 0)
+          )
+        return -1;
+    }
+  return 0;
+}
+
+static char pickle___setstate__doc[] =
+"Set the object serialization state\n"
+"\n"
+"The state should be in one of 3 forms:\n"
+"\n"
+"- None\n"
+"\n"
+"  Ignored\n"
+"\n"
+"- A dictionary\n"
+"\n"
+"  In this case, the object's instance dictionary will be cleared and \n"
+"  updated with the new state.\n"
+"\n"
+"- A two-tuple with a string as the first element.  \n"
+"\n"
+"  In this case, the method named by the string in the first element will be\n"
+"  called with the second element.\n"
+"\n"
+"  This form supports migration of data formats.\n"
+"\n"
+"- A two-tuple with None or a Dictionary as the first element and\n"
+"  with a dictionary as the second element.\n"
+"\n"
+"  If the first element is not None, then the object's instance dictionary \n"
+"  will be cleared and updated with the value.\n"
+"\n"
+"  The items in the second element will be assigned as attributes.\n"
+;
+
+static PyObject *
+pickle___setstate__(PyObject *self, PyObject *state)
+{
+  PyObject *slots=NULL;
+
+  if (PyTuple_Check(state))
+    {
+      if (! PyArg_ParseTuple(state, "OO", &state, &slots))
+        return NULL;
+    }
+
+  if (state != Py_None)
+    {
+      PyObject **dict;
+
+      dict = _PyObject_GetDictPtr(self);
+      if (dict)
+        {
+          if (*dict == NULL)
+            {
+              *dict = PyDict_New();
+              if (*dict == NULL)
+                return NULL;
+            }
+        }
+
+      if (*dict != NULL)
+        {
+          PyDict_Clear(*dict);
+          if (PyDict_Update(*dict, state) < 0)
+            return NULL;
+        }
+      else if (pickle_setattrs_from_dict(self, state) < 0)
+        return NULL;
+    }
+
+  if (slots != NULL && pickle_setattrs_from_dict(self, slots) < 0)
+    return NULL;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+static char pickle___reduce__doc[] = 
+"Reduce an object to contituent parts for serialization\n"
+;
+
+static PyObject *
+pickle___reduce__(PyObject *self)
+{
+  PyObject *args=NULL, *bargs=0, *state=NULL;
+  int l, i;
+
+  /* we no longer require '__getnewargs__' to be defined but use it if it is */
+  PyObject *getnewargs=NULL;
+
+  getnewargs = PyObject_GetAttr(self, str__getnewargs__);
+  if (getnewargs)
+    bargs = PyEval_CallObject(getnewargs, (PyObject *)NULL);
+  else {
+    PyErr_Clear();
+    bargs = PyTuple_New(0);
+  }
+
+  l = PyTuple_Size(bargs);
+  if (l < 0)
+    goto end;
+
+  args = PyTuple_New(l+1);
+  if (args == NULL)
+    goto end;
+  
+  Py_INCREF(self->ob_type);
+  PyTuple_SET_ITEM(args, 0, (PyObject*)(self->ob_type));
+  for (i = 0; i < l; i++)
+    {
+      Py_INCREF(PyTuple_GET_ITEM(bargs, i));
+      PyTuple_SET_ITEM(args, i+1, PyTuple_GET_ITEM(bargs, i));
+    }
+  
+  state = PyObject_CallMethodObjArgs(self, str__getstate__, NULL);
+  if (state == NULL)
+    goto end;
+
+  state = Py_BuildValue("(OON)", __newobj__, args, state);
+
+ end:
+  Py_XDECREF(bargs);
+  Py_XDECREF(args);
+  Py_XDECREF(getnewargs);
+
+  return state;
+}
+
+#define PICKLE_GETSTATE_DEF \
+{"__getstate__", (PyCFunction)pickle___getstate__, METH_NOARGS,      \
+   pickle___getstate__doc},
+
+#define PICKLE_SETSTATE_DEF \
+{"__setstate__", (PyCFunction)pickle___setstate__, METH_O,           \
+   pickle___setstate__doc},                                          
+
+#define PICKLE_GETNEWARGS_DEF
+
+#define PICKLE_REDUCE_DEF \
+{"__reduce__", (PyCFunction)pickle___reduce__, METH_NOARGS,          \
+   pickle___reduce__doc},
+
+#define PICKLE_METHODS PICKLE_GETSTATE_DEF PICKLE_SETSTATE_DEF \
+                       PICKLE_GETNEWARGS_DEF PICKLE_REDUCE_DEF

include/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 call certain methods defined by `persistent.Persistent`.  Detailed
+examples and documentation is provided in the test module,
+`persistent.tests.test_overriding_attrs`.

include/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.1 (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 25186 2004-06-02 15:07:33Z jim $
+"""
+
+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)

include/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.1 (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 "py24compat.h"
+
+#include "ring.h"
+
+#define CACHE_HEAD \
+    PyObject_HEAD \
+    CPersistentRing ring_home; \
+    int non_ghost_count; \
+    PY_LONG_LONG total_estimated_size;
+
+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
+    4  size info
+
+  (56) so far
+
+    4  dict ptr
+    4  weaklist ptr
+  -------------------------
+   68  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 state:8;                              \
+    unsigned estimated_size:24;
+
+/* We recently added estimated_size.  We originally added it as a new
+   unsigned long field after a signed char state field and a
+   3-character reserved field.  This didn't work because there
+   are packages in the wild that have their own copies of cPersistence.h
+   that didn't see the update.  
+
+   To get around this, we used the reserved space by making
+   estimated_size a 24-bit bit field in the space occupied by the old
+   3-character reserved field.  To fit in 24 bits, we made the units
+   of estimated_size 64-character blocks.  This allows is to handle up
+   to a GB.  We should never see that, but to be paranoid, we also
+   truncate sizes greater than 1GB.  We also set the minimum size to
+   64 bytes.
+
+   We use the _estimated_size_in_24_bits and _estimated_size_in_bytes
+   macros both to avoid repetition and to make intent a little clearer.
+*/
+#define _estimated_size_in_24_bits(I) ((I) > 1073741696 ? 16777215 : (I)/64+1)
+#define _estimated_size_in_bytes(I) ((I)*64)
+
+#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

include/persistent/dict.py

+##############################################################################
+#
+# Copyright Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (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.
+#
+##############################################################################
+
+# persistent.dict is deprecated. User persistent.mapping
+from persistent.mapping import PersistentMapping as PersistentDict

include/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.1 (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 103159 2009-08-24 15:30:11Z patricks $"""
+
+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, **kwargs):
+        self.__super_sort(*args, **kwargs)
+        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))

include/persistent/py24compat.h

+/* Backport type definitions from Python 2.5's object.h */
+#ifndef PERSISTENT_PY24COMPAT_H
+#define PERSISTENT_PY24COMPAT_H
+#if PY_VERSION_HEX < 0x02050000
+typedef int Py_ssize_t;
+#define PY_SSIZE_T_MAX INT_MAX
+#define PY_SSIZE_T_MIN INT_MIN
+#endif /* PY_VERSION_HEX */
+#endif /* PERSISTENT_PY24COMPAT_H */

include/persistent/tests/__init__.py

+# package

include/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.1 (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 unittest
+from doctest import DocTestSuite
+
+def test_suite():
+    return DocTestSuite('persistent.wref')
+
+if __name__ == '__main__':
+    unittest.main()

setup.cfg

+[egg_info]
+tag_build = 
+tag_date = 0
+tag_svn_revision = 0
+

src/Persistence.egg-info/dependency_links.txt

+

src/Persistence.egg-info/not-zip-safe

+

src/Persistence.egg-info/requires.txt

+ExtensionClass
+ZODB3
\ No newline at end of file

src/Persistence.egg-info/top_level.txt

+Persistence

src/Persistence/tests/__init__.py

+# package