1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
# -*- test-case-name: tubes.test.test_tube -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
Various component utilities.
"""
from zope.interface.adapter import AdapterRegistry
from twisted.python.components import _addHook, _removeHook
from contextlib import contextmanager
if 0:
from zope.interface.interfaces import IInterface
IInterface
@contextmanager
def _registryActive(registry):
"""
A context manager that activates and deactivates a zope adapter registry
for the duration of the call.
For example, if you wanted to have a function that could adapt C{IFoo} to
C{IBar}, but doesn't expose that adapter outside of itself::
def convertToBar(maybeFoo):
with _registryActive(_registryAdapting((IFoo, IBar, fooToBar))):
return IBar(maybeFoo)
@note: This isn't thread safe, so other threads will be affected as well.
@param registry: The registry to activate.
@type registry: L{AdapterRegistry}
@rtype:
"""
hook = _addHook(registry)
yield
_removeHook(hook)
def _registryAdapting(*fromToAdapterTuples):
"""
Construct a Zope Interface adapter registry.
For example, if you want to construct an adapter registry that can convert
C{IFoo} to C{IBar} with C{fooToBar}.
@param fromToAdapterTuples: A sequence of tuples of C{(fromInterface,
toInterface, adapterCallable)}, where C{fromInterface} and
C{toInterface} are L{IInterface}s, and C{adapterCallable} is a callable
that takes one argument which provides C{fromInterface} and returns an
object providing C{toInterface}.
@type fromToAdapterTuples: C{tuple} of 3-C{tuple}s of C{(Interface,
Interface, callable)}
@return: an adapter registry adapting the given tuples.
@rtype: L{AdapterRegistry}
"""
result = AdapterRegistry()
for _from, to, adapter in fromToAdapterTuples:
result.register([_from], to, '', adapter)
return result
|
