+
    -½i”)  ã                   ó˜   € ^ RI t ^ RIHt ^ RIHt ^ RIHt ^ RIHt ^ RIHt ^ RIH	t	 . t
 ! R R	4      t ! R
 R]4      tR t]! 4       tR# )é    N)ÚFunctionType)Ú	Interface)ÚclassImplements)ÚInterfaceClass)Ú_decorator_non_return)ÚfromFunctionc                   ó&   a € ] tR t^ t o R tRtV tR# )Úoptionalc                ó(   € VP                   V n         R # ©N©Ú__doc__)ÚselfÚmethods   &&Ú@/usr/lib/python3/dist-packages/zope/interface/common/__init__.pyÚ__init__Úoptional.__init__$   s   € Ø—~‘~ˆŽó    r   N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__r   Ú__static_attributes__Ú__classdictcell__©Ú__classdict__s   @r   r
   r
       s   ø‡ € ÷&ð &r   r
   c                   ó|   a € ] tR t^(t o RtR t]R 4       tR t]R 4       t	]R 4       t
R tRR	 ltR
 tR tRtV tR# )ÚABCInterfaceClassa 
  
An interface that is automatically derived from a
:class:`abc.ABCMeta` type.

Internal use only.

The body of the interface definition *must* define
a property ``abc`` that is the ABC to base the interface on.

If ``abc`` is *not* in the interface definition, a regular
interface will be defined instead (but ``extra_classes`` is still
respected).

Use the ``@optional`` decorator on method definitions if
the ABC defines methods that are not actually required in all cases
because the Python language has multiple ways to implement a protocol.
For example, the ``iter()`` protocol can be implemented with
``__iter__`` or the pair ``__len__`` and ``__getitem__``.

When created, any existing classes that are registered to conform
to the ABC are declared to implement this interface. This is *not*
automatically updated as the ABC registry changes. If the body of the
interface definition defines ``extra_classes``, it should be a
tuple giving additional classes to declare implement the interface.

Note that this is not fully symmetric. For example, it is usually
the case that a subclass relationship carries the interface
declarations over::

    >>> from zope.interface import Interface
    >>> class I1(Interface):
    ...     pass
    ...
    >>> from zope.interface import implementer
    >>> @implementer(I1)
    ... class Root(object):
    ...     pass
    ...
    >>> class Child(Root):
    ...     pass
    ...
    >>> child = Child()
    >>> isinstance(child, Root)
    True
    >>> from zope.interface import providedBy
    >>> list(providedBy(child))
    [<InterfaceClass __main__.I1>]

However, that's not the case with ABCs and ABC interfaces. Just
because ``isinstance(A(), AnABC)`` and ``isinstance(B(), AnABC)``
are both true, that doesn't mean there's any class hierarchy
relationship between ``A`` and ``B``, or between either of them
and ``AnABC``. Thus, if ``AnABC`` implemented ``IAnABC``, it would
not follow that either ``A`` or ``B`` implements ``IAnABC`` (nor
their instances provide it)::

    >>> class SizedClass(object):
    ...     def __len__(self): return 1
    ...
    >>> from collections.abc import Sized
    >>> isinstance(SizedClass(), Sized)
    True
    >>> from zope.interface import classImplements
    >>> classImplements(Sized, I1)
    None
    >>> list(providedBy(SizedClass()))
    []

Thus, to avoid conflicting assumptions, ABCs should not be
declared to implement their parallel ABC interface. Only concrete
classes specifically registered with the ABC should be declared to
do so.

