Go to the latest version of this document.
search in docstrings

Search bar offers the following options:

- Term presence. The below example searches for documents that must contain “foo”, might contain “bar” and must not contain “baz”: `+foo bar -baz`
- Wildcards. The below example searches for documents with words beginning with “foo”: `foo*`
- Search in specific fields. The following search matches all objects in "twisted.mail" that matches “search”: `+qname:twisted.mail.* +search`

  Possible fields: 'name', 'qname' (fully qualified name), 'docstring', and 'kind'. Last two fields are only applicable if "search in docstrings" is enabled.

- Fuzzy matches. The following search matches all documents that have a word within 1 edit distance of “foo”: `foo~1`

Results provided by Lunr.js

# ``twisted`.`python`.`components``

module documentation
(source)

Component architecture for Twisted, based on Zope3 components.

Using the Zope3 API directly is strongly recommended. Everything you need is in the top-level of the zope.interface package, e.g.:

       from zope.interface import Interface, implementer

       class IFoo(Interface):
           pass

       @implementer(IFoo)
       class Foo:
           pass

       print(IFoo.implementedBy(Foo)) # True
       print(IFoo.providedBy(Foo())) # True

`twisted.python.components.registerAdapter` from this module may be used to add to Twisted's global adapter registry.

`twisted.python.components.proxyForInterface` is a factory for classes which allow access to only the parts of another class defined by a specified interface.

Class | `Adapter` | I am the default implementation of an Adapter for some interface.
Class | `Componentized` | I am a mixin to allow you to be adapted in various ways persistently.
Class | `ReprableComponentized` | Undocumented
Function | `getAdapterFactory` | Return registered adapter for a given class and interface.
Function | `getRegistry` | Returns the Twisted global `zope.interface.adapter.AdapterRegistry` instance.
Function | `proxyForInterface` | Create a class which proxies all method calls which adhere to an interface to another provider of that interface.
Function | `registerAdapter` | Register an adapter class.
Constant | `ALLOW_DUPLICATES` | Undocumented
Variable | `globalRegistry` | Undocumented
Class | `_ProxiedClassMethod` | A proxied class method.
Class | `_ProxyDescriptor` | A descriptor which will proxy attribute access, mutation, and deletion to the `_ProxyDescriptor.originalAttribute` of the object it is being accessed from.
Function | `_addHook` | Add an adapter hook which will attempt to look up adapters in the given registry.
Function | `_removeHook` | Remove a previously added adapter hook.

def getAdapterFactory(fromInterface, toInterface, default): (source)

Return registered adapter for a given class and interface.

Note that is tied to the *Twisted* global registry, and will thus not find adapters registered elsewhere.

def getRegistry(): (source)

Returns the Twisted global `zope.interface.adapter.AdapterRegistry` instance.

def proxyForInterface(iface, originalAttribute='original'): (source)

Create a class which proxies all method calls which adhere to an interface to another provider of that interface.

This function is intended for creating specialized proxies. The typical way to use it is by subclassing the result:

      class MySpecializedProxy(proxyForInterface(IFoo)):
          def someInterfaceMethod(self, arg):
              if arg == 3:
                  return 3
              return self.original.someInterfaceMethod(arg)

Parameters
iface | The Interface to which the resulting object will conform, and which the wrapped object must provide.
originalAttribute:`str` | name of the attribute used to save the original object in the resulting class. Default to `original`.
Returns
A class whose constructor takes the original object as its only argument. Constructing the class creates the proxy.

def registerAdapter(adapterFactory, origInterface, *interfaceClasses): (source)

Register an adapter class.

An adapter class is expected to implement the given interface, by adapting instances implementing 'origInterface'. An adapter class's __init__ method should accept one parameter, an instance implementing 'origInterface'.

ALLOW_DUPLICATES: `int` = (source)

Undocumented

Value

    0

globalRegistry = (source)

Undocumented

def _addHook(registry): (source)

Add an adapter hook which will attempt to look up adapters in the given registry.

Parameters
registry:`zope.interface.adapter.AdapterRegistry` | Undocumented
Returns
The hook which was added, for later use with `_removeHook`.

def _removeHook(hook): (source)

Remove a previously added adapter hook.

Parameters
hook | An object previously returned by a call to `_addHook`. This will be removed from the list of adapter hooks.