Ñò
¶TJJc @ s± d Z d Z d d k Z d d k Z d d k l Z l Z d d k l Z l Z d d k Z d d k
l Z l Z d d k
l Z h Z d e f d „ ƒ YZ d
e f d „ ƒ YZ d „ Z e Z d
„ Z d „ Z d „ Z d d- d „ ƒ YZ d „ Z d „ Z d „ Z d e f d „ ƒ YZ e Z e i ƒ Z d „ Z e e _ e e! f Z" d „ Z# d „ Z$ d „ Z% d e& f d „ ƒ YZ' e' Z( y d d k) Z) Wn e* j
o n Xd d k) l( Z( d e e( f d „ ƒ YZ+ d „ Z, d! „ Z- d" „ Z. d# „ Z/ d$ „ Z0 d% „ Z1 d& „ Z2 d' e& f d( „ ƒ YZ3 e3 Z4 d d) „ Z6 e ƒ Z7 y d d k) Z) Wn e* j
o n8 Xd d* k) l Z l2 Z2 d d+ k) l1 Z1 d d, k) l4 Z4 e4 ƒ Z8 d S(. sç Implementation of interface declarations
There are three flavors of declarations:
- Declarations are used to simply name declared interfaces.
- ImplementsDeclarations are used to express the interfaces that a
class implements (that instances of the class provides).
Implements specifications support inheriting interfaces.
- ProvidesDeclarations are used to express interfaces directly
provided by objects.
$Id: declarations.py 72236 2007-01-26 16:50:29Z alga $
t restructuredtextiÿÿÿÿN( t InterfaceClasst
Specification( t mergeOrderingst ro( t ClassTypet
ModuleType( t addClassAdvisort Declarationc B sS e Z d Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z e Z
RS( s Interface declarationsc G s t i | t | ƒ ƒ d S( N( R t __init__t _normalizeargs( t selft
interfaces( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR - s c C s4 t i | | ƒ y
| ` Wn t j
o n Xd S( N( R t changedt _v_attrst AttributeError( R t originally_changed( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR
0 s
c C s | i | ƒ o | | i ƒ j S( sJ Test whether an interface is in the specification
for example:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(I1): pass
...
>>> class I3(Interface): pass
...
>>> class I4(I3): pass
...
>>> spec = Declaration(I2, I3)
>>> spec = Declaration(I4, spec)
>>> int(I1 in spec)
0
>>> int(I2 in spec)
1
>>> int(I3 in spec)
1
>>> int(I4 in spec)
1
( t extendsR ( R t interface( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt __contains__7 s c C s
| i ƒ S( s{ Return an iterator for the interfaces in the specification
for example:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(I1): pass
...
>>> class I3(Interface): pass
...
>>> class I4(I3): pass
...
>>> spec = Declaration(I2, I3)
>>> spec = Declaration(I4, spec)
>>> i = iter(spec)
>>> i.next().getName()
'I4'
>>> i.next().getName()
'I2'
>>> i.next().getName()
'I3'
>>> list(i)
[]
( R ( R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt __iter__R s c C s
t | i ƒ S( sé Return an iterator of all included and extended interfaces
for example:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(I1): pass
...
>>> class I3(Interface): pass
...
>>> class I4(I3): pass
...
>>> spec = Declaration(I2, I3)
>>> spec = Declaration(I4, spec)
>>> i = spec.flattened()
>>> i.next().getName()
'I4'
>>> i.next().getName()
'I2'
>>> i.next().getName()
'I1'
>>> i.next().getName()
'I3'
>>> i.next().getName()
'Interface'
>>> list(i)
[]
( t itert __iro__( R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt flattenedn s c C sn t g } | i ƒ D]P } g } | i ƒ D]$ } | i | d ƒ o | | q+ q+ ~ p | | q q ~ Œ S( sÎ Remove interfaces from a specification
Examples:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(I1): pass
...
>>> class I3(Interface): pass
...
>>> class I4(I3): pass
...
>>> spec = Declaration()
>>> [iface.getName() for iface in spec]
[]
>>> spec -= I1
>>> [iface.getName() for iface in spec]
[]
>>> spec -= Declaration(I1, I2)
>>> [iface.getName() for iface in spec]
[]
>>> spec = Declaration(I2, I4)
>>> [iface.getName() for iface in spec]
['I2', 'I4']
>>> [iface.getName() for iface in spec - I4]
['I2']
>>> [iface.getName() for iface in spec - I1]
['I4']
>>> [iface.getName() for iface
... in spec - Declaration(I3, I4)]
['I2']
i ( R R R ( R t othert _[1]t it _[2]t j( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt __sub__ s $c C s” h } g } x< | i ƒ D]. } | | j o d | | <| i | ƒ q q Wx< | i ƒ D]. } | | j o d | | <| i | ƒ qX qX Wt | Œ S( s Add two specifications or a specification and an interface
Examples:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(I1): pass
...
>>> class I3(Interface): pass
...
>>> class I4(I3): pass
...
>>> spec = Declaration()
>>> [iface.getName() for iface in spec]
[]
>>> [iface.getName() for iface in spec+I1]
['I1']
>>> [iface.getName() for iface in I1+spec]
['I1']
>>> spec2 = spec
>>> spec += I1
>>> [iface.getName() for iface in spec]
['I1']
>>> [iface.getName() for iface in spec2]
[]
>>> spec2 += Declaration(I3, I4)
>>> [iface.getName() for iface in spec2]
['I3', 'I4']
>>> [iface.getName() for iface in spec+spec2]
['I1', 'I3', 'I4']
>>> [iface.getName() for iface in spec2+spec]
['I3', 'I4', 'I1']
i ( R t appendR ( R R t seent resultR ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt __add__º s %
( t __name__t
__module__t __doc__R R
R R R R R! t __radd__( ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR * s ! + 2t
Implementsc B s, e Z d Z d Z d Z d „ Z d „ Z RS( t ?c C s d | i S( Ns ( R" ( R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt __repr__ÿ s c C s t | i f f S( N( t
implementedByt inherit( R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt
__reduce__ s N( ( R" R# t NoneR* t declaredR( R+ ( ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR& õ s
c C s‡ y | i i d ƒ } Wn} t j
oq t | d d ƒ } | d j o& t i | ƒ } | d j o | St S| i t j o | St t
| f ƒ Œ SXt | t ƒ o | S| d j o% t i | ƒ } | d j o | Sn | d j o. | f } t t
| ƒ Œ } d | _ | `
n€ y
| i } Wn9 t j
o- t | ƒ p t d | ƒ ‚ n d } n Xt g } | D] } | t | ƒ qo~ Œ } | | _ t | d d ƒ p d d t | d d ƒ p d | _ yr | | _
t | d ƒ p
t | _ n t | t ƒ o8 d | i j o( t | t | d t | ƒ ƒ ƒ | _ n Wn@ t j
o4 t | t ƒ p t d
| ƒ ‚ n | t | >> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(I1): pass
...
>>> class I3(Interface): pass
...
>>> class I4(I3): pass
...
>>> class C1(object):
... implements(I2)
>>> class C2(C1):
... implements(I3)
>>> [i.getName() for i in implementedBy(C2)]
['I3', 'I2']
Really, any object should be able to receive a successful answer, even
an instance:
>>> class Callable(object):
... def __call__(self):
... return self
>>> implementedBy(Callable())
Note that the name of the spec ends with a '?', because the `Callable`
instance does not have a `__name__` attribute.
t __implemented__s$ ImplementedBy called for non-factoryR# R' t .R" t __providedBy__t __provides__t __class__s! ImplementedBy called for non-typeN( ( t __dict__t getR t getattrR, t# BuiltinImplementationSpecificationst _emptyR2 R& R R
t
isinstanceR* R. t __bases__t callablet TypeErrorR) R" t hasattrt objectSpecificationDescriptorR0 t DescriptorAwareMetaClassest
ClassProvidest typeR1 ( t clst spect basesR t c( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt implementedByFallback s\ &
- 7
&c G s/ t | ƒ } d | _ d | _ t | | Œ d S( sü 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:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(Interface): pass
...
>>> class I3(Interface): pass
...
>>> class I4(Interface): pass
...
>>> class A(object):
... implements(I3)
>>> class B(object):
... implements(I4)
>>> class C(A, B):
... pass
>>> classImplementsOnly(C, I1, I2)
>>> [i.getName() for i in implementedBy(C)]
['I1', 'I2']
Instances of ``C`` provide only ``I1``, ``I2``, and regardless of
whatever interfaces instances of ``A`` and ``B`` implement.
N( ( R) R- R, R* t classImplements( RA R RB ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt classImplementsOnly s ! c G sá t | ƒ } | i t t | ƒ ƒ 7_ g } h } x9 | i D]. } | | j o d | | <| i | ƒ q= q= W| i d j oO xL | i i D]: } t | ƒ } | | j o d | | <| i | ƒ qŒ qŒ Wn t | ƒ | _ d S( s¸ 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:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(Interface): pass
...
>>> class I3(Interface): pass
...
>>> class I4(Interface): pass
...
>>> class I5(Interface): pass
...
>>> class A(object):
... implements(I3)
>>> class B(object):
... implements(I4)
>>> class C(A, B):
... pass
>>> classImplements(C, I1, I2)
>>> [i.getName() for i in implementedBy(C)]
['I1', 'I2', 'I3', 'I4']
>>> classImplements(C, I5)
>>> [i.getName() for i in implementedBy(C)]
['I1', 'I2', 'I5', 'I3', 'I4']
Instances of ``C`` provide ``I1``, ``I2``, ``I5``, and whatever
interfaces instances of ``A`` and ``B`` provide.
i N( R) R- t tupleR
R R* R, R9 ( RA R RB RC R t bRD ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyRF ¥ s" '
c C s* | i d \ } } | ` | | | Œ | S( Nt __implements_advice_data__( R3 RJ ( RA R RF ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt _implements_adviceá s
t implementerc B s e Z d „ Z d „ Z RS( c G s
| | _ d S( N( R ( R R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR ê s c C se t | t ƒ o t d ƒ ‚ n t | i Œ } y
| | _ Wn" t j
o t d | ƒ ‚ n X| S( NsX Can't use implementer with classes. Use one of the class-declaration functions instead.s Can't declare implements( R8 R> R; R& R R. R ( R t obRB ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt __call__í s
( R" R# R RN ( ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyRL è s c C s¢ t i d ƒ } | i } | | i j p! d | j o( t i d d j o t | d ƒ ‚ n d | j o t | d ƒ ‚ n | | f | d >> from zope.interface import Interface
>>> class IA1(Interface): pass
...
>>> class IA2(Interface): pass
...
>>> class IB(Interface): pass
...
>>> class IC(Interface): pass
...
>>> class A(object): implements(IA1, IA2)
...
>>> class B(object): implements(IB)
...
>>> class C(A, B):
... implements(IC)
>>> ob = C()
>>> int(IA1 in providedBy(ob))
1
>>> int(IA2 in providedBy(ob))
1
>>> int(IB in providedBy(ob))
1
>>> int(IC in providedBy(ob))
1
Instances of ``C`` implement ``I1``, ``I2``, and whatever interfaces
instances of ``A`` and ``B`` implement.
t
implementsN( RX RF ( R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyRY
s >> from zope.interface import Interface
>>> class IA1(Interface): pass
...
>>> class IA2(Interface): pass
...
>>> class IB(Interface): pass
...
>>> class IC(Interface): pass
...
>>> class A(object): implements(IA1, IA2)
...
>>> class B(object): implements(IB)
...
>>> class C(A, B):
... implementsOnly(IC)
>>> ob = C()
>>> int(IA1 in providedBy(ob))
0
>>> int(IA2 in providedBy(ob))
0
>>> int(IB in providedBy(ob))
0
>>> int(IC in providedBy(ob))
1
Instances of ``C`` implement ``IC``, regardless of what
instances of ``A`` and ``B`` implement.
t implementsOnlyN( RX RG ( R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyRZ H s 8t Providesc B s/ e Z d Z d „ Z d „ Z d Z d „ Z RS( s Implement __provides__, the instance-specific specification
When an object is pickled, we pickle the interfaces that it implements.
c G s: | f | | _ | | _ t i | | t | ƒ f Œ d S( N( t _Provides__argst _clsR R R) ( R RA R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR Œ s c C s
t | i f S( N( R[ R\ ( R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR+ ‘ s s zope.interfacec C s2 | d j o | | i j o | St d ƒ ‚ d S( sÍ Make sure that a class __provides__ doesn't leak to an instance
For example:
>>> from zope.interface import Interface
>>> class IFooFactory(Interface): pass
...
>>> class C(object):
... pass
>>> C.__provides__ = ProvidesClass(C, IFooFactory)
>>> [i.getName() for i in C.__provides__]
['IFooFactory']
>>> getattr(C(), '__provides__', 0)
0
R1 N( R, R] R ( R t instRA ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt __get__– s ( R" R# R$ R R+ R_ ( ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR[ † s
c G s: t i | ƒ } | d j o t | Œ } | t | >> import gc
>>> def collect():
... for i in range(4):
... gc.collect()
)
>>> collect()
>>> before = len(InstanceDeclarations)
>>> class C(object):
... pass
>>> from zope.interface import Interface
>>> class I(Interface):
... pass
>>> c1 = C()
>>> c2 = C()
>>> len(InstanceDeclarations) == before
1
>>> directlyProvides(c1, I)
>>> len(InstanceDeclarations) == before + 1
1
>>> directlyProvides(c2, I)
>>> len(InstanceDeclarations) == before + 1
1
>>> del c1
>>> collect()
>>> len(InstanceDeclarations) == before + 1
1
>>> del c2
>>> collect()
>>> len(InstanceDeclarations) == before
1
N( t InstanceDeclarationsR4 R, t
ProvidesClass( R RB ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR[ · s
7
c G sí t | d d ƒ } | d j o= t | d d ƒ | j o$ t | t ƒ p t d ƒ ‚ q\ n t | ƒ } | d j o t | ƒ } n t } x) t D]! } t | | ƒ o t } Pq’ q’ W| o t
| | | Œ | _ n t | | Œ | _ d S( s« Declare interfaces declared directly for an object
The arguments after the object are one or more interfaces or interface
specifications (``IDeclaration`` objects).
The interfaces given (including the interfaces in the specifications)
replace interfaces previously declared for the object.
Consider the following example:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(Interface): pass
...
>>> class IA1(Interface): pass
...
>>> class IA2(Interface): pass
...
>>> class IB(Interface): pass
...
>>> class IC(Interface): pass
...
>>> class A(object): implements(IA1, IA2)
...
>>> class B(object): implements(IB)
...
>>> class C(A, B):
... implements(IC)
>>> ob = C()
>>> directlyProvides(ob, I1, I2)
>>> int(I1 in providedBy(ob))
1
>>> int(I2 in providedBy(ob))
1
>>> int(IA1 in providedBy(ob))
1
>>> int(IA2 in providedBy(ob))
1
>>> int(IB in providedBy(ob))
1
>>> int(IC in providedBy(ob))
1
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)
>>> int(I1 in providedBy(ob))
1
>>> int(I2 in providedBy(ob))
0
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:
>>> int(I2 in providedBy(ob))
0
>>> directlyProvides(ob, directlyProvidedBy(ob), I2)
adds ``I2`` to the interfaces directly provided by ob::
>>> int(I2 in providedBy(ob))
1
R2 sH Attempt to make an interface declaration on a non-descriptor-aware classN(
R5 R, R8 R> R; R
R@ t Falset
issubclasst TrueR? R1 R[ ( t objectR RA t issubt damc( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt directlyProvidesø s P&
c G s t | t | ƒ | Œ d S( s„ Declare interfaces declared directly for an object
The arguments after the object are one or more interfaces or interface
specifications (``IDeclaration`` objects).
The interfaces given (including the interfaces in the specifications) are
added to the interfaces previously declared for the object.
Consider the following example:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(Interface): pass
...
>>> class IA1(Interface): pass
...
>>> class IA2(Interface): pass
...
>>> class IB(Interface): pass
...
>>> class IC(Interface): pass
...
>>> class A(object): implements(IA1, IA2)
...
>>> class B(object): implements(IB)
...
>>> class C(A, B):
... implements(IC)
>>> ob = C()
>>> directlyProvides(ob, I1)
>>> int(I1 in providedBy(ob))
1
>>> int(I2 in providedBy(ob))
0
>>> int(IA1 in providedBy(ob))
1
>>> int(IA2 in providedBy(ob))
1
>>> int(IB in providedBy(ob))
1
>>> int(IC in providedBy(ob))
1
>>> alsoProvides(ob, I2)
>>> int(I1 in providedBy(ob))
1
>>> int(I2 in providedBy(ob))
1
>>> int(IA1 in providedBy(ob))
1
>>> int(IA2 in providedBy(ob))
1
>>> int(IB in providedBy(ob))
1
>>> int(IC in providedBy(ob))
1
The object, ``ob`` provides ``I1``, ``I2``, and whatever interfaces
instances have been declared for instances of ``C``. Notice that the
alsoProvides just extends the provided interfaces.
N( Rh t directlyProvidedBy( Re R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt alsoProvides` s Ac C s; t | t | ƒ | ƒ | i | ƒ o t d ƒ ‚ n d S( s:
This removes a directly provided interface from an object.
Consider the following two interfaces:
>>> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(Interface): pass
...
``I1`` is provided through the class, ``I2`` is directly provided
by the object:
>>> class C(object):
... implements(I1)
>>> c = C()
>>> alsoProvides(c, I2)
>>> I2.providedBy(c)
True
Remove I2 from c again:
>>> noLongerProvides(c, I2)
>>> I2.providedBy(c)
False
Removing an interface that is provided through the class is not possible:
>>> noLongerProvides(c, I1)
Traceback (most recent call last):
...
ValueError: Can only remove directly provided interfaces.
s- Can only remove directly provided interfaces.N( Rh Ri t
providedByt
ValueError( Re R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt noLongerProvides£ s #t ClassProvidesBasePyc B s e Z d „ Z RS( c C s: | | i j o | d j o | S| i St d ƒ ‚ d S( NR1 ( R] R, RX R ( R R^ RA ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR_ Ì s
( R" R# R_ ( ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyRn Ê s ( t ClassProvidesBaseR? c B s) e Z d Z d „ Z d „ Z e i Z RS( se Special descriptor for class __provides__
The descriptor caches the implementedBy info, so that
we can get declarations for objects without instance-specific
interfaces a bit quicker.
For example:
>>> from zope.interface import Interface
>>> class IFooFactory(Interface):
... pass
>>> class IFoo(Interface):
... pass
>>> class C(object):
... implements(IFoo)
... classProvides(IFooFactory)
>>> [i.getName() for i in C.__provides__]
['IFooFactory']
>>> [i.getName() for i in C().__provides__]
['IFoo']
c G sL | | _ t | ƒ | _ | | f | | _ t i | | t | ƒ f Œ d S( N( R] R) RX t _ClassProvides__argsR R ( R RA t metaclsR ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR ü s c C s | i | i f S( N( R2 Rp ( R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR+ s ( R" R# R$ R R+ Ro R_ ( ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR? ä s c C sE t | d d ƒ } | d j p t | t ƒ o t St | i d ƒ S( sp Return the interfaces directly provided by the given object
The value returned is an ``IDeclaration``.
R1 iÿÿÿÿN( R5 R, R8 R& R7 R R9 ( Re t provides( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyRi s
c G s† t i d ƒ } | i } | | i j p
d | j o t d ƒ ‚ n d | j o t d ƒ ‚ n t | ƒ | d >> from zope.interface import Interface
>>> class IFoo(Interface): pass
...
>>> class IFooFactory(Interface): pass
...
>>> class C(object):
... implements(IFoo)
... classProvides(IFooFactory)
>>> [i.getName() for i in C.__providedBy__]
['IFooFactory']
>>> [i.getName() for i in C().__providedBy__]
['IFoo']
if equivalent to:
>>> from zope.interface import Interface
>>> class IFoo(Interface): pass
...
>>> class IFooFactory(Interface): pass
...
>>> class C(object):
... implements(IFoo)
>>> directlyProvides(C, IFooFactory)
>>> [i.getName() for i in C.__providedBy__]
['IFooFactory']
>>> [i.getName() for i in C().__providedBy__]
['IFoo']
If classProvides is called outside of a class definition, it fails.
>>> classProvides(IFooFactory)
Traceback (most recent call last):
...
TypeError: classProvides can be used only from a class definition.
i R# s7 classProvides can be used only from a class definition.R1 s: classProvides can only be used once in a class definition.RO i N( RP RQ RR RS R; R
R t _classProvides_advice( R RV RW ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt
classProvides s B
c C s$ | i d } | ` t | | Π| S( NR1 ( R3 R1 Rh ( RA R ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyRs k s
c G s t i d ƒ } | i } | | i j p
d | j o t d ƒ ‚ n d | j o t d ƒ ‚ n t t t | ƒ Œ | d >> from zope.interface import Interface
>>> class I1(Interface): pass
...
>>> class I2(Interface): pass
...
>>> class I3(Interface): pass
...
>>> class I31(I3): pass
...
>>> class I4(Interface): pass
...
>>> class I5(Interface): pass
...
>>> class A(object): implements(I1)
...
>>> class B(object): __implemented__ = I2
...
>>> class C(A, B): implements(I31)
...
>>> c = C()
>>> directlyProvides(c, I4)
>>> [i.getName() for i in providedBy(c)]
['I4', 'I31', 'I1', 'I2']
>>> [i.getName() for i in providedBy(c).flattened()]
['I4', 'I31', 'I3', 'I1', 'I2', 'Interface']
>>> int(I1 in providedBy(c))
1
>>> int(I3 in providedBy(c))
0
>>> int(providedBy(c).extends(I3))
1
>>> int(providedBy(c).extends(I31))
1
>>> int(providedBy(c).extends(I5))
0
>>> class COnly(A, B): implementsOnly(I31)
...
>>> class D(COnly): implements(I5)
...
>>> c = D()
>>> directlyProvides(c, I4)
>>> [i.getName() for i in providedBy(c)]
['I4', 'I5', 'I31']
>>> [i.getName() for i in providedBy(c).flattened()]
['I4', 'I5', 'I31', 'I3', 'Interface']
>>> int(I1 in providedBy(c))
0
>>> int(I3 in providedBy(c))
0
>>> int(providedBy(c).extends(I3))
1
>>> int(providedBy(c).extends(I1))
0
>>> int(providedBy(c).extends(I31))
1
>>> int(providedBy(c).extends(I5))
1
( R[ ( t directRA ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt ObjectSpecification› s Bc C sR t | d d ƒ } | d j o | Sy
| i } Wn t j
o t SXt | ƒ S( NR1 ( R5 R, R2 R R7 R) ( RM Rr RA ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt getObjectSpecificationß s
c C s¾ y
| i } Wn t j
o t | ƒ SXy | i Wn‚ t j
ov y
| i } Wn t j
o t | i ƒ SXy | i i } Wn t j
o | SX| | j o t | i ƒ Sn X| S( N( R0 R Rx R R1 R) R2 ( RM t rt cp( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyRk í s$
t ObjectSpecificationDescriptorPyc B s e Z d Z d „ Z RS( s„ Implement the `__providedBy__` attribute
The `__providedBy__` attribute computes the interfaces peovided by
an object.
c C sF | d j o t | ƒ St | d d ƒ } | d j o | St | ƒ S( sú Get an object specification for an object
For example:
>>> from zope.interface import Interface
>>> class IFoo(Interface): pass
...
>>> class IFooFactory(Interface): pass
...
>>> class C(object):
... implements(IFoo)
... classProvides(IFooFactory)
>>> [i.getName() for i in C.__providedBy__]
['IFooFactory']
>>> [i.getName() for i in C().__providedBy__]
['IFoo']
R1 N( R, Rx R5 R) ( R R^ RA Rr ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR_ & s
( R" R# R$ R_ ( ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR{ s c C ss | d j o
g } n | i } t | i j p t | i j o | i | ƒ n x | D] } t | | ƒ qX W| S( sË Normalize declaration arguments
Normalization arguments might contain Declarions, tuples, or single
interfaces.
Anything but individial interfaces or implements specs will be expanded.
N( R, R2 R t __mro__R& R R
( t sequencet outputRA t v( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyR
J s
( R) Rk ( Rx ( t ObjectSpecificationDescriptor( (9 R$ t
__docformat__RP t weakreft zope.interface.interfaceR R R R t
exceptionst typesR R t zope.interface.adviceR R6 R R& RE R) RG RF RK RL RX RY RZ R[ Ra t WeakValueDictionaryR` Rd t __safe_for_unpickling__R@ R> Rh Rj Rm Re Rn Ro t _zope_interface_coptimizationst ImportErrorR? Ri Rt Rs Ru Rw Rx Rk R{ R€ R, R
R7 R= ( ( ( sA /usr/lib64/python2.6/site-packages/zope/interface/declarations.pyt sp Ë x & < > >+ = h C '$ Q * D 2'