o $ x`7@s dZdZddlmZddlmZddlmZgdZGdddeZGd d d eZ Gd d d e Z Gd ddeZ Gddde eZ Gddde Z GdddeZGdddeZGdddeZGdddeZGdddeZeeGdddeZGdd d eZGd!d"d"eZGd#d$d$eZGd%d&d&eZGd'd(d(eZGd)d*d*eZGd+d,d,eZGd-d.d.eZeeGd/d0d0eZGd1d2d2eZ ee Gd3d4d4eZ!Gd5d6d6eZ"ee"Gd7d8d8eZ#Gd9d:d:eZ$Gd;d<dzInterface Package Interfaces restructuredtext) Attribute) Interface) implementer)IAdapterRegistrationIAdapterRegistry IAttributeIComponentLookupIComponentRegistry IComponents IDeclarationIElementIHandlerRegistration IInterfaceIInterfaceDeclarationIMethod IObjectEvent IRegistered IRegistrationIRegistrationEventISpecification ISubscriptionAdapterRegistration IUnregisteredIUtilityRegistrationc@s`eZdZdZeddZeddZddZdd d Zd d Zd dZddZ dddZ ddZ 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 stringcCdS)aReturns 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. Ntagrr;/usr/lib/python3/dist-packages/zope/interface/interfaces.pygetTaggedValueRzIElement.getTaggedValueNcCr)z As for `getTaggedValue`, but instead of raising a `KeyError`, returns *default*. .. versionchanged:: 4.7.0 This method should respect inheritance if present. Nrrdefaultrrr queryTaggedValue_r"zIElement.queryTaggedValuecCr)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. Nrrrrr getTaggedValueTagshr"zIElement.getTaggedValueTagscCr)zH Associates *value* with *key* directly in this object. Nr)rvaluerrr setTaggedValuetr"zIElement.setTaggedValuecCr)zk As for `getTaggedValue`, but never includes inheritance. .. versionadded:: 5.0.0 Nrrrrr getDirectTaggedValueyr"zIElement.getDirectTaggedValuecCr)zm As for `queryTaggedValue`, but never includes inheritance. .. versionadded:: 5.0.0 Nrr#rrr queryDirectTaggedValuer"zIElement.queryDirectTaggedValuecCr)z As for `getTaggedValueTags`, but includes only tags directly set on this object. .. versionadded:: 5.0.0 Nrrrrr getDirectTaggedValueTagsr"z!IElement.getDirectTaggedValueTagsN) r __module__ __qualname__rrr!r%r&r(r)r*r+rrrr r 1s       r c@seZdZdZeddZdS)rzAttribute descriptors interfacez@Stores the interface instance in which the attribute is located.N)rr-r.rrr/rrrr rs rc@s eZdZdZddZddZdS)rzMethod attributescCr)aReturns 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). Nrrrrr getSignatureInfor"zIMethod.getSignatureInfocCr)aReturn 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')"``. Nrrrrr getSignatureStringr"zIMethod.getSignatureStringN)rr-r.rr0r1rrrr rs rc@s^eZdZdZddZddZddZdd d Zdd d Ze dZ e dZ e dZ dddZ d S)rz Object Behavioral specificationscCr)zTest 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. Nrobjectrrr providedByr"zISpecification.providedBycCr)zTest 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. Nrclass_rrr implementedByr"zISpecification.implementedBycCr)z=Test whether the specification is or extends another Nr)otherrrr isOrExtendsr"zISpecification.isOrExtendsTcCr)zTest 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)r8strictrrr extendsr"zISpecification.extendsNcCr)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)callbackrrr weakrefr"zISpecification.weakrefzoBase specifications A tuple of specifications from which this specification is directly derived. aSpecification-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.) aInterface-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.) cCr)z|Look up the description for a name If the named attribute is not defined, the default is returned. Nr)namer$rrr getr"zISpecification.get)Tr,)rr-r.rr4r7r9r;r=r __bases____sro____iro__r?rrrr rs     rc@sVeZdZdZdddZdddZddZd d Zdd d ZddZ ddZ e dZd S)ra4 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. FcCr)agGet 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. Nrallrrr namesWr"zIInterface.namescCr)aGet 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. NrrCrrr namesAndDescriptionsbr"zIInterface.namesAndDescriptionscCr)zoGet the description for a name If the named attribute is not defined, a `KeyError` is raised. Nrr>rrr __getitem__nr"zIInterface.__getitem__cCr)zGet the description for the name if it was defined by the interface If the interface doesn't define the name, returns None. NrrGrrr directtr"zIInterface.directNcCr)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)objerrorsrrr validateInvariantszr"zIInterface.validateInvariantscCr)z1Test whether the name is defined by the interfaceNrrGrrr __contains__r"zIInterface.__contains__cCr)zReturn 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. Nrrrrr __iter__r"zIInterface.__iter__z-The name of the module defining the interface)Fr,) rr-r.rrErFrHrIrLrMrNrrrrr rs W    rc@s@eZdZdZddZddZddZdd Zd d Zd d Z dS)r zInterface declaration Declarations are used to express the interfaces implemented by classes or provided by objects. cCr)zTest whether an interface is in the specification Return true if the given interface is one of the interfaces in the specification and false otherwise. Nrr/rrr rMr"zIDeclaration.__contains__cCr)zCReturn an iterator for the interfaces in the specification Nrrrrr rNr"zIDeclaration.__iter__cCr)aReturn 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. Nrrrrr flattenedr"zIDeclaration.flattenedcCr)aCreate 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 interfacesrrr __sub__r"zIDeclaration.__sub__cCr)azCreate 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. NrrQrrr __add__r"zIDeclaration.__add__cCr)zHReturn a true value of the interface specification is non-empty Nrrrrr __nonzero__r"zIDeclaration.__nonzero__N) rr-r.rrMrNrPrSrTrUrrrr r s  r c@seZdZdZedZddZddZddZd d Z d d Z d dZ ddZ ddZ ddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+S),ra 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 interfacescCr)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'rrr taggedValuer"z!IInterfaceDeclaration.taggedValuecCr)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)checker_functionrrr invariantr"zIInterfaceDeclaration.invariantcCr)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)methodrrr interfacemethodr"z%IInterfaceDeclaration.interfacemethodcCr)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)obrrr r4/r"z IInterfaceDeclaration.providedBycCr)z Return the interfaces implemented for a class's instances. The value returned is an `IDeclaration`. .. seealso:: `zope.interface.implementedBy` Nrr5rrr r7;r"z#IInterfaceDeclaration.implementedBycGr)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` Nrr6rRrrr classImplementsHr"z%IInterfaceDeclaration.classImplementscCr)zB See :func:`zope.interface.classImplementsFirst`. Nr)clsr/rrr classImplementsFirstfr"z*IInterfaceDeclaration.classImplementsFirstcGr)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` NrrQrrr rkr"z!IInterfaceDeclaration.implementercGr)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` Nrr]rrr classImplementsOnlyvr"z)IInterfaceDeclaration.classImplementsOnlycGr)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` NrrQrrr implementer_onlyr"z&IInterfaceDeclaration.implementer_onlycCr)z Return the interfaces directly provided by the given object. The value returned is an `IDeclaration`. .. seealso:: `zope.interface.directlyProvidedBy` Nrr2rrr directlyProvidedByr"z(IInterfaceDeclaration.directlyProvidedBycGr)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` Nrr3rRrrr directlyProvidesr"z&IInterfaceDeclaration.directlyProvidescGr)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` Nrrdrrr alsoProvidesr"z"IInterfaceDeclaration.alsoProvidescCr)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)r3r/rrr noLongerProvidesr"z&IInterfaceDeclaration.noLongerProvidescGr)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. NrrQrrr implementsr"z IInterfaceDeclaration.implementscGr)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. NrrQrrr implementsOnlyr"z$IInterfaceDeclaration.implementsOnlycGr)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. NrrQrrr classProvides>r"z#IInterfaceDeclaration.classProvidescGr)zo A class decorator version of `classProvides`. .. seealso:: `zope.interface.provider` NrrQrrr providerar"zIInterfaceDeclaration.providercGr)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` NrrQrrr moduleProvideshr"z$IInterfaceDeclaration.moduleProvidescGr)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` NrrQrrr Declarationr"z!IInterfaceDeclaration.DeclarationN)rr-r.rrrrWrYr[r4r7r^r`rrarbrcrerfrgrhrirjrkrlrmrrrr rs. !     ,)%# rc@seZdZdZddZdddZddd Zdd d Zdd d ZdddZ dddZ ddZ ddZ ddZ ddZddZddZdS) raProvide 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. cCr)zRegister a value A value is registered for a *sequence* of required specifications, a provided interface, and a name, which must be text. Nr)requiredprovidedr>r'rrr registerr"zIAdapterRegistry.registercCr)aReturn 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)rnror>rrr registeredr"zIAdapterRegistry.registeredNcCr)zLookup a value A value is looked up based on a *sequence* of required specifications, a provided interface, and a name, which must be text. Nrrnror>r$rrr lookupr"zIAdapterRegistry.lookupcCr)zDAdapt a sequence of objects to a named, provided, interface Nr)objectsror>r$rrr queryMultiAdapterr"z"IAdapterRegistry.queryMultiAdaptercCr)zLookup 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. Nrrsrrr lookup1r"zIAdapterRegistry.lookup1cCr)zr$rrr queryAdapterr"zIAdapterRegistry.queryAdaptercCr)zXAdapt an object using a registered adapter factory. name must be text. Nr)ror3r>r$rrr adapter_hookr"zIAdapterRegistry.adapter_hookcCr)zFind all adapters from the required to the provided interfaces An iterable object is returned that provides name-value two-tuples. Nrrnrorrr lookupAllr"zIAdapterRegistry.lookupAllcCr)z@Return the names for which there are registered objects Nrrzrrr rEr"zIAdapterRegistry.namescCr)aRegister 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. Nrrnro subscriberrrr subscriber"zIAdapterRegistry.subscribecCr)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 Nrr|rrr subscribedr"zIAdapterRegistry.subscribedcCr)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. Nrrzrrr subscriptionsr"zIAdapterRegistry.subscriptionscCr)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. Nrrurorrr subscribers r"zIAdapterRegistry.subscribersrqrqN)rr-r.rrprrrtrvrwrxryr{rEr~rrrrrrr rs       rc@eZdZdZdS)ComponentLookupErrorzA component could not be found.Nrr-r.rrrrr r(rc@r)Invalidz&A component doesn't satisfy a promise.Nrrrrr r+rrc@seZdZdZedZdS)rzAn 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)rr-r.rrr3rrrr r.s rc@seZdZddZdS) ObjectEventcCs ||_dSr,r2)selfr3rrr __init__;s zObjectEvent.__init__N)rr-r.rrrrr r8s rc@szeZdZdZedZedZdddZddd Zdd d Z dd d Z ddZ ddZ ddZ dddZddZddZdS)r zComponent 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.rqNcCr)zLook for a named adapter to an interface for an object If a matching adapter cannot be found, returns the default. Nr)r3r/r>r$rrr rxLr"zIComponentLookup.queryAdaptercCr)zLook for a named adapter to an interface for an object If a matching adapter cannot be found, a `ComponentLookupError` is raised. Nr)r3r/r>rrr getAdapterRr"zIComponentLookup.getAdaptercCr)zLook for a multi-adapter to an interface for multiple objects If a matching adapter cannot be found, returns the default. Nr)rur/r>r$rrr rvYr"z"IComponentLookup.queryMultiAdaptercCr)zLook for a multi-adapter to an interface for multiple objects If a matching adapter cannot be found, a `ComponentLookupError` is raised. Nr)rur/r>rrr getMultiAdapter_r"z IComponentLookup.getMultiAdaptercCr)zLook for all matching adapters to a provided interface for objects Return an iterable of name-adapter pairs for adapters that provide the given interface. Nrrrrr getAdaptersfr"zIComponentLookup.getAdapterscCr)zGet subscribers Subscribers are returned that provide the provided interface and that depend on and are comuted from the sequence of required objects. Nrrrrr rmr"zIComponentLookup.subscriberscGr)zkCall handlers for the given objects Handlers registered for the given objects are called. Nr)rurrr handleur"zIComponentLookup.handlecCr)zeLook up a utility that provides an interface. If one is not found, returns default. Nr)r/r>r$rrr queryUtility{r"zIComponentLookup.queryUtilitycCr)zxLook up the registered utilities that provide an interface. Returns an iterable of name-utility pairs. NrrOrrr getUtilitiesForr"z IComponentLookup.getUtilitiesForcCr)zReturn all registered utilities for an interface This includes overridden utilities. An iterable of utility instances is returned. No names are returned. NrrOrrr getAllUtilitiesRegisteredForr"z-IComponentLookup.getAllUtilitiesRegisteredForrr)rr-r.rradapters utilitiesrxrrvrrrrrrrrrrr r ?s$      r c@(eZdZdZedZedZedZdS)rz&A registration-information object z$The registry having the registrationzThe registration namezInformation 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)rr-r.rrregistryr>inforrrr rs  rc@r)rz4Information about the registration of a utility z1The factory used to create the utility. Optional.zThe object registeredz'The interface provided by the componentN)rr-r.rrfactory componentrorrrr rs  rc@r)_IBaseAdapterRegistration5Information about the registration of an adapter z#The factory used to create adapterszThe 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)rr-r.rrrrnrorrrr rs  rc@r)rrNrrrrr rrrc@r)rzAInformation about the registration of a subscription adapter Nrrrrr rrrc@seZdZedZedZdS)rz(An object called used to handle an eventzThe 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)rr-r.rhandlerrnrrrr rs rc@r)rz%An event that involves a registrationNrrrrr rrrc@seZdZdZddZdS)RegistrationEventz.There has been a change in a registration cCsd|jj|jfS)Nz %s event: %r) __class__rr3)rrrr __repr__szRegistrationEvent.__repr__N)rr-r.rrrrrr rs rc@r)rz*A component or factory was registered Nrrrrr rrrc@s eZdZdS) RegisteredN)rr-r.rrrr rsrc@r)r,A component or factory was unregistered Nrrrrr rrrc@r) UnregisteredrNrrrrr rsrc@seZdZdZ  dddZ  dddZdd Z  dd d Z  dd d ZddZ  dddZ  dddZ ddZ d ddZ d!ddZddZdS)"r zRegister components NrqcCr)aRegister 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)rror>rrrrr registerUtilityr"z"IComponentRegistry.registerUtilitycCr)aUnregister 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)rror>rrrr unregisterUtility r"z$IComponentRegistry.unregisterUtilitycCr)zReturn an iterable of `IUtilityRegistration` instances. These registrations describe the current utility registrations in the object. Nrrrrr registeredUtilities*r"z&IComponentRegistry.registeredUtilitiescCr)aRegister 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)rrnror>rrrr registerAdapter1r"z"IComponentRegistry.registerAdaptercCr)aUnregister 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)rrnror>rrr unregisterAdapterTr"z$IComponentRegistry.unregisterAdaptercCr)zReturn an iterable of `IAdapterRegistration` instances. These registrations describe the current adapter registrations in the object. Nrrrrr registeredAdapters~r"z%IComponentRegistry.registeredAdapterscCr)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)rrnprovidesr>rrrr registerSubscriptionAdapterr"z.IComponentRegistry.registerSubscriptionAdaptercCr)aUnregister 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)rrnrr>rrr unregisterSubscriptionAdapterr"z0IComponentRegistry.unregisterSubscriptionAdaptercCr)zReturn an iterable of `ISubscriptionAdapterRegistration` instances. These registrations describe the current subscription adapter registrations in the object. Nrrrrr registeredSubscriptionAdaptersr"z1IComponentRegistry.registeredSubscriptionAdapterscCr)aRegister 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)rrnr>rrrr registerHandlerr"z"IComponentRegistry.registerHandlercCr)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)rrnr>rrr unregisterHandlerr"z$IComponentRegistry.unregisterHandlercCr)zReturn an iterable of `IHandlerRegistration` instances. These registrations describe the current handler registrations in the object. Nrrrrr registeredHandlers'r"z%IComponentRegistry.registeredHandlers)NNrqrqN)NNrqN)NNrqrq)NNNrq)Nrqrq)NNrq)rr-r.rrrrrrrrrrrrrrrrr r s4  ! # * & .  # $r c@r)r z&Component registration and access Nrrrrr r /rr N)&r __docformat__zope.interface.interfacerrzope.interface.declarationsr__all__r rrrrr rr LookupErrorr Exceptionrrr3rr rrrrrrrrrrrrr r rrrr sX    _K;J Q H