Merge lp:~sidnei/zope3/reduce-deps into lp:~landscape/zope3/trunk

[Sidnei da Silva]

Reduce deps

[Sidnei da Silva (sidnei)]

Approved as part of https://code.launchpad.net/~sidnei/landscape/reduce-deps/+merge/29236

review: Approve

=== removed directory 'src/zc/sourcefactory'
=== removed file 'src/zc/sourcefactory/README.txt'
--- src/zc/sourcefactory/README.txt	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/README.txt	1970-01-01 00:00:00 +0000
@@ -1,211 +0,0 @@
-================
-Source Factories
-================
-
-Source factories are used to simplify the creation of sources for certain
-standard cases.
-
-Sources split up the process of providing input fields with choices for users
-into several components: a context binder, a source class, a terms class, and a
-term class.
-
-This is the correct abstraction and will fit many complex cases very well. To
-reduce the amount of work to do for some standard cases, the source factories
-allow users to define only the business relevant code for getting a list of
-values, getting a token and a title to display.
-
-.. contents::
-
-Simple case
-===========
-
-In the most simple case, you only have to provide a method that returns a list
-of values and derive from `BasicSourceFactory`:
-
-  >>> import zc.sourcefactory.basic
-  >>> class MyStaticSource(zc.sourcefactory.basic.BasicSourceFactory):
-  ...     def getValues(self):
-  ...         return ['a', 'b', 'c']
-
-When calling the source factory, we get a source:
-
-  >>> source = MyStaticSource()
-  >>> import zope.schema.interfaces
-  >>> zope.schema.interfaces.ISource.providedBy(source)
-  True
-
-The values match our `getValues`-method of the factory:
-
-  >>> list(source)
-  ['a', 'b', 'c']
-  >>> 'a' in source
-  True
-  >>> len(source)
-  3
-
-
-Contextual sources
-==================
-
-Sometimes we need context to determine the values. In this case, the
-`getValues`-method gets a parameter `context`.
-
-Let's assume we have a small object containing data to be used by the source:
-
-  >>> class Context(object):
-  ...      values = []
-
-  >>> import zc.sourcefactory.contextual
-  >>> class MyDynamicSource(
-  ...     zc.sourcefactory.contextual.BasicContextualSourceFactory):
-  ...     def getValues(self, context):
-  ...         return context.values
-
-When instanciating, we get a ContextSourceBinder:
-
-  >>> binder = MyDynamicSource()
-  >>> zope.schema.interfaces.IContextSourceBinder.providedBy(binder)
-  True
-
-Binding it to a context, we get a source:
-
-  >>> context = Context()
-  >>> source = binder(context)
-  >>> zope.schema.interfaces.ISource.providedBy(source)
-  True
-
-  >>> list(source)
-  []
-
-Modifying the context also modifies the data in the source:
-
-  >>> context.values = [1,2,3,4]
-  >>> list(source)
-  [1, 2, 3, 4]
-  >>> 1 in source
-  True
-  >>> len(source)
-  4
-
-It's possible to have the default machinery return different sources, by
-providing a source_class argument when calling the binder.  One can also
-provide arguments to the source.
-
-  >>> class MultiplierSource(zc.sourcefactory.source.FactoredContextualSource):
-  ...     def __init__(self, factory, context, multiplier):
-  ...         super(MultiplierSource, self).__init__(factory, context)
-  ...         self.multiplier = multiplier
-  ...
-  ...     def _get_filtered_values(self):
-  ...         for value in self.factory.getValues(self.context):
-  ...             yield self.multiplier * value
-  >>> class MultiplierSourceFactory(MyDynamicSource):
-  ...     source_class = MultiplierSource
-  >>> binder = MultiplierSourceFactory()
-  >>> source = binder(context, multiplier=5)
-  >>> list(source)
-  [5, 10, 15, 20]
-  >>> 5 in source
-  True
-  >>> len(source)
-  4
-
-Filtering
-=========
-
-Additional to providing the `getValues`-method you can also provide a
-`filterValue`-method that will allow you to reduce the items from the list,
-piece by piece.
-
-This is useful if you want to have more specific sources (by subclassing) that
-share the same basic origin of the data but have different filters applied to
-it:
-
-  >>> class FilteringSource(zc.sourcefactory.basic.BasicSourceFactory):
-  ...     def getValues(self):
-  ...         return xrange(1,20)
-  ...     def filterValue(self, value):
-  ...         return value % 2
-  >>> source = FilteringSource()
-  >>> list(source)
-  [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
-
-Subclassing modifies the filter, not the original data:
-
-  >>> class OtherFilteringSource(FilteringSource):
-  ...     def filterValue(self, value):
-  ...         return not value % 2
-  >>> source = OtherFilteringSource()
-  >>> list(source)
-  [2, 4, 6, 8, 10, 12, 14, 16, 18]
-
-The "in" operator gets applied also to filtered values:
-
-  >>> 2 in source
-  True
-  >>> 3 in source
-  False
-
-The "len" also gets applied to filtered values:
-
-  >>> len(source)
-  9
-
-
-Scaling
-=======
-
-Sometimes the number of items available through a source is very large.  So
-large that you only want to access them if absolutely neccesary.  One such
-occasion is with truth-testing a source.  By default Python will call
-__nonzero__ to get the boolean value of an object, but if that isn't available
-__len__ is called to see what it returns.  That might be very expensive, so we
-want to make sure it isn't called.
-
-  >>> class MyExpensiveSource(zc.sourcefactory.basic.BasicSourceFactory):
-  ...     def getValues(self):
-  ...         yield 'a'
-  ...         raise RuntimeError('oops, iterated too far')
-
-  >>> source = MyExpensiveSource()
-
-  >>> bool(source)
-  True
-
-
-Simple case
-===========
-
-In the most simple case, you only have to provide a method that returns a list
-of values and derive from `BasicSourceFactory`:
-
-  >>> import zc.sourcefactory.basic
-  >>> class MyStaticSource(zc.sourcefactory.basic.BasicSourceFactory):
-  ...     def getValues(self):
-  ...         return ['a', 'b', 'c']
-
-When calling the source factory, we get a source:
-
-  >>> source = MyStaticSource()
-  >>> import zope.schema.interfaces
-  >>> zope.schema.interfaces.ISource.providedBy(source)
-  True
-
-The values match our `getValues`-method of the factory:
-
-  >>> list(source)
-  ['a', 'b', 'c']
-  >>> 'a' in source
-  True
-  >>> len(source)
-  3
-
-
-WARNING about the standard adapters for ITerms
-==============================================
-
-The standard adapters for ITerms are only suitable if the value types returned
-by your `getValues` function are homogenous. Mixing integers, persistent
-objects, strings, and unicode within one source may create non-unique tokens.
-In this case, you have to provide a custom `getToken`-method to provide unique
-and unambigous tokens.

=== removed file 'src/zc/sourcefactory/__init__.py'
--- src/zc/sourcefactory/__init__.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-# This directory is a Python package.

=== removed file 'src/zc/sourcefactory/adapters.py'
--- src/zc/sourcefactory/adapters.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/adapters.py	1970-01-01 00:00:00 +0000
@@ -1,28 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Support to adapt factored sources to some common interfaces.
-
-"""
-__docformat__ = "reStructuredText"
-
-import zope.schema.interfaces
-import zope.component
-import zc.sourcefactory.source
-
[e-mail](zope.schema.interfaces.ISourceQueriables)
[e-mail](zc.sourcefactory.source.FactoredSource)
-def getSourceQueriables(factored_source):
-    return zope.component.queryMultiAdapter(
-        (factored_source, factored_source.factory),
-        zope.schema.interfaces.ISourceQueriables)

=== removed file 'src/zc/sourcefactory/adapters.txt'
--- src/zc/sourcefactory/adapters.txt	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/adapters.txt	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-===========================
-Common adapters for sources
-===========================
-
-To allow adapting factored sources specific to the factory, a couple of
-standard interfaces that can be adapters are re-adapted as using a
-multi-adapter for (FactoredSource, SourceFactory).
-
-ISourceQueriables
-=================
-
-  >>> from zc.sourcefactory.basic import BasicSourceFactory
-  >>> class Factory(BasicSourceFactory):
-  ...     def getValues(self):
-  ...         return [1,2,3]
-  >>> source = Factory()
-
-  >>> from zope.schema.interfaces import ISourceQueriables
-  >>> import zope.interface
-  >>> class SourceQueriables(object):
-  ...     zope.interface.implements(ISourceQueriables)
-  ...     def __init__(self, source, factory):
-  ...         self.source = source
-  ...         self.factory = factory
-  ...     def getQueriables(self):
-  ...         return [('test', None)]
-
-  >>> from zc.sourcefactory.source import FactoredSource
-  >>> zope.component.provideAdapter(factory=SourceQueriables,
-  ...                               provides=ISourceQueriables,
-  ...                               adapts=(FactoredSource, Factory))
-
-  >>> queriables = ISourceQueriables(source)
-  >>> queriables.factory
-  <Factory object at 0x...>
-  >>> queriables.source
-  <zc.sourcefactory.source.FactoredSource object at 0x...>
-  >>> queriables.getQueriables()
-  [('test', None)]
-
-Cleanup
--------
-
-  >>> zope.component.getSiteManager().unregisterAdapter(factory=SourceQueriables,
-  ...     provided=ISourceQueriables, required=(FactoredSource, Factory))
-  True

=== removed file 'src/zc/sourcefactory/basic.py'
--- src/zc/sourcefactory/basic.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/basic.py	1970-01-01 00:00:00 +0000
@@ -1,30 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""The most basic source factory that supports all the required interfaces.
-
-This is used for sources that do not require the context.
-
-"""
-__docformat__ = "reStructuredText"
-
-
-import zc.sourcefactory.factories
-import zc.sourcefactory.policies
-
-class BasicSourceFactory(zc.sourcefactory.factories.BasicSourceFactory,
-                         zc.sourcefactory.policies.BasicSourcePolicy):
-    """Basic source factory implementation including a factory and the
-    basic policies.
-
-    """

=== removed directory 'src/zc/sourcefactory/browser'
=== removed file 'src/zc/sourcefactory/browser/README.txt'
--- src/zc/sourcefactory/browser/README.txt	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/browser/README.txt	1970-01-01 00:00:00 +0000
@@ -1,207 +0,0 @@
-=====================================================
-Browser views for sources created by source factories
-=====================================================
-
-Sources that were created using source factories already come with ready-made
-terms and term objects.
-
-
-Simple use
-==========
-
-Let's start with a simple source factory:
-
-  >>> import zc.sourcefactory.basic
-  >>> class DemoSource(zc.sourcefactory.basic.BasicSourceFactory):
-  ...     def getValues(self):
-  ...         return ['a', 'b', 'c', 'd']
-  >>> source = DemoSource()
-  >>> list(source)
-  ['a', 'b', 'c', 'd']
-
-We need a request first, then we can adapt the source to ITerms:
-
-  >>> from zope.publisher.browser import TestRequest
-  >>> import zope.browser.interfaces
-  >>> import zope.component
-  >>> request = TestRequest()
-  >>> terms = zope.component.getMultiAdapter(
-  ...     (source, request), zope.browser.interfaces.ITerms)
-  >>> terms
-  <zc.sourcefactory.browser.source.FactoredTerms object at 0x...>
-
-For each value we get a factored term:
-
-  >>> terms.getTerm('a')
-  <zc.sourcefactory.browser.source.FactoredTerm object at 0x...>
-  >>> terms.getTerm('b')
-  <zc.sourcefactory.browser.source.FactoredTerm object at 0x...>
-  >>> terms.getTerm('c')
-  <zc.sourcefactory.browser.source.FactoredTerm object at 0x...>
-  >>> terms.getTerm('d')
-  <zc.sourcefactory.browser.source.FactoredTerm object at 0x...>
-
-Unicode values are allowed as well:
-
-  >>> terms.getTerm(u'\xd3')
-  <zc.sourcefactory.browser.source.FactoredTerm object at 0x...>
-
-Our terms are ITitledTokenizedTerm-compatible:
-
-  >>> import zope.schema.interfaces
-  >>> zope.schema.interfaces.ITitledTokenizedTerm.providedBy(
-  ...     terms.getTerm('a'))
-  True
-
-In the most simple case, the title of a term is the string representation of
-the object:
-
-  >>> terms.getTerm('a').title
-  u'a'
-
-If an adapter from the value to IDCDescriptiveProperties exists, the title
-will be retrieved from this adapter:
-
-  >>> import persistent
-  >>> class MyObject(persistent.Persistent):
-  ...    custom_title = u'My custom title'
-  ...    _p_oid = 12
-  >>> class DCDescriptivePropertiesAdapter(object):
-  ...    def __init__(self, context):
-  ...        self.title = context.custom_title
-  ...        self.description = u""
-  >>> from zope.component import provideAdapter
-  >>> from zope.dublincore.interfaces import IDCDescriptiveProperties
-  >>> provideAdapter(DCDescriptivePropertiesAdapter, [MyObject],
-  ...     IDCDescriptiveProperties)
-  >>> terms.getTerm(MyObject()).title
-  u'My custom title'
-
-Extended use: provide your own titles
-=====================================
-
-Instead of relying on string representation or IDCDescriptiveProperties
-adapters you can specify the `getTitle` method on the source factory to
-determine the title for a value:
-
-  >>> class DemoSourceWithTitles(DemoSource):
-  ...     def getTitle(self, value):
-  ...         return 'Custom title ' + value.custom_title
-  >>> source2 = DemoSourceWithTitles()
-  >>> terms2 = zope.component.getMultiAdapter(
-  ...     (source2, request), zope.browser.interfaces.ITerms)
-  >>> o1 = MyObject()
-  >>> o1.custom_title = u"Object one"
-  >>> o2 = MyObject()
-  >>> o2.custom_title = u"Object two"
-  >>> terms2.getTerm(o1).title
-  u'Custom title Object one'
-  >>> terms2.getTerm(o2).title
-  u'Custom title Object two'
-
-
-Extended use: provide your own tokens
-=====================================
-
-Instead of relying on default adapters to generate tokens for your values, you
-can override the `getToken` method on the source factory to determine the
-token for a value:
-
-  >>> class DemoObjectWithToken(object):
-  ...     token = None
-  >>> o1 = DemoObjectWithToken()
-  >>> o1.token = "one"
-  >>> o2 = DemoObjectWithToken()
-  >>> o2.token = "two"
-
-  >>> class DemoSourceWithTokens(DemoSource):
-  ...     values = [o1, o2]
-  ...     def getValues(self):
-  ...         return self.values
-  ...     def getToken(self, value):
-  ...         return value.token
-
-  >>> source3 = DemoSourceWithTokens()
-  >>> terms3 = zope.component.getMultiAdapter(
-  ...     (source3, request), zope.browser.interfaces.ITerms)
-
-  >>> terms3.getTerm(o1).token
-  'one'
-  >>> terms3.getTerm(o2).token
-  'two'
-
-Looking up by the custom tokens works as well:
-
-  >>> terms3.getValue("one") is o1
-  True
-  >>> terms3.getValue("two") is o2
-  True
-  >>> terms3.getValue("three")
-  Traceback (most recent call last):
-  KeyError: "No value with token 'three'"
-
-
-Value mapping sources
-=====================
-
-  XXX to come
-
-
-Contextual sources
-==================
-
-Let's start with an object that we can use as the context:
-
-  >>> zip_to_city = {'06112': 'Halle',
-  ...                '06844': 'Dessau'}
-  >>> import zc.sourcefactory.contextual
-  >>> class DemoContextualSource(
-  ...     zc.sourcefactory.contextual.BasicContextualSourceFactory):
-  ...     def getValues(self, context):
-  ...         return context.keys()
-  ...     def getTitle(self, context, value):
-  ...         return context[value]
-  ...     def getToken(self, context, value):
-  ...         return 'token-%s' % value
-  >>> source = DemoContextualSource()(zip_to_city)
-  >>> sorted(list(source))
-  ['06112', '06844']
-
-Let's look at the terms:
-
-  >>> terms = zope.component.getMultiAdapter(
-  ...     (source, request), zope.browser.interfaces.ITerms)
-  >>> terms
-  <zc.sourcefactory.browser.source.FactoredContextualTerms object at 0x...>
-
-For each value we get a factored term with the right title from the context:
-
-  >>> terms.getTerm('06112')
-  <zc.sourcefactory.browser.source.FactoredTerm object at 0x...>
-  >>> terms.getTerm('06112').title
-  'Halle'
-  >>> terms.getTerm('06844')
-  <zc.sourcefactory.browser.source.FactoredTerm object at 0x...>
-  >>> terms.getTerm('06844').title
-  'Dessau'
-  >>> terms.getTerm('06844').token
-  'token-06844'
-
-And in reverse we can get the value for a given token as well:
-
-  >>> terms.getValue('token-06844')
-  '06844'
-
-Interfaces
-==========
-
-Both the FactoredSource and FactoredContextualSource have associated
-interfaces.
-
-  >>> from zc.sourcefactory import interfaces
-  >>> from zc.sourcefactory import source
-  >>> from zope import interface
-  >>> interface.classImplements(
-  ...     source.FactoredSource, interfaces.IFactoredSource)
-  >>> interface.classImplements(
-  ...     source.FactoredContextualSource, interfaces.IContextualSource)

=== removed file 'src/zc/sourcefactory/browser/__init__.py'
--- src/zc/sourcefactory/browser/__init__.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/browser/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-# This directory is a Python package.

=== removed file 'src/zc/sourcefactory/browser/configure.zcml'
--- src/zc/sourcefactory/browser/configure.zcml	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/browser/configure.zcml	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configure
-    xmlns="http://namespaces.zope.org/zope"
-    xmlns:browser="http://namespaces.zope.org/browser"
-    i18n_domain="zc.sourcefactory">
-
-  <adapter factory=".source.FactoredTerms"/>
-  <adapter factory=".source.FactoredContextualTerms"/>
-
-  <adapter factory=".mapping.MappedTerms"/>
-
-  <adapter factory=".token.fromString"/>
-  <adapter factory=".token.fromUnicode"/>
-  <adapter factory=".token.fromInteger"/>
-  <adapter factory=".token.fromPersistent"/>
-  <adapter factory=".token.fromInterface"/>
-
-</configure>

=== removed file 'src/zc/sourcefactory/browser/mapping.py'
--- src/zc/sourcefactory/browser/mapping.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/browser/mapping.py	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Mapping-source related terms stuff
-
-"""
-__docformat__ = "reStructuredText"
-
-
-import zope.proxy
-import zope.interface
-import zope.component
-import zope.browser
-import zope.publisher.interfaces.browser
-
-import zc.sourcefactory.mapping
-
-
-class MappedTerms(object):
-    """A terms implementation that knows how to handle a source that was 
-    created through a source factory.
-    """
-
-    zope.interface.implements(zope.browser.interfaces.ITerms)
-
-    zope.component.adapts(zc.sourcefactory.mapping.ValueMappingSource,
-        zope.publisher.interfaces.browser.IBrowserRequest)
-
-    def __init__(self, source, request):
-        self.base = zope.component.getMultiAdapter(
-            [source.base, request], zope.browser.interfaces.ITerms)
-        self.source = source
-        self.request = request
-
-    def getTerm(self, value):
-        real_value = self.source.mapReverse(value)
-        term = self.base.getTerm(real_value)
-        return MappedTermProxy(value, term)
-
-    def getValue(self, token):
-        return self.source.map(self.base.getValue(token))
-
-
-class MappedTermProxy(zope.proxy.ProxyBase):
-    """A mapped term that provides access to the mapped value
-    without destroying the real term.
-
-    """
-
-    __slots__ = ('value',)
-
-    def __new__(self, value, baseterm):
-        return zope.proxy.ProxyBase.__new__(self, baseterm)
-
-    def __init__(self, value, baseterm):
-        zope.proxy.ProxyBase.__init__(self, baseterm)
-        self.value = value

=== removed file 'src/zc/sourcefactory/browser/source.py'
--- src/zc/sourcefactory/browser/source.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/browser/source.py	1970-01-01 00:00:00 +0000
@@ -1,83 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Interfaces for zc.z4m.
-
-"""
-__docformat__ = "reStructuredText"
-
-
-import zope.interface
-import zope.component
-import zope.browser.interfaces
-import zope.publisher.interfaces.browser
-import zope.schema.interfaces
-
-import zc.sourcefactory.source
-
-
-class FactoredTerms(object):
-    """A terms implementation that knows how to handle a source that was
-    created through a source factory.
-    """
-
-    zope.interface.implements(zope.browser.interfaces.ITerms)
-
-    zope.component.adapts(
-        zc.sourcefactory.source.FactoredSource,
-        zope.publisher.interfaces.browser.IBrowserRequest)
-
-    def __init__(self, source, request):
-        self.source = source
-        self.request = request
-
-    def getTerm(self, value):
-        title = self.source.factory.getTitle(value)
-        token = self.source.factory.getToken(value)
-        return self.source.factory.createTerm(
-            self.source, value, title, token, self.request)
-
-    def getValue(self, token):
-        return self.source.factory.getValue(self.source, token)
-
-
-class FactoredContextualTerms(FactoredTerms):
-    """A terms implementation that knows how to handle a source that was
-    created through a contextual source factory.
-    """
-
-    zope.component.adapts(
-        zc.sourcefactory.source.FactoredContextualSource,
-        zope.publisher.interfaces.browser.IBrowserRequest)
-
-    def getTerm(self, value):
-        title = self.source.factory.getTitle(self.source.context, value)
-        token = self.source.factory.getToken(self.source.context, value)
-        return self.source.factory.createTerm(
-            self.source.context, self.source, value, title, token,
-            self.request)
-
-    def getValue(self, token):
-        return self.source.factory.getValue(self.source.context, self.source,
-                                            token)
-
-
-class FactoredTerm(object):
-    """A title tokenized term."""
-
-    zope.interface.implements(zope.schema.interfaces.ITitledTokenizedTerm)
-
-    def __init__(self, value, title, token):
-        self.value = value
-        self.title = title
-        self.token = token

=== removed file 'src/zc/sourcefactory/browser/tests.py'
--- src/zc/sourcefactory/browser/tests.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/browser/tests.py	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Unit tests
-
-"""
-__docformat__ = "reStructuredText"
-
-import unittest
-
-from zope.testing import doctest
-import zope.app.testing.functional
-
-from zc.sourcefactory.tests import SourceFactoryLayer
-
-def test_suite():
-    suite = unittest.TestSuite()
-    token = zope.app.testing.functional.FunctionalDocFileSuite('token.txt')
-    token.layer = SourceFactoryLayer
-    readme =  zope.app.testing.functional.FunctionalDocFileSuite(
-            'README.txt', optionflags=doctest.ELLIPSIS)
-    readme.layer = SourceFactoryLayer
-    suite.addTest(token)
-    suite.addTest(readme)
-    return suite

=== removed file 'src/zc/sourcefactory/browser/token.py'
--- src/zc/sourcefactory/browser/token.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/browser/token.py	1970-01-01 00:00:00 +0000
@@ -1,84 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Various token adapters.
-
-"""
-__docformat__ = "reStructuredText"
-
-try:
-    import hashlib
-except ImportError:
-    import md5 as hashlib # Python 2.4 compat
-
-import ZODB.utils
-import ZODB.interfaces
-import persistent.interfaces
-
-import zope.proxy
-import zope.component
-import zope.interface
-
-import zc.sourcefactory.interfaces
-
-
[e-mail](str)
[e-mail](zc.sourcefactory.interfaces.IToken)
-def fromString(value):
-    # We hash generic strings to be sure they are suitable
-    # for URL encoding.
-    return hashlib.md5(value).hexdigest()
-
-
[e-mail](unicode)
[e-mail](zc.sourcefactory.interfaces.IToken)
-def fromUnicode(value):
-    value = value.encode("utf-8")
-    return fromString(value)
-
-
[e-mail](int)
[e-mail](zc.sourcefactory.interfaces.IToken)
-def fromInteger(value):
-    # We do not have to hash integers as their string representations
-    # are definitely suitable for URL encoding.
-    return str(value)
-
-
[e-mail](persistent.interfaces.IPersistent)
[e-mail](zc.sourcefactory.interfaces.IToken)
-def fromPersistent(value):
-    # Persistent objects are identified by their oid. If it is persistent but
-    # not added to the database, we try to get to the parent, add the value to
-    # the database and get the oid then.
-    # We have to remove proxies to avoid security here.
-    value_unproxied = zope.proxy.removeAllProxies(value)
-    try:
-        oid = value_unproxied._p_oid
-    except AttributeError:
-        oid = None
-
-    if oid is None:
-        if not hasattr(value, '__parent__'):
-            raise ValueError('Can not determine OID for %r' % value)
-        connection = ZODB.interfaces.IConnection(value_unproxied.__parent__)
-        connection.add(value_unproxied)
-        oid = value_unproxied._p_oid
-    return ZODB.utils.oid_repr(oid)
-
-
[e-mail](zope.interface.interfaces.IInterface)
[e-mail](zc.sourcefactory.interfaces.IToken)
-def fromInterface(value):
-    # Interface are identified by their module path and name
-    return "%s.%s" % (value.__module__, value.__name__)

=== removed file 'src/zc/sourcefactory/browser/token.txt'
--- src/zc/sourcefactory/browser/token.txt	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/browser/token.txt	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-======
-Tokens
-======
-
-Tokens are an identifying representation of an object, suitable for
-transmission amongs URL-encoded data.
-
-The sourcefactory package provides a few standard generators for tokens:
-
-  >>> import zc.sourcefactory.browser.token
-
-We have generators for strings:
-
-  >>> zc.sourcefactory.browser.token.fromString('somestring')
-  '1f129c42de5e4f043cbd88ff6360486f'
-
-Unicode
-=======
-
-  Argh, I have to write the umlauts as unicode escapes otherwise
-  distutils will have a encoding error in preparing upload to pypi:
-
-  >>> zc.sourcefactory.browser.token.fromUnicode(
-  ...     u'somestring with umlauts \u00F6\u00E4\u00FC')
-  '45dadc304e0d6ae7f4864368bad74951'
-
-Integer
-=======
-
-  >>> zc.sourcefactory.browser.token.fromInteger(12)
-  '12'
-
-Persistent
-==========
-
-  >>> import persistent
-  >>> class PersistentDummy(persistent.Persistent):
-  ...     pass
-  >>> p = PersistentDummy()
-  >>> p._p_oid = 1234
-  >>> zc.sourcefactory.browser.token.fromPersistent(p)
-  '1234'
-
-If an object is persistent but has not been added to a database yet, it will
-be added to the database of it's __parent__:
-
-  >>> root = getRootFolder()
-  >>> p1 = PersistentDummy()
-  >>> p1.__parent__ = root
-  >>> zc.sourcefactory.browser.token.fromPersistent(p1)
-  '0x...'
-
-If an object has no parent, we fail:
-
-  >>> p2 = PersistentDummy()
-  >>> zc.sourcefactory.browser.token.fromPersistent(p2)
-  Traceback (most recent call last):
-  ValueError: Can not determine OID for <PersistentDummy object at 0x...>
-
-Security proxied objects are unwrapped to get to their oid or connection
-attribute:
-
-  >>> from zope.security.proxy import ProxyFactory
-  >>> p3 = PersistentDummy()
-  >>> root['p3'] = p3
-  >>> p3.__parent__ = root
-  >>> p3p = ProxyFactory(p3)
-  >>> p3p._p_jar
-  Traceback (most recent call last):
-    ...
-  ForbiddenAttribute: ('_p_jar', <PersistentDummy object at 0x...>)
-
-  >>> zc.sourcefactory.browser.token.fromPersistent(p3p)
-  '0x...'
-
-
-As a side-effect `p3` now has an _p_oid assigned.  When an object already has
-an OID the connection is not queried, so a __parent__ would not be necessary:
-
-  >>> del p3.__parent__
-  >>> zc.sourcefactory.browser.token.fromPersistent(p3p)
-  '0x...'
-
-
-
-Interfaces
-==========
-
-  >>> from zope.interface import Interface
-  >>> class I(Interface):
-  ...     pass
-  >>> zc.sourcefactory.browser.token.fromInterface(I)
-  '__builtin__.I'

=== removed file 'src/zc/sourcefactory/configure-z2.zcml'
--- src/zc/sourcefactory/configure-z2.zcml	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/configure-z2.zcml	1970-01-01 00:00:00 +0000
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configure
-    xmlns="http://namespaces.zope.org/zope"
-    >
-  <!-- Configuration for usage with Zope 2/Five -->
-
-  <class class=".source.FactoredSource">
-    <require
-        interface=".interfaces.IFactoredSource"
-        permission="zope2.View"
-        />
-  </class>
-
-  <class class=".source.FactoredContextualSource">
-    <require
-        interface=".interfaces.IContextualSource"
-        permission="zope2.View"
-        />
-  </class>
-
-  <adapter factory=".adapters.getSourceQueriables"/>
-
-  <include package=".browser"/>
-
-</configure>

=== removed file 'src/zc/sourcefactory/configure.zcml'
--- src/zc/sourcefactory/configure.zcml	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/configure.zcml	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configure
-    xmlns="http://namespaces.zope.org/zope"
-    >
-
-  <class class=".source.FactoredSource">
-    <require
-        interface=".interfaces.IFactoredSource"
-        permission="zope.View"
-        />
-  </class>
-
-  <class class=".source.FactoredContextualSource">
-    <require
-        interface=".interfaces.IContextualSource"
-        permission="zope.View"
-        />
-  </class>
-
-  <adapter factory=".adapters.getSourceQueriables"/>
-
-  <include package=".browser"/>
-
-</configure>

=== removed file 'src/zc/sourcefactory/constructors.txt'
--- src/zc/sourcefactory/constructors.txt	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/constructors.txt	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-===================
-Custom constructors
-===================
-
-Source factories are intended to behave as natural as possible. A side-effect
-of using a custom factory method (__new__) on the base class is that
-sub-classes may have a hard time if their constructor (__init__) has a
-different signature.
-
-zc.sourcefactory takes extra measures to allow using a custom constructor with
-a different signature.
-
->>> import zc.sourcefactory.basic
-
->>> class Source(zc.sourcefactory.basic.BasicSourceFactory):
-...
-...     def __init__(self, values):
-...         super(Source, self).__init__()
-...         self.values = values
-...
-...     def getValues(self):
-...         return self.values
-
->>> source = Source([1, 2, 3])
->>> list(source)
-[1, 2, 3]
-
-This is also true for contextual sources. The example is a bit silly
-but it shows that it works in principal:
-
->>> import zc.sourcefactory.contextual
->>> default_values = (4, 5, 6)
->>> context_values = (6, 7, 8)
->>> class ContextualSource(
-...     zc.sourcefactory.contextual.BasicContextualSourceFactory):
-...
-...     def __init__(self, defaults):
-...         super(ContextualSource, self).__init__()
-...         self.defaults = defaults
-...
-...     def getValues(self, context):
-...         return self.defaults + context
-
->>> contextual_source = ContextualSource(default_values)(context_values)
->>> list(contextual_source)
-[4, 5, 6, 6, 7, 8]

=== removed file 'src/zc/sourcefactory/contextual.py'
--- src/zc/sourcefactory/contextual.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/contextual.py	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""The most basic source factory that supports context binding.
-
-"""
-__docformat__ = "reStructuredText"
-
-
-import zc.sourcefactory.factories
-import zc.sourcefactory.policies
-
-
-class BasicContextualSourceFactory(
-    zc.sourcefactory.factories.ContextualSourceFactory,
-    zc.sourcefactory.policies.BasicContextualSourcePolicy):
-    """Abstract base implementation for a basic contextual source factory."""

=== removed file 'src/zc/sourcefactory/factories.py'
--- src/zc/sourcefactory/factories.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/factories.py	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Basic factories.
-
-"""
-__docformat__ = "reStructuredText"
-
-
-import zope.interface
-import zope.schema.interfaces
-
-import zc.sourcefactory.interfaces
-import zc.sourcefactory.source
-
-
-class BasicSourceFactory(object):
-    """Abstract base class for a source factory.
-
-    Implementors must provide an implementation for `getValues`.
-    """
-
-    zope.interface.implements(zc.sourcefactory.interfaces.ISourceFactory)
-
-    def __new__(cls, *args, **kw):
-        """Create the factory object and return source."""
-        factory = object.__new__(cls)
-        factory.__init__(*args, **kw)
-        return zc.sourcefactory.source.FactoredSource(factory)
-
-
-class ContextualSourceFactory(BasicSourceFactory):
-    """Abstract base class for a source factory for a context-bound source.
-
-    Implementors must provide an implementation for `getValues`.
-    """
-
-    source_class = zc.sourcefactory.source.FactoredContextualSource
-
-    def __new__(cls, *args, **kw):
-        """Create the factory object and return source."""
-        factory = object.__new__(cls)
-        factory.__init__(*args, **kw)
-        return FactoredContextualSourceBinder(factory, cls.source_class)
-
-
-class FactoredContextualSourceBinder(object):
-    """A context source binder for factored sources."""
-
-    zope.interface.implements(zope.schema.interfaces.IContextSourceBinder)
-
-    def __init__(self, factory, source_class):
-        self.factory = factory
-        self.source_class = source_class
-
-    def __call__(self, context, *args, **kwargs):
-        return self.source_class(self.factory, context, *args, **kwargs)

=== removed file 'src/zc/sourcefactory/ftesting.zcml'
--- src/zc/sourcefactory/ftesting.zcml	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/ftesting.zcml	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-<configure
-    xmlns="http://namespaces.zope.org/zope"
-    xmlns:browser="http://namespaces.zope.org/browser"
-    >
-
-  <include package="zope.app.zcmlfiles" />
-  <include package="zope.app.keyreference" />
-  <include package="zc.sourcefactory" />
-
-</configure>

=== removed file 'src/zc/sourcefactory/interfaces.py'
--- src/zc/sourcefactory/interfaces.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/interfaces.py	1970-01-01 00:00:00 +0000
@@ -1,142 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Interfaces for zc.sourcefactory.
-
-"""
-__docformat__ = "reStructuredText"
-
-
-import zope.interface
-import zope.schema.interfaces
-
-class ISourceFactory(zope.interface.Interface):
-
-    def __call__():
-        """Create and return the source or source binder."""
-
-
-class IFactoredSource(zope.schema.interfaces.IIterableSource):
-    """An iterable source that was created from a source factory."""
-
-    factory = zope.interface.Attribute("The source factory.")
-
-
-class IContextualSource(IFactoredSource):
-    """A source operating in context."""
-
-    context = zope.interface.Attribute("The context the source is bound to.")
-    factory = zope.interface.Attribute("The source factory.")
-
-
-class INamedSource(zope.interface.Interface):
-    """A marker interface to register named source for."""
-
-
-class IToken(zope.interface.Interface):
-    """A string representing a token that uniquely identifies a value."""
-
-
-# Policies
-
-class ITokenPolicy(zope.interface.Interface):
-    """The token policy maps values and tokens."""
-
-    def getValue(source, token):
-        """Return a token for the value."""
-
-    def getToken(value):
-        """Return a token for the value."""
-
-
-class IContextualTokenPolicy(zope.interface.Interface):
-    """The contextua token policy maps values and tokens.
-
-    It allows access to the context.
-
-    """
-
-    def getValue(context, source, token):
-        """Return a token for the value."""
-
-    def getToken(context, value):
-        """Return a token for the value."""
-
-
-class ITermPolicy(zope.interface.Interface):
-    """The term policy creates terms and provides data for terms."""
-
-    def createTerm(source, value, title, token, request):
-        """Create and return a term object."""
-
-    def getTitle(value):
-        """Return a title for the value.
-
-        The return value should not be localized; that is the
-        responsibility of the user.  The title may be an
-        internationalized message value.
-
-        """
-
-
-class IContextualTermPolicy(zope.interface.Interface):
-    """The contextual term policy creates terms and provides data for terms.
-
-    It allows access to the context.
-
-    """
-
-    def createTerm(context, source, value, title, token, request):
-        """Create and return a term object."""
-
-    def getTitle(context, value):
-        """Return a title for the value.
-
-        The return value should not be localized; that is the
-        responsibility of the user.  The title may be an
-        internationalized message value.
-
-        """
-
-
-class IValuePolicy(zope.interface.Interface):
-    """The value policy retrieves and filters values for a source."""
-
-    def getValues():
-        """Return the values for the source."""
-
-    def filterValue(value):
-        """Determine whether the value should be filtered out or not."""
-
-
-class IContextualValuePolicy(zope.interface.Interface):
-    """The contextual value policy retrieves and filters values for a source
-    within context.
-
-    """
-
-    def getValues(context):
-        """Return the values for the source in the given context."""
-
-    def filterValue(context, value):
-        """Return the values for the source in the given context."""
-
-# Standard combined policies
-
-class ISourcePolicy(ITokenPolicy, ITermPolicy, IValuePolicy):
-    pass
-
-
-class IContextualSourcePolicy(
-    ITokenPolicy, IContextualTermPolicy, IContextualValuePolicy):
-    pass

=== removed file 'src/zc/sourcefactory/mapping.py'
--- src/zc/sourcefactory/mapping.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/mapping.py	1970-01-01 00:00:00 +0000
@@ -1,78 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""A source proxy providing a mapping between values
-
-"""
-__docformat__ = "reStructuredText"
-
-import zope.interface
-import zope.schema.interfaces
-
-
-class ValueMappingSourceContextBinder(object):
-
-    zope.interface.implements(zope.schema.interfaces.IContextSourceBinder)
-
-    def __init__(self, base, map):
-        self.base = base
-        self.map = map
-
-    def __call__(self, context):
-        source = self.base(context)
-        return ValueMappingSource(source, self.map)
-
-
-class ValueMappingSource(object):
-
-    zope.interface.implements(zope.schema.interfaces.IIterableSource)
-
-    def __init__(self, base, map):
-        self.base = base
-        self._mapping_cache = {}
-        self.map = map
-
-    def mapReverse(self, mapped_value):
-        if mapped_value in self._mapping_cache:
-            return self._mapping_cache[mapped_value]
-
-        # Not found in cache, continue to look for the mapped value in
-        # the rest of the iterator
-        if not hasattr(self, '_cache_iterator'):
-            self._cache_iterator = iter(self.base)
-        for original_value in self._cache_iterator:
-            original_mapped_value = self.map(original_value)
-            self._mapping_cache[original_mapped_value] = original_value
-            if mapped_value == original_mapped_value:
-                return original_value
-        raise KeyError(mapped_value)
-
-    def __contains__(self, value):
-        try:
-            self.mapReverse(value)
-        except KeyError:
-            return False
-        else:
-            return True
-
-    def __iter__(self):
-        for item in self.base:
-            yield self.map(item)
-
-    def __len__(self):
-        return len(self.base)
-
-    def __nonzero__(self):
-        for dummy in self.base:
-            return True
-        return False

=== removed file 'src/zc/sourcefactory/mapping.txt'
--- src/zc/sourcefactory/mapping.txt	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/mapping.txt	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-Mapping source values
-=====================
-
-Sometimes a source provides the right choice of objects, but the actual values
-we want to talk about are properties or computed views on those objects. The
-`mapping proxy source` helps us to map a source to a different value space.
-
-We start out with a source:
-
-  >>> source = [1,2,3,4,5]
-
-and we provide a method that maps the values of the original source to the
-values we want to see (we map the numbers to the characters in the english
-alphabet):
-
-  >>> map = lambda x: chr(x+96)
-
-Now we can create a mapped source:
-
-  >>> from zc.sourcefactory.mapping import ValueMappingSource
-  >>> mapped_source = ValueMappingSource(source, map)
-  >>> list(mapped_source)
-  ['a', 'b', 'c', 'd', 'e']
-  >>> len(mapped_source)
-  5
-  >>> 'a' in mapped_source
-  True
-  >>> 1 in mapped_source
-  False
-
-You can also use context-dependent sources:
-
-  >>> def bindSource(context):
-  ...     return [1,2,3,4,5]
-  >>> from zc.sourcefactory.mapping import ValueMappingSourceContextBinder
-  >>> binder = ValueMappingSourceContextBinder(bindSource, map)
-  >>> bound_source = binder(object())
-  >>> list(bound_source)
-  ['a', 'b', 'c', 'd', 'e']
-  >>> len(bound_source)
-  5
-  >>> 'a' in bound_source
-  True
-  >>> 1 in bound_source
-  False
-
-
-Scaling
--------
-
-Sometimes the number of items available through a source is very large.  So
-large that you only want to access them if absolutely neccesary.  One such
-occasion is with truth-testing a source.  By default Python will call
-__nonzero__ to get the boolean value of an object, but if that isn't available
-__len__ is called to see what it returns.  That might be very expensive, so we
-want to make sure it isn't called.
-
-  >>> class ExpensiveSource(object):
-  ...     def __len__(self):
-  ...         raise RuntimeError("oops, don't want to call __len__")
-  ...
-  ...     def __iter__(self):
-  ...         return iter(xrange(999999))
-
-  >>> expensive_source = ExpensiveSource()
-  >>> mapped_source = ValueMappingSource(expensive_source, map)
-  >>> bool(mapped_source)
-  True

=== removed file 'src/zc/sourcefactory/named.py'
--- src/zc/sourcefactory/named.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/named.py	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Named source binder
-
-"""
-__docformat__ = "reStructuredText"
-
-import zope.interface
-import zope.schema.interfaces
-
-import zc.sourcefactory.interfaces
-
-
-class NamedSource(object):
-    """Factory for named sources.
-
-    This is a generic thin wrapper to look up sources by name.
-    """
-
-    zope.interface.implements(zope.schema.interfaces.IContextSourceBinder)
-
-    def __init__(self, name):
-        self.name = name
-
-    def __call__(self, context):
-        factory = zope.component.getUtility(
-            zc.sourcefactory.interfaces.INamedSource, name=self.name)
-        source = factory()
-        if zope.schema.interfaces.IContextSourceBinder.providedBy(source):
-            source = source(context)
-        return source

=== removed file 'src/zc/sourcefactory/policies.py'
--- src/zc/sourcefactory/policies.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/policies.py	1970-01-01 00:00:00 +0000
@@ -1,186 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Implementations of the basic policy components.
-
-"""
-__docformat__ = "reStructuredText"
-
-
-from zope.dublincore import interfaces as dublincoreinterfaces
-import zc.sourcefactory.browser.source
-import zc.sourcefactory.interfaces
-import zope.component
-import zope.intid.interfaces
-
-# Term policies
-
-class BasicTermPolicy(object):
-    """A basic term policy.
-
-    createTerm creates a FactoredTerm object.
-
-    getTitle uses IDCDescriptiveProperties.title and falls back to
-    `str`-representation of the value.
-    """
-
-    zope.interface.implements(zc.sourcefactory.interfaces.ITermPolicy)
-
-    def createTerm(self, source, value, title, token, request):
-        return zc.sourcefactory.browser.source.FactoredTerm(
-            value, title, token)
-
-    def getTitle(self, value):
-        try:
-            md = dublincoreinterfaces.IDCDescriptiveProperties(value)
-        except TypeError:
-            md = None
-
-        if md:
-            title = md.title
-        else:
-            title = unicode(value)
-        return title
-
-
-class BasicContextualTermPolicy(BasicTermPolicy):
-    """A basic contextual term policy.
-
-    All methods are deferred to the BasicTermPolicy by removing the context
-    argument.
-
-    """
-
-    zope.interface.implements(zc.sourcefactory.interfaces.ITermPolicy)
-
-    def createTerm(self, context, source, value, title, token, request):
-        return super(BasicContextualTermPolicy, self).createTerm(
-            source, value, title, token, request)
-
-    def getTitle(self, context, value):
-        return super(BasicContextualTermPolicy, self).getTitle(value)
-
-
-# Token policies
-
-class BasicTokenPolicy(object):
-    """A basic token policy.
-
-    getToken adapts the value to IToken
-
-    getValue iterates over the source comparing the tokens of the values to the
-    token.
-    """
-
-    zope.interface.implements(zc.sourcefactory.interfaces.ITokenPolicy)
-
-    def getValue(self, source, token):
-        for value in source:
-            if source.factory.getToken(value) == token:
-                return value
-        raise KeyError, "No value with token '%s'" % token
-
-    def getToken(self, value):
-        return zc.sourcefactory.interfaces.IToken(value)
-
-
-class BasicContextualTokenPolicy(BasicTokenPolicy):
-    """A basic contextual token policy.
-
-    This implements a fallback to the context-free token policy but satisfies
-    the contextual interfaces.
-
-    """
-
-    zope.interface.implements(zc.sourcefactory.interfaces.IContextualTokenPolicy)
-
-    def getValue(self, context, source, token):
-        for value in source:
-            if source.factory.getToken(context, value) == token:
-                return value
-        raise KeyError, "No value with token '%s'" % token
-
-    def getToken(self, context, value):
-        return super(BasicContextualTokenPolicy, self).getToken(value)
-
-
-class IntIdTokenPolicy(object):
-    """A token policy based on intids."""
-
-    zope.interface.implements(zc.sourcefactory.interfaces.ITokenPolicy)
-
-    def getValue(self, source, token):
-        iid = int(token)
-        value = self.intids.getObject(iid)
-        if value in self.source:
-            return value
-        else:
-            raise LookupError("no value matching token: %r" % token)
-
-    def getToken(self, value):
-        return str(self.intids.getId(value))
-
-    # We can't use zope.cachedescriptors.property.Lazy for this since
-    # the source factory exists across the entire process, and is used
-    # across different requests.  Using Lazy for this would result in
-    # the wrong ZODB connection being used in most threads.
-    #
-    @property
-    def intids(self):
-        return zope.component.getUtility(
-            zope.intid.interfaces.IIntIds)
-
-
-# Value policies
-
-class BasicValuePolicy(object):
-    """An abstract basic value policy.
-
-    `getValues()` is not implemented.
-
-    The filter allows all values.
-    """
-
-    zope.interface.implements(zc.sourcefactory.interfaces.IValuePolicy)
-
-    def filterValue(self, value):
-        return True
-
-class BasicContextualValuePolicy(BasicValuePolicy):
-    """An abstract basic value policy.
-
-    `getValues()` is not implemented.
-
-    The filter allows all values.
-    """
-
-    zope.interface.implements(
-        zc.sourcefactory.interfaces.IContextualValuePolicy)
-
-    def filterValue(self, context, value):
-        return True
-
-
-# Standard combined policies
-
-class BasicSourcePolicy(BasicValuePolicy, BasicTokenPolicy, BasicTermPolicy):
-    pass
-
-
-class BasicContextualSourcePolicy(
-    BasicContextualValuePolicy, BasicContextualTokenPolicy, BasicContextualTermPolicy):
-    pass
-
-
-class IntIdSourcePolicy(BasicValuePolicy, IntIdTokenPolicy, BasicTermPolicy):
-    pass

=== removed file 'src/zc/sourcefactory/source.py'
--- src/zc/sourcefactory/source.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/source.py	1970-01-01 00:00:00 +0000
@@ -1,76 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006-2007 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.
-#
-##############################################################################
-"""Source that uses the policies from the source factory.
-
-"""
-__docformat__ = "reStructuredText"
-
-
-import zope.interface
-import zope.schema.interfaces
-
-import zc.sourcefactory.interfaces
-
-
-class FactoredSource(object):
-    """An iterable source that was created from a source factory."""
-
-    zope.interface.implements(zc.sourcefactory.interfaces.IFactoredSource)
-
-    factory = None
-
-    def __init__(self, factory):
-        self.factory = factory
-
-    def __iter__(self):
-        return self._get_filtered_values()
-
-    def __len__(self):
-        # This is potentially expensive!
-        return len(list(self._get_filtered_values()))
-
-    def __nonzero__(self):
-        for dummy in self._get_filtered_values():
-            return True
-        return False
-
-    def __contains__(self, value):
-        # This is potentially expensive!
-        return value in self._get_filtered_values()
-
-    def _get_filtered_values(self):
-        for value in self.factory.getValues():
-            if not self.factory.filterValue(value):
-                continue
-            yield value
-
-
-class FactoredContextualSource(FactoredSource):
-    """An iterable context-aware source that was created from a source factory.
-    """
-
-    zope.interface.implements(zc.sourcefactory.interfaces.IContextualSource)
-
-    context = None
-
-    def __init__(self, factory, context):
-        self.factory = factory
-        self.context = context
-        self.__parent__ = context
-
-    def _get_filtered_values(self):
-        for value in self.factory.getValues(self.context):
-            if not self.factory.filterValue(self.context, value):
-                continue
-            yield value

=== removed file 'src/zc/sourcefactory/tests.py'
--- src/zc/sourcefactory/tests.py	2010-03-01 20:29:16 +0000
+++ src/zc/sourcefactory/tests.py	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006 Zope Corporation. All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Visible Source
-# License, Version 1.0 (ZVSL).  A copy of the ZVSL 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
-
-"""
-__docformat__ = "reStructuredText"
-
-import os.path
-import unittest
-
-from zope.testing import doctest
-import zope.app.testing.functional
-from zope.app.testing.functional import FunctionalDocFileSuite
-
-here = os.path.realpath(os.path.dirname(__file__))
-
-SourceFactoryLayer = zope.app.testing.functional.ZCMLLayer(
-            os.path.join(here, "ftesting.zcml"), __name__, "SourceFactoryLayer")
-
-
-def test_suite():
-    suite = unittest.TestSuite()
-    suite.addTest(doctest.DocFileSuite('README.txt'))
-    suite.addTest(doctest.DocFileSuite('mapping.txt'))
-    suite.addTest(doctest.DocFileSuite('constructors.txt'))
-    adapters = FunctionalDocFileSuite('adapters.txt')
-    adapters.layer = SourceFactoryLayer
-    suite.addTest(adapters)
-    return suite

=== removed directory 'src/zodbcode'
=== removed file 'src/zodbcode/DEPENDENCIES.cfg'
--- src/zodbcode/DEPENDENCIES.cfg	2009-04-23 15:12:18 +0000
+++ src/zodbcode/DEPENDENCIES.cfg	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-persistent
-transaction
-zope.interface
-# ZODB.utils and ZODB.tests.utils are used by the tests
-ZODB

=== removed file 'src/zodbcode/__init__.py'
--- src/zodbcode/__init__.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-#
-# This file is necessary to make this directory a package.

=== removed file 'src/zodbcode/class_.py'
--- src/zodbcode/class_.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/class_.py	1970-01-01 00:00:00 +0000
@@ -1,436 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 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.
-#
-##############################################################################
-"""Persistent Classes."""
-
-__metaclass__ = type
-
-from zope.interface import implements
-from persistent.cPersistence import UPTODATE, CHANGED, GHOST
-from persistent.interfaces import IPersistent
-from zodbcode.function import PersistentFunction
-
-import time
-
-# XXX There is a lot of magic here to give classes and instances
-# separate sets of attributes.  This code should be documented, as it
-# it quite delicate, and it should be move to a separate module.
-
-class SimpleDescriptor(object):
-
-    missing = object()
-
-    def __init__(self, value):
-        self._value = value
-
-    def __get__(self, obj, cls):
-        if self._value is self.missing:
-            raise AttributeError
-        return self._value
-
-    def __set__(self, obj, value):
-        self._value = value
-
-    def __delete__(self, obj):
-        if self._value is self.missing:
-            raise AttributeError
-        del self._value
-
-class ExtClassDescr:
-    """Maintains seperate class and instance descriptors for an attribute.
-
-    This allows a class to provide methods and attributes without
-    intefering with normal use of instances.  The class and its
-    instances can each have methods with the same name.
-
-    This does interfere with introspection on the class.
-    """
-
-    def __init__(self, name, instdescr):
-        self.name = name
-        self.instdescr = instdescr
-
-    def __get__(self, obj, cls):
-        if obj is None:
-            return self.clsget(cls)
-        else:
-            return self.instdescr.__get__(obj, cls)
-
-    def __set__(self, obj, val):
-        if obj is None:
-            self.clsset(val)
-        else:
-            if self.instdescr is None:
-                raise AttributeError(self.name)
-            return self.instdescr.__set__(obj, val)
-
-    def __delete__(self, obj):
-        if self.instdescr is None:
-            raise AttributeError(self.name)
-        return self.instdescr.__delete__(obj)
-
-    # subclass should override
-
-    def clsget(self, cls):
-        pass
-
-    def clsset(self, val):
-        pass
-
-    def clsdelete(self):
-        pass
-
-class MethodMixin:
-
-    def __init__(self, name, descr, func):
-        if not hasattr(descr, "__get__"):
-            # If the object defined in the metaclass is not a descriptor,
-            # create one for it.
-            descr = SimpleDescriptor(descr)
-        super(MethodMixin, self).__init__(name, descr)
-        self.func = func
-
-    def clsget(self, cls):
-        def f(*args, **kwargs):
-            try:
-                return self.func(cls, *args, **kwargs)
-            except TypeError:
-                print `self.func`, `cls`, `args`, `kwargs`
-                raise
-        return f
-
-class DataMixin:
-
-    def __init__(self, name, descr, val):
-        if not hasattr(descr, "__get__"):
-            # If the object defined in the metaclass is not a descriptor,
-            # create one for it.
-            descr = SimpleDescriptor(descr)
-        super(DataMixin, self).__init__(name, descr)
-        self.val = val
-
-    def clsget(self, cls):
-        return self.val
-
-    def clsset(self, val):
-        self.val = val
-
-    def clsdelete(self):
-        del self.val
-
-class ExtClassMethodDescr(MethodMixin, ExtClassDescr):
-    pass
-
-class ExtClassDataDescr(DataMixin, ExtClassDescr):
-    pass
-
-class ExtClassHookDataDescr(ExtClassDataDescr):
-    # Calls a hook when clsset() is called.
-
-    def __init__(self, name, descr, val, hook):
-        super(ExtClassHookDataDescr, self).__init__(name, descr, val)
-        self.hook = hook
-
-    def clsset(self, val):
-        self.val = val
-        self.hook()
-
-# The next three classes conspire to make a PersistentFunction
-# behave like a method when found in a class's __dict__.
-
-class PersistentMethod:
-    """Make PersistentFunctions into methods."""
-    def __init__(self, klass, inst, func):
-        self.im_class = klass
-        self.im_self = inst
-        self.im_func = func
-
-    def __repr__(self):
-        if self.im_self is None:
-            fmt = "<persistent unbound method %s.%s>"
-        else:
-            fmt = "<persistent bound method %%s.%%s of %s>" % (self.im_self,)
-        return fmt % (self.im_class.__name__, self.im_func.__name__)
-
-    def __call__(self, *args, **kwargs):
-        if self.im_self is None:
-            if not isinstance(args[0], self.im_class):
-                raise TypeError("unbound method %s() must be called "
-                                "with %s instance as first argument ("
-                                "got %s instead)" % (self.im_func.__name__,
-                                                     self.im_class.__name__,
-                                                     type(args[0]).__name__))
-        else:
-            return self.im_func(self.im_self, *args, **kwargs)
-
-class PersistentDescriptor:
-
-    def __init__(self, objclass, func):
-        self.__name__ = func.__name__
-        self.__doc__ = func.__doc__
-        self.__objclass__ = objclass
-        self._func = func
-        # Delegate __getstate__ and __setstate__ to the persistent func.
-        # The patch module will use these methods to update persistent
-        # methods in place.
-        self.__getstate__ = func.__getstate__
-        self.__setstate__ = func.__setstate__
-
-    def __repr__(self):
-        return "<persistent descriptor %s.%s>" % (self.__objclass__.__name__,
-                                                  self.__name__)
-
-    def __get__(self, object, klass=None):
-        if object is None:
-            return PersistentMethod(klass or self.__objclass__, None,
-                                    self._func)
-        else:
-            return PersistentMethod(klass or self.__objclass__, object,
-                                    self._func)
-
-
-_missing = object()
-
-def findattr(cls, attr, default):
-    """Walk the mro of cls to find attr."""
-    for c in cls.__mro__:
-        o = c.__dict__.get(attr, _missing)
-        if o is not _missing:
-            return o
-    return default
-
-class StateChangeDataDescr(ExtClassDataDescr):
-    # A data descriptor for _p_changed.
-    pass
-
-class PersistentClassMetaClass(type):
-
-    # An attempt to make persistent classes look just like other
-    # persistent objects by providing class attributes and methods
-    # that behave like the persistence machinery.
-
-    # The chief limitation of this approach is that class.attr won't
-    # always behave the way it does for normal classes
-
-    # A persistent class can never be a ghost, because there are too
-    # many places where Python will attempt to inspect the class
-    # without using getattr().  As a result, it would be impossible to
-    # guarantee that the class would be unghostified at the right
-    # time.  It's really difficult to guarantee this property without
-    # help from the connection, because a ghost can't be unghosted
-    # until after the connection sets its _p_jar.
-
-    # The hack solution is to have a hook for _p_jar that activates
-    # the object the first time it is set.
-
-    #implements(IPersistent)
-    __implements__ = IPersistent
-
-    # A class is normally created in the UPTODATE state, but when a
-    # new ghost is created for it the serialization machinery passes
-    # GHOST instead of UPTODATE.  See __getnewargs__().
-
-    def __new__(meta, name, bases, dict, state=UPTODATE):
-
-        if "__dict__" in dict:
-            del dict["__dict__"]
-        cls = super(PersistentClassMetaClass, meta).__new__(
-            meta, name, bases, dict)
-        cls._pc_init = False
-
-        # helper functions
-        def extend_attr(attr, v):
-            prev = findattr(cls, attr, SimpleDescriptor.missing)
-            setattr(cls, attr, ExtClassDataDescr(attr, prev, v))
-
-        def extend_meth(attr, m):
-            prev = findattr(cls, attr, SimpleDescriptor.missing)
-            setattr(cls, attr, ExtClassMethodDescr(attr, prev, m))
-
-        extend_attr("_p_oid", None)
-        extend_attr("_p_atime", time.time() % 86400)
-        extend_attr("_p_state", state)
-        extend_attr("_p_changed", None)
-        extend_meth("_p_activate", meta._p_activate)
-        extend_meth("_p_deactivate", meta._p_deactivate)
-        # XXX _p_invalidate
-
-        # Create a descriptor that calls _p_activate() when _p_jar is set.
-        inst_jar_descr = findattr(cls, "_p_jar", None)
-        setattr(cls, "_p_jar",
-                ExtClassHookDataDescr("_p_jar", inst_jar_descr, None,
-                                      getattr(cls, "_p_activate")))
-
-        for k, v in dict.items():
-            if isinstance(v, PersistentFunction):
-                setattr(cls, k, PersistentDescriptor(cls, v))
-
-        # A class could define any of these attributes, thus we
-        # need to create extended descriptors so that the class
-        # and its instances have separate versions.
-        extend_meth("__getstate__", meta.__getstate__)
-        extend_meth("__setstate__", meta.__setstate__)
-
-        # Don't need this with interface geddon
-        # extend_attr("__implements__", meta.__implements__)
-
-        cls._pc_init = True
-        return cls
-
-    def __getattribute__(cls, name):
-        # XXX I'm not sure I understand this code any more.
-        super_meth = super(PersistentClassMetaClass, cls).__getattribute__
-
-        # If we are initializing the class, don't trying to check variables
-        # like _p_state, since they may not be initialized.
-        if not super_meth("_pc_init"):
-            return super_meth(name)
-        if (name[0] != "_" or
-            not (name.startswith("_p_") or name.startswith("_pc_") or
-                 name == "__dict__")):
-            if cls._p_state == GHOST:
-                cls._p_activate()
-                cls._p_atime = int(time.time() % 86400)
-        return super_meth(name)
-
-    # XXX There needs to be an _p_changed flag so that classes get
-    # registered with the txn when they are modified.
-
-    def __setattr__(cls, attr, val):
-        if not attr.startswith("_pc_") and cls._pc_init:
-            descr = cls.__dict__.get(attr)
-            if descr is not None:
-                set = getattr(descr, "__set__", None)
-                if set is not None:
-                    set(None, val)
-##                    cls._p_changed = True
-                    return
-        super(PersistentClassMetaClass, cls).__setattr__(attr, val)
-
-    def __delattr__(cls, attr):
-        if attr.startswith('_p_'):
-            # XXX what should happen with these?
-            return
-        super(PersistentClassMetaClass, cls).__delattr__(attr)
-
-    def __repr__(cls):
-        return "<persistent class %s.%s>" % (cls.__module__,
-                                             cls.__name__)
-
-    # It should be possible for getstate / setstate to deal with
-    # arbitrary class attributes.  That goal is hard to achieve,
-    # because there are several funny descriptors that need to
-    # be handled specially.
-
-    def __getstate__(cls):
-        dict = {}
-
-        for k in cls.__dict__.keys():
-            v = getattr(cls, k)
-            if isinstance(v, PersistentMethod):
-                dict[k] = v.im_func
-                continue
-            if (k in ["__module__", "__weakref__", "__dict__"]
-                or k.startswith("_p_") or k.startswith("_pc_")):
-                continue
-            # XXX The following test isn't right because overriding
-            # must be allowed, but I haven't figured that out yet.
-            # __getstate__ and __setstate__ might be overridden
-            # __implements__ might be overridden
-            if k in ["__getstate__", "__setstate__", "__implements__"]:
-                continue
-            dict[k] = v
-        return dict
-
-    def __setstate__(cls, dict):
-        for k, v in dict.items():
-            if isinstance(v, PersistentFunction):
-                setattr(cls, k, PersistentDescriptor(cls, v))
-            else:
-                setattr(cls, k, v)
-
-    # XXX Should the object get marked as a ghost when it is, in fact,
-    # not a ghost?  The most obvious answer is no.  But if we don't
-    # then we need some other attribute that can be used to handle
-    # invalidations of classes and make _p_activate() work as expected.
-    # Need to decide on a good answer.
-
-    def _p_deactivate(cls):
-        # do nothing but mark the state change for now
-        cls._p_state = GHOST
-
-    def _p_activate(cls):
-        # The logic here is:
-        # If the class hasn't finished executing __new__(), don't
-        # try to load its state.
-        # If the class has a jar but no oid, it's a new object
-        # and doesn't have state in the database.
-
-        if cls._p_state == GHOST and cls._pc_init:
-            dm = cls._p_jar
-            if dm is not None and cls._p_oid:
-                cls._p_state = CHANGED
-                try:
-                    # XXX Make sure the object is in the cache before
-                    # calling setstate().
-                    dm._cache[cls._p_oid] = cls
-                    dm.setstate(cls)
-                finally:
-                    # XXX Should really put in special inconsistent state
-                    cls._p_state = UPTODATE
-            else:
-                print id(cls), "dm", dm, "oid", cls._p_oid
-
-    # Methods below here are not wrapped to be class-only attributes.
-    # They are available as methods of classes using this metaclass.
-
-    def __getnewargs__(cls):
-        # XXX This should really be _p_getnewargs() or something like that.
-
-        # If the class is later loaded and unghostified, the arguments
-        # passed to __new__() won't have an __module__.  It seems that
-        # the module gets set to zodb.code.class_ in that case, which
-        # is wrong.
-        return (cls.__name__, cls.__bases__,
-                {"__module__": cls.__module__}, GHOST)
-
-    def _p_newstate(cls, acls):
-        # Update a class's __dict__ in place.  Must use setattr and
-        # delattr because __dict__ is a read-only proxy.
-        # XXX This doesn't handle __methods__ correctly.
-
-        # XXX I'm not sure how this is supposed to handle the
-        # ExtClassDataDescrs.  As a hack, I'm deleting _p_oid
-        # and _p_jar from the keys dict, because I know they
-        # will be descrs and they won't change as a result of
-        # update.  It appears that if the new class has a descr
-        # that isn't set on the class, it will stomp on the old
-        # class's value.  Not sure if this is a problem in general.
-        
-        def getkeys(cls):
-            L = [n for n in cls.__dict__.keys()
-                 if (not (n.startswith("__") and n.endswith("__"))
-                     and not n.startswith("_p_"))
-                 ]
-            d = {}
-            for elt in L:
-                d[elt] = True
-            return d
-        oldnames = getkeys(cls)
-        newnames = getkeys(acls)
-        for name in oldnames:
-            if not name in newnames:
-                delattr(cls, name)
-        for name in newnames:
-            setattr(cls, name, acls.__dict__[name])
-

=== removed file 'src/zodbcode/function.py'
--- src/zodbcode/function.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/function.py	1970-01-01 00:00:00 +0000
@@ -1,201 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 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.
-#
-##############################################################################
-"""Persistent functions."""
-
-import dis
-import new
-import sys
-# in 2.3, this will be spelled new.function and new.code
-from types import FunctionType as function, CodeType as code
-
-from persistent import Persistent
-
-_STORE_GLOBAL = chr(dis.opname.index("STORE_GLOBAL"))
-
-def has_side_effect(func):
-    # will find this as an opcode or oparg
-    return _STORE_GLOBAL in func.func_code.co_code
-
-class CodeWrapper:
-    """Package a code object so that it can be pickled."""
-
-    nested = 0
-
-    def __init__(self, co):
-        consts = co.co_consts
-        nested = [(i, c) for i, c in zip(range(len(consts)), consts)
-                  if isinstance(c, code)]
-        if nested:
-            self.nested = 1
-            L = list(consts)
-            for i, c in nested:
-                L[i] = CodeWrapper(c)
-            consts = tuple(L)
-
-        # args stores the arguments to new.code in order
-        self.args = [co.co_argcount,
-                     co.co_nlocals,
-                     co.co_stacksize,
-                     co.co_flags,
-                     co.co_code,
-                     consts,
-                     co.co_names,
-                     co.co_varnames,
-                     co.co_filename,
-                     co.co_name,
-                     co.co_firstlineno,
-                     co.co_lnotab,
-                     co.co_freevars,
-                     co.co_cellvars]
-
-    def ascode(self):
-        if self.nested:
-            L = list(self.args[5])
-            for i, elt in zip(range(len(L)), L):
-                if isinstance(elt, CodeWrapper):
-                    L[i] = elt.ascode()
-            self.args[5] = tuple(L)
-        return new.code(*self.args)
-
-def get_code_args(co):
-    """Return args from code object suitable for passing to constructor."""
-
-class PersistentFunction(Persistent):
-
-    def __init__(self, func, module):
-        # Use _pf_ as the prefix to minimize the possibility that
-        # these attribute names will conflict with function attributes
-        # found in user code.  It would have been nice to use _p_
-        # since it's already an reserved attribute prefix, but the
-        # base persistent getattr function does not unghostify an
-        # object on refences to _p_ attributes.
-        self._pf_func = func
-        self._v_side_effect = has_side_effect(func)
-        self._pf_module = module
-        self._pf_code = {}
-        # Python doesn't provide enough rope to recreate a closure.  The
-        # cell objects are opaque which means Python code can't extra
-        # the objects from them or recreate them on unpickling.  In
-        # principle this code be fixed with C code, but it should be
-        # done in Python, not Zope.
-        if func.func_code.co_freevars:
-            raise TypeError("persistent function can not have free variables")
-
-    def __repr__(self):
-        return "<PersistentFunction %s.%s>" % (self._pf_module.__name__,
-                                               self._pf_func.func_name)
-
-    # We need attribute hooks to handle access to _pf_ attributes in a
-    # special way.  All other attributes should be looked up on
-    # _pf_func.
-
-    def __getattr__(self, attr):
-        # If it wasn't found in __dict__, then it must be a function
-        # attribute.
-        if attr == '_pf_func':
-            raise AttributeError(attr)
-        return getattr(self._pf_func, attr)
-
-    def __setattr__(self, attr, value):
-        if not self._p_setattr(attr, value):
-            # the persistence machinery didn't handle this attribute,
-            # it must be ours
-            if attr.startswith('_pf_'):
-                self.__dict__[attr] = value
-                if attr == "_pf_func":
-                    self._v_side_effect = has_side_effect(self._pf_func)
-            else:
-                setattr(self._pf_func, attr, value)
-            if not attr.startswith('_v_'):
-                self._p_changed = 1
-
-    def __delattr__(self, attr):
-        if not self._p_delattr(attr):
-            # the persistence machinery didn't handle this attribute,
-            # it must be ours
-            if attr.startswith('_pf_'):
-                del self.__dict__[attr]
-            else:
-                delattr(self._pf_func, attr)
-            if not attr.startswith('_v_'):
-                self._p_changed = 1
-
-    def __call__(self, *args, **kwargs):
-        # We must make sure that _module is loaded when func is
-        # executed because the function may reference a global
-        # variable and that global variable must be in the module's
-        # __dict__.  We can't use a PersistentDict because the
-        # interpreter requires that globals be a real dict.
-        self._pf_module._p_activate()
-
-        # XXX What if the function module is deactivated while the
-        # function is executing?  It seems like we need to expose
-        # refcounts at the Python level to guarantee that this will
-        # work.
-
-        try:
-            return self._pf_func(*args, **kwargs)
-        finally:
-            # If the func has a side-effect, the module must be marked
-            # as changed.  We use the conservative approximation that
-            # any function with a STORE_GLOBAL opcode has a
-            # side-effect, regardless of whether a a particular call
-            # of the function actually executes STORE_GLOBAL.
-
-            # XXX Is this sufficient?
-            if self._v_side_effect:
-                self._pf_module._p_changed = True
-
-    def __getstate__(self):
-        # If func_dict is empty, store None to avoid creating a dict
-        # unnecessarily when the function is unpickled
-        # XXX new.function doesn't accept a closure
-        func = self._pf_func
-        func_state = func.func_defaults, func.func_dict or None
-
-        # Store the code separately from the function
-        code = func.func_code
-
-        # The code object is can only be reused in an interpreter
-        # running the same version of Python and with the same
-        # __debug__ value.  Store code in a dict keyed by these two values.
-
-        key = sys.version_info, __debug__
-        if key not in self._pf_code:
-            self._pf_code[key] = CodeWrapper(code)
-
-        return func_state, self._pf_code, self._pf_module
-
-    def __setstate__(self, (func, code, mod)):
-        self._pf_code = code
-        self._pf_module = mod
-
-        # recreate the code object
-        code = None
-        key = sys.version_info, __debug__
-        cowrap = self._pf_code.get(key, None)
-        if cowrap is None:
-            assert False, "not implemented yet"
-        else:
-            code = cowrap.ascode()
-
-        func_defaults, func_dict = func
-        if func_defaults:
-            func = new.function(code, mod.__dict__, None, func_defaults)
-        else:
-            func = new.function(code, mod.__dict__)
-        if func_dict:
-            func.func_dict.update(func_dict)
-        self._pf_func = func
-        self._v_side_effect = has_side_effect(func)

=== removed file 'src/zodbcode/interfaces.py'
--- src/zodbcode/interfaces.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/interfaces.py	1970-01-01 00:00:00 +0000
@@ -1,54 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 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.
-#
-##############################################################################
-"""Persistent Module Interfaces
-
-$Id$
-"""
-from zope.interface import Interface, Attribute
-
-class IPersistentModuleImportRegistry(Interface):
-
-    def findModule(name):
-        """Return module registered under name or None."""
-
-    def modules():
-        """Return a list of module names in the registry."""
-
-class IPersistentModuleUpdateRegistry(IPersistentModuleImportRegistry):
-
-    def setModule(name, module):
-        """Register module under name.
-
-        Raises ValueError if module is already registered.
-        """
-
-    def delModule(name):
-        """Unregister module registered under name.
-
-        Raises KeyError in module is not registered.
-        """
-
-class IPersistentModuleManager(Interface):
-
-    def new(name, source):
-        """Create and register a new named module from source."""
-
-    def update(src):
-        """Update the source of the existing module."""
-
-    def remove():
-        """Unregister the module and forget about it."""
-
-    name = Attribute("Absolute module name")
-    source = Attribute("Module source string")

=== removed file 'src/zodbcode/module.py'
--- src/zodbcode/module.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/module.py	1970-01-01 00:00:00 +0000
@@ -1,343 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 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.
-#
-##############################################################################
-"""Persistent Module."""
-
-__metaclass__ = type
-
-from zope.interface import implements
-
-from persistent import Persistent
-from persistent.cPersistence import GHOST
-from zodbcode.interfaces import IPersistentModuleManager
-from zodbcode.interfaces \
-     import IPersistentModuleImportRegistry, IPersistentModuleUpdateRegistry
-from zodbcode.patch import NameFinder, convert
-
-# builtins are explicitly assigned when a module is unpickled
-import __builtin__
-
-# Modules aren't picklable by default, but we'd like them to be
-# pickled just like classes (by name).
-import copy_reg
-
-def _pickle_module(mod):
-    return _unpickle_module, (mod.__name__,)
-
-def _unpickle_module(modname):
-    mod = __import__(modname)
-    if "." in modname:
-        parts = modname.split(".")[1:]
-        for part in parts:
-            mod = getattr(mod, part)
-    return mod
-
-copy_reg.pickle(type(copy_reg), _pickle_module, _unpickle_module)
-
-# XXX Is this comment still relevant?
-#
-# There seems to be something seriously wrong with a module pickle
-# that contains objects pickled via save_global().  These objects are
-# pickled using references to the module.  It appears that unpickling the
-# object in the module causes the persistence machinery to fail.
-#
-# My suspicion is that the assignment to po_state before trying to
-# load the state confuses things.  The first call to setstate attempts
-# to reference an attribute of the module.  That getattr() fails because
-# the module is not a ghost, but does have any empty dict.  Since
-# that getattr() fails, its state can't be unpickled.
-#
-# Not sure what to do about this.
-
-class PersistentModule(Persistent):
-
-    def __init__(self, name):
-        self.__name__ = name
-
-    def __repr__(self):
-        return "<%s %s>" % (self.__class__.__name__, self.__name__)
-
-    # XXX need getattr &c. hooks to update _p_changed?
-    # XXX what about code that modifies __dict__ directly?
-    # XXX one example is a function that rebinds a global
-
-    def __getstate__(self):
-        d = self.__dict__.copy()
-        try:
-            del d["__builtins__"]
-        except KeyError:
-            pass
-        return d
-
-    def __setstate__(self, state):
-        state["__builtins__"] = __builtin__
-        self.__dict__.update(state)
-
-class PersistentPackage(PersistentModule):
-    # XXX Is it okay that these packages don't have __path__?
-
-    # A PersistentPackage can exist in a registry without a manager.
-    # It only gets a manager if someone creates an __init__ module for
-    # the package.
-
-    def __init__(self, name):
-        self.__name__ = name
-
-__persistent_module_registry__ = "__persistent_module_registry__"
-
-def newModule(registry, name, source):
-    """Return a manager object for a newly created module."""
-    mgr = PersistentModuleManager(registry)
-    mgr.new(name, source)
-    return mgr
-
-
-def compileModule(module, registry, source):
-    # Try to prevent compilation errors from files without trailing newlines.
-    if source and source[-1] != "\n":
-        source += "\n"
-    module._p_changed = True
-    moddict = module.__dict__
-    old_names = NameFinder(module)
-    moddict[__persistent_module_registry__] = registry
-    # XXX need to be able to replace sys.std{in,out,err} at this point
-    exec source in moddict
-    # XXX and restore them here.
-    del moddict[__persistent_module_registry__]
-    new_names = NameFinder(module)
-    replacements = new_names.replacements(old_names)
-    convert(module, replacements)
-
-class PersistentModuleManager(Persistent):
-
-    implements(IPersistentModuleManager)
-
-    def __init__(self, registry):
-        self._registry = registry
-        self._module = None
-        self.name = None
-        self.source = None
-
-    def new(self, name, source):
-        """Return a new module from a name and source text."""
-        if self._module is not None:
-            raise ValueError("module already exists")
-        if "." in name:
-            parent = self._new_package(name)
-        else:
-            parent = None
-            self._module = PersistentModule(name)
-        try:
-            self._registry.setModule(name, self._module)
-        except ValueError:
-            self._module = None
-            raise
-        self.name = name
-        try:
-            self.update(source)
-        except:
-            self._registry.delModule(name)
-            raise
-        if parent is not None:
-            modname = name.split(".")[-1]
-            setattr(parent, modname, self._module)
-
-    def update(self, source):
-        # Try to prevent compilation errors from files without trailing
-        # newlines.
-        compileModule(self._module, self._registry, source)
-        self.source = source
-
-    def remove(self):
-        self._registry.delModule(self._module.__name__)
-        self._module = None
-
-    def _new_package(self, name):
-        parent = self._get_parent(name)
-        modname = name.split(".")[-1]
-        if modname == "__init__":
-            self._module = parent
-            return None
-        else:
-            self._module = PersistentModule(name)
-            return parent
-
-    def _get_parent(self, name):
-        # If a module is being created in a package, automatically
-        # create parent packages that do no already exist.
-        parts = name.split(".")[:-1]
-        parent = None
-        for i in range(len(parts)):
-            if parts[i] == "__init__":
-                raise ValueError("__init__ can not be a package")
-            pname = ".".join(parts[:i+1])
-            package = self._registry.findModule(pname)
-            if package is None:
-                package = PersistentPackage(pname)
-                self._registry.setModule(pname, package)
-                if parent is not None:
-                    setattr(parent, parts[i], package)
-            elif not isinstance(package, PersistentPackage):
-                raise ValueError("%s is module" % pname)
-            parent = package
-        return parent
-
-class PersistentModuleImporter:
-    """An import hook that loads persistent modules.
-
-    The importer cooperates with other objects to make sure imports of
-    persistent modules work correctly.  The default importer depends
-    on finding a persistent module registry in the globals passed to
-    __import__().  It looks for the name __persistent_module_registry__.
-    A PersistentModuleManager places its registry in the globals used
-    to exec module source.
-
-    It is important that the registry be activated before it is used
-    to handle imports.  If a ghost registry is used for importing, a
-    circular import occurs.  The second import occurs when the
-    machinery searches for the class of the registry.  It will re-use
-    the registry and fail, because the registry will be marked as
-    changed but not yet have its state loaded.
-    XXX There ought to be a way to deal with this.
-    """
-
-    # The import hook doesn't use sys.modules, because Zope might want
-    # to have placeful registries.  That is, a particular module might
-    # execute in a context where there is more than one persistent
-    # module registry active.  In this case, it isn't safe to use
-    # sys.modules, because each registry could have a different binding
-    # for a particular name.
-
-    _saved_import = None
-
-    def install(self):
-        if self._saved_import is not None:
-            raise TypeError("Already installed!")
-        self._saved_import = __builtin__.__import__
-        __builtin__.__import__ = self.__import__
-
-    def uninstall(self):
-        if self._saved_import is None:
-            raise TypeError("Not installed!")
-        __builtin__.__import__ = self._saved_import
-        self._saved_import = None
-
-    def _import(self, registry, name, parent, fromlist):
-        mod = None
-        if parent is not None:
-            fullname = "%s.%s" % (parent, name)
-            mod = registry.findModule(fullname)
-            if mod is None:
-                parent = None
-        if mod is None: # no parent or didn't find in parent
-            mod = registry.findModule(name)
-        if mod is None:
-            return None
-        if fromlist:
-            if isinstance(mod, PersistentPackage):
-                self._import_fromlist(registry, mod, fromlist)
-            return mod
-        else:
-            i = name.find(".")
-            if i == -1:
-                return mod
-            name = name[:i]
-            if parent:
-                name = "%s.%s" % (parent, name)
-            top = registry.findModule(name)
-            assert top is not None, "No package for module %s" % name
-            return top
-
-    def _import_fromlist(self, registry, mod, fromlist):
-        for name in fromlist:
-            if not hasattr(mod, name):
-                fullname = "%s.%s" % (mod.__name__, name)
-                self._import(registry, fullname, None, [])
-
-    def __import__(self, name, globals={}, locals={}, fromlist=[]):
-        registry = globals.get(__persistent_module_registry__)
-        if registry is not None:
-            mod = self._import(registry, name, self._get_parent(globals),
-                               fromlist)
-            if mod is not None:
-                return mod
-        return self._saved_import(name, globals, locals, fromlist)
-
-    def _get_parent(self, globals):
-        name = globals.get("__name__")
-        if name is None or "." not in name:
-            return None
-        i = name.rfind(".")
-        return name[:i]
-
-class PersistentModuleRegistry(Persistent):
-    """A collection of persistent modules.
-
-    The registry is similar in purpose to sys.modules.  A persistent
-    module manager stores its modules in a registry, and the importer
-    looks for them there.
-    """
-
-    implements(IPersistentModuleImportRegistry,
-               IPersistentModuleUpdateRegistry)
-
-    def __init__(self):
-        self._modules = {}
-
-    def findModule(self, name):
-        assert self._p_changed is not None
-        return self._modules.get(name)
-
-    def setModule(self, name, module):
-        if name in self._modules:
-            # The name is already in use.
-            # XXX should raise a better error
-            raise ValueError(name)
-        self._p_changed = True
-        self._modules[name] = module
-
-    def delModule(self, name):
-        self._p_changed = True
-        del self._modules[name]
-
-    def modules(self):
-        """Return a list of the modules in the registry."""
-        return self._modules.keys()
-    
-class ManagedRegistry(PersistentModuleRegistry):
-    """A collection of persistent modules and their managers.
-
-    An extension of the persistent module registry that also collects
-    the managers.  For persistent modules to be useful, the managers
-    must be stored in the database.  This registry stores managers
-    as well as their modules, so that all objects related to the modules
-    in the registry are reachable from the registry.
-    """
-
-    def __init__(self):
-        super(ManagedRegistry, self).__init__()
-        self._mgrs = {}
-
-    def newModule(self, name, source):
-        mgr = PersistentModuleManager(self)
-        mgr.new(name, source)
-        self._p_changed = True
-        self._mgrs[name] = mgr
-
-    def updateModule(self, name, source):
-        self._mgrs[name].update(source)
-
-    def removeModule(self, name):
-        self._mgrs[name].remove()
-        self._p_changed = True
-        del self._mgrs[name]

=== removed file 'src/zodbcode/module.txt'
--- src/zodbcode/module.txt	2009-04-23 15:12:18 +0000
+++ src/zodbcode/module.txt	1970-01-01 00:00:00 +0000
@@ -1,300 +0,0 @@
-==================
-Persistent Modules
-==================
-
-Document Overview
------------------
-
-This document seeks to capture technical information about persistent modules
-to guide and document their design.
-
-Goals
------
-
-These goals largely come from Zope 3.  It would be worth while considering
-other applications.
-
-- Persistent modules are used to support management of software using the
-  ZODB.
-
-- Software can be updated using network clients, such as web browsers and
-  file-synchonozation tools.
-
-- Application-server clusters can be updated transactionally without requiring
-  server restarts.
-
-- Persistent modules leverage a familiar model, modules, for managing Python
-  software.
-
-- Persistent modules can be synchronized to a file-system using the Zope
-  file-system synchronization framework.  Persistent modules are synchronized
-  for purposes including:
-
-  o Use of traditional tools such as editors and code-analysis tools
-
-  o Revision control
-
-  Ideally, the file-system representation would consist of a Python source
-  file.
-
-Use cases
----------
-
-- Create classes and functions that implement Zope 3 components.
-
-  o Utility, Adapter, View, and service classes and factories.
-
-  o Content components, which are typically persistent and/or
-    pickleable.
-
-- Define interfaces, including schema
-
-- Import classes, functions, and interfaces from other modules.
-
-- Import classes, functions, and interfaces from other persistent objects. For
-  example, an adapter registration object might have a direct reference to a
-  persistent-module-defined class.
-
-- Change module source
-
-  - Changes are reflected in module state
-
-  - Changes are reflected in objects imported into other modules.
-
-- Synchronize modules with a file-system representation.
-
-Edge cases
-----------
-
-  ???
-
-Fundamental dilema
-------------------
-
-Python modules were not designed to change at run time.  The source of a
-Python module normally doesn't change while a Python program is running.
-There is a crude reload tool that allows modules to be manually reloaded to
-handle source changes.
-
-Python modules contain mutable state.  A module has a dictionary that may be
-mutated by application code. It may contain mutable data that is modified at
-run time.  This is typeically used to implement global registries.
-
-When a module is reloaded, it is reexecuted with a dictionary that includes
-the results of the previous execution.
-
-Programs using the ZODB may be said to have logical lifetimes that exceed the
-lifetimes of individual processes. In addition, the program might exist as
-multiple individual processes with overlapping run-times.
-
-The lifetime of a persistent program is long enough that it is likely that
-module source code will change during the life time of the program.
-
-Issues
-------
-
-Should the state of a module be represented soley by the module source?
-
-Consider the possibilities:
-
-A. Module state is represented soley by it's source.
-
-- This would be a departure from the behavior of standard Python modules.
-  Standard Python modules retain a module dictionary that is not overwritten
-  by reloads.  Python modules may be mutated from outside and may contain
-  mutable data structures that are modified at run time.
-
-  OTOH, a regular module's state is not persistent or shared accross
-  processes.
-
-  For standard Python modules, one could view the module source as an
-  expression of the initial state of the module. (This isn't quite right
-  either, since some modules are written in such a way that they anticipate
-  module reloads.)
-
-- Deleting variables from a module's source that have been imported by other
-  modules or objects will cause the imported values to become disconnected
-  from the module's source.  Even if the variables are added back later, the
-  previously-imported values will be disconnected.
-
-  It is tempting to introduce a data structure to record imports make from a
-  module.  For example, suppose module M1 imports X from M2.  It's tempting to
-  record that fact in M2, so that we disallow M2 to be removed or to be
-  changed in such a way that M2 no-longer defines X.  Unfortunately, that
-  would introduce state that isn't captured by my M2's source.
-
-- Persistent modules could only be used for software. You wouldn't be able to
-  use them to store mutable data, such as registries or counters, that are
-  updated outside of the execution of the module source.
-
-B. Module state isn't represented soley by it's source.
-
- - It would become possible to allow mutable data, such as registries in
-   persistent modules.
-
- - It could be very difficult to see what a module's state is.  If a module
-   contained mutable data, you'd need some way to get to that data so you
-   could inspect and manipulate it.
-
- - When a module is synchronized to the file system, you'd need to syncronize
-   it's source and you'd also need to synchronize it's contents in some
-   way. Synchronization of the contents could be done using an XML pickle, but
-   management of the data using file-system-based tools would be cumbersome.
-
-   You'd end up with data duplicated between the two representations.  It
-   would be cumbersome to manage the duplicated data in a consistent way.
-
-C. Module state is represented soley by it's source, but allow additional meta
-   data.
-
-   This is the same as option A, except we support meta-data management.  The
-   meta data could include dependency information. We'd keep track of external
-   usage (import) of module variables to influence whether deletion of the
-   module or defined variables is allowed, or whether to issue warnings when
-   variables are deleted.
-
-   Note that the management of the meta data need not be the responsibility of
-   the module. This could be done via some application-defined facility, in
-   which case, the module facility would need to provide an api for
-   implimenting hooks for managing this information.
-
-Special cases
--------------
-
-This section contains examples that may introduce challenges for persistent
-modules or that might motivate or highlight issues described above,
-
-- Persistent classes
-
-  Persistent classes include data that are not represented by the class
-  sources.  A class caches slot definitions inherited from base classes.  This
-  is information that is only indirectly represented by it's source.
-  Similarly, a class manages a collection of it's subclasses.  This allows a
-  class to invalidate cached slots in subclasses when a new slot definition is
-  assigned (via a setattr).  The cached slots and collection of subclasses is
-  not part of a persistent class' state.  It isn't saved in the database, but
-  is recomputed when the class is loaded into memory or when it's subclasses
-  are loaded into memory.
-
-  Consider two persistent modules, M1, which defines class C1, and M2, which
-  defines class C2.  C2 subclasses C1.  C1 defines a __getitem__ slot, which
-  is inherited and cached by C2.
-
-  Suppose we have a process, P1, which has M1 and M2 in memory.  C2 in P1 has
-  a (cached) __getitem__ slot filled with the definition inherited from C1 in
-  P1.  C1 in P1 has C2 in it's collection of subclasses. In P1, we modify M1,
-  by editing and recompiling its source.  When we recompile M1's source, we'll
-  update the state of C1 by calling it's __setstate__ method, passing the new
-  class dictionary.  The __setstate__ method will, in turn, use setattr to
-  assign the values from the new dictionary.  If we set a slot attribute, the
-  __setattribute__ method in C1 will notify each of it's subclasses that the
-  slot has changed.  Now, suppose that we've added a __len__ slot definition
-  when we modified the source.  When we set the __len__ attribute in C1, C2
-  will be notified that there is a new slot definition for __len__.
-
-  Suppose we have a process P2, which also has M1 and M2 loaded into memory.
-  As in P1, C2 in P2 caches the __getitem__ slot and C1 in P2 has C2 in P2 in
-  it's collection of subclasses.  Now, when M1 in P1 is modified and the
-  corresponding transaction is committed, an invalidation for M1 and all of
-  the persistent objects it defines, including C1, is sent to all other
-  processes. When P2 gets the invalidation for C1, it invalidates C1. It
-  happens that persistent classes are not allowed to be ghosts.  When a
-  persistent class is invalidated, it immediately reloads it's state, rather
-  than converting itself into a ghost. When C2's state is reloaded in P2, we
-  assign it's attributes from the new class dictionary. When we assign slots,
-  we notify it's subclasses, including C2 in P2.
-
-  Suppose we have a process P3, that only has M1 in memory.  In P3, M2 is not
-  in memory, nor are any of it's subobjects.  In P3, C2 is not in the
-  collection of subclasses of C1, because C2 is not in memory and the
-  collection of subclasses is volatile data for C1.  When we modify C1 in P1
-  and commit the transaction, the state of C1 in P3 will be updated, but the
-  state of C2 is not affected in P3, because it's not in memory.
-
-  Finally, consider a process, P4 that has M2, but not M1 in memory.  M2 is
-  not a ghost, so C2 is in memory. Now, since C2 is in memory, C1 must be in
-  memory, even though M1 is not in memory, because C2 has a reference to C1.
-  Further, C1 cannot be a ghost, because persistent classes are not allowed to
-  be ghosts. When we commit the transation in P1 that updates M1, an
-  invalidation for C1 is sent to P4 and C1 is updated.  When C1 is updated,
-  it's subclasses (in P4), including C2 are notified, so that their cached
-  slot definitions are updated.
-
-  When we modify M1, all copies in memory of C1 and C2 are updated properly,
-  even though the data they cache is not cached persistently. This works, and
-  only works, because persistent classes are never ghosts.  If a class could
-  be a ghost, then invalidating it would have not effect and non-ghost
-  dependent classes would not be updated.
-
-- Persistent interfaces
-
-  Like classes, Zope interfaces cache certain information.  An interface
-  maintains a set of all of the interfaces that it extends.  In addition,
-  interfaces maintain a collection of all of their sub-interfaces.  The
-  collection of subinterfaces is used to notify sub=interfaces when an
-  interface changes.
-
-  (Interfaces are a special case of a more general class of objects, called
-   "specifications", that include both interfaces and interface declareations.
-   Similar caching is performed for other specifications and related data
-   structures. To simplify the discussion, however, we'll limit ourselves to
-   interfaces.)
-
-  When designing persistent interfaces, we have alternative approaches to
-  consider:
-
-  A. We could take the same approach as that taken with persistent classes.
-     We would not save cached data persistently.  We would compute it as
-     objects are moved into memory.
-
-     To take this approach, we'd need to also make persistent interfaces
-     non-ghostifiable.  This is necessary to properly propigate object
-     changes.
-
-     One could argue that non-ghostifiability if classes is a necessary wart
-     forced on us by details of Python classes that are beyond our control,
-     and that we should avoid creating new kinds of objects that require
-     non-ghostifiability.
-
-  B. We could store the cached data persistently.  For example, we could store
-     the set of extended interfaces and the set of subinterfaces in persistent
-     dictionaries.
-
-     A significant disadvantage of this approach is that persistent interfaces
-     would accumulate state is that not refelcted in their source code,
-     however, it's worth noting that, while the dependency and cache data
-     cannot be derived from a single module source, it *can* be derived from
-     the sources of all of the modules in the system.  We can implement
-     persistent interface in such a way that execution of module code causes
-     all dependcies among module-defined interfaces to be recomputed
-     correctly.
-
-     (This is, to me, Jim, an interesting case: state that can be computed
-      during deserialization from other serialized state. This should not be
-      surprising, as we are essentially talking about cached data used for
-      optimization purposes.)
-
-Proposals
----------
-
-- A module's state must be reprersented, directly or indirectly, by it's
-  source.  The state may also include information, such as caching data, that
-  is derivable from it's source-represented state.
-
-  It is unclear if or how we will enforce this.  Perhaps it will be just a
-  guideline.  The module-synchronization adapters used in Zope will only
-  synchronize the module source.  If a module defines state that is not
-  represented by or derivable from it's source, then that data will be lost in
-  synchronization.  Of course, applications that don't use the synchronization
-  framework would be unaffected by this limitation. Alternatively, one could
-  develop custom module-synchronization adapters that handled extra module
-  data, however, development of such adapters will be outside the scope of the
-  Zope project.
-
-Notes
------
-
-- When we invalidate a persistent class, we need to delete all of the
-  attributes defined by it's old dictionary that are not defined by the new
-  class dictionary.
-

=== removed file 'src/zodbcode/patch.py'
--- src/zodbcode/patch.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/patch.py	1970-01-01 00:00:00 +0000
@@ -1,468 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 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.
-#
-##############################################################################
-"""Patch references to auto-persistent objects in a module.
-
-When a persistent module is compiled, all classes and functions should
-be converted to persistent classes and functions.  When a module is
-updated, it is compiled and its persistent functions and classes are
-updated in place so that clients of the module see the update.
-
-The specific semantics of the convert and update-in-place operations
-are still being determined.  Here are some rough notes:
-
-- Classes and functions are not converted in place.  New objects are
-  created to replace the builtin functions and classes.
-
-- Every function object is converted to a PersistentFunction.
-
-- Every class is converted to a new class that is created by calling
-  the PersistentClassMetaClass with the name, bases, and dict of the
-  class being converted.
-
-- The conversion operation must preserve object identity.  If an
-  object created by a def or class statement is referenced elsewhere
-  in the module, all references must be replaced with references to
-  the converted object.
-
-Implementation notes
---------------------
-
-The conversion operation is implemented using a pickler.  It wasn't
-possible to use the copy module, because it isn't possible to extend
-the copy module in a safe way.  The copy module depends on module globals.
-
-The pickler uses a Wrapper object that creates the appropriate new
-object or updates an old one when it is unpickled.  The wrapper also
-causes parts of the wrapped object's state to be traversed by the
-pickler, for example the func_defaults of a function object.  This
-traversal is necessary because references to convertable objects could
-be contained in the state and must be updated to refer to the new
-objects.
-
-What semantics do we want for update-in-place in the presence of aliases?
-
-Semantics based on per-namespace updates don't work in the presence of
-aliases.  If an update changes an alias, then the old binding will be
-updated with the state of the new binding.
-
-Semantics based on containing namespaces seem to work.  The outermost
-namespace that contains a name is updated in place.  Aliases are
-simple rebinding operations that do not update in place.
-
-The containment approach seems to have a problem with bound methods,
-where an instance can stash a copy of a bound method created via an
-alias.  When the class is updated, the alias changes, but the bound
-method isn't.  Then the bound method can invoke an old method on a new
-object, which may not be legal.  It might sufficient to outlaw this case.
-
-Open issues
------------
-
-Can we handle metaclasses within this framework?  That is, what if an
-object's type is not type, but a subclass of type.
-
-How do we handle things like staticmethods?  We'd like the code to be
-able to use them, but Python doesn't expose an introspection on them.
-
-What if the same object is bound to two different names in the same
-namespace?  For example::
-
-    x = lambda: 1
-    y = x
-
-If the module is updated to::
-
-    x = lambda: 1
-    y = lambda: 2
-
-What are the desired semantics?
-"""
-
-__metaclass__ = type
-
-from copy_reg import dispatch_table
-from cStringIO import StringIO
-import pickle
-import sys
-from types import *
-
-from zodbcode.class_ import PersistentClassMetaClass, PersistentDescriptor
-from zodbcode.function import PersistentFunction
-
-class Wrapper:
-    """Implement pickling reduce protocol for update-able object.
-
-    The Pickler creates a Wrapper instance and uses it as the reduce
-    function.  The Unpickler calls the instance to recreate the
-    object.
-    """
-    __safe_for_unpickling__ = True
-
-    def __init__(self, obj, module, replace=None):
-        self._obj = obj
-        self._module = module
-        self._replace = replace
-
-    def __call__(self, *args):
-        new = self.unwrap(*args)
-        if self._replace is not None:
-            # XXX Hack: Use _p_newstate for persistent classes, because
-            # a persistent class's persistent state is a fairly limited
-            # subset of the dict and we really want to replace everything.
-            if hasattr(self._replace, "_p_newstate"):
-                self._replace._p_newstate(new)
-            else:
-                self._replace.__setstate__(new.__getstate__())
-            return self._replace
-        else:
-            return new
-
-class FunctionWrapper(Wrapper):
-
-    def unwrap(self, defaults, dict):
-        self._obj.func_defaults = defaults
-        self._obj.func_dict.update(dict)
-        return PersistentFunction(self._obj, self._module)
-
-class TypeWrapper(Wrapper):
-
-    def unwrap(self, bases, dict):
-        return PersistentClassMetaClass(self._obj.__name__, bases, dict)
-
-def registerWrapper(atype, wrapper, unwrap_args, getstate=None):
-    """Register a patch wrapper for an external object type."""
-    Pickler.dispatch[atype] = Pickler.save_external
-    Pickler.external[atype] = wrapper, unwrap_args, getstate
-
-marker = object()
-
-_module_cache = {}
-
-def whichmodule(func, funcname):
-    """Return a likely candidate for the module that defines obj,
-    where context is the name of the module in which obj was found.
-
-    Use a trick suggested by Guido to make sure we found the right
-    module: Compare the function's globals with the module's globals.
-    You've found the right module only when they match.
-    """
-    mod = getattr(func, "__module__", None)
-    if mod is not None:
-        return mod
-    mod = _module_cache.get(func)
-    if mod is not None:
-        return mod
-    for name, module in sys.modules.items():
-        if module is None:
-            continue # skip dummy package entries
-        if getattr(module, funcname, None) is func:
-            if module.__dict__ is func.func_globals:
-                break
-    else:
-        name = '__main__'
-    _module_cache[func] = name
-    return name
-    
-
-class Pickler(pickle.Pickler):
-
-    dispatch = pickle.Pickler.dispatch.copy()
-
-    def __init__(self, file, module, memo, replacements):
-        # The pickler must be created in binary mode, because
-        # it pickles instances using the OBJ code.  The text-mode
-        # pickler uses a different strategy that explicitly
-        # stores the name of the instance's class which defeats
-        # the desire to replace references to classes with
-        # persistent classes.
-        pickle.Pickler.__init__(self, file, protocol=1)
-
-        self._pmemo = memo
-        self._wrapped = {} # set of objects already wrapped
-        self._module = module
-        self._module_name = module.__name__
-        self._repl = replacements
-        self._builtins = module.__builtins__
-
-    def wrap(self, wrapperclass, obj):
-        return wrapperclass(obj, self._module, self._repl.get(id(obj)))
-
-    def persistent_id(self, obj, force=False):
-        if (isinstance(obj, Wrapper)
-            or isinstance(obj, ModuleType)
-            or obj is self._builtins
-            or force):
-            oid = id(obj)
-            self._pmemo[oid] = obj
-            return oid
-        else:
-            # If the object is a real persistent object, patch it by
-            # persistent id, too.  This case is specifically intended
-            # to catch persistent classes imported from other modules.
-            # They are classes, but can't be pickled as globals because
-            # pickle looks in sys.modules and the persistent import
-            # doesn't use sys.modules.
-
-            # If we find a class, pickle it via save_type()
-            if isinstance(obj, PersistentClassMetaClass):
-                return None
-            
-            # XXX Is this safe in all cases?
-            oid = getattr(obj, "_p_oid", marker)
-            if oid is marker:
-                return None
-            elif oid is None:
-                # It's a persistent object, but it's newly created.
-                oid = object()
-            descr = getattr(oid, "__get__", None)
-            if descr is not None:
-                return None
-            self._pmemo[oid] = obj
-            return oid
-
-    def save_type(self, atype):
-        if atype.__module__ == self._module_name:
-            self.save_reduce(self.wrap(TypeWrapper, atype),
-                             (atype.__bases__, atype.__dict__),
-                             obj=atype)
-        else:
-            if isinstance(atype, PersistentClassMetaClass):
-                self.save_pers(self.persistent_id(atype, True))
-            else:
-                self.save_global(atype)
-
-    dispatch[TypeType] = save_type
-    dispatch[ClassType] = save_type
-    dispatch[type] = save_type
-    dispatch[PersistentClassMetaClass] = save_type
-
-    def save_function(self, func):
-        modname = whichmodule(func, func.__name__)
-        if modname == self._module_name or modname == "__main__":
-            self.save_reduce(self.wrap(FunctionWrapper, func),
-                             (func.func_defaults, func.func_dict),
-                             obj=func)
-        else:
-            self.save_global(func)
-
-    dispatch[FunctionType] = save_function
-
-    external = {}
-
-    def save_external(self, obj):
-        # XXX Will this object always have an __module__?
-        if obj.__module__ == self._module_name:
-            # Save an external type registered through registerWrapper
-            objtype = type(obj)
-            wrapper, unwrap_args, getstate = self.external[objtype]
-            if getstate is not None:
-                self.save_reduce(self.wrap(wrapper, obj), unwrap_args(obj),
-                                 getstate(obj),
-                                 obj=obj)
-            else:
-                self.save_reduce(self.wrap(wrapper, obj), unwrap_args(obj),
-                                 obj=obj)
-        else:
-            # In general, we don't know how to pickle this object,
-            # so pickle it by reference to the original.
-            self.save_pers(self.persistent_id(obj, True))
-
-    # New-style classes don't have real dicts.  They have dictproxies.
-    # There's no official way to spell the dictproxy type, so we have
-    # to get it by using type() on an example.
-    dispatch[type(Wrapper.__dict__)] = pickle.Pickler.save_dict
-
-    def save(self, obj, ignore=None):
-        # Override the save() implementation from pickle.py, because
-        # we don't ever want to invoke __reduce__() on builtin types
-        # that aren't picklable.  Instead, we'd like to pickle all of
-        # those objects using the persistent_id() mechanism.  There's
-        # no need to cover every type with this pickler, because it
-        # isn't being used for persistent just to create a copy.
-
-        # The ignored parameter is for compatible with Python 2.2,
-        # which has the old inst_persistent_id feature.
-        pid = self.persistent_id(obj)
-        if pid is not None:
-            self.save_pers(pid)
-            return
-
-        d = id(obj)
-        t = type(obj)
-        if (t is TupleType) and (len(obj) == 0):
-            if self.bin:
-                self.save_empty_tuple(obj)
-            else:
-                self.save_tuple(obj)
-            return
-
-        if d in self.memo:
-            self.write(self.get(self.memo[d][0]))
-            return
-
-        try:
-            f = self.dispatch[t]
-        except KeyError:
-            try:
-                issc = issubclass(t, TypeType)
-            except TypeError: # t is not a class
-                issc = 0
-            if issc:
-                self.save_global(obj)
-                return
-
-            try:
-                reduce = dispatch_table[t]
-            except KeyError:
-                self.save_pers(self.persistent_id(obj, True))
-                return
-            else:
-                tup = reduce(obj)
-
-            if type(tup) is StringType:
-                self.save_global(obj, tup)
-                return
-            if type(tup) is not TupleType:
-                raise pickle.PicklingError("Value returned by %s must be a "
-                                           "tuple" % reduce)
-
-            l = len(tup)
-            if (l != 2) and (l != 3):
-                raise pickle.PicklingError("tuple returned by %s must "
-                                           "contain only two or three "
-                                           "elements" % reduce)
-
-            callable = tup[0]
-            arg_tup  = tup[1]
-            if l > 2:
-                state = tup[2]
-            else:
-                state = None
-
-            if type(arg_tup) is not TupleType and arg_tup is not None:
-                raise pickle.PicklingError("Second element of tuple "
-                                           "returned by %s must be a "
-                                           "tuple" % reduce)
-
-            self.save_reduce(callable, arg_tup, state, obj=obj)
-            return
-
-        f(self, obj)
-
-    def save_reduce(self, callable, arg_tup, state = None, obj = None):
-        write = self.write
-        save = self.save
-
-        save(callable)
-        save(arg_tup)
-        write(pickle.REDUCE)
-
-        if obj is not None:
-            memo_len = len(self.memo)
-            self.write(self.put(memo_len))
-            self.memo[id(obj)] = (memo_len, obj)
-
-        if state is not None:
-            save(state)
-            write(pickle.BUILD)
-
-class Unpickler(pickle.Unpickler):
-
-    def __init__(self, file, pmemo):
-        pickle.Unpickler.__init__(self, file)
-        self._pmemo = pmemo
-
-    def persistent_load(self, oid):
-        return self._pmemo[oid]
-
-class NameFinder:
-    """Find a canonical name for each update-able object."""
-
-    # XXX should we try to handle descriptors?  If it looks like a
-    # descriptor, try calling it and passing the class object?
-
-    classTypes = {
-        TypeType: True,
-        ClassType: True,
-        PersistentClassMetaClass: True,
-        }
-
-    types = {
-        FunctionType: True,
-        PersistentFunction: True,
-        PersistentDescriptor: True,
-        }
-    types.update(classTypes)
-
-    def __init__(self, module):
-        self._names = {} # map object ids to (canonical name, obj) pairs
-        self.walkModule(module)
-
-    def names(self):
-        return [n for n, o in self._names.itervalues()]
-
-    def _walk(self, obj, name, fmt):
-        classes = []
-        for k, v in obj.__dict__.items():
-            aType = type(v)
-            anId = id(v)
-            if aType in self.types and not anId in self._names:
-                self._names[anId] = fmt % (name, k), v
-                if aType in self.classTypes:
-                    classes.append((v, k))
-        for _klass, _name in classes:
-            self.walkClass(_klass, fmt % (name, _name))
-
-    def walkModule(self, mod):
-        self._walk(mod, "", "%s%s")
-
-    def walkClass(self, klass, name):
-        self._walk(klass, name, "%s.%s")
-
-    def replacements(self, aFinder):
-        """Return a dictionary of replacements.
-
-        self and aFinder are two NameFinder instances.  Return a dict
-        of all the objects in the two that share the same name.  The
-        keys are the ids in self and the values are the objects in
-        aFinder.
-        """
-        temp = {}
-        result = {}
-        for anId, (name, obj) in self._names.iteritems():
-            temp[name] = anId
-        for anId, (name, obj) in aFinder._names.iteritems():
-            if name in temp:
-                result[temp[name]] = obj
-        return result
-
-def convert(module, replacements):
-    """Convert object to persistent objects in module.
-
-    Use replacements dictionary to determine which objects to update
-    in place.
-    """
-    f = StringIO()
-    memo = {}
-    p = Pickler(f, module, memo, replacements)
-    moddict = module.__dict__
-    p.dump(moddict)
-    f.seek(0)
-    u = Unpickler(f, memo)
-    newdict = u.load()
-    module.__dict__.clear()
-    module.__dict__.update(newdict)
-
-if __name__ == "__main__":
-    pass

=== removed directory 'src/zodbcode/tests'
=== removed file 'src/zodbcode/tests/__init__.py'
--- src/zodbcode/tests/__init__.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-#
-# This file is necessary to make this directory a package.

=== removed file 'src/zodbcode/tests/_pmtest.py'
--- src/zodbcode/tests/_pmtest.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/tests/_pmtest.py	1970-01-01 00:00:00 +0000
@@ -1,25 +0,0 @@
-##############################################################################
-#
-# 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.
-#
-##############################################################################
-"""A simple module"""
-
-# XXX why aren't modules pickleable?
-# import os
-# from xml import sax
-
-a = 1
-b = 2
-c = 3
-
-def f(x):
-    return a * x ** 2 + b * x + c

=== removed file 'src/zodbcode/tests/atestmodule.py'
--- src/zodbcode/tests/atestmodule.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/tests/atestmodule.py	1970-01-01 00:00:00 +0000
@@ -1,53 +0,0 @@
-##############################################################################
-#
-# 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.
-#
-##############################################################################
-"""A module used to test persistent module patching."""
-
-from ZODB.utils import *
-
-def aFunc():
-    def nestedFunc():
-        return aFunc
-    return 1
-
-class Foo(object):
-    def meth(self):
-        return 0
-
-    class Nested(object):
-        def bar(self):
-            return 1
-
-# put aFunc inside a function to be sure it is found
-foo = (aFunc,)
-
-class Bar:
-    def bar(self, x):
-        return 2 * x
-
-    static = staticmethod(aFunc)
-    alias = aFunc
-
-    classbar = classmethod(bar)
-
-class Sub(Bar):
-    pass
-
-def anotherFunc():
-    class NotFound:
-        pass
-
-
-# import a module that won't be imported by something else:
-from zodbcode.tests import tobeimportedbyatestmodule
-

=== removed file 'src/zodbcode/tests/test_class.py'
--- src/zodbcode/tests/test_class.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/tests/test_class.py	1970-01-01 00:00:00 +0000
@@ -1,215 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 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.
-#
-##############################################################################
-import unittest
-
-from zodbcode.tests.test_module import TestBase
-
-import transaction
-from persistent.cPersistence import CHANGED, UPTODATE
-
-class TestClass(TestBase):
-
-    # TODO
-    # test classes with getstate and setstate
-    # make sure class invalidation works correctly
-
-    class_with_init = """class Foo:
-    def __init__(self, arg):
-        self.var = arg""" "\n"
-
-    def _load_path(self, path):
-        # Load an object from a new connection given a database path.
-        tm = transaction.TransactionManager()
-        root = self.db.open(transaction_manager=tm).root()
-        obj = root
-        for part in path.split("."):
-            try:
-                obj = obj[part]
-            except TypeError:
-                obj = getattr(obj, part)
-        return obj
-
-    def _load_name(self, name):
-        # Load a class from a new connection given a dotted name
-        i = name.rfind(".")
-        module = name[:i]
-        klass = name[i+1:]
-        # The following depends entirely on the internals of the
-        # implementation.
-        return self._load_path("registry._mgrs.%s._module.%s"
-                               % (module, klass))
-
-    def testClassWithInit(self):
-        self.registry.newModule("testclass", self.class_with_init)
-        transaction.commit()
-        import testclass
-        x = testclass.Foo(12)
-        self.assertEqual(x.var, 12)
-
-        Foo2 = self._load_name("testclass.Foo")
-        y = Foo2(12)
-        self.assertEqual(y.var, 12)
-
-    class_and_instance = """class Foo:
-    def __init__(self, arg):
-        self.var = arg
-
-    # The class must have a getinitargs because the instance
-    # will be pickled during module conversion.
-
-    def __getinitargs__(self):
-        return self.var,
-
-y = Foo(11)
-x = Foo(12)""" "\n"
-
-    def testClassAndInstance(self):
-        self.registry.newModule("testclass", self.class_and_instance)
-        transaction.commit()
-        import testclass
-        self.assertEqual(testclass.x.var, 12)
-
-        Foo2 = self._load_name("testclass.Foo")
-        self.assertEqual(Foo2(12).var, 12)
-        x = self._load_name("testclass.x")
-        self.assertEqual(x.var, 12)
-        y = self._load_name("testclass.y")
-        self.assertEqual(y.var, 11)
-
-        self.assert_(not hasattr(x, "_p_oid"))
-        self.assert_(not hasattr(y, "_p_oid"))
-        x._p_oid = 1234
-        y._p_oid = 4321
-
-    class_interface = """class Foo:
-    __implements__ = 1""" + "\n"
-
-    def testClassInterface(self):
-        # this doesn't do a proper zope interface, but we're really
-        # only concerned about handling of the __implements__ attribute.
-        self.registry.newModule("testclass", self.class_interface)
-        transaction.commit()
-        import testclass
-        obj = testclass.Foo()
-        self.assertEqual(obj.__implements__, 1)
-
-    cross_module_import = "from testclass import Foo"
-
-    def testCrossModuleImport(self):
-        self.registry.newModule("testclass", self.class_with_init)
-        transaction.commit()
-        self.registry.newModule("another", self.cross_module_import)
-        transaction.commit()
-
-    update_in_place1 = """class Foo:
-    def meth(self, arg):
-        return arg * 3""" "\n"
-
-    update_in_place2 = """class Foo:
-    def meth(self, arg):
-        return arg + 3""" "\n"
-
-    def testUpdateInPlace(self):
-        self.registry.newModule("testclass", self.update_in_place1)
-        transaction.commit()
-        import testclass
-        inst = testclass.Foo()
-        self.assertEqual(inst.meth(4), 12)
-
-        Foo2 = self._load_name("testclass.Foo")
-        inst2 = Foo2()
-        self.assertEqual(inst2.meth(4), 12)
-
-        self.registry.updateModule("testclass", self.update_in_place2)
-        transaction.commit()
-        self.assertEqual(inst.meth(4), 7)
-
-        # The old instance's connection hasn't processed the
-        # invalidation yet.
-        self.assertEqual(inst2.meth(4), 12)
-        self.assertEqual(Foo2().meth(4), 12)
-        inst2.__class__._p_jar.sync()
-        self.assertEqual(inst2.meth(4), 7)
-        self.assertEqual(Foo2().meth(4), 7)
-
-    parent1 = """class Foo(object):
-    def meth(self, arg):
-        return arg * 2""" "\n"
-
-    parent2 = """class Foo(object):
-    def meth(self, arg):
-        return arg // 2""" "\n"
-
-    child = """import parent
-
-class Bar(parent.Foo):
-    def meth(self, arg):
-        return super(Bar, self).meth(arg) + 5""" "\n"
-
-    def testInheritanceAcrossModules(self):
-        self.registry.newModule("parent", self.parent1)
-        self.registry.newModule("child", self.child)
-        transaction.commit()
-        import child
-        self.assertEqual(child.Bar().meth(3), 3*2+5)
-        self.registry.updateModule("parent", self.parent2)
-        transaction.commit()
-        self.assertEqual(child.Bar().meth(3), 3//2+5)
-
-        Bar = self._load_name("child.Bar")
-        self.assertEqual(Bar().meth(3), 3//2+5)
-
-    persist = """from persistent import Persistent
-class Foo(Persistent):
-    pass""" "\n"
-
-    def testPersistentSubclass(self):
-        self.registry.newModule("persist", self.persist)
-        transaction.commit()
-        import persist
-        # Verify that the instances are persistent and that the
-        # _p_ namespace is separate.
-        obj = persist.Foo()
-        foo_oid = persist.Foo._p_oid
-        self.assertEqual(obj._p_oid, None)
-        obj._p_oid = 1
-        self.assertEqual(obj._p_oid, 1)
-        self.assertEqual(persist.Foo._p_oid, foo_oid)
-
-    save_persist = """from persist import Foo
-x = Foo()
-"""
-
-    def testSavePersistentSubclass(self):
-        self.registry.newModule("persist", self.persist)
-        transaction.commit()
-        import persist
-        self.registry.newModule("save_persist", self.save_persist)
-        transaction.commit()
-        import save_persist
-
-    def XXXtestUpdateClassAttribute(self):
-        self.registry.newModule("parent", self.parent1)
-        transaction.commit()
-        import parent
-        parent.Foo.attr = 2
-        self.assertEqual(parent.Foo._p_state, CHANGED)
-        transaction.commit()
-        self.assertEqual(parent.Foo._p_state, UPTODATE)
-
-        Foo = self._load_name("parent.Foo")
-        self.assertEqual(Foo.attr, 2)
-
-def test_suite():
-    return unittest.makeSuite(TestClass)

=== removed file 'src/zodbcode/tests/test_module.py'
--- src/zodbcode/tests/test_module.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/tests/test_module.py	1970-01-01 00:00:00 +0000
@@ -1,444 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 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.
-#
-##############################################################################
-import os
-import pickle
-import unittest
-
-from persistent.dict import PersistentDict
-from persistent import UPTODATE
-import transaction
-
-import ZODB.tests.util
-from zodbcode import tests # import this package, to get at __file__ reliably
-from zodbcode.module \
-     import ManagedRegistry, PersistentModuleImporter, PersistentPackage
-
-# snippets of source code used by testModules
-foo_src = """\
-import string
-x = 1
-def f(y):
-    return x + y
-"""
-quux_src = """\
-from foo import x
-def f(y):
-    return x + y
-"""
-side_effect_src = """\
-x = 1
-def inc():
-    global x
-    x += 1
-    return x
-"""
-builtin_src = """\
-x = 1, 2, 3
-def f():
-    return len(x)
-"""
-nested_src = """\
-def f(x):
-    def g(y):
-        def z(z):
-            return x + y + z
-        return x + y
-    return g
-"""
-
-nested_err_src = nested_src + """\
-g = f(3)
-"""
-
-closure_src = """\
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-inc = f(1)
-"""
-
-class TestPersistentModuleImporter(PersistentModuleImporter):
-
-    def __init__(self, registry):
-        self._registry = registry
-        self._registry._p_activate()
-
-    def __import__(self, name, globals={}, locals={}, fromlist=[]):
-        mod = self._import(self._registry, name, self._get_parent(globals),
-                           fromlist)
-        if mod is not None:
-            return mod
-        return self._saved_import(name, globals, locals, fromlist)
-
-class TestBase(unittest.TestCase):
-
-    def setUp(self):
-        self.db = ZODB.tests.util.DB()
-        self.root = self.db.open().root()
-        self.registry = ManagedRegistry()
-        self.importer = TestPersistentModuleImporter(self.registry)
-        self.importer.install()
-        self.root["registry"] = self.registry
-        transaction.commit()
-        _dir, _file = os.path.split(tests.__file__)
-        self._pmtest = os.path.join(_dir, "_pmtest.py")
-
-    def tearDown(self):
-        # just in case
-        transaction.abort()
-        self.db.close()
-        self.importer.uninstall()
-
-    def sameModules(self, registry):
-        m1 = self.registry.modules()
-        m1.sort()
-        m2 = registry.modules()
-        m2.sort()
-        self.assertEqual(m1, m2)
-
-    def useNewConnection(self):
-        # load modules using a separate connection to test that
-        # modules can be recreated from the database
-        cn = self.db.open()
-        reg = cn.root()["registry"]
-        self.sameModules(reg)
-        for name in reg.modules():
-            mod = reg.findModule(name)
-            mod._p_activate()
-            self.assertEqual(mod._p_state, UPTODATE)
-            for obj in mod.__dict__.values():
-                if hasattr(obj, "_p_activate"):
-                    obj._p_activate()
-        # XXX somehow objects are getting registered here, but not
-        # modified.  need to figure out what is going wrong, but for
-        # now just abort the transaction.
-        ##assert not cn._registered
-        transaction.abort()
-        cn.close()
-
-class TestModule(TestBase):
-
-    def testModule(self):
-        self.registry.newModule("pmtest", open(self._pmtest).read())
-        transaction.commit()
-        self.assert_(self.registry.findModule("pmtest"))
-        import pmtest
-        pmtest._p_deactivate()
-        self.assertEqual(pmtest.a, 1)
-        pmtest.f(4)
-        self.useNewConnection()
-
-    def testUpdateFunction(self):
-        self.registry.newModule("pmtest", "def f(x): return x")
-        transaction.commit()
-        import pmtest
-        self.assertEqual(pmtest.f(3), 3)
-        copy = pmtest.f
-        self.registry.updateModule("pmtest", "def f(x): return x + 1")
-        transaction.commit()
-        pmtest._p_deactivate()
-        self.assertEqual(pmtest.f(3), 4)
-        self.assertEqual(copy(3), 4)
-        self.useNewConnection()
-
-    def testUpdateClass(self):
-        self.registry.newModule("pmtest", src)
-        transaction.commit()
-        import pmtest
-        inst = pmtest.Foo()
-        v0 = inst.x
-        v1 = inst.m()
-        v2 = inst.n()
-        self.assertEqual(v1 - 1, v2)
-        self.assertEqual(v0 + 1, v1)
-        self.registry.updateModule("pmtest", src2)
-        transaction.commit()
-        self.assertRaises(AttributeError, getattr, inst, "n")
-        self.useNewConnection()
-
-    def testModules(self):
-        self.registry.newModule("foo", foo_src)
-        # quux has a copy of foo.x
-        self.registry.newModule("quux", quux_src)
-        # bar has a reference to foo
-        self.registry.newModule("bar", "import foo")
-        # baz has reference to f and copy of x,
-        # remember the the global x in f is looked up in foo
-        self.registry.newModule("baz", "from foo import *")
-        import foo, bar, baz, quux
-        self.assert_(foo._p_oid is None)
-        transaction.commit()
-        self.assert_(foo._p_oid)
-        self.assert_(bar._p_oid)
-        self.assert_(baz._p_oid)
-        self.assert_(quux._p_oid)
-        self.assertEqual(foo.f(4), 5)
-        self.assertEqual(bar.foo.f(4), 5)
-        self.assertEqual(baz.f(4), 5)
-        self.assertEqual(quux.f(4), 5)
-        self.assert_(foo.f is bar.foo.f)
-        self.assert_(foo.f is baz.f)
-        foo.x = 42
-        self.assertEqual(quux.f(4), 5)
-        transaction.commit()
-        self.assertEqual(quux.f(4), 5)
-        foo._p_deactivate()
-        # foo is deactivated, which means its dict is empty when f()
-        # is activated, how do we guarantee that foo is also
-        # activated?
-        self.assertEqual(baz.f(4), 46)
-        self.assertEqual(bar.foo.f(4), 46)
-        self.assertEqual(foo.f(4), 46)
-        self.useNewConnection()
-
-    def testFunctionAttrs(self):
-        self.registry.newModule("foo", foo_src)
-        import foo
-        A = foo.f.attr = "attr"
-        self.assertEqual(foo.f.attr, A)
-        transaction.commit()
-        self.assertEqual(foo.f.attr, A)
-        foo.f._p_deactivate()
-        self.assertEqual(foo.f.attr, A)
-        del foo.f.attr
-        self.assertRaises(AttributeError, getattr, foo.f, "attr")
-        foo.f.func_code
-        self.useNewConnection()
-
-    def testFunctionSideEffects(self):
-        self.registry.newModule("effect", side_effect_src)
-        import effect
-        effect.inc()
-        transaction.commit()
-        effect.inc()
-        self.assert_(effect._p_changed)
-        self.useNewConnection()
-
-    def testBuiltins(self):
-        self.registry.newModule("test", builtin_src)
-        transaction.commit()
-        import test
-        self.assertEqual(test.f(), len(test.x))
-        test._p_deactivate()
-        self.assertEqual(test.f(), len(test.x))
-        self.useNewConnection()
-
-    def testNested(self):
-        self.assertRaises(TypeError,
-                          self.registry.newModule, "nested", nested_err_src)
-        self.registry.newModule("nested", nested_src)
-        transaction.commit()
-        import nested
-        g = nested.f(3)
-        self.assertEqual(g(4), 7)
-
-    def testLambda(self):
-        # test a lambda that contains another lambda as a default
-        self.registry.newModule("test",
-                                "f = lambda x, y = lambda: 1: x + y()")
-        transaction.commit()
-        import test
-        self.assertEqual(test.f(1), 2)
-        self.useNewConnection()
-
-    def testClass(self):
-        self.registry.newModule("foo", src)
-        transaction.commit()
-        import foo
-        obj = foo.Foo()
-        obj.m()
-        self.root["m"] = obj
-        transaction.commit()
-        foo._p_deactivate()
-        o = foo.Foo()
-        i = o.m()
-        j = o.m()
-        self.assertEqual(i + 1, j)
-        self.useNewConnection()
-
-    def testPackage(self):
-        self.registry.newModule("A.B.C", "def f(x): return x")
-        transaction.commit()
-
-        import A.B.C
-        self.assert_(isinstance(A, PersistentPackage))
-        self.assertEqual(A.B.C.f("A"), "A")
-
-        self.assertRaises(ValueError, self.registry.newModule,
-                          "A.B", "def f(x): return x + 1")
-
-        self.registry.newModule("A.B.D", "def f(x): return x")
-        transaction.commit()
-
-        from A.B import D
-        self.assert_(hasattr(A.B.D, "f"))
-        self.useNewConnection()
-
-    def testPackageInit(self):
-        self.registry.newModule("A.B.C", "def f(x): return x")
-        transaction.commit()
-
-        import A.B.C
-
-        self.registry.newModule("A.B.__init__", "x = 2")
-        transaction.commit()
-
-        import A.B
-        self.assert_(hasattr(A.B, "C"))
-        self.assertEqual(A.B.x, 2)
-
-        self.assertRaises(ValueError, self.registry.newModule,
-                          "A.__init__.D", "x = 2")
-        self.useNewConnection()
-
-    def testPackageRelativeImport(self):
-        self.registry.newModule("A.B.C", "def f(x): return x")
-        transaction.commit()
-
-        self.registry.newModule("A.Q", "from B.C import f")
-        transaction.commit()
-
-        import A.Q
-        self.assertEqual(A.B.C.f, A.Q.f)
-
-        self.registry.updateModule("A.Q", "import B.C")
-        transaction.commit()
-
-        self.assertEqual(A.B.C.f, A.Q.B.C.f)
-
-        try:
-            import A.B.Q
-        except ImportError:
-            pass
-        self.useNewConnection()
-
-    def testImportAll(self):
-        self.registry.newModule("A.B.C",
-                                """__all__ = ["a", "b"]; a, b, c = 1, 2, 3""")
-        transaction.commit()
-
-        d = {}
-        exec "from A.B.C import *" in d
-        self.assertEqual(d['a'], 1)
-        self.assertEqual(d['b'], 2)
-        self.assertRaises(KeyError, d.__getitem__, "c")
-
-        self.registry.newModule("A.B.D", "from C import *")
-        transaction.commit()
-
-        import A.B.D
-        self.assert_(hasattr(A.B.D, "a"))
-        self.assert_(hasattr(A.B.D, "b"))
-        self.assert_(not hasattr(A.B.D, "c"))
-
-        self.registry.newModule("A.__init__", """__all__ = ["B", "F"]""")
-        transaction.commit()
-
-        self.registry.newModule("A.F", "spam = 1")
-        transaction.commit()
-
-        import A
-        self.assertEqual(A.F.spam, 1)
-        self.useNewConnection()
-
-class TestModuleReload(unittest.TestCase):
-    """Test reloading of modules"""
-
-    def setUp(self):
-        self.db = ZODB.tests.util.DB()
-        self.open()
-        _dir, _file = os.path.split(tests.__file__)
-        self._pmtest = os.path.join(_dir, "_pmtest.py")
-
-    def tearDown(self):
-        transaction.abort()
-        self.close()
-        self.db.close()
-
-    def open(self):
-        # open a new db and importer from the storage
-        self.root = self.db.open().root()
-        self.registry = self.root.get("registry")
-        if self.registry is None:
-            self.root["registry"] = self.registry = ManagedRegistry()
-        self.importer = TestPersistentModuleImporter(self.registry)
-        self.importer.install()
-        transaction.commit()
-
-    def close(self):
-        self.importer.uninstall()
-        self.root._p_jar.close()
-
-    def testModuleReload(self):
-        self.registry.newModule("pmtest", open(self._pmtest).read())
-        transaction.commit()
-        import pmtest
-        pmtest._p_deactivate()
-        self.assertEqual(pmtest.a, 1)
-        pmtest.f(4)
-        self.close()
-        pmtest._p_deactivate()
-        self.open()
-        del pmtest
-        import pmtest
-
-    def testClassReload(self):
-        self.registry.newModule("foo", src)
-        transaction.commit()
-        import foo
-        obj = foo.Foo()
-        obj.m()
-        self.root["d"] = d = PersistentDict()
-        d["m"] = obj
-        transaction.commit()
-        self.close()
-        foo._p_deactivate()
-        self.open()
-        del foo
-        import foo
-
-    def testModulePicklability(self):
-        from zodbcode.tests import test_module
-        s = pickle.dumps(test_module)
-        m = pickle.loads(s)
-        self.assertEqual(m, test_module)
-
-def test_suite():
-    s = unittest.TestSuite()
-    for klass in TestModule, TestModuleReload:
-        s.addTest(unittest.makeSuite(klass))
-    return s
-
-src = """\
-class Foo(object):
-    def __init__(self):
-        self.x = id(self)
-    def m(self):
-        self.x += 1
-        return self.x
-    def n(self):
-        self.x -= 1
-        return self.x
-"""
-
-src2 = """\
-class Foo(object):
-    def __init__(self):
-        self.x = 0
-    def m(self):
-        self.x += 10
-        return self.x
-"""

=== removed file 'src/zodbcode/tests/test_patch.py'
--- src/zodbcode/tests/test_patch.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/tests/test_patch.py	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-##############################################################################
-#
-# 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.
-#
-##############################################################################
-from zodbcode.patch import NameFinder, convert
-from zodbcode.tests import atestmodule
-
-import unittest
-from types import FunctionType as function
-
-class TestNameFinder(unittest.TestCase):
-
-    def testNameFinder(self):
-        nf = NameFinder(atestmodule)
-        names = nf.names()
-        for name in ("Foo", "Bar", "aFunc", "anotherFunc",
-                     "Foo.meth", "Foo.Nested", "Bar.bar",
-                     "Foo.Nested.bar"):
-            self.assert_(name in names)
-        for name in ("aFunc.nestedFunc", "anotherFunc.NotFound"):
-            self.assert_(name not in names)
-
-class TestPatch(unittest.TestCase):
-
-    def setUp(self):
-        self.olddict = atestmodule.__dict__.copy()
-
-    def tearDown(self):
-        atestmodule.__dict__.clear()
-        atestmodule.__dict__.update(self.olddict)
-
-    def testPatch(self):
-        # verify obvious facts of object identity
-        self.assert_(atestmodule.Bar is atestmodule.Sub.__bases__[0])
-        self.assert_(atestmodule.aFunc is atestmodule.foo[0])
-
-        moddict = self.olddict
-        convert(atestmodule, {})
-        newdict = atestmodule.__dict__
-
-        L1 = moddict.keys()
-        L2 = newdict.keys()
-        L1.sort()
-        L2.sort()
-        self.assertEqual(L1, L2)
-
-        self.assertEqual(atestmodule.__dict__, atestmodule.aFunc.func_globals)
-
-        # make sure object identity is maintained by patch
-        Bar = newdict["Bar"]
-        Bar_as_base = newdict["Sub"].__bases__[0]
-        self.assert_(Bar is Bar_as_base)
-
-        self.assert_(newdict["aFunc"] is newdict["foo"][0])
-
-        # The patch should not touch modules, functions, etc. that
-        # are imported from other modules.
-        import ZODB.utils
-        for name in ZODB.utils.__all__:
-            obj = getattr(ZODB.utils, name)
-            if isinstance(obj, type) or isinstance(obj, function):
-                self.assert_(obj is newdict[name])
-
-def test_suite():
-    s = unittest.TestSuite()
-    for c in TestNameFinder, TestPatch:
-        s.addTest(unittest.makeSuite(c))
-    return s

=== removed file 'src/zodbcode/tests/tobeimportedbyatestmodule.py'
--- src/zodbcode/tests/tobeimportedbyatestmodule.py	2009-04-23 15:12:18 +0000
+++ src/zodbcode/tests/tobeimportedbyatestmodule.py	1970-01-01 00:00:00 +0000
@@ -1,22 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2004 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.
-#
-##############################################################################
-"""This module exists soley to e imported by atestmodule
-
-$Id: tobeimportedbyatestmodule.py 25177 2004-06-02 13:17:31Z jim $
-"""
-
-x = 1
-
-class C:
-    pass

=== removed directory 'src/zope/app/basicskin'
=== removed file 'src/zope/app/basicskin/__init__.py'
--- src/zope/app/basicskin/__init__.py	2010-03-01 20:29:16 +0000
+++ src/zope/app/basicskin/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,23 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2006 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.
-#
-##############################################################################
-"""Basic skin
-
-$Id: __init__.py 106669 2009-12-16 22:42:40Z hannosch $
-"""
-__docformat__ = 'restructuredtext'
-from zope.publisher.interfaces.browser import IDefaultBrowserLayer
-
-class IBasicSkin(IDefaultBrowserLayer):
-    """Basic skin that simply only contains the default layer and
-    nothing else"""

=== removed file 'src/zope/app/basicskin/arrowup.gif'
Binary files src/zope/app/basicskin/arrowup.gif	2009-04-23 15:12:18 +0000 and src/zope/app/basicskin/arrowup.gif	1970-01-01 00:00:00 +0000 differ
=== removed file 'src/zope/app/basicskin/configure.zcml'
--- src/zope/app/basicskin/configure.zcml	2009-04-23 15:12:18 +0000
+++ src/zope/app/basicskin/configure.zcml	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-<zope:configure
-   xmlns:zope="http://namespaces.zope.org/zope"
-   xmlns="http://namespaces.zope.org/browser">
-
-  <zope:interface
-      interface=".IBasicSkin"
-      type="zope.publisher.interfaces.browser.IBrowserSkinType"
-      name="Basic"
-      />
-
-  <page
-      name="standard_macros"
-      for="*"
-      class=".standardmacros.StandardMacros"
-      allowed_interface="zope.interface.common.mapping.IItemMapping"
-      permission="zope.Public" />
-
-  <page
-      name="view_macros"
-      for="*"
-      permission="zope.View"
-      template="view_macros.pt" />
-
-  <page
-      name="dialog_macros"
-      for="*"
-      permission="zope.View"
-      template="dialog_macros.pt" />
-
-  <resource
-      name="zopetopBasic.css"
-      file="zopetopbasic.css" />
-
-  <resource
-      name="zopetopWidgets.css"
-      file="zopetopwidgets.css" />
-
-  <resource
-      name="zopetopStructure.css"
-      file="zopetopstructure.css" />
-
-  <resource name="arrowUp.gif" file="arrowup.gif"/>
-
-</zope:configure>

=== removed file 'src/zope/app/basicskin/dialog_macros.pt'
--- src/zope/app/basicskin/dialog_macros.pt	2009-04-23 15:12:18 +0000
+++ src/zope/app/basicskin/dialog_macros.pt	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html metal:define-macro="dialog" i18n:domain="zope">
-<head metal:use-macro="context/@@standard_macros/head" />
-
-<body>
-  <span metal:use-macro="context/@@standard_macros/breadcrumbs" />
-
-  <div metal:define-slot="body">
-     <p>Body here</p>
-  </div>
-
-  <div metal:use-macro="context/@@standard_macros/footer" />
-</body>
-</html>
-

=== removed file 'src/zope/app/basicskin/document_icon.gif'
Binary files src/zope/app/basicskin/document_icon.gif	2009-04-23 15:12:18 +0000 and src/zope/app/basicskin/document_icon.gif	1970-01-01 00:00:00 +0000 differ
=== removed file 'src/zope/app/basicskin/folder_icon.gif'
Binary files src/zope/app/basicskin/folder_icon.gif	2009-04-23 15:12:18 +0000 and src/zope/app/basicskin/folder_icon.gif	1970-01-01 00:00:00 +0000 differ
=== removed file 'src/zope/app/basicskin/standardmacros.py'
--- src/zope/app/basicskin/standardmacros.py	2009-04-23 15:12:18 +0000
+++ src/zope/app/basicskin/standardmacros.py	1970-01-01 00:00:00 +0000
@@ -1,51 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 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.
-#
-##############################################################################
-"""Standard macros for page templates in the ZMI
-
-The macros are drawn from various different page templates.
-
-$Id: standardmacros.py 67630 2006-04-27 00:54:03Z jim $
-"""
-__docformat__ = 'restructuredtext'
-import zope.interface
-
-from zope.component import getMultiAdapter
-from zope.publisher.browser import BrowserView
-
-class Macros(object):
-    zope.interface.implements(zope.interface.common.mapping.IItemMapping)
-
-    macro_pages = ()    
-    aliases = {
-        'view': 'page',
-        'dialog': 'page',
-        'addingdialog': 'page'
-        }
-
-    def __getitem__(self, key):
-        key = self.aliases.get(key, key)
-        context = self.context
-        request = self.request
-        for name in self.macro_pages:
-            page = getMultiAdapter((context, request), name=name)
-            try:
-                v = page[key]
-            except KeyError:
-                pass
-            else:
-                return v
-        raise KeyError(key)
-
-class StandardMacros(BrowserView, Macros):
-    macro_pages = ('view_macros', 'dialog_macros')

=== removed directory 'src/zope/app/basicskin/tests'
=== removed file 'src/zope/app/basicskin/tests/__init__.py'
--- src/zope/app/basicskin/tests/__init__.py	2009-04-23 15:12:18 +0000
+++ src/zope/app/basicskin/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-#
-# This file is necessary to make this directory a package.

=== removed file 'src/zope/app/basicskin/tests/test.gif'
Binary files src/zope/app/basicskin/tests/test.gif	2009-04-23 15:12:18 +0000 and src/zope/app/basicskin/tests/test.gif	1970-01-01 00:00:00 +0000 differ
=== removed file 'src/zope/app/basicskin/tests/test_standardmacros.py'
--- src/zope/app/basicskin/tests/test_standardmacros.py	2010-03-01 20:29:16 +0000
+++ src/zope/app/basicskin/tests/test_standardmacros.py	1970-01-01 00:00:00 +0000
@@ -1,120 +0,0 @@
-##############################################################################
-#
-# 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.
-#
-##############################################################################
-"""Basic skin standard macros
-
-$Id: test_standardmacros.py 106671 2009-12-16 22:56:40Z hannosch $
-"""
-import unittest
-
-from zope.component import getGlobalSiteManager
-from zope.component.testing import PlacelessSetup
-from zope.interface import implements, Interface
-from zope.publisher.browser import TestRequest
-from zope.publisher.interfaces.browser import IBrowserView
-from zope.publisher.interfaces.browser import IDefaultBrowserLayer
-
-from zope.app.basicskin.standardmacros import Macros
-
-
-class ViewWithMacros(object):
-    implements(IBrowserView)
-
-    def __init__(self, context, request):
-        self.context = context
-        self.request = request
-
-    def __call__(self):
-        pass
-
-    def __getitem__(self, key):
-        return self.pages[key]
-
-    pages = {}
-
-class I(Interface): pass
-
-class C(object):
-    implements(I)
-
-class page1(ViewWithMacros):
-    pages = {'foo':'page1_foo',
-             'bar':'page1_bar'}
-
-class collides_with_page1(ViewWithMacros):
-    pages = {'foo':'collides_with_page1_foo',
-             'baz':'collides_with_page1_baz'}
-
-class works_with_page1(ViewWithMacros):
-    pages = {'fish':'works_with_page1_fish',
-             'tree':'works_with_page1_tree'}
-
-def createMacrosInstance(pages):
-
-    class T(Macros):
-        aliases = {'afoo': 'foo', 'abar': 'bar'}
-
-        def __init__(self, context, request):
-            self.context = context
-            self.request = request
-        macro_pages = pages
-    return T(C(), TestRequest())
-
-
-def browserView(for_, name, factory):
-    gsm = getGlobalSiteManager()
-    for_ = (for_, ) + (IDefaultBrowserLayer,)
-    gsm.registerAdapter(factory, for_, Interface, name, event=False)
-
-
-class Test(PlacelessSetup, unittest.TestCase):
-
-    def setUp(self):
-        PlacelessSetup.setUp(self)
-        browserView(I, 'page1', page1)
-        browserView(I, 'collides_with_page1', collides_with_page1)
-        browserView(I, 'works_with_page1',  works_with_page1)
-
-    def testSinglePage(self):
-        macros = createMacrosInstance(('page1',))
-        self.assertEqual(macros['foo'], 'page1_foo')
-        self.assertEqual(macros['bar'], 'page1_bar')
-        self.assertRaises(KeyError, macros.__getitem__, 'fish')
-
-    def testConcordentPages(self):
-        macros = createMacrosInstance(('page1', 'works_with_page1'))
-        self.assertEqual(macros['foo'], 'page1_foo')
-        self.assertEqual(macros['bar'], 'page1_bar')
-        self.assertEqual(macros['fish'], 'works_with_page1_fish')
-        self.assertEqual(macros['tree'], 'works_with_page1_tree')
-        self.assertRaises(KeyError, macros.__getitem__, 'pants')
-
-    def testConflictingPages(self):
-        macros = createMacrosInstance(('page1', 'collides_with_page1'))
-        self.assertEqual(macros['foo'], 'page1_foo')
-        self.assertEqual(macros['bar'], 'page1_bar')
-        self.assertEqual(macros['baz'], 'collides_with_page1_baz')
-        self.assertRaises(KeyError, macros.__getitem__, 'pants')
-
-    def testMacroAliases(self):
-        macros = createMacrosInstance(('page1', 'collides_with_page1'))
-        self.assertEqual(macros['afoo'], 'page1_foo')
-        self.assertEqual(macros['abar'], 'page1_bar')
-
-
-def test_suite():
-    loader = unittest.TestLoader()
-    return loader.loadTestsFromTestCase(Test)
-
-if __name__=='__main__':
-    unittest.TextTestRunner().run(test_suite())

=== removed file 'src/zope/app/basicskin/view_macros.pt'
--- src/zope/app/basicskin/view_macros.pt	2009-04-23 15:12:18 +0000
+++ src/zope/app/basicskin/view_macros.pt	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html metal:define-macro="page" i18n:domain="zope">
-<head metal:define-macro="head">
-  <title
-    metal:define-slot="title"
-    tal:content="options/getTitle|view/getTitle|context/getTitle|default"
-    >Zope</title>
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-  <link href="/@@/zopetopBasic.css" rel="stylesheet" type="text/css"
-        tal:attributes="href string:/@@/zopetopBasic.css" />
-  <link href="/@@/zopetopWidgets.css" rel="stylesheet" type="text/css"
-        tal:attributes="href string:/@@/zopetopWidgets.css" />
-  <link href="/@@/zopetopStructure.css" rel="stylesheet" type="text/css"
-        tal:attributes="href string:/@@/zopetopStructure.css" />
-  <div metal:define-slot="headers">
-  </div>
-</head>
-<body>
-
-  <table metal:define-macro="zmi_tabs"><tr>
-    <td tal:repeat="view context/@@view_get_menu/zmi_views">
-    <a href="" tal:attributes="href view/action"
-               tal:content="view/title"
-               i18n:translate="">
-        label</a>
-    <tal:block condition="not: repeat/view/end">'</tal:block>
-    </td>
-   </tr></table>
-
-  <div metal:define-slot="body">
-     <p>Body here</p>
-  </div>
-
-  <div metal:define-macro="logged_user">
-  <p i18n:translate="">User:
-    <span tal:replace="request/principal/title"
-          i18n:name="user_title">User</span>
-  </p>
-  </div>
-
-  <div metal:define-macro="footer">
-  <p i18n:translate="">Powered by Zope</p>
-  </div>
-
-</body>
-</html>
-

=== removed file 'src/zope/app/basicskin/zmi_stylesheet.css'
--- src/zope/app/basicskin/zmi_stylesheet.css	2009-04-23 15:12:18 +0000
+++ src/zope/app/basicskin/zmi_stylesheet.css	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-body {
-    font-family: sans-serif;
-    color: Black;
-    background-color: White;
-}
-
-h1 {
-    font-size: x-large;
-    font-weight: bold;
-}
-
-h2 {
-    font-size: large;
-    font-weight: bold;
-}
-
-h3 {
-    font-size: large;
-    font-weight: bold;
-    font-style: italic;
-}
-
-h4 {
-    font-weight: bold;
-    font-style: italic;
-}
-
-h5 {
-    font-size: small;
-    font-weight: bold;
-}
-
-h6 {
-    font-size: small;
-    font-weight: bold;
-    font-style: italic;
-}
-
-img {
-    border: none;
-}
-
-caption {
-    font-weight: bold;
-}

=== removed file 'src/zope/app/basicskin/zopetopbasic.css'
--- src/zope/app/basicskin/zopetopbasic.css	2009-04-23 15:12:18 +0000
+++ src/zope/app/basicskin/zopetopbasic.css	1970-01-01 00:00:00 +0000
@@ -1,183 +0,0 @@
-/*****************************************************************************
- *
- * Copyright (c) 2001, 2002 Zope Corporation and Contributors.
- * All Rights Reserved.
- *