Your IP : 172.28.240.42

Current Path : /usr/lib/python2.7/dist-packages/zope/interface/
Upload File :
Current File : //usr/lib/python2.7/dist-packages/zope/interface/declarations.pyc


Kc@sdZdZddlZddlZddlmZmZddlmZddlm	Z	m
Z
mZddlm
Z
iZdefd	YZd
efdYZdZeZd
ZdZdZdd2dYZdd3dYZdZdZdZdefdYZeZejZdZee_ y ddlm!Z!e!e"fZ#Wne$k
re"fZ#nXdZ%dZ&dZ'de(fdYZ)e)Z*yddl+Z+Wne$k
rnXdd l+m*Z*d!ee*fd"YZ,d#Z-d$Z.d%Z/d&d4d'YZ0d(Z1d)Z2d*Z3d+Z4d,e(fd-YZ5e5Z6dd.Z8eZ9yddl+Z+Wne$k
rn7Xdd/l+mZm4Z4dd0l+m3Z3dd1l+m6Z6e6Z:dS(5sImplementation 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 110736 2010-04-11 10:59:30Z regebro $
trestructuredtextiN(tInterfaceClasst
Specification(tSpecificationBase(t
ModuleTypet
MethodTypetFunctionType(taddClassAdvisortDeclarationcBsSeZdZdZdZdZdZdZdZdZ	e	Z
RS(sInterface declarationscGstj|t|dS(N(Rt__init__t_normalizeargs(tselft
interfaces((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR	,scCs2tj||y
|`Wntk
r-nXdS(N(Rtchangedt_v_attrstAttributeError(Rtoriginally_changed((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR
/s


cCs|j|o||jkS(sJTest 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
        (textendsR(Rt	interface((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt__contains__6scCs
|jS(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)
          >>> [x.getName() for x in i]
          ['I4', 'I2', 'I3']
          >>> list(i)
          []
        (R(R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt__iter__QscCs
t|jS(sIReturn 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()
          >>> [x.getName() for x in i]
          ['I4', 'I2', 'I1', 'I3', 'Interface']
          >>> list(i)
          []

        (titert__iro__(R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt	flattenediscCsTtg|jD]=}g|jD]}|j|dr#|^q#s|^qS(sRemove 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(RRR(Rtothertitj((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt__sub__s$cCsi}g}x:|jD],}||krd||<|j|qqWx:|jD],}||krVd||<|j|qVqVWt|S(sAdd 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tappendR(RRtseentresultR((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt__add__s%

(t__name__t
__module__t__doc__R	R
RRRRRt__radd__(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR)s						+	2t
ImplementscBs,eZdZdZdZdZdZRS(t?cCsd|jS(Ns<implementedBy %s>(R (R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt__repr__scCst|jffS(N(t
implementedBytinherit(R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt
__reduce__sN((R R!tNoneR(tdeclaredR&R)(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR$s
	c
Cs`y|jjd}Wnutk
rt|dd}|dkrgtj|}|dk	rc|StS|jtkrz|St	t
|fSXt|tr|S|dkrtj|}|dk	r|Sn|dk	r|f}tt
|}d|_|`
nsy
|j}Wn5tk
rLt|sCtd|nd}nXtg|D]}t|^qW}||_t|ddpddt|ddpd|_ym||_
t|dst|_nt|trd|jkrt|t|d	t||_nWn<tk
r[t|tsNtd
|n|t|<nX|S(
sReturn the interfaces implemented for a class' instances

      The value returned is an IDeclaration.

      for example:

        >>> 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())
        <implementedBy zope.interface.declarations.?>

      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__tgetRtgetattrR*t#BuiltinImplementationSpecificationst_emptyR0R$RR
t
isinstanceR(R,t	__bases__tcallablet	TypeErrorR'R thasattrtobjectSpecificationDescriptorR.tDescriptorAwareMetaClassest
ClassProvidesttypeR/(tclstspectbasestc((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pytimplementedByFallbacks\&
			


%	5	%
cGs/t|}d|_d|_t||dS(sDeclare 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(tclassImplements(R?RR@((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pytclassImplementsOnlyrs!		cGst|}|jtt|7_g}i}x7|jD],}||kr=d||<|j|q=q=W|jdk	rxI|jjD]8}t|}||krd||<|j|qqWnt||_dS(sDeclare 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.
      iN(R'R+ttupleR
RR(R*R7(R?RR@RARtbRB((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRDs'

cCs*|jd\}}|`||||S(Nt__implements_advice_data__(R1RH(R?RRD((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt_implements_advices
timplementercBseZdZdZRS(cGs
||_dS(N(R(RR((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR	scCsft|tr#t||j|St|j}y
||_Wn tk
ratd|nX|S(NsCan't declare implements(R6R<RDRR$R,RR9(RtobR@((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt__call__s

(R R!R	RL(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRJs	timplementer_onlycBseZdZdZRS(cGs
||_dS(N(R(RR((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR	scCs<t|ttfr$tdnt||j|SdS(NsIThe implementor_only decorator is not supported for methods or functions.(R6RRt
ValueErrorRER(RRK((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRLs(R R!R	RL(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRMs	cCstjd}|j}||jksFd|krYtjd d	krYt|dnd|krxt|dn||f|d<ttdddS(
NiR!iis* can be used only from a class definition.RHs- can be used only once in a class definition.tdepth(iii(tsyst	_getframetf_localst	f_globalstversion_infoR9RRI(tnameRRDtframetlocals((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt_implementss	cGstd|tdS(sDeclare interfaces implemented by instances of a class

      This function is called in a class definition.

      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::


        >>> 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(RXRD(R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRYs<cGstd|tdS(suDeclare the only interfaces implemented by instances of a class

      This function is called in a class definition.

      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::

        >>> 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.

      timplementsOnlyN(RXRE(R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRZLs8tProvidescBs/eZdZdZdZdZdZRS(sImplement __provides__, the instance-specific specification

    When an object is pickled, we pickle the interfaces that it implements.
    cGs:|f||_||_tj||t|fdS(N(t_Provides__argst_clsRR	R'(RR?R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR	s	cCs
t|jfS(N(R[R\(R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR)sszope.interfacecCs/|dkr||jkr|StddS(sMake 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

        R/N(R*R]R(RtinstR?((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt__get__s(R R!R"R	R)R_(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR[s
		cGs8tj|}|dkr4t|}|t|<n|S(s~Cache instance declarations

      Instance declarations are shared among instances that have the same
      declaration. The declarations are cached in a weak value dictionary.

      (Note that, in the examples below, we are going to make assertions about
       the size of the weakvalue dictionary.  For the assertions to be
       meaningful, we need to force garbage collection to make sure garbage
       objects are, indeed, removed from the system. Depending on how Python
       is run, we may need to make multiple calls to be sure.  We provide a
       collect function to help with this:

       >>> 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(tInstanceDeclarationsR2R*t
ProvidesClass(RR@((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR[s
7
(t	ClassTypecGst|dd}|dk	rWt|dd|krWt|tsWtdqWnt|}|dkr~t|}nt}x'tD]}t||rt	}PqqW|rt
||||_nt|||_dS(sDeclare 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

      R0sHAttempt to make an interface declaration on a non-descriptor-aware classN(
R3R*R6R<R9R
R>tFalset
issubclasstTrueR=R/R[(tobjectRR?tissubtdamc((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pytdirectlyProvidessP$
cGst|t||dS(sDeclare 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(RitdirectlyProvidedBy(RfR((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pytalsoProvideshsAcCs9t|t|||j|r5tdndS(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(RiRjt
providedByRN(RfR((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pytnoLongerProvidess#tClassProvidesBasePycBseZdZRS(cCs6||jkr&|dkr|S|jStddS(NR/(R]R*RXR(RR^R?((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR_s
(R R!R_(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRns(tClassProvidesBaseR=cBs)eZdZdZdZejZRS(seSpecial 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']
    cGsL||_t||_||f||_tj||t|fdS(N(R]R'RXt_ClassProvides__argsRR	(RR?tmetaclsR((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR	s	cCs|j|jfS(N(R0Rp(R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR)
s(R R!R"R	R)RoR_(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR=s		cCsBt|dd}|dks-t|tr1tSt|jd S(spReturn the interfaces directly provided by the given object

    The value returned is an ``IDeclaration``.
    R/iN(R3R*R6R$R5RR7(Rftprovides((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRjs
cGstjd}|j}||jks3d|krBtdnd|kr]tdnt||d<ttdddS(	s-Declare interfaces provided directly by a class

      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.

      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']

      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']

      iR!s7classProvides can be used only from a class definition.R/s:classProvides can only be used once in a class definition.ROiN(RPRQRRRSR9R
Rt_classProvides_advice(RRVRW((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt
classProvides"s;	cCs$|jd}|`t|||S(NR/(R1R/Ri(R?R((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRsls

tprovidercBs eZdZdZdZRS(s(Class decorator version of classProvidescGs
||_dS(N(R(RR((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR	uscCst||j|S(N(RiR(RRK((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRLxs(R R!R"R	RL(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRurs	cGsztjd}|j}||jk	s3d|krBtdnd|kr]tdnttt||d<dS(sDeclare 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 example::

      moduleImplements(I1)

    is equivalent to::

      directlyProvides(sys.modules[__name__], I1)
    iR s9moduleProvides can only be used from a module definition.R/s<moduleProvides can only be used once in a module definition.N(RPRQRRRSR9R[RR
(RRVRW((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pytmoduleProvides|s	cCs
t||S(sProvide object specifications

    These combine information for the object and for it's classes.

    For example:

      >>> 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[(tdirectR?((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pytObjectSpecificationsBcCs`t|dd}|dk	r4t|tr4|Sny
|j}Wntk
rUtSXt|S(NR/(R3R*R6RR0RR5R'(RKRrR?((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pytgetObjectSpecifications

cCsy
|j}Wntk
r't|SXy|jWnztk
ry
|j}Wntk
rmt|jSXy|jj}Wntk
r|SX||krt|jSnX|S(N(R.RRyRR/R'R0(RKtrtcp((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyRls$





tObjectSpecificationDescriptorPycBseZdZdZRS(sImplement the `__providedBy__` attribute

    The `__providedBy__` attribute computes the interfaces peovided by
    an object.
    cCsB|dkrt|St|dd}|dk	r8|St|S(sGet 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']

        R/N(R*RyR3R'(RR^R?Rr((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR_2s
(R R!R"R_(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR|+scCsn|dkrg}n|j}t|jks<t|jkrL|j|nx|D]}t||qSW|S(sNormalize declaration arguments

    Normalization arguments might contain Declarions, tuples, or single
    interfaces.

    Anything but individial interfaces or implements specs will be expanded.
    N(R*R0Rt__mro__R$RR
(tsequencetoutputR?tv((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyR
Vs		
(R'Rl(Ry(tObjectSpecificationDescriptor((((;R"t
__docformat__RPtweakreftzope.interface.interfaceRRRttypesRRRtzope.interface.adviceRR4RR$RCR'RERDRIRJRMRXRYRZR[RatWeakValueDictionaryR`Ret__safe_for_unpickling__RbR>R<tImportErrorRiRkRmRfRnRot_zope_interface_coptimizationsR=RjRtRsRuRvRxRyRlR|RR*R
R5R;(((s?/usr/lib/python2.7/dist-packages/zope/interface/declarations.pyt<module>sz	x	&	<			>	>+	=	

	h	C	'
$		J	
	*	D		2'