This file is indexed.

/usr/share/pyshared/zope.container-3.12.0.egg-info/PKG-INFO is in python-zope.container 3.12.0-0ubuntu2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
Metadata-Version: 1.1
Name: zope.container
Version: 3.12.0
Summary: Zope Container
Home-page: http://pypi.python.org/pypi/zope.container
Author: Zope Foundation 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
        
        The constraints prevent us from moving a container beneath itself (either into
        itself or another folder beneath it):
        
            >>> container = Container()
            >>> checkObject(container, 'x', container)
            Traceback (most recent call last):
            TypeError: Cannot add an object to itself or its children.
        
            >>> import zope.location.interfaces
            >>> import zope.interface
            >>> subcontainer = Container()
            >>> zope.interface.directlyProvides(subcontainer,
            ...     zope.location.interfaces.ILocation)
            >>> subcontainer.__parent__ = container
            >>> checkObject(subcontainer, 'x', container)
            Traceback (most recent call last):
            TypeError: Cannot add an object to itself or its children.
        
        
        =======
        CHANGES
        =======
        
        3.12.0 (2010-12-14)
        -------------------
        
        - Fix detection of moving folders into itself or a subfolder of itself.
          (#118088)
        
        - Fixed ZCML-related tests and dependencies.
        
        - Added ``zcml`` extra dependencies.
        
        3.11.1 (2010-04-30)
        -------------------
        
        - Prefer the standard libraries doctest module to the one from zope.testing.
        
        - Added compatibility with ZODB3 3.10 by importing the IBroken interface from
          it directly. Once we can rely on the new ZODB3 version exclusively, we can
          remove the dependency onto the zope.broken distribution.
        
        - Never fail if the suggested name is in a wrong type (#227617)
        
        - ``checkName`` first checks the parameter type before the emptiness.
        
        3.11.0 (2009-12-31)
        -------------------
        
        - Copy two trivial classes from zope.cachedescriptors into this package, which
          allows us to remove that dependency. We didn't actually use any caching
          properties as the dependency suggested.
        
        3.10.1 (2009-12-29)
        -------------------
        
        - Moved zope.copypastemove related tests into that package.
        
        - Removed no longer used zcml prefix from the configure file.
        
        - Stop importing DocTestSuite from zope.testing.doctestunit. Fixes
          compatibility problems with zope.testing 3.8.4.
        
        3.10.0 (2009-12-15)
        -------------------
        
        - Break testing dependency on zope.app.testing.
        
        - Break testing dependency on zope.app.dependable by moving the code and tests
          into that package.
        
        - Import ISite from zope.component after it was moved there from
          zope.location.
        
        3.9.1 (2009-10-18)
        ------------------
        
        - Rerelease 3.9.0 as it had a broken Windows 2.6 egg.
        
        - Marked as part of the ZTK.
        
        3.9.0 (2009-08-28)
        ------------------
        
        - Previous releases should be versioned 3.9.0 as they are not pure bugfix
          releases and worth a "feature" release, increasing feature version.
          
          Packages that depend on any changes introduced in version 3.8.2 or 3.8.3
          should depend on version 3.9 or greater.
        
        3.8.3 (2009-08-27)
        ------------------
        
        - Move IXMLRPCPublisher ZCML registrations for containers from
          zope.app.publisher.xmlrpc to zope.container for now.
        
        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: zope 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