================

================
.. contents::

,
( ) - . ,
. (
.)
" "
, .

==================

::
>>> from zope.interface.adapter import AdapterRegistry
>>> import zope.interface
>>> class IR1(zope.interface.Interface):
...
pass
>>> class IP1(zope.interface.Interface):
...
pass
>>> class IP2(IP1):
...
pass
>>> registry = AdapterRegistry()
IR1 "" IP2::
>>> registry.register([IR1], IP2, '', 12)
::
>>> registry.lookup([IR1], IP2, '')
12
, .

. ,
, .
. None
.

::
>>> class IR2(IR1):
...
pass
>>> registry.lookup([IR2], IP2, '')
12
::
>>> class C2:

...

zope.interface.implements(IR2)

>>> registry.lookup([zope.interface.implementedBy(C2)], IP2, '')

12

::
>>> registry.lookup([IR1], IP1, '')
12
>>> registry.lookup([IR2], IP1, '')
12

, ::
>>> registry.lookup([zope.interface.Interface], IP1, '')
, ::
>>> registry.lookup([zope.interface.Interface], IP1, '', 42)
42

::
>>> class IP (IP2):
...
pass
>>> registry.lookup([IR1], IP , '')
::
>>> registry.lookup([IR1], IP1, 'bob')
>>> registry.register([IR1], IP2, 'bob', "Bob's 12")
>>> registry.lookup([IR1], IP1, 'bob')
"Bob's 12"
::
>>> registry.lookup([IR1], IP1)
12
IP1::
>>> registry.register([IR1], IP1, '', 11)
O(12)::
>>> registry.lookup([IR1], IP1, '')
11
, IR2
IR2::
>>> registry.register([IR2], IP1, '', 21)
>>> registry.lookup([IR2], IP1, '')
21
, ( -)
-----------------------------------------------------

 - .
::
>>> print registry.registered([IR1], IP1)
11
>>> print registry.registered([IR1], IP2)
12
>>> print registry.registered([IR1], IP2, 'bob')
Bob's 12
>>> print registry.registered([IR2], IP1)
21
>>> print registry.registered([IR2], IP2)
None
, None ,
.
lookup1
------ -

::
>>> registry.lookup1(IR2, IP1, '')
21
>>> registry.lookup1(IR2, IP1)
21

--------------------

. .
::
>>> class IR(zope.interface.Interface):
...
pass
>>> class X:
...
zope.interface.implements(IR)
>>> class Y:
...
zope.interface.implements(IP1)
...
def __init__(self, context):
...
self.context = context
>>> registry.register([IR], IP1, '', Y)
.
`queryAdapter` ::
>>> x = X()

>>> y = registry.queryAdapter(x, IP1)

>>> y.__class__.__name__
'Y'
>>> y.context is x
True
::
>>> class Y2(Y):
...
pass
>>> registry.register([IR], IP1, 'bob', Y2)
>>> y = registry.queryAdapter(x, IP1, 'bob')
>>> y.__class__.__name__
'Y2'
>>> y.context is x
True
`None` -
. ( )

::
>>> def factory(context):
...
if context.name == 'object':
...
return 'adapter'
...
return None
>>> class Object(object):
...
zope.interface.implements(IR)
...
name = 'object'
>>> registry.register([IR], IP1, 'conditional', factory)
>>> obj = Object()
>>> registry.queryAdapter(obj, IP1, 'conditional')
'adapter'
>>> obj.name = 'no object'
>>> registry.queryAdapter(obj, IP1, 'conditional') is None
True
>>> registry.queryAdapter(obj, IP1, 'conditional', 'default')
'default'

`queryAdapter()` - `adapter_hook()`::
>>> y = registry.adapter_hook(IP1, x)
>>> y.__class__.__name__
'Y'
>>> y.context is x
True
>>> y = registry.adapter_hook(IP1, x, 'bob')
>>> y.__class__.__name__
'Y2'
>>> y.context is x
True
`adapter_hook()` .
.

--------------------
. None ::
>>> registry.register([None], IP1, '', 1)

::
>>> class IQ(zope.interface.Interface):
...
pass
>>> registry.lookup([IQ], IP1, '')
1
, ::
>>> registry.lookup([IR2], IP1, '')
21

--------------- ,
::
>>> registry.register([zope.interface.implementedBy(C2)], IP1, '', 'C21')
>>> registry.lookup([zope.interface.implementedBy(C2)], IP1, '')
'C21'

-------------------- -
- . ::
>>> adapter = {}
>>> registry.register((), IQ, '', adapter)
>>> registry.lookup((), IQ, '') is adapter
True

------------------- None ::
>>> registry.register([zope.interface.implementedBy(C2)], IP1, '', None)
>>> registry.lookup([zope.interface.implementedBy(C2)], IP1, '')
21
, None .
, , .
-
===============
::
>>> registry.register([IR1, IQ], IP2, '', '1q2')
>>> registry.lookup([IR1, IQ], IP2, '')

