Metadata-Version: 1.0
Name: zope.container
Version: 3.8.2
Summary: Zope Container
Home-page: http://pypi.python.org/pypi/zope.container
Author: Zope Corporation and Contributors
Author-email: zope-dev@zope.org
License: ZPL 2.1
Description: This package define interfaces of container components, and provides
        container implementations such as a BTreeContainer and
        OrderedContainer, as well as the base class used by ``zope.site.folder``
        for the Folder implementation.
        
        
        .. contents::
        
        
        =========================
        Containment constraints
        =========================
        
        Containment constraints allow us to express restrictions on the types
        of items that can be placed in containers or on the types of
        containers an item can be placed in.  We express these constraints in
        interfaces.  Let's define some container and item interfaces:
        
        >>> from zope.container.interfaces import IContainer
        >>> from zope.location.interfaces import IContained
        >>> from zope.container.constraints import containers, contains
        
        >>> class IBuddyFolder(IContainer):
        ...     contains('.IBuddy')
        
        
        In this example, we used the contains function to declare that objects
        that provide IBuddyFolder can only contain items that provide IBuddy.
        Note that we used a string containing a dotted name for the IBuddy
        interface. This is because IBuddy hasn't been defined yet.  When we
        define IBuddy, we can use IBuddyFolder directly:
        
        >>> class IBuddy(IContained):
        ...     containers(IBuddyFolder)
        
        
        Now, with these interfaces in place, we can define Buddy and
        BuddyFolder classes and verify that we can put buddies in buddy
        folders:
        
        >>> from zope import interface
        
        >>> class Buddy:
        ...     interface.implements(IBuddy)
        
        >>> class BuddyFolder:
        ...     interface.implements(IBuddyFolder)
        
        >>> from zope.container.constraints import checkObject, checkFactory
        >>> from zope.component.factory import Factory
        
        >>> checkObject(BuddyFolder(), 'x', Buddy())
        >>> checkFactory(BuddyFolder(), 'x', Factory(Buddy))
        True
        
        If we try to use other containers or folders, we'll get errors:
        
        >>> class Container:
        ...     interface.implements(IContainer)
        
        >>> class Contained:
        ...     interface.implements(IContained)
        
        >>> checkObject(Container(), 'x', Buddy())
        ... # doctest: +ELLIPSIS
        Traceback (most recent call last):
        InvalidContainerType: ...
        
        >>> checkFactory(Container(), 'x', Factory(Buddy))
        False
        
        >>> checkObject(BuddyFolder(), 'x', Contained())
        ... # doctest: +ELLIPSIS
        Traceback (most recent call last):
        InvalidItemType: ...
        
        >>> checkFactory(BuddyFolder(), 'x', Factory(Contained))
        False
        
        In the example, we defined the container first and then the items.  We
        could have defined these in the opposite order:
        
        >>> class IContact(IContained):
        ...     containers('.IContacts')
        
        >>> class IContacts(IContainer):
        ...     contains(IContact)
        
        >>> class Contact:
        ...     interface.implements(IContact)
        
        >>> class Contacts:
        ...     interface.implements(IContacts)
        
        >>> checkObject(Contacts(), 'x', Contact())
        
        >>> checkFactory(Contacts(), 'x', Factory(Contact))
        True
        
        >>> checkObject(Contacts(), 'x', Buddy())
        ... # doctest: +ELLIPSIS
        Traceback (most recent call last):
        InvalidItemType: ...
        
        >>> checkFactory(Contacts(), 'x', Factory(Buddy))
        False
        
        
        
        
        =======
        CHANGES
        =======
        
        3.8.2 (2009-05-17)
        ------------------
        
        - Rid ourselves of ``IContained`` interface.  This interface was moved
        to ``zope.location.interfaces``.  A b/w compat import still exists
        to keep old code running.  Depend on ``zope.location``>=3.5.4.
        
        - Rid ourselves of the implementations of ``IObjectMovedEvent``,
        ``IObjectAddedEvent``, ``IObjectRemovedEvent`` interfaces and
        ``ObjectMovedEvent``, ``ObjectAddedEvent`` and
        ``ObjectRemovedEvent`` classes.  B/w compat imports still exist.
        All of these were moved to ``zope.lifecycleevent``. Depend on
        ``zope.lifecycleevent``>=3.5.2.
        
        - Fix a bug in OrderedContainer where trying to set the value for a
        key that already exists (duplication error) would actually delete the
        key from the order, leaving a dangling reference.
        
        - Partially break dependency on ``zope.traversing`` by disusing
        zope.traversing.api.getPath in favor of using
        ILocationInfo(object).getPath().  The rest of the runtime
        dependencies on zope.traversing are currently interface
        dependencies.
        
        - Break runtime dependency on ``zope.app.dependable`` by using a zcml
        condition on the qsubscriber ZCML directive that registers the
        CheckDependency handler for IObjectRemovedEvent.  If
        ``zope.app.dependable`` is not installed, this subscriber will never
        be registered.  ``zope.app.dependable`` is now a testing dependency
        only.
        
        3.8.1 (2009-04-03)
        ------------------
        
        - Fixed misspackaged 3.8.0
        
        
        3.8.0 (2009-04-03)
        ------------------
        
        - Change configure.zcml to not depend on zope.app.component.
        Fixes: https://bugs.launchpad.net/bugs/348329
        
        - Moved the declaration of ``IOrderedContainer.updateOrder``  to a new, basic
        ``IOrdered`` interface and let ``IOrderedContainer`` inherit it. This allows
        easier reuse of the declaration.
        
        3.7.2 (2009-03-12)
        ------------------
        
        - Fix: added missing ComponentLookupError, missing since revision 95429 and
        missing in last release.
        
        - Adapt to the move of IDefaultViewName from zope.component.interfaces
        to zope.publisher.interfaces.
        
        - Add support for reserved names for containers. To specify reserved
        names for some container, you need to provide an adapter from the
        container to the ``zope.container.interfaces.IReservedNames`` interface.
        The default NameChooser is now also aware of reserved names.
        
        3.7.1 (2009-02-05)
        ------------------
        
        - Raise more "Pythonic" errors from ``__setitem__``, losing the dependency
        on ``zope.exceptions``:
        
        o ``zope.exceptions.DuplicationError`` -> ``KeyError``
        
        o ``zope.exceptions.UserError`` -> ``ValueError``
        
        - Moved import of ``IBroken`` interface to use new ``zope.broken``
        package, which has no dependencies beyond ``zope.interface``.
        
        - Made ``test`` part pull in the extra test requirements of this package.
        
        - Split the ``z3c.recipe.compattest`` configuration out into a new file,
        ``compat.cfg``, to reduce the burden of doing standard unit tests.
        
        - Stripped out bogus develop eggs from ``buildout.cfg``.
        
        3.7.0 (2009-01-31)
        ------------------
        
        - Split this package off ``zope.app.container``. This package is
        intended to have far less dependencies than ``zope.app.container``.
        
        - This package also contains the container implementation that
        used to be in ``zope.app.folder``.
        
Keywords: zope3 container
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Zope Public License
Classifier: Programming Language :: Python
Classifier: Natural Language :: English
Classifier: Operating System :: OS Independent
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: Framework :: Zope3
