File: //usr/lib/python3/dist-packages/zope/interface/__pycache__/interfaces.cpython-38.pyc
U
$
x`7� � @ s0 d Z dZddlmZ ddlmZ ddlmZ dddd d
d d d
ddddddddddddgZG dd
� d
e�ZG dd� de�Z G d d� de �Z
G d d� de�Z G d d� de e�Z G d d � d e �Z
G d d� de�ZG d!d� de�ZG d"d#� d#e�ZG d$d%� d%e�ZG d&d� de�Zee�G d'd(� d(e��ZG d)d � d e�ZG d*d� de�ZG d+d� de�ZG d,d-� d-e�ZG d.d� de�ZG d/d� de�Z G d0d� de�Z G d1d� de�Z ee �G d2d3� d3e��Z G d4d� de �Z ee �G d5d6� d6e ��Z!G d7d� de �Z"ee"�G d8d9� d9e ��Z#G d:d
� d
e�Z$G d;d � d ee$�Z%d<S )=z Interface Package Interfaces
�restructuredtext� )� Attribute)� Interface)� implementer�IAdapterRegistration�IAdapterRegistry�
IAttribute�IComponentLookup�IComponentRegistry� IComponents� IDeclaration�IElement�IHandlerRegistration�
IInterface�IInterfaceDeclaration�IMethod� IObjectEvent� IRegistered�
IRegistration�IRegistrationEvent�ISpecification� ISubscriptionAdapterRegistration�
IUnregistered�IUtilityRegistrationc @ s` e Zd ZdZedd�Z edd�Zdd� Zdd d
�Zd d � Zd
d� Zdd� Z ddd�Z
dd� Z dS )r
a�
Objects that have basic documentation and tagged values.
Known derivatives include :class:`IAttribute` and its derivative
:class:`IMethod`; these have no notion of inheritance.
:class:`IInterface` is also a derivative, and it does have a
notion of inheritance, expressed through its ``__bases__`` and
ordered in its ``__iro__`` (both defined by
:class:`ISpecification`).
�__name__zThe object name�__doc__zThe object doc stringc C s dS )a� Returns the value associated with *tag*.
Raise a `KeyError` if the tag isn't set.
If the object has a notion of inheritance, this searches
through the inheritance hierarchy and returns the nearest result.
If there is no such notion, this looks only at this object.
.. versionchanged:: 4.7.0
This method should respect inheritance if present.
N� ��tagr r �;/usr/lib/python3/dist-packages/zope/interface/interfaces.py�getTaggedValueR s zIElement.getTaggedValueNc C s dS )z�
As for `getTaggedValue`, but instead of raising a `KeyError`, returns *default*.
.. versionchanged:: 4.7.0
This method should respect inheritance if present.
Nr �r �defaultr r r �queryTaggedValue_ s zIElement.queryTaggedValuec C s dS )aZ
Returns a collection of all tags in no particular order.
If the object has a notion of inheritance, this
includes all the inherited tagged values. If there is
no such notion, this looks only at this object.
.. versionchanged:: 4.7.0
This method should respect inheritance if present.
Nr r r r r �getTaggedValueTagsh s zIElement.getTaggedValueTagsc C s dS )zH
Associates *value* with *key* directly in this object.
Nr )r �valuer r r �setTaggedValuet s zIElement.setTaggedValuec C s dS )zk
As for `getTaggedValue`, but never includes inheritance.
.. versionadded:: 5.0.0
Nr r r r r �getDirectTaggedValuey s z IElement.getDirectTaggedValuec C s dS )zm
As for `queryTaggedValue`, but never includes inheritance.
.. versionadded:: 5.0.0
Nr r! r r r �queryDirectTaggedValue� s z IElement.queryDirectTaggedValuec C s dS )z�
As for `getTaggedValueTags`, but includes only tags directly
set on this object.
.. versionadded:: 5.0.0
Nr r r r r �getDirectTaggedValueTags� s z!IElement.getDirectTaggedValueTags)N)N) r �
__module__� __qualname__r r r r# r$ r& r' r( r) r r r r r
1 s
c @ s e Zd ZdZedd�ZdS )r zAttribute descriptors� interfacez@Stores the interface instance in which the attribute is located.N)r r* r+ r r r, r r r r r � s �c @ s e Zd ZdZdd� Zdd� ZdS )r zMethod attributesc C s dS )a Returns the signature information.
This method returns a dictionary with the following string keys:
- positional
A sequence of the names of positional arguments.
- required
A sequence of the names of required arguments.
- optional
A dictionary mapping argument names to their default values.
- varargs
The name of the varargs argument (or None).
- kwargs
The name of the kwargs argument (or None).
Nr r r r r �getSignatureInfo� s zIMethod.getSignatureInfoc C s dS )a Return a signature string suitable for inclusion in documentation.
This method returns the function signature string. For example, if you
have ``def func(a, b, c=1, d='f')``, then the signature string is ``"(a, b,
c=1, d='f')"``.
Nr r r r r �getSignatureString� s zIMethod.getSignatureStringN)r r* r+ r r- r. r r r r r � s c @ s^ e Zd ZdZdd� Zdd� Zdd� Zdd d
�Zdd d
�Ze d�Z
e d�Z e d�Z ddd�Z
d S )r z Object Behavioral specificationsc C s dS )z�Test whether the interface is implemented by the object
Return true of the object asserts that it implements the
interface, including asserting that it implements an extended
interface.
Nr ��objectr r r �
providedBy� s zISpecification.providedByc C s dS )z�Test whether the interface is implemented by instances of the class
Return true of the class asserts that its instances implement the
interface, including asserting that they implement an extended
interface.
Nr ��class_r r r �
implementedBy� s z ISpecification.implementedByc C s dS )z=Test whether the specification is or extends another
Nr )�otherr r r � isOrExtends� s zISpecification.isOrExtendsTc C s dS )z�Test whether a specification extends another
The specification extends other if it has other as a base
interface or if one of it's bases extends other.
If strict is false, then the specification extends itself.
Nr )r5 �strictr r r �extends� s zISpecification.extendsNc C s dS )a/ Return a weakref to the specification
This method is, regrettably, needed to allow weakrefs to be
computed to security-proxied specifications. While the
zope.interface package does not require zope.security or
zope.proxy, it has to be able to coexist with it.
Nr )�callbackr r r �weakref� s zISpecification.weakrefzoBase specifications
A tuple of specifications from which this specification is
directly derived.
a Specification-resolution order
A tuple of the specification and all of it's ancestor
specifications from most specific to least specific. The specification
itself is the first element.
(This is similar to the method-resolution order for new-style classes.)
a Interface-resolution order
A tuple of the specification's ancestor interfaces from
most specific to least specific. The specification itself is
included if it is an interface.
(This is similar to the method-resolution order for new-style classes.)
c C s dS )z|Look up the description for a name
If the named attribute is not defined, the default is
returned.
Nr )�namer" r r r �get� s zISpecification.get)T)N)N)r r* r+ r r1 r4 r6 r8 r: r � __bases__�__sro__�__iro__r< r r r r r � s
c @ sV e Zd ZdZddd�Zddd�Zdd� Zd d
� Zdd d
�Zdd� Z dd� Z
e d�Zd S )r a4 Interface objects
Interface objects describe the behavior of an object by containing
useful information about the object. This information includes:
- Prose documentation about the object. In Python terms, this
is called the "doc string" of the interface. In this element,
you describe how the object works in prose language and any
other useful information about the object.
- Descriptions of attributes. Attribute descriptions include
the name of the attribute and prose documentation describing
the attributes usage.
- Descriptions of methods. Method descriptions can include:
- Prose "doc string" documentation about the method and its
usage.
- A description of the methods arguments; how many arguments
are expected, optional arguments and their default values,
the position or arguments in the signature, whether the
method accepts arbitrary arguments and whether the method
accepts arbitrary keyword arguments.
- Optional tagged data. Interface objects (and their attributes and
methods) can have optional, application specific tagged data
associated with them. Examples uses for this are examples,
security assertions, pre/post conditions, and other possible
information you may want to associate with an Interface or its
attributes.
Not all of this information is mandatory. For example, you may
only want the methods of your interface to have prose
documentation and not describe the arguments of the method in
exact detail. Interface objects are flexible and let you give or
take any of these components.
Interfaces are created with the Python class statement using
either `zope.interface.Interface` or another interface, as in::
from zope.interface import Interface
class IMyInterface(Interface):
'''Interface documentation'''
def meth(arg1, arg2):
'''Documentation for meth'''
# Note that there is no self argument
class IMySubInterface(IMyInterface):
'''Interface documentation'''
def meth2():
'''Documentation for meth2'''
You use interfaces in two ways:
- You assert that your object implement the interfaces.
There are several ways that you can declare that an object
provides an interface:
1. Call `zope.interface.implementer` on your class definition.
2. Call `zope.interface.directlyProvides` on your object.
3. Call `zope.interface.classImplements` to declare that instances
of a class implement an interface.
For example::
from zope.interface import classImplements
classImplements(some_class, some_interface)
This approach is useful when it is not an option to modify
the class source. Note that this doesn't affect what the
class itself implements, but only what its instances
implement.
- You query interface meta-data. See the IInterface methods and
attributes for details.
Fc C s dS )ag Get the interface attribute names
Return a collection of the names of the attributes, including
methods, included in the interface definition.
Normally, only directly defined attributes are included. If
a true positional or keyword argument is given, then
attributes defined by base classes will be included.
Nr ��allr r r �namesW s zIInterface.namesc C s dS )a� Get the interface attribute names and descriptions
Return a collection of the names and descriptions of the
attributes, including methods, as name-value pairs, included
in the interface definition.
Normally, only directly defined attributes are included. If
a true positional or keyword argument is given, then
attributes defined by base classes will be included.
Nr r@ r r r �namesAndDescriptionsb s z IInterface.namesAndDescriptionsc C s dS )zoGet the description for a name
If the named attribute is not defined, a `KeyError` is raised.
Nr �r; r r r � __getitem__n s zIInterface.__getitem__c C s dS )z�Get the description for the name if it was defined by the interface
If the interface doesn't define the name, returns None.
Nr rD r r r �directt s zIInterface.directNc C s dS )a
Validate invariants
Validate object to defined invariants. If errors is None,
raises first Invalid error; if errors is a list, appends all errors
to list, then raises Invalid with the errors as the first element
of the "args" tuple.Nr )�obj�errorsr r r �validateInvariantsz s z IInterface.validateInvariantsc C s dS )z1Test whether the name is defined by the interfaceNr rD r r r � __contains__� s zIInterface.__contains__c C s dS )z�Return an iterator over the names defined by the interface
The names iterated include all of the names defined by the
interface directly and indirectly by base interfaces.
Nr r r r r �__iter__� s zIInterface.__iter__z-The name of the module defining the interface)F)F)N) r r* r+ r rB rC rE rF rI rJ rK r r r r r r � s W
c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dS )r z�Interface declaration
Declarations are used to express the interfaces implemented by
classes or provided by objects.
c C s dS )z�Test whether an interface is in the specification
Return true if the given interface is one of the interfaces in
the specification and false otherwise.
Nr �r, r r r rJ � s zIDeclaration.__contains__c C s dS )zCReturn an iterator for the interfaces in the specification
Nr r r r r rK � s zIDeclaration.__iter__c C s dS )a Return an iterator of all included and extended interfaces
An iterator is returned for all interfaces either included in
or extended by interfaces included in the specifications
without duplicates. The interfaces are in "interface
resolution order". The interface resolution order is such that
base interfaces are listed after interfaces that extend them
and, otherwise, interfaces are included in the order that they
were defined in the specification.
Nr r r r r � flattened� s zIDeclaration.flattenedc C s dS )a� Create an interface specification with some interfaces excluded
The argument can be an interface or an interface
specifications. The interface or interfaces given in a
specification are subtracted from the interface specification.
Removing an interface that is not in the specification does
not raise an error. Doing so has no effect.
Removing an interface also removes sub-interfaces of the interface.
Nr ��
interfacesr r r �__sub__� s zIDeclaration.__sub__c C s dS )az Create an interface specification with some interfaces added
The argument can be an interface or an interface
specifications. The interface or interfaces given in a
specification are added to the interface specification.
Adding an interface that is already in the specification does
not raise an error. Doing so has no effect.
Nr rN r r r �__add__� s zIDeclaration.__add__c C s dS )zHReturn a true value of the interface specification is non-empty
Nr r r r r � __nonzero__� s zIDeclaration.__nonzero__N)
r r* r+ r rJ rK rM rP rQ rR r r r r r � s c @ s� e Zd ZdZed�Zdd� Zdd� Zdd� Zd d
� Z d d � Z
d
d� Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+S ),r a�
Declare and check the interfaces of objects.
The functions defined in this interface are used to declare the
interfaces that objects provide and to query the interfaces that
have been declared.
Interfaces can be declared for objects in two ways:
- Interfaces are declared for instances of the object's class
- Interfaces are declared for the object directly.
The interfaces declared for an object are, therefore, the union of
interfaces declared for the object directly and the interfaces
declared for instances of the object's class.
Note that we say that a class implements the interfaces provided
by it's instances. An instance can also provide interfaces
directly. The interfaces provided by an object are the union of
the interfaces provided directly and the interfaces implemented by
the class.
This interface is implemented by :mod:`zope.interface`.
z,The base class used to create new interfacesc C s dS )aZ
Attach a tagged value to an interface while defining the interface.
This is a way of executing :meth:`IElement.setTaggedValue` from
the definition of the interface. For example::
class IFoo(Interface):
taggedValue('key', 'value')
.. seealso:: `zope.interface.taggedValue`
Nr )�keyr% r r r � taggedValue� s z!IInterfaceDeclaration.taggedValuec C s dS )ao
Attach an invariant checker function to an interface while defining it.
Invariants can later be validated against particular implementations by
calling :meth:`IInterface.validateInvariants`.
For example::
def check_range(ob):
if ob.max < ob.min:
raise ValueError("max value is less than min value")
class IRange(Interface):
min = Attribute("The min value")
max = Attribute("The max value")
invariant(check_range)
.. seealso:: `zope.interface.invariant`
Nr )Zchecker_functionr r r � invariant� s z IInterfaceDeclaration.invariantc C s dS )an
A decorator that transforms a method specification into an
implementation method.
This is used to override methods of ``Interface`` or provide new methods.
Definitions using this decorator will not appear in :meth:`IInterface.names()`.
It is possible to have an implementation method and a method specification
of the same name.
For example::
class IRange(Interface):
@interfacemethod
def __adapt__(self, obj):
if isinstance(obj, range):
# Return the builtin ``range`` as-is
return obj
return super(type(IRange), self).__adapt__(obj)
You can use ``super`` to call the parent class functionality. Note that
the zero-argument version (``super().__adapt__``) works on Python 3.6 and above, but
prior to that the two-argument version must be used, and the class must be explicitly
passed as the first argument.
.. versionadded:: 5.1.0
.. seealso:: `zope.interface.interfacemethod`
Nr )�methodr r r �interfacemethod s z%IInterfaceDeclaration.interfacemethodc C s dS )a
Return the interfaces provided by an object.
This is the union of the interfaces directly provided by an
object and interfaces implemented by it's class.
The value returned is an `IDeclaration`.
.. seealso:: `zope.interface.providedBy`
Nr )�obr r r r1 / s z IInterfaceDeclaration.providedByc C s dS )z�
Return the interfaces implemented for a class's instances.
The value returned is an `IDeclaration`.
.. seealso:: `zope.interface.implementedBy`
Nr r2 r r r r4 ; s z#IInterfaceDeclaration.implementedByc G s dS )a.
Declare additional interfaces implemented for instances of a class.
The arguments after the class are one or more interfaces or
interface specifications (`IDeclaration` objects).
The interfaces given (including the interfaces in the
specifications) are added to any interfaces previously
declared.
Consider the following example::
class C(A, B):
...
classImplements(C, I1, I2)
Instances of ``C`` provide ``I1``, ``I2``, and whatever interfaces
instances of ``A`` and ``B`` provide. This is equivalent to::
@implementer(I1, I2)
class C(A, B):
pass
.. seealso:: `zope.interface.classImplements`
.. seealso:: `zope.interface.implementer`
Nr �r3 rO r r r �classImplementsH s z%IInterfaceDeclaration.classImplementsc C s dS )zB
See :func:`zope.interface.classImplementsFirst`.
Nr )�clsr, r r r �classImplementsFirstf s z*IInterfaceDeclaration.classImplementsFirstc G s dS )z�
Create a decorator for declaring interfaces implemented by a
factory.
A callable is returned that makes an implements declaration on
objects passed to it.
.. seealso:: :meth:`classImplements`
Nr rN r r r r k s z!IInterfaceDeclaration.implementerc G s dS )a�
Declare the only interfaces implemented by instances of a class.
The arguments after the class are one or more interfaces or
interface specifications (`IDeclaration` objects).
The interfaces given (including the interfaces in the
specifications) replace any previous declarations.
Consider the following example::
class C(A, B):
...
classImplements(C, IA, IB. IC)
classImplementsOnly(C. I1, I2)
Instances of ``C`` provide only ``I1``, ``I2``, and regardless of
whatever interfaces instances of ``A`` and ``B`` implement.
.. seealso:: `zope.interface.classImplementsOnly`
Nr rY r r r �classImplementsOnlyv s z)IInterfaceDeclaration.classImplementsOnlyc G s dS )z�
Create a decorator for declaring the only interfaces implemented.
A callable is returned that makes an implements declaration on
objects passed to it.
.. seealso:: `zope.interface.implementer_only`
Nr rN r r r �implementer_only� s z&IInterfaceDeclaration.implementer_onlyc C s dS )z�
Return the interfaces directly provided by the given object.
The value returned is an `IDeclaration`.
.. seealso:: `zope.interface.directlyProvidedBy`
Nr r/ r r r �directlyProvidedBy� s z(IInterfaceDeclaration.directlyProvidedByc G s dS )a�
Declare interfaces declared directly for an object.
The arguments after the object are one or more interfaces or
interface specifications (`IDeclaration` objects).
.. caution::
The interfaces given (including the interfaces in the
specifications) *replace* interfaces previously
declared for the object. See :meth:`alsoProvides` to add
additional interfaces.
Consider the following example::
class C(A, B):
...
ob = C()
directlyProvides(ob, I1, I2)
The object, ``ob`` provides ``I1``, ``I2``, and whatever interfaces
instances have been declared for instances of ``C``.
To remove directly provided interfaces, use `directlyProvidedBy` and
subtract the unwanted interfaces. For example::
directlyProvides(ob, directlyProvidedBy(ob)-I2)
removes I2 from the interfaces directly provided by
``ob``. The object, ``ob`` no longer directly provides ``I2``,
although it might still provide ``I2`` if it's class
implements ``I2``.
To add directly provided interfaces, use `directlyProvidedBy` and
include additional interfaces. For example::
directlyProvides(ob, directlyProvidedBy(ob), I2)
adds I2 to the interfaces directly provided by ob.
.. seealso:: `zope.interface.directlyProvides`
Nr �r0 rO r r r �directlyProvides� s z&IInterfaceDeclaration.directlyProvidesc G s dS )a
Declare additional interfaces directly for an object.
For example::
alsoProvides(ob, I1)
is equivalent to::
directlyProvides(ob, directlyProvidedBy(ob), I1)
.. seealso:: `zope.interface.alsoProvides`
Nr r` r r r � alsoProvides� s z"IInterfaceDeclaration.alsoProvidesc C s dS )a�
Remove an interface from the list of an object's directly provided
interfaces.
For example::
noLongerProvides(ob, I1)
is equivalent to::
directlyProvides(ob, directlyProvidedBy(ob) - I1)
with the exception that if ``I1`` is an interface that is
provided by ``ob`` through the class's implementation,
`ValueError` is raised.
.. seealso:: `zope.interface.noLongerProvides`
Nr )r0 r, r r r �noLongerProvides� s z&IInterfaceDeclaration.noLongerProvidesc G s dS )a�
Declare interfaces implemented by instances of a class.
.. deprecated:: 5.0
This only works for Python 2. The `implementer` decorator
is preferred for all versions.
This function is called in a class definition (Python 2.x only).
The arguments are one or more interfaces or interface
specifications (`IDeclaration` objects).
The interfaces given (including the interfaces in the
specifications) are added to any interfaces previously
declared.
Previous declarations include declarations for base classes
unless implementsOnly was used.
This function is provided for convenience. It provides a more
convenient way to call `classImplements`. For example::
implements(I1)
is equivalent to calling::
classImplements(C, I1)
after the class has been created.
Consider the following example (Python 2.x only)::
class C(A, B):
implements(I1, I2)
Instances of ``C`` implement ``I1``, ``I2``, and whatever interfaces
instances of ``A`` and ``B`` implement.
Nr rN r r r �
implements� s z IInterfaceDeclaration.implementsc G s dS )a
Declare the only interfaces implemented by instances of a class.
.. deprecated:: 5.0
This only works for Python 2. The `implementer_only` decorator
is preferred for all versions.
This function is called in a class definition (Python 2.x only).
The arguments are one or more interfaces or interface
specifications (`IDeclaration` objects).
Previous declarations including declarations for base classes
are overridden.
This function is provided for convenience. It provides a more
convenient way to call `classImplementsOnly`. For example::
implementsOnly(I1)
is equivalent to calling::
classImplementsOnly(I1)
after the class has been created.
Consider the following example (Python 2.x only)::
class C(A, B):
implementsOnly(I1, I2)
Instances of ``C`` implement ``I1``, ``I2``, regardless of what
instances of ``A`` and ``B`` implement.
Nr rN r r r �implementsOnly s z$IInterfaceDeclaration.implementsOnlyc G s dS )a�
Declare interfaces provided directly by a class.
.. deprecated:: 5.0
This only works for Python 2. The `provider` decorator
is preferred for all versions.
This function is called in a class definition.
The arguments are one or more interfaces or interface
specifications (`IDeclaration` objects).
The given interfaces (including the interfaces in the
specifications) are used to create the class's direct-object
interface specification. An error will be raised if the module
class has an direct interface specification. In other words, it is
an error to call this function more than once in a class
definition.
Note that the given interfaces have nothing to do with the
interfaces implemented by instances of the class.
This function is provided for convenience. It provides a more
convenient way to call `directlyProvides` for a class. For example::
classProvides(I1)
is equivalent to calling::
directlyProvides(theclass, I1)
after the class has been created.
Nr rN r r r �
classProvides> s z#IInterfaceDeclaration.classProvidesc G s dS )zo
A class decorator version of `classProvides`.
.. seealso:: `zope.interface.provider`
Nr rN r r r �providera s z IInterfaceDeclaration.providerc G s dS )a�
Declare interfaces provided by a module.
This function is used in a module definition.
The arguments are one or more interfaces or interface
specifications (`IDeclaration` objects).
The given interfaces (including the interfaces in the
specifications) are used to create the module's direct-object
interface specification. An error will be raised if the module
already has an interface specification. In other words, it is
an error to call this function more than once in a module
definition.
This function is provided for convenience. It provides a more
convenient way to call `directlyProvides` for a module. For example::
moduleImplements(I1)
is equivalent to::
directlyProvides(sys.modules[__name__], I1)
.. seealso:: `zope.interface.moduleProvides`
Nr rN r r r �moduleProvidesh s z$IInterfaceDeclaration.moduleProvidesc G s dS )a>
Create an interface specification.
The arguments are one or more interfaces or interface
specifications (`IDeclaration` objects).
A new interface specification (`IDeclaration`) with the given
interfaces is returned.
.. seealso:: `zope.interface.Declaration`
Nr rN r r r � Declaration� s z!IInterfaceDeclaration.DeclarationN)r r* r+ r r r rT rU rW r1 r4 rZ r\ r r] r^ r_ ra rb rc rd re rf rg rh ri r r r r r � s,
!
,)%# c @ s� e Zd ZdZdd� Zd dd�Zd dd �Zd d
d �Zd!d d
�Zd"dd�Z d#dd�Z
dd� Z dd� Z dd� Z
dd� Zdd� Zd d � ZdS )$r a� Provide an interface-based registry for adapters
This registry registers objects that are in some sense "from" a
sequence of specification to an interface and a name.
No specific semantics are assumed for the registered objects,
however, the most common application will be to register factories
that adapt objects providing required specifications to a provided
interface.
c C s dS )z�Register a value
A value is registered for a *sequence* of required specifications, a
provided interface, and a name, which must be text.
Nr )�required�providedr; r% r r r �register� s zIAdapterRegistry.register� c C s dS )a� Return the component registered for the given interfaces and name
name must be text.
Unlike the lookup method, this methods won't retrieve
components registered for more specific required interfaces or
less specific provided interfaces.
If no component was registered exactly for the given
interfaces and name, then None is returned.
Nr )rj rk r; r r r �
registered� s zIAdapterRegistry.registeredNc C s dS )z�Lookup a value
A value is looked up based on a *sequence* of required
specifications, a provided interface, and a name, which must be
text.
Nr �rj rk r; r" r r r �lookup� s zIAdapterRegistry.lookupc C s dS )zDAdapt a sequence of objects to a named, provided, interface
Nr )�objectsrk r; r" r r r �queryMultiAdapter� s z"IAdapterRegistry.queryMultiAdapterc C s dS )z�Lookup a value using a single required interface
A value is looked up based on a single required
specifications, a provided interface, and a name, which must be
text.
Nr ro r r r �lookup1� s zIAdapterRegistry.lookup1c C s dS )z<Adapt an object using a registered adapter factory.
Nr )r0 rk r; r" r r r � queryAdapter� s z IAdapterRegistry.queryAdapterc C s dS )zXAdapt an object using a registered adapter factory.
name must be text.
Nr )rk r0 r; r" r r r � adapter_hook� s z IAdapterRegistry.adapter_hookc C s dS )z�Find all adapters from the required to the provided interfaces
An iterable object is returned that provides name-value two-tuples.
Nr �rj rk r r r � lookupAll� s zIAdapterRegistry.lookupAllc C s dS )z@Return the names for which there are registered objects
Nr rv r r r rB � s zIAdapterRegistry.namesc C s dS )a� Register a subscriber
A subscriber is registered for a *sequence* of required
specifications, a provided interface, and a name.
Multiple subscribers may be registered for the same (or
equivalent) interfaces.
.. versionchanged:: 5.1.1
Correct the method signature to remove the ``name`` parameter.
Subscribers have no names.
Nr �rj rk Z
subscriberr r r � subscribe� s zIAdapterRegistry.subscribec C s dS )a�
Check whether the object *subscriber* is registered directly
with this object via a previous call to
``subscribe(required, provided, subscriber)``.
If the *subscriber*, or one equal to it, has been subscribed,
for the given *required* sequence and *provided* interface,
return that object. (This does not guarantee whether the *subscriber*
itself is returned, or an object equal to it.)
If it has not, return ``None``.
Unlike :meth:`subscriptions`, this method won't retrieve
components registered for more specific required interfaces or
less specific provided interfaces.
.. versionadded:: 5.3.0
Nr rx r r r �
subscribed� s zIAdapterRegistry.subscribedc C s dS )a
Get a sequence of subscribers.
Subscribers for a sequence of *required* interfaces, and a *provided*
interface are returned. This takes into account subscribers
registered with this object, as well as those registered with
base adapter registries in the resolution order, and interfaces that
extend *provided*.
.. versionchanged:: 5.1.1
Correct the method signature to remove the ``name`` parameter.
Subscribers have no names.
Nr rv r r r �
subscriptions� s z IAdapterRegistry.subscriptionsc C s dS )a
Get a sequence of subscription **adapters**.
This is like :meth:`subscriptions`, but calls the returned
subscribers with *objects* (and optionally returns the results
of those calls), instead of returning the subscribers directly.
:param objects: A sequence of objects; they will be used to
determine the *required* argument to :meth:`subscriptions`.
:param provided: A single interface, or ``None``, to pass
as the *provided* parameter to :meth:`subscriptions`.
If an interface is given, the results of calling each returned
subscriber with the the *objects* are collected and returned
from this method; each result should be an object implementing
the *provided* interface. If ``None``, the resulting subscribers
are still called, but the results are ignored.
:return: A sequence of the results of calling the subscribers
if *provided* is not ``None``. If there are no registered
subscribers, or *provided* is ``None``, this will be an empty
sequence.
.. versionchanged:: 5.1.1
Correct the method signature to remove the ``name`` parameter.
Subscribers have no names.
Nr �rq rk r r r � subscribers s z IAdapterRegistry.subscribers)rm )rm N)rm N)rm N)rm N)rm N)r r* r+ r rl rn rp rr rs rt ru rw rB ry rz r{ r} r r r r r � s
c @ s e Zd ZdZdS )�ComponentLookupErrorz A component could not be found.N�r r* r+ r r r r r r~ ( s r~ c @ s e Zd ZdZdS )�Invalidz&A component doesn't satisfy a promise.Nr r r r r r� + s r� c @ s e Zd ZdZed�ZdS )r z�An event related to an object.
The object that generated this event is not necessarily the object
refered to by location.
zThe subject of the event.N)r r* r+ r r r0 r r r r r . s c @ s e Zd Zdd� ZdS )� ObjectEventc C s
|| _ d S )Nr/ )�selfr0 r r r �__init__; s zObjectEvent.__init__N)r r* r+ r� r r r r r� 8 s r� c @ sz e Zd ZdZed�Zed�Zddd�Zddd �Zd d
d �Z d d d
�Z
dd� Z dd� Z dd� Z
d dd�Zdd� Zdd� ZdS ) r z�Component Manager for a Site
This object manages the components registered at a particular site. The
definition of a site is intentionally vague.
z3Adapter Registry to manage all registered adapters.z4Adapter Registry to manage all registered utilities.rm Nc C s dS )z�Look for a named adapter to an interface for an object
If a matching adapter cannot be found, returns the default.
Nr )r0 r, r; r" r r r rt L s z IComponentLookup.queryAdapterc C s dS )z�Look for a named adapter to an interface for an object
If a matching adapter cannot be found, a `ComponentLookupError`
is raised.
Nr )r0 r, r; r r r �
getAdapterR s zIComponentLookup.getAdapterc C s dS )z�Look for a multi-adapter to an interface for multiple objects
If a matching adapter cannot be found, returns the default.
Nr )rq r, r; r" r r r rr Y s z"IComponentLookup.queryMultiAdapterc C s dS )z�Look for a multi-adapter to an interface for multiple objects
If a matching adapter cannot be found, a `ComponentLookupError`
is raised.
Nr )rq r, r; r r r �getMultiAdapter_ s z IComponentLookup.getMultiAdapterc C s dS )z�Look for all matching adapters to a provided interface for objects
Return an iterable of name-adapter pairs for adapters that
provide the given interface.
Nr r| r r r � getAdaptersf s z IComponentLookup.getAdaptersc C s dS )z�Get subscribers
Subscribers are returned that provide the provided interface
and that depend on and are comuted from the sequence of
required objects.
Nr r| r r r r} m s z IComponentLookup.subscribersc G s dS )zkCall handlers for the given objects
Handlers registered for the given objects are called.
Nr )rq r r r �handleu s zIComponentLookup.handlec C s dS )zeLook up a utility that provides an interface.
If one is not found, returns default.
Nr )r, r; r" r r r � queryUtility{ s z IComponentLookup.queryUtilityc C s dS )zxLook up the registered utilities that provide an interface.
Returns an iterable of name-utility pairs.
Nr rL r r r �getUtilitiesFor� s z IComponentLookup.getUtilitiesForc C s dS )z�Return all registered utilities for an interface
This includes overridden utilities.
An iterable of utility instances is returned. No names are
returned.
Nr rL r r r � getAllUtilitiesRegisteredFor� s z-IComponentLookup.getAllUtilitiesRegisteredFor)rm N)rm )rm N)rm )rm N)r r* r+ r r ZadaptersZ utilitiesrt r� rr r� r� r} r� r� r� r� r r r r r ? s" ��
c @ s( e Zd ZdZed�Zed�Zed�ZdS )r z&A registration-information object
z$The registry having the registrationzThe registration namez�Information about the registration
This is information deemed useful to people browsing the
configuration of a system. It could, for example, include
commentary or information about the source of the configuration.
N)r r* r+ r r �registryr; �infor r r r r � s c @ s( e Zd ZdZed�Zed�Zed�ZdS )r z4Information about the registration of a utility
z1The factory used to create the utility. Optional.zThe object registeredz'The interface provided by the componentN)r r* r+ r r �factory� componentrk r r r r r � s c @ s( e Zd ZdZed�Zed�Zed�ZdS )�_IBaseAdapterRegistration�5Information about the registration of an adapter
z#The factory used to create adaptersz�The adapted interfaces
This is a sequence of interfaces adapters by the registered
factory. The factory will be caled with a sequence of objects, as
positional arguments, that provide these interfaces.
z^The interface provided by the adapters.
This interface is implemented by the factory
N)r r* r+ r r r� rj rk r r r r r� � s r� c @ s e Zd ZdZdS )r r� Nr r r r r r � s c @ s e Zd ZdZdS )r zAInformation about the registration of a subscription adapter
Nr r r r r r � s c @ s e Zd Zed�Zed�ZdS )r z(An object called used to handle an eventz�The handled interfaces
This is a sequence of interfaces handled by the registered
handler. The handler will be caled with a sequence of objects, as
positional arguments, that provide these interfaces.
N)r r* r+ r �handlerrj r r r r r � s c @ s e Zd ZdZdS )r z%An event that involves a registrationNr r r r r r � s c @ s e Zd ZdZdd� ZdS )�RegistrationEventz.There has been a change in a registration
c C s d| j j| jf S )Nz %s event:
%r)� __class__r r0 )r� r r r �__repr__� s zRegistrationEvent.__repr__N)r r* r+ r r� r r r r r� � s r� c @ s e Zd ZdZdS )r z*A component or factory was registered
Nr r r r r r � s c @ s e Zd ZdS )�
RegisteredN)r r* r+ r r r r r� � s r� c @ s e Zd ZdZdS )r �,A component or factory was unregistered
Nr r r r r r � s c @ s e Zd ZdZdS )� Unregisteredr� Nr r r r r r� � s r� c @ s� e Zd ZdZd dd�Zd dd�Zdd � Zd d
d �Zd d d
�Zdd� Z d dd�Z
d!dd�Z dd� Z d"dd�Z
d#dd�Zdd� ZdS )$r
zRegister components
Nrm c C s dS )a� Register a utility
:param factory:
Factory for the component to be registered.
:param component:
The registered component
:param provided:
This is the interface provided by the utility. If the
component provides a single interface, then this
argument is optional and the component-implemented
interface will be used.
:param name:
The utility name.
:param info:
An object that can be converted to a string to provide
information about the registration.
Only one of *component* and *factory* can be used.
A `IRegistered` event is generated with an `IUtilityRegistration`.
Nr )r� rk r; r� r� r r r �registerUtility� s z"IComponentRegistry.registerUtilityc C s dS )a Unregister a utility
:returns:
A boolean is returned indicating whether the registry was
changed. If the given *component* is None and there is no
component registered, or if the given *component* is not
None and is not registered, then the function returns
False, otherwise it returns True.
:param factory:
Factory for the component to be unregistered.
:param component:
The registered component The given component can be
None, in which case any component registered to provide
the given provided interface with the given name is
unregistered.
:param provided:
This is the interface provided by the utility. If the
component is not None and provides a single interface,
then this argument is optional and the
component-implemented interface will be used.
:param name:
The utility name.
Only one of *component* and *factory* can be used.
An `IUnregistered` event is generated with an `IUtilityRegistration`.
Nr )r� rk r; r� r r r �unregisterUtility s z$IComponentRegistry.unregisterUtilityc C s dS )z�Return an iterable of `IUtilityRegistration` instances.
These registrations describe the current utility registrations
in the object.
Nr r r r r �registeredUtilities* s z&IComponentRegistry.registeredUtilitiesc C s dS )a� Register an adapter factory
:param factory:
The object used to compute the adapter
:param required:
This is a sequence of specifications for objects to be
adapted. If omitted, then the value of the factory's
``__component_adapts__`` attribute will be used. The
``__component_adapts__`` attribute is
normally set in class definitions using
the `.adapter`
decorator. If the factory doesn't have a
``__component_adapts__`` adapts attribute, then this
argument is required.
:param provided:
This is the interface provided by the adapter and
implemented by the factory. If the factory
implements a single interface, then this argument is
optional and the factory-implemented interface will be
used.
:param name:
The adapter name.
:param info:
An object that can be converted to a string to provide
information about the registration.
A `IRegistered` event is generated with an `IAdapterRegistration`.
Nr )r� rj rk r; r� r r r �registerAdapter1 s z"IComponentRegistry.registerAdapterc C s dS )a� Unregister an adapter factory
:returns:
A boolean is returned indicating whether the registry was
changed. If the given component is None and there is no
component registered, or if the given component is not
None and is not registered, then the function returns
False, otherwise it returns True.
:param factory:
This is the object used to compute the adapter. The
factory can be None, in which case any factory
registered to implement the given provided interface
for the given required specifications with the given
name is unregistered.
:param required:
This is a sequence of specifications for objects to be
adapted. If the factory is not None and the required
arguments is omitted, then the value of the factory's
__component_adapts__ attribute will be used. The
__component_adapts__ attribute attribute is normally
set in class definitions using adapts function, or for
callables using the adapter decorator. If the factory
is None or doesn't have a __component_adapts__ adapts
attribute, then this argument is required.
:param provided:
This is the interface provided by the adapter and
implemented by the factory. If the factory is not
None and implements a single interface, then this
argument is optional and the factory-implemented
interface will be used.
:param name:
The adapter name.
An `IUnregistered` event is generated with an `IAdapterRegistration`.
Nr )r� rj rk r; r r r �unregisterAdapterT s z$IComponentRegistry.unregisterAdapterc C s dS )z�Return an iterable of `IAdapterRegistration` instances.
These registrations describe the current adapter registrations
in the object.
Nr r r r r �registeredAdapters~ s z%IComponentRegistry.registeredAdaptersc C s dS )a, Register a subscriber factory
:param factory:
The object used to compute the adapter
:param required:
This is a sequence of specifications for objects to be
adapted. If omitted, then the value of the factory's
``__component_adapts__`` attribute will be used. The
``__component_adapts__`` attribute is
normally set using the adapter
decorator. If the factory doesn't have a
``__component_adapts__`` adapts attribute, then this
argument is required.
:param provided:
This is the interface provided by the adapter and
implemented by the factory. If the factory implements
a single interface, then this argument is optional and
the factory-implemented interface will be used.
:param name:
The adapter name.
Currently, only the empty string is accepted. Other
strings will be accepted in the future when support for
named subscribers is added.
:param info:
An object that can be converted to a string to provide
information about the registration.
A `IRegistered` event is generated with an
`ISubscriptionAdapterRegistration`.
Nr )r� rj �providesr; r� r r r �registerSubscriptionAdapter� s z.IComponentRegistry.registerSubscriptionAdapterc C s dS )a Unregister a subscriber factory.
:returns:
A boolean is returned indicating whether the registry was
changed. If the given component is None and there is no
component registered, or if the given component is not
None and is not registered, then the function returns
False, otherwise it returns True.
:param factory:
This is the object used to compute the adapter. The
factory can be None, in which case any factories
registered to implement the given provided interface
for the given required specifications with the given
name are unregistered.
:param required:
This is a sequence of specifications for objects to be
adapted. If omitted, then the value of the factory's
``__component_adapts__`` attribute will be used. The
``__component_adapts__`` attribute is
normally set using the adapter
decorator. If the factory doesn't have a
``__component_adapts__`` adapts attribute, then this
argument is required.
:param provided:
This is the interface provided by the adapter and
implemented by the factory. If the factory is not
None implements a single interface, then this argument
is optional and the factory-implemented interface will
be used.
:param name:
The adapter name.
Currently, only the empty string is accepted. Other
strings will be accepted in the future when support for
named subscribers is added.
An `IUnregistered` event is generated with an
`ISubscriptionAdapterRegistration`.
Nr )r� rj r� r; r r r � unregisterSubscriptionAdapter� s z0IComponentRegistry.unregisterSubscriptionAdapterc C s dS )z�Return an iterable of `ISubscriptionAdapterRegistration` instances.
These registrations describe the current subscription adapter
registrations in the object.
Nr r r r r � registeredSubscriptionAdapters� s z1IComponentRegistry.registeredSubscriptionAdaptersc C s dS )a� Register a handler.
A handler is a subscriber that doesn't compute an adapter
but performs some function when called.
:param handler:
The object used to handle some event represented by
the objects passed to it.
:param required:
This is a sequence of specifications for objects to be
adapted. If omitted, then the value of the factory's
``__component_adapts__`` attribute will be used. The
``__component_adapts__`` attribute is
normally set using the adapter
decorator. If the factory doesn't have a
``__component_adapts__`` adapts attribute, then this
argument is required.
:param name:
The handler name.
Currently, only the empty string is accepted. Other
strings will be accepted in the future when support for
named handlers is added.
:param info:
An object that can be converted to a string to provide
information about the registration.
A `IRegistered` event is generated with an `IHandlerRegistration`.
Nr )r� rj r; r� r r r �registerHandler� s z"IComponentRegistry.registerHandlerc C s dS )a) Unregister a handler.
A handler is a subscriber that doesn't compute an adapter
but performs some function when called.
:returns: A boolean is returned indicating whether the registry was
changed.
:param handler:
This is the object used to handle some event
represented by the objects passed to it. The handler
can be None, in which case any handlers registered for
the given required specifications with the given are
unregistered.
:param required:
This is a sequence of specifications for objects to be
adapted. If omitted, then the value of the factory's
``__component_adapts__`` attribute will be used. The
``__component_adapts__`` attribute is
normally set using the adapter
decorator. If the factory doesn't have a
``__component_adapts__`` adapts attribute, then this
argument is required.
:param name:
The handler name.
Currently, only the empty string is accepted. Other
strings will be accepted in the future when support for
named handlers is added.
An `IUnregistered` event is generated with an `IHandlerRegistration`.
Nr )r� rj r; r r r �unregisterHandler s z$IComponentRegistry.unregisterHandlerc C s dS )z�Return an iterable of `IHandlerRegistration` instances.
These registrations describe the current handler registrations
in the object.
Nr r r r r �registeredHandlers' s z%IComponentRegistry.registeredHandlers)NNrm rm N)NNrm N)NNrm rm )NNNrm )NNrm rm )NNNrm )Nrm rm )NNrm )r r* r+ r r� r� r� r� r� r� r� r� r� r� r� r� r r r r r
� s: �
�
! �
# �
* �
& �
.
#
$c @ s e Zd ZdZdS )r z&Component registration and access
Nr r r r r r / s N)&r �
__docformat__�zope.interface.interfacer r �zope.interface.declarationsr �__all__r
r r r r r r r � LookupErrorr~ � Exceptionr� r r0 r� r r r r� r r r r r� r r� r r� r
r r r r r �<module> s~ �_ K ; J
Q H