'1q2'
>>> registry.lookup([IR2, IQ], IP1, '')
'1q2'
>>> class IS(zope.interface.Interface):
...
pass
>>> registry.lookup([IR2, IS], IP1, '')
>>> class IQ2(IQ):
...
pass
>>> registry.lookup([IR2, IQ2], IP1, '')
'1q2'
>>> registry.register([IR1, IQ2], IP2, '', '1q22')
>>> registry.lookup([IR2, IQ2], IP1, '')
'1q22'
-
--------------- ::
>>> class Q:
...
zope.interface.implements(IQ)
,
::
>>> class IM(zope.interface.Interface):
...
pass
>>> class M:
...
zope.interface.implements(IM)
...
def __init__(self, x, q):
...
self.x, self.q = x, q
>>> registry.register([IR, IQ], IM, '', M)
`queryMultiAdapter` ::
>>> q = Q()
>>> m = registry.queryMultiAdapter((x, q), IM)
>>> m.__class__.__name__
'M'
>>> m.x is x and m.q is q
True
, , ::
>>> class M2(M):
...
pass
>>> registry.register([IR, IQ], IM, 'bob', M2)
>>> m = registry.queryMultiAdapter((x, q), IM, 'bob')
>>> m.__class__.__name__
'M2'
>>> m.x is x and m.q is q
True

---------------------


None

::
>>> registry.register([None, IQ], IP2, '', 'q2')
>>> registry.lookup([IS, IQ], IP2, '')
'q2'

================
::
>>> registry.register([], IP2, '', 2)
>>> registry.lookup([], IP2, '')
2
>>> registry.lookup([], IP1, '')
2

--------------------------------- .
::
>>> adapters = list(registry.lookupAll([IR1], IP1))
>>> adapters.sort()
>>> assert adapters == [(u'', 11), (u'bob', "Bob's 12")]
-::
>>>
>>>
>>>
>>>

registry.register([IR1, IQ2], IP2, 'bob', '1q2 for bob')

adapters = list(registry.lookupAll([IR2, IQ2], IP1))
adapters.sort()
assert adapters == [(u'', '1q22'), (u'bob', '1q2 for bob')]

::
>>>
>>>
>>>
>>>

registry.register([], IP2, 'bob', )

adapters = list(registry.lookupAll([], IP1))
adapters.sort()
assert adapters == [(u'', 2), (u'bob', )]

========

.
- . .
::
>>> registry.subscribe([IR1], IP2, 'sub12 1')
>>> registry.subscriptions([IR1], IP2)
['sub12 1']
, .
::
>>> registry.subscribe([IR1], IP2, 'sub12 2')
>>> registry.subscriptions([IR1], IP2)

['sub12 1', 'sub12 2']

,
.
None::
>>> registry.subscribe([None], IP1, 'sub_1')
>>> registry.subscriptions([IR2], IP1)
['sub_1', 'sub12 1', 'sub12 2']
, .

.
::
>>> registry.subscriptions([IR2], IP1)
['sub_1', 'sub12 1', 'sub12 2']
>>> registry.subscribe([IR1], IP1, 'sub11')
>>> registry.subscriptions([IR2], IP1)
['sub_1', 'sub12 1', 'sub12 2', 'sub11']
>>> registry.subscribe([IR2], IP2, 'sub22')
>>> registry.subscriptions([IR2], IP1)
['sub_1', 'sub12 1', 'sub12 2', 'sub11', 'sub22']
>>> registry.subscriptions([IR2], IP2)
['sub12 1', 'sub12 2', 'sub22']
::
>>> registry.subscribe([IR1, IQ], IP2, 'sub1q2')
>>> registry.subscriptions([IR1, IQ], IP2)
['sub1q2']
,
None , ::
>>> registry.subscribe([None, IQ], IP2, 'sub_q2')
>>> registry.subscriptions([IS, IQ], IP2)
['sub_q2']
>>> registry.subscriptions([IR1, IQ], IP2)
['sub_q2', 'sub1q2']
::
>>> list(registry.subscriptions([], IP1))
[]
>>> registry.subscribe([], IP2, 'sub2')
>>> registry.subscriptions([], IP1)
['sub2']
>>> registry.subscribe([], IP1, 'sub1')
>>> registry.subscriptions([], IP1)
['sub2', 'sub1']
>>> registry.subscriptions([], IP2)
['sub2']

--------------------------------

 .
::
>>> registry.unsubscribe([IR1], IP1, 'sub11')
>>> registry.subscriptions([IR1], IP1)
['sub_1', 'sub12 1', 'sub12 2']

::
>>> registry.unsubscribe([IR1], IP2)
>>> registry.subscriptions([IR1], IP1)
['sub_1']

----------------
, .
::
>>> registry.subscribe([IR, IQ], IM, M)
>>> registry.subscribe([IR, IQ], IM, M2)
>>> subscribers = registry.subscribers((x, q), IM)
>>> len(subscribers)
2
>>> class_names = [s.__class__.__name__ for s in subscribers]
>>> class_names.sort()
>>> class_names
['M', 'M2']
>>> [(s.x is x and s.q is q) for s in subscribers]
[True, True]
None::
>>> def M (x, y):
...
return None
>>> registry.subscribe([IR, IQ], IM, M )
>>> subscribers = registry.subscribers((x, q), IM)
>>> len(subscribers)
2

---------- -
. None. ,
.
None
::
>>> def handler(event):
...
print 'handler', event
>>> registry.subscribe([IR1], None, handler)
>>> registry.subscriptions([IR1], None) == [handler]
True