.. versionadded:: 5.0.0
c           	     ó8  € Wn         VP                  R R4      pVP                  RR4      pRV9  d;   \        P                  ! WW#4       \        P                  WV4       \        V n        R# VP                  R4      pW`n        \        V4      V n	        \        V4      V n
        VR,          VP                   8X  g	   Q W34       h\        V4      P                  4        UUu/ uF`  w  rx\        V\        4      '       g   K  V P                  V4      '       d   K6  V P!                  V4      '       d   KO  WpP#                  W‡4      bKb  	  p	ppV P%                  V4      V	R&   V	P'                  V4       \        P                  ! WW)4       V P                  4        R# u uppi )Úextra_classesÚignored_classesÚabcNºé   NNr   © )r   Úpopr   r   r   Ú$_ABCInterfaceClass__register_classesÚ	__class__Ú_ABCInterfaceClass__abcÚtupleÚ!_ABCInterfaceClass__extra_classesÚ#_ABCInterfaceClass__ignored_classesÚvarsÚitemsÚ
isinstancer   Ú#_ABCInterfaceClass__is_private_nameÚ,_ABCInterfaceClass__is_reverse_protocol_nameÚ(_ABCInterfaceClass__method_from_functionÚ$_ABCInterfaceClass__create_class_docÚupdate)
r   ÚnameÚbasesÚattrsr    r!   Úbased_onÚkÚvÚmethodss
   &&&&      r   r   ÚABCInterfaceClass.__init__z   si  € àŒØŸ	™	 /°2Ó6ˆØŸ)™)Ð$5°rÓ:ˆà˜Ôô ×#Ò# D°Ô=Ü×0Ñ0Ø _ôô ,ˆDŒNÙà—9‘9˜UÓ#ˆØŒ
Ü$ ]Ó3ˆÔÜ!& Ó!7ˆÔà�B�x˜8×,Ñ,Ô,Ð>¨tÐ.>Ó>Ð,ô
 ˜X›×,Ñ,Ô.ô	
ñ /‘�Ü˜!œ\×*ô 1ð ×&Ñ& q×)ô 1ð ×/Ñ/°×2ô	 1ˆA×*Ñ*¨1Ó0Ò0Ù.ð	 	ñ 
ð "×4Ñ4°UÓ;ˆ�	Ñà�‰�uÔÜ×Ò ¨EÔ;Ø×ÑÖ!ùó
s   ÃFÃ>FÄFÄ0Fc                ó  € V P                  4        UUu/ uF  w  r\        V\        4      '       g   K  WbK!  	  pppV F  p\        W&   K  	  V'       g   R # RRP	                  R VP                  4        4       4      ,           pV# u uppi )Ú z)

The following methods are optional:
 - z
-c              3   óH   "  € T F  w  rV R VP                    2x € K  	  R# 5i)Ú
Nr   )Ú.0r9   r:   s   &  r   Ú	<genexpr>Ú?ABCInterfaceClass.__optional_methods_to_docs.<locals>.<genexpr>©   s&   é € ð K
Ù,=¡D Aˆqˆc��A—I‘I�;ÕÓ,=ùs   ‚ ")r.   r/   r
   r   Újoin)r7   r9   r:   Ú	optionalsÚdocss   &    r   Ú__optional_methods_to_docsÚ,ABCInterfaceClass.__optional_methods_to_docs    s}   € à&+§k¡k¤mÔO¡m™d˜a´zÀ!ÄX×7N”T�Q’T¡mˆ	ÑOÛˆAÜ,ˆE‹Hñ ÷ Ùà=ÀÇ
Á
ñ K
Ø,5¯O©OÔ,=óK
ó A
õ 
ˆð ˆùó Ps
   ”B³Bc                ó²  a€ V P                   pR  oRP                  V3R l\        V P                  4       SR7       4       4      pV'       d
   RV,           pVP                  ;'       g    RpVP                  4       pV'       d
   V^ ,          MRpRP                  VP                  VP                  VP                  RV4      V P                  V4      V4      pV# )c                 ó’   € V P                   pV P                  pV\        P                   8X  d
   R V,          # VR8X  d   RpRV RV R2# )z`%s`Ú_ioÚioÚ`Ú.)r   r   Ústr)ÚcÚmodr5   s   &  r   ÚrefÚ1ABCInterfaceClass.__create_class_doc.<locals>.ref±   sK   € Ø—,‘,ˆCØ—:‘:ˆDØ”c—n‘nÔ$Ø •}Ð$Ø�eŒ|Ø�Ø�s�e˜1˜T˜F !Ð$Ð$r   z
 - c              3   ó4   <"  € T F  pS! V4      x € K  	  R # 5ir   r%   )rA   rP   rR   s   & €r   rB   Ú7ABCInterfaceClass.__create_class_doc.<locals>.<genexpr>º   s   øé € ð +
áD�ñ ��FˆFÛDùs   ƒ)Úkeyz!

Known implementations are:

 - r>   z&Interface for the ABC `{}.{}`.

{}{}{}r   )r)   rD   ÚsortedÚgetRegisteredConformersr   Ú
splitlinesÚformatr   r   ÚgetÚ,_ABCInterfaceClass__optional_methods_to_docs)r   r7   r8   Úimplementations_docÚbased_on_docÚdocrR   s   &&    @r   Ú__create_class_docÚ$ABCInterfaceClass.__create_class_doc®   sÉ   ø€ Ø—:‘:ˆò	%ð &Ÿl™lô +
ä˜D×8Ñ8Ó:ÀÕDó+
ó 
Ð÷ à7Ð:MÕMð  ð !×(Ñ(×.Ð.¨BˆØ#×.Ñ.Ó0ˆß*6�| A–¸Bˆà<×CÑCØ×Ñ ×!2Ñ!2Ø�I‰I�i Ó.Ø×+Ñ+¨EÓ2Øó	
ˆð ˆ
r   c                ó„   € V P                  R 4      '       d   V P                  R 4      '       d   R# V P                  R4      # )Ú__FÚ_©Ú
startswithÚendswith©r5   s   &r   Ú__is_private_nameÚ#ABCInterfaceClass.__is_private_nameÏ   s1   € à�?‰?˜4× Ò  T§]¡]°4×%8Ò%8ÙØ�‰˜sÓ#Ð#r   c                óV   € V P                  R 4      ;'       d    V P                  R4      # )Ú__rrc   re   rh   s   &r   Ú__is_reverse_protocol_nameÚ,ABCInterfaceClass.__is_reverse_protocol_nameÕ   s$   € ð �‰˜uÓ%×=Ð=¨$¯-©-¸Ó*=Ð=r   c                óP   € \        WVR 7      pVP                  R,          Vn        V# )rh   r#   )r   Ú
positional)r   Úfunctionr5   r   s   &&& r   Ú__method_from_functionÚ(ABCInterfaceClass.__method_from_functionÝ   s(   € Ü˜h°4Ô8ˆð #×-Ñ-¨bÕ1ˆÔØˆr   Nc                óŽ   € Ve   TMV P                  4       pVe   TMV P                  pV F  pWC9   d   K  \        W@4       K  	  R # r   )rX   r,   r   )r   Ú
conformersr!   ÚignoredÚclss   &&&  r   Ú__register_classesÚ$ABCInterfaceClass.__register_classesä   sQ   € ð %Ò0‰JØ×-Ñ-Ó/ð 	ð
  /Ò:‰OØ×'Ñ'ð 	ó ˆCØŒ~ÙÜ˜CÖ&ó r   c                ó   € V P                   # )z+
Return the ABC this interface represents.
)r)   )r   s   &r   ÚgetABCÚABCInterfaceClass.getABCô   s   € ð �z‰zÐr   c                óÄ  € V P                   p \        VP                  4      \        VP                  4      ,           p\        \        P                  ! W P                  4      4      #   \         do    ^ RIHp T! T4      pT^ ,          pT^,          p\        P                  ! YV4       Uu. uF	  qw! 4       NK  	  Mu upi ppT Uu. uF
  qwf   K  TNK  	  Mu upi pp L¡i ; i)zb
Return an iterable of the classes that are known to conform to
the ABC this interface parallels.
)Ú	_get_dump)r)   ÚlistÚ_abc_registryÚ
_abc_cacheÚAttributeErrorr"   r~   Ú	itertoolsÚchainÚsetr+   )r   r8   Ú
registeredr~   ÚdataÚregistryÚcacheÚxs   &       r   rX   Ú)ABCInterfaceClass.getRegisteredConformersú   sÅ   € ð
 —:‘:ˆð	Bä�X×+Ñ+Ó,¬t°H×4GÑ4GÓ/HÕHð ô ”9—?’? :×/CÑ/CÓDÓEÐEøô ô 	Bõ &Ù˜XÓ&ˆDØ˜A•wˆHØ˜•GˆEÜ'0§¢°xÔ'GÓHÑ'G !˜!ž#Ò'GùÒHˆJÐHÙ%/ÓA¡Z Ÿ!˜!¢ZùÒAˆJÐA‰Jð	Bús0   Ž/A& Á&ACÂ)B9Â8CÃCÃCÃCÃC)Ú__abcr(   Ú__extra_classesÚ__ignored_classesr   )NN)r   r   r   r   r   r   Ústaticmethodr\   r3   r0   r1   r2   r'   r{   rX   r   r   r   s   @r   r   r   (   so   ø‡ € ñJòb$"ðL ñó ðòðB ñ$ó ð$ð
 ñ>ó ð>òô'ò ÷Fð Fr   r   c                  ó‚   € R \         3/ 3p \        P                  ! \        .V O5!  p\        P                  ! V.V O5!   V# )ÚABCInterface)r   r   Ú__new__r   r   )Úabc_name_bases_attrsÚinstances     r   Ú_create_ABCInterfacer•     sI   € ð
 +¬Y¨L¸"Ð=ÐÜ ×(Ò(ÜðØ0ó€Hô ×Ò˜HÐ<Ð';Ô<Ø€Or   )rƒ   Útypesr   Úzope.interfacer   r   Úzope.interface.interfacer   r   r   Ú__all__r
   r   r•   r‘   r%   r   r   Ú<module>rš      sM   ðó Ý å $Ý *Ý 3Ý :Ý 1ð€÷&ñ &ôkF˜ô kFò\
ñ $Ó%‚r   