HOME


Mini Shell 1.0
Redirecting to https://devs.lapieza.net/iniciar-sesion Redirecting to https://devs.lapieza.net/iniciar-sesion.
DIR: /proc/self/root/usr/lib/python3/dist-packages/zope/interface/__pycache__/
Upload File :
Current File : //proc/self/root/usr/lib/python3/dist-packages/zope/interface/__pycache__/interface.cpython-311.pyc
�

JDvc{���D�dZddlZddlmZddlmZddlZddlmZddlmZ	ddl
mZddlm
Zddlm
Z
gd	�Zd
ZdZdZd
Ze��Ze��Zd�Zd�ZGd�de��ZeZeGd�de����ZGd�de��ZeGd�dee����Zegd��ZGd�de��Z Gd�de!��Z"e"dee efddi��Z#d �Z$Gd!�de#��Z%e%d"d#�$��Z&d%�e&_'e&�(e&��e&j)e&fksJ�e&e _*e&e
_*Gd&�d'e%��Z+Gd(�d)e��Z,Gd*�d+e,��Z-d4d,�Z.d5d-�Z/d.�Z0dd/l1m2Z2dd0l1m3Z3dd1l
m4Z4dd2l
m5Z5dd3l1m6Z6e �(e6e6��dS)6z Interface object implementation
�N)�
MethodType)�FunctionType)�_use_c_impl)�PYTHON2)�Invalid)�ro)�InterfaceClass�
Specification�
adapter_hooks���__interface_tagged_values__�__interface_methods__c���tjd��j}|�ti��}|�dg��}|�|��tS)N��
invariants)�sys�	_getframe�f_locals�
setdefault�TAGGED_DATA�append�_decorator_non_return)�callr�tagsrs    �:/usr/lib/python3/dist-packages/zope/interface/interface.py�	invariantr2sV���}�Q���(�H����{�B�/�/�D�����r�2�2�J����d���� � �c��tjd��j}|�ti��}|||<t
S)z;Attaches a tagged value to an interface at definition time.r)rrrrrr)�key�valuer�
tagged_valuess    r�taggedValuer#:s9���}�Q���(�H��'�'��R�8�8�M��M�#�� � rc�L�eZdZdZdd�Zd�Zd�Zd�Zdd�Zd	�Z	d
�Z
eZeZe	Z
dS)
�ElementzI
    Default implementation of `zope.interface.interfaces.IElement`.
    �c�n�|s|�d��dkr|}d}||_||_d|_dS)N� r)�find�__name__�__doc__�_Element__tagged_values)�selfr*r+s   r�__init__zElement.__init__LsH���	�8�=�=��-�-��2�2��G��H� ��
���� $����rc��|jS)z! Returns the name of the object. �r*�r-s r�getNamezElement.getNameWs
���}�rc��|jS)z+ Returns the documentation for the object. )r+r1s r�getDoczElement.getDoc[s
���|�rc�H�|jst|���|j|S��* Returns the value associated with 'tag'. )r,�KeyError)r-�tags  r�getTaggedValuezElement.getTaggedValuefs'���#�	 ��3�-�-���#�C�(�(rNc�J�|jr|j�||��n|Sr6)r,�get)r-r9�defaults   r�queryTaggedValuezElement.queryTaggedValuels)��9=�9M�Z�t�#�'�'��W�5�5�5�SZ�Zrc�F�|jr|j���ndS)z# Returns a collection of all tags. �)r,�keysr1s r�getTaggedValueTagszElement.getTaggedValueTagsps$��.2�.B�J�t�#�(�(�*�*�*��Jrc�6�|j�i|_||j|<dS)z  Associates 'value' with 'key'. N)r,�r-r9r!s   r�setTaggedValuezElement.setTaggedValuets&����'�#%�D� �$)���S�!�!�!r)r&�N)r*�
__module__�__qualname__r+r.r2r4r:r>rBrE�queryDirectTaggedValue�getDirectTaggedValue�getDirectTaggedValueTagsr@rrr%r%Bs���������	$�	$�	$�	$�������)�)�)�[�[�[�[�K�K�K�*�*�*�.��)��1���rr%c�(�eZdZdZd�Zd�Zd�ZeZdS)�SpecificationBase)�_implied�_dependents�_bases�_v_attrs�__iro__�__sro__�__weakref__c�2�t|��}||jvS)z2Is the interface implemented by an object
        )�
providedByrN)r-�ob�specs   rrVzSpecificationBase.providedBy�s���"�~�~���t�}�$�$rc�2�t|��}||jvS)z�Test whether the specification is implemented by a class or factory.

        Raise TypeError if argument is neither a class nor a callable.
        )�
implementedByrN)r-�clsrXs   rrZzSpecificationBase.implementedBy�s��
�S�!�!���t�}�$�$rc��||jvS)zCIs the interface the same as or extend the given interface
        �rN)r-�	interfaces  r�isOrExtendszSpecificationBase.isOrExtends�s���D�M�)�)rN)r*rGrH�	__slots__rVrZr_�__call__r@rrrMrM�sI������
�I�%�%�%�%�%�%�*�*�*�
�H�H�HrrMc�0�eZdZdZd�Zd�Zd�Zd�Zd�ZdS)�NameAndModuleComparisonMixinr@c��||urdS|�dS|j|jf}	|j|jf}n#t$r
tcYSwxYw||k||kz
S)a�
        Compare *self* to *other* based on ``__name__`` and ``__module__``.

        Return 0 if they are equal, return 1 if *self* is
        greater than *other*, and return -1 if *self* is less than
        *other*.

        If *other* does not have ``__name__`` or ``__module__``, then
        return ``NotImplemented``.

        .. caution::
           This allows comparison to things well outside the type hierarchy,
           perhaps not symmetrically.

           For example, ``class Foo(object)`` and ``class Foo(Interface)``
           in the same file would compare equal, depending on the order of
           operands. Writing code like this by hand would be unusual, but it could
           happen with dynamic creation of types and interfaces.

        None is treated as a pseudo interface that implies the loosest
        contact possible, no contract. For that reason, all interfaces
        sort before None.
        rN���)r*rG�AttributeError�NotImplemented)r-�other�n1�n2s    r�_comparez%NameAndModuleComparisonMixin._compare�s|��0�D�=�=��1��=��2��m�T�_�
-��	"��.�%�"2�3�B�B���	"�	"�	"�!�!�!�!�	"�����R��B��G�$�$s�)�=�=c�N�|�|��}|tur|S|dkS�Nr�rkrg�r-rh�cs   r�__lt__z#NameAndModuleComparisonMixin.__lt__��,���M�M�%� � �������H��1�u�rc�N�|�|��}|tur|S|dkSrmrnros   r�__le__z#NameAndModuleComparisonMixin.__le__��,���M�M�%� � �������H��A�v�
rc�N�|�|��}|tur|S|dkSrmrnros   r�__gt__z#NameAndModuleComparisonMixin.__gt__�rrrc�N�|�|��}|tur|S|dkSrmrnros   r�__ge__z#NameAndModuleComparisonMixin.__ge__�rurN)	r*rGrHr`rkrqrtrwryr@rrrcrc�sg�������I�%%�%%�%%�N�������������rrcc�\�eZdZdZdZdd�Zd�Zed���Ze	fd�Z
d�Zd	�Zd
�Z
d�ZdS)
�
InterfaceBasez:Base class that wants to be replaced with a C base :)
    )r*�__ibmodule__�_v_cached_hashNc�"�||_||_dSrF�r*r|)r-�name�modules   rr.zInterfaceBase.__init__
s����
�"����rc��t�rF)�NotImplementedError�r-�conforms  r�
_call_conformzInterfaceBase._call_conforms��!�!rc��|jSrF)r|r1s r�__module_property__z!InterfaceBase.__module_property__s
��� � rc���	|j}n#t$rd}YnwxYw|�|�|��}|�|S|�|��}|�|S|tur|Std||���)z)Adapt an object to the interface
        NzCould not adapt)�__conform__rfr��	__adapt__�_marker�	TypeError)r-�obj�	alternater��adapters     rrazInterfaceBase.__call__s���	��o�G�G���	�	�	��G�G�G�	�������(�(��1�1�G��"����.�.��%�%�����N��G�#�#����)�3��5�5�5s�
��c�l�|�|��r|StD]}|||��}|�|cS�dS)z(Adapt an object to the receiver
        N)rVr)r-r��hookr�s    rr�zInterfaceBase.__adapt__+sV���?�?�3���	��J�!�	�	�D��d�4��o�o�G��"�����#��trc��	|jS#t$r#t|j|jf��|_YnwxYw|jSrF)r}rf�hashr*rGr1s r�__hash__zInterfaceBase.__hash__8sX��	I��&�&���	I�	I�	I�"&��
�t��'G�"H�"H�D����	I�����"�"s�	�*6�6c�N�|�|��}|tur|S|dkSrmrnros   r�__eq__zInterfaceBase.__eq__@rurc�Z�||urdS|�|��}|tur|S|dkS)NFrrnros   r�__ne__zInterfaceBase.__ne__Fs:���D�=�=��5��M�M�%� � �������H��A�v�
r�NN)r*rGrHr+r`r.r��propertyr�r�rar�r�r�r�r@rrr{r{�s����������I�#�#�#�#�"�"�"��!�!��X�!�'.�6�6�6�6�*���#�#�#��������rr{rc��eZdZdZdZdZejZejZdd�Z	e
d���Zd�Zd�Z
d�Ze
d	�e��ZeZd
�Zd�Zd�Zdd�Zdd�Zdd�ZdS)r
awSpecifications

    An interface specification is used to track interface declarations
    and component registrations.

    This class is a base class for both interfaces themselves and for
    interface specifications (declarations).

    Specifications are mutable.  If you reassign their bases, their
    relations with other specifications are adjusted accordingly.
    r@Nc��d|_d|_i|_d|_d|_d|_t
|��|_dS)Nr@)rOrPrNrQrRrS�tuple�	__bases__)r-�basess  rr.zSpecification.__init__hs@�� ��������
���
��������u������rc�N�|j�tj��|_|jSrF)rO�weakref�WeakKeyDictionaryr1s r�
dependentszSpecification.dependentszs%����#�&�8�:�:�D����rc�R�|j�|d��dz|j|<dS)Nrr)r�r<rO)r-�	dependents  r�	subscribezSpecification.subscribe�s,��&*�o�&9�&9�)�Q�&G�&G�!�&K����#�#�#rc��	|j|}n#t$rt|���wxYw|dz}|s
|j|=dS|dksJ�||j|<dS)Nrr)rOr�r8r�)r-r��ns   r�unsubscribezSpecification.unsubscribe�s��	&�� ��+�A�A���	&�	&�	&��9�%�%�%�	&����	�Q����	+���	�*�*�*��q�5�5�5�5�)*�D�O�I�&�&�&s�
�*c��|jD]}|�|���||_|D]}|�|���|�|��dSrF)r�r�rPr��changed)r-r��bs   r�
__setBaseszSpecification.__setBases�sm����	 �	 �A�
�M�M�$���������	�	�A�
�K�K���������T�����rc��|jSrF)rPr1s r�<lambda>zSpecification.<lambda>�s��T�[�rc����|�d�|jD�����}|j���/|r-|d�ur#�fd�|D��}|����|S)z�
        Calculate and return the resolution order for this object, using its ``__bases__``.

        Ensures that ``Interface`` is always the last (lowest priority) element.
        c��i|]
}||j��Sr@)rS��.0r�s  r�
<dictcomp>z0Specification._calculate_sro.<locals>.<dictcomp>�s,��/
�/
�/
��
�q�y�/
�/
�/
r)�	base_mrosNrec���g|]}|�u�|��	Sr@r@)r��x�roots  �r�
<listcomp>z0Specification._calculate_sro.<locals>.<listcomp>�s*��������D�=�=�� �=�=r)�_do_calculate_ror��_ROOTr)r-�sror�s  @r�_calculate_srozSpecification._calculate_sro�s����F�#�#�/
�/
��^�/
�/
�/
�#�����z�������B��t�(;�(;���������C�

�J�J�t�����
rc��d|_|j}|���|���}t	|��|_t	d�|D����|_|D]}d||<�t	|jr|j���nd��D]}|�	|���d|_dS)z�
        We, or something we depend on, have changed.

        By the time this is called, the things we depend on,
        such as our bases, should themselves be stable.
        Nc�<�g|]}t|t���|��Sr@��
isinstancer	)r��ancestors  rr�z)Specification.changed.<locals>.<listcomp>�s6�� � � �8�!+�H�n�!E�!E� �h� � � rr@)
rQrN�clearr�r�rSrRrOrAr�)r-�originally_changed�implied�	ancestorsr�r�s      rr�zSpecification.changed�s�����
��-���
�
�����'�'�)�)�	��Y�'�'���� � �y� � � �!�!���"�	#�	#�H� "�G�H����$�:J�R�t�/�4�4�6�6�6�PR�S�S�	2�	2�I����0�1�1�1�1�
��
�
�
rc#�jK�i}|jD]&}|���D]}||vr	d||<|V���'dS)�DReturn an iterator for the interfaces in the specification.
        rN)r��
interfaces)r-�seen�baser^s    rr�zSpecification.interfacessd�������N�	$�	$�D�!�_�_�.�.�
$�
$�	��D�(�(�&'�D��O�#�O�O�O��
$�	$�	$rTc�&�||jvo|p||kS)z�Does the specification extend the given interface?

        Test whether an interface in the specification extends the
        given interface
        r])r-r^�stricts   r�extendszSpecification.extends
s'���d�m�+�6��*�4�$�)�"3�	rc�,�tj||��SrF)r��ref)r-�callbacks  rr�zSpecification.weakrefs���{�4��*�*�*rc��|j}|�	ix}|_|�|��}|�(|jD] }|�|��}|�|||<n�!|�|n|S)z+Query for an attribute description
        )rQr<rR�direct)r-r�r=�attrs�attr�ifaces      rr<zSpecification.gets{���
���=�$&�&�E�D�M��y�y������<���
�
���|�|�D�)�)���#�"&�E�$�K��E�$��,�w�w�D�0r)r@)TrF)r*rGrHr+r`r�rMr_rVr.r�r�r�r��_Specification__setBasesr��calculate_ror�r�r�r�r�r�r<r@rrr
r
Rs,������
�
��I�
�E�$�/�K�"�-�J�&�&�&�&�$� � ��X� �
L�L�L�
+�
+�
+�
�
�
��� � ��
�
�I�$��7�7�7�r���@$�$�$�	�	�	�	�+�+�+�+�1�1�1�1�1�1rr
c�4�eZdZdZd�Zed���Zd�ZdS)�_InterfaceMetaClassr@c��tjd��jd}tjd}t|t��rtjd}||d<t�||||��}||_	|S)Nrr*rGr�)
rr�	f_globalsr{�__dict__r��str�type�__new__�_InterfaceMetaClass__module)r[r�r�r�rG�moduledescr�kinds       rr�z_InterfaceMetaClass.__new__tsz��
�]�1�%�%�/�
�;�
�$�,�\�:���k�3�'�'�	H�(�0�1F�G�K�)��l���|�|�C��u�e�4�4��"��
��rc��|jSrF)r��r[s rrGz_InterfaceMetaClass.__module__�s
���|�rc�(�d|j�d|j�d�S)Nz<class '�.z'>)r�r*r�s r�__repr__z_InterfaceMetaClass.__repr__�s ����L�L�L��L�L�L�
�	
rN)r*rGrHr`r�r�r�r@rrr�r�)sU������R�I����$����X��
�
�
�
�
rr�r	r`r@c��tjd��j}|�ti��}|||j<tS)a�
    Convert a method specification to an actual method of the interface.

    This is a decorator that functions like `staticmethod` et al.

    The primary use of this decorator is to allow interface definitions to
    define the ``__adapt__`` method, but other interface methods can be
    overridden this way too.

    .. seealso:: `zope.interface.interfaces.IInterfaceDeclaration.interfacemethod`
    r)rrrr�INTERFACE_METHODSr*r)�funcr�methodss   r�interfacemethodr��s>���}�Q���(�H��!�!�"3�R�8�8�G�!�G�D�M�� � rc��eZdZdZ		dd�Z		dd�Zd�Zd�Zd�Zd	�Z	dd�Z
d�Zdd
�Zd�Z
e
Zd�Zd�Zdd�Zdd�Zdd�Zd�Zd�Zd�Zd�Zd�Zd�ZdS)r	z�
    Prototype (scarecrow) Interfaces Implementation.

    Note that it is not possible to change the ``__name__`` or ``__module__``
    after an instance of this object has been constructed.
    Nr@c�h�t|t��sJ�|pi}|�td��}|r�|�d|vrd|�d��ini��d|vrd|d<t|t��r|f}n|tur	tf}n	|tf}t|��|dz||��}nVtrO|rMt|��dkr:td�|D����}|rt|dz|i��jd}t�
|��S)N�
__classcell__r�r�_CALL_CUSTOM_ADAPTz<WithCustomMethods>c3�xK�|]5}tt|��t���$t|��V��6dSrF)�
issubclassr�� _InterfaceClassWithCustomMethodsr�s  r�	<genexpr>z)InterfaceClass.__new__.<locals>.<genexpr>�sS����.�.���d�1�g�g�'G�H�H�.��Q���.�.�.�.�.�.r)r�r��popr��updater�r�r	r��PY2�len�__mro__�_InterfaceClassBaser�)	r[r�r�r�r+rG�needs_custom_class�	cls_bases�bases_with_custom_methodss	         rr�zInterfaceClass.__new__�s����%��'�'�'�'�'�����"�Y�Y�'8�$�?�?���*	��%�%�"�e�+�+�!�%�)�)�O�"<�"<�=�=��
�
�
�
�0�0�0�;<�"�#7�8��#�?�@�@�
D� �F�	�	���&�&�=�?�	�	� �"B�C�	��$�s�)�)��,�,��"���C�C�
�	�U�	�s�5�z�z�A�~�~�(-�.�.��.�.�.�)�)�%�)�
���0�0�-�����!�	��#�*�*�3�/�/�/rc�(�td�|D����std���|�i}|�f|�d��}t|t��r|d=n8	tjd��jd}n#ttf$rYnwxYwt�|||��|�d��}|�t|t��s|�|}|d=|�d}t�|||��|�td��}|�0|���D]\}}	|�||	���t$�||��|�|��|_|�d|��|_dS)	Nc3�@K�|]}t|t��V��dSrFr�)r�r�s  rr�z*InterfaceClass.__init__.<locals>.<genexpr>�s,����F�F��:�d�N�3�3�F�F�F�F�F�FrzExpected base interfacesrGrr*r+r&r�)�allr�r<r�r�rrr�rfr8r{r.�	Attributer%r�r�itemsrEr
�_InterfaceClass__compute_attrs�_InterfaceClass__attrs�__identifier__)
r-r�r�r�r+rG�d�tagged_datar �vals
          rr.zInterfaceClass.__init__�s���
�F�F��F�F�F�F�F�	8��6�7�7�7��=��E������<�0�0�J��*�c�*�*�	
��,�'�'��"%��q�!1�!1�!;�J�!G�J�J��&��1�����D�����	���t�T�:�6�6�6�

�I�I�i� � ���=��a��+�+�
%��?��G��)�$��?��G�����t�W�-�-�-��i�i��T�2�2���"�'�-�-�/�/�
.�
.���S��#�#�C��-�-�-�-����t�U�+�+�+��+�+�E�2�2���)3���T�T�:����s�A>�>B�Bc�P����fd���fd�|���D��S)Nc����t|t��r�|_|js||_n:t|t��rt|�|���}nt
d|z���|S)N)r�zConcrete attribute, )r�rr^r*r�fromFunction�InvalidInterface)�aname�avalr-s  �r�update_valuez4InterfaceClass.__compute_attrs.<locals>.update_value!sq����$�	�*�*�
G�!%����}�*�$)�D�M���D�,�/�/�
G�#�D�$�U�;�;�;���&�'=��'E�F�F�F��Krc�J��i|]\}}|dvr|tu�|�||���� S))�
__locals__rH�__annotations__)r)r�rrrs   �rr�z2InterfaceClass.__compute_attrs.<locals>.<dictcomp>,sW���
�
�
���t������1�1�1�
�<�<��t�,�,�2�1�1r)r)r-r�rs` @r�__compute_attrszInterfaceClass.__compute_attrssP����		�		�		�		�		�
�
�
�
�$�{�{�}�}�
�
�
�	
rc#�K�|V�dS)r�Nr@r1s rr�zInterfaceClass.interfaces:s�����
�
�
�
�
rc��|jSrF)r�r1s r�getBaseszInterfaceClass.getBases?s
���~�rc�8�||kp|�|��S)zSame interface or extends?)r�)r-rhs  r�isEqualOrExtendedByz"InterfaceClass.isEqualOrExtendedByBs���u�}�3��
�
�d� 3� 3�3rFc�&�|s|j���S|j���}|jD]B}|�t
�|�|�������C|���S)z4Return the attribute names defined by the interface.)rrA�copyr�r��dict�fromkeys�names�r-r�rr�s    rrzInterfaceClass.namesFsz���	'��<�$�$�&�&�&��L�������N�	5�	5�D�
�H�H�T�]�]�4�:�:�c�?�?�3�3�4�4�4�4��v�v�x�x�rc�H�t|�d�����S)NT)r)�iterrr1s r�__iter__zInterfaceClass.__iter__Rs���D�J�J�4�J�(�(�)�)�)rc�(�|s|j���Si}|jddd�D]7}|�t	|�|�������8|�|j��|���S)z=Return attribute names and descriptions defined by interface.Nre)rrr�r�r�namesAndDescriptionsr s    rr&z#InterfaceClass.namesAndDescriptionsUs����	(��<�%�%�'�'�'����N�4�4�R�4�(�	;�	;�D�
�H�H�T�$�3�3�C�8�8�9�9�:�:�:�:�	���������w�w�y�y�rc�R�|�|��}|�|St|���)z4Return the attribute description for the given name.)r<r8�r-r�r!s   r�getDescriptionForz InterfaceClass.getDescriptionForbs'���H�H�T�N�N���=��H��t�n�n�rc�0�|�|��duSrF�r<�r-r�s  r�__contains__zInterfaceClass.__contains__ls���x�x��~�~�T�)�)rc�6�|j�|��SrF)rr<r,s  rr�zInterfaceClass.directos���|����%�%�%rc�.�|�||��SrFr+)r-r�r=s   r�queryDescriptionForz"InterfaceClass.queryDescriptionForrs���x�x��g�&�&�&rc���|jD]W}|�dd��D]>}	||���#t$r#}|�|�|��n�Yd}~�7d}~wwxYw�X|rt|���dS)z&validate object to defined invariants.rr@N)rRrIrr)r-r��errorsr�r�errors      r�validateInvariantsz!InterfaceClass.validateInvariantsus����\�	�	�E�"�9�9�,��K�K�
�
�	���I�c�N�N�N�N�������)��
�
�e�,�,�,�,��-�,�,�,�,���������
��	"��&�/�/�!�	"�	"s�/�
A�A�Ac�j�|jD]*}|�|t��}|tur|cS�+|S)z�
        Queries for the value associated with *tag*, returning it from the nearest
        interface in the ``__iro__``.

        If not found, returns *default*.
        )rRrIr�)r-r9r=r�r!s     rr>zInterfaceClass.queryTaggedValue�sH���\�	�	�E��0�0��g�>�>�E��G�#�#�����$��rc�n�|�|t���}|turt|���|S)r7)r=)r>r�r8rDs   rr:zInterfaceClass.getTaggedValue�s6���%�%�c�7�%�;�;���G����3�-�-���rc��t��}|jD])}|�|������*|S)z Returns a list of all tags. )�setrRr�rK)r-rAr�s   rrBz!InterfaceClass.getTaggedValueTags�sB���u�u���L�	9�	9�D��K�K��5�5�7�7�8�8�8�8��rc��	|jS#t$r.t|��}d|jj�d|�d�}||_|cYSwxYw)N�<r(�>)�_v_reprrfr��	__class__r*r(s   rr�zInterfaceClass.__repr__�s`��	��<����	�	�	��t�9�9�D�D�!�^�4�4�4�d�d�d�;�A��D�L��H�H�H�		���s�	�5A�Ac�4�|j}|j}|r|�d|��}|S)Nr�r)r-r��ms   r�__str__zInterfaceClass.__str__�s.���}������	'��a�a���&�D��rc�|�	||��S#t$r"tj��dj��YnwxYwdS)N�)r�r�exc_info�tb_nextr�s  rr�zInterfaceClass._call_conform�sZ��
	��7�4�=�=� ���	�	�	��|�~�~�a� �(�4��5�4�	�����ts�

�)9�9c��|jSrFr0r1s r�
__reduce__zInterfaceClass.__reduce__�s
���}�r)Nr@NNN)r@NNN)FrF)r*rGrHr+r�r.rr�rrrr$r&r)�__getitem__r-r�r0r4r>r:rBr�r@r�rFr@rrr	r	�s���������?C��10�10�10�10�f<@� �1;�1;�1;�1;�f
�
�
�8���
���4�4�4�
�
�
�
�*�*�*��������$�K�*�*�*�&�&�&�'�'�'�'�"�"�"�"� �������������������&����r�	Interfacezzope.interface)rGc��tfSrF)rHr@rrr�r��s��I�<�rc��eZdZdZdS)r�z_
    Marker class for interfaces with custom methods that override InterfaceClass methods.
    N)r*rGrHr+r@rrr�r��s���������rr�c�(�eZdZdZdZd�Zd�Zd�ZdS)rzAttribute descriptions
    Nc��dS)z/Return extra data to put at the end of __str__.r&r@r1s r�
_get_str_infozAttribute._get_str_info�s���rrc��d}|j�|jjdz|jjzdz}||jpdz|���zS)Nr&r�z	<unknown>)r^rGr*rM)r-�ofs  rr@zAttribute.__str__�sP��
���>�%���*�S�0�4�>�3J�J�S�P�B��T�]�1�k�2�T�5G�5G�5I�5I�I�Irc�v�dt|��jt|��jt|��|fzS)Nz<%s.%s object at 0x%x %s>)r�rGr*�idr1s rr�zAttribute.__repr__�s8��*���J�J�!���J�J���t�H�H��	.
�
�	
r)r*rGrHr+r^rMr@r�r@rrrr�sU���������I����J�J�J�
�
�
�
�
rrc�h�eZdZdZdxZZdxZxZZd�Z	d�Z
d�Zee	e
e��Z
d�Zd�Zd	�ZeZdS)
�Methodz�Method interfaces

    The idea here is that you have objects that describe methods.
    This provides an opportunity for rich meta-data.
    r@Nc�"�|j�iS|jSrF��	_optionalr1s r�
_get_optionalzMethod._get_optionals���>�!��I��~�rc��||_dSrFrU)r-�opts  r�
_set_optionalzMethod._set_optionals
������rc��d|_dSrFrUr1s r�
_del_optionalzMethod._del_optionals
������rc�6�t|j|j���rF)�BrokenImplementationr^r*)r-�args�kws   rrazMethod.__call__s��"�4�>�4�=�A�A�Arc�D�|j|j|j|j|jd�S)N��
positional�required�optional�varargs�kwargsrbr1s r�getSignatureInfozMethod.getSignatureInfos*��"�o� �M� �M��<��+�	��	rc	��g}|jD]]}|�|��||j���vr+|dxxdt	|j|��zz
cc<�^|jr|�d|jz��|jr|�d|jz��dd�|��zS)Nre�=�*z**z(%s)z, )rcrrerA�reprrfrg�join)r-�sig�vs   r�getSignatureStringzMethod.getSignatureStrings�������	8�	8�A��J�J�q�M�M�M��D�M�&�&�(�(�(�(��B����3��d�m�A�&6�!7�!7�7�7������<�	+��J�J�s�T�\�)�*�*�*��;�	+��J�J�t�d�k�)�*�*�*���	�	�#���&�&r)r*rGrHr+rcrdrVrfrgrWrZr\r�rerarhrprMr@rrrSrS�s�����������J��#'�'�I�'��&�����������x�
�}�m�D�D�H�B�B�B����'�'�'�'�M�M�MrrSc	���|p|j}t||j��}t|dd��pd}|j}|j|z
}|j|d�}i}	t|��}
|
st|dd��}
||
z
}|dkr
||d�}d}|	�tt||d�|������|d|�|_|d|�|_|	|_
|}|jtzr|||_|dz}nd|_|jt"zr|||_nd|_||_|j���D]\}
}|�|
|���|S)N�__defaults__r@�__defaults_count__rr)r*rSr+�getattr�__code__�co_argcount�co_varnamesr�r�r�ziprcrdre�co_flags�
CO_VARARGSrf�CO_VARKEYWORDSrgr^r�rrE)r�r^�imlevelr��method�defaults�code�narrY�defaults_count�nr�argnor r!s               rr
r
&s���� �4�=�D�
�D�$�,�
'�
'�F��t�^�T�2�2�8�b�H��=�D�	
�	�G�	#�B���W�X�X�&�E�
�C���]�]�N��@�!��';�Q�?�?��	�n�	�B�	�A�v�v��R�C�D�D�>��
���J�J�t�C��b�c�c�
�H�-�-�.�.�/�/�/��c�r�c�
�F���C�R�C�j�F�O��F�O��E��}�z�!���u������	�������}�~�%���e���
�
���
� �F���m�)�)�+�+�*�*�
��U����c�5�)�)�)�)��Mrc�f�t|t��r|j}n|}t||d|���S)Nr)r|r�)r�r�__func__r
)�methr^r�r�s    r�
fromMethodr�Zs9���$�
�#�#���}�������i���>�>�>�>rc��ddlm}ddlm}|t|��ddlm}|t|��ddlm}|t|��ddlm	}|t|��ddlm}|t|��dS)Nr)�classImplements)�IElement)�
IAttribute)�IMethod)�ISpecification)�
IInterface)
�zope.interface.declarationsr��zope.interface.interfacesr�r%r�rr�rSr�r
r�r	)r�r�r�r�r�r�s      r�_wirer�cs���;�;�;�;�;�;�2�2�2�2�2�2��O�G�X�&�&�&�4�4�4�4�4�4��O�I�z�*�*�*�1�1�1�1�1�1��O�F�G�$�$�$�8�8�8�8�8�8��O�M�>�2�2�2�4�4�4�4�4�4��O�N�J�/�/�/�/�/r)rZ)rV)r)r^)�_empty)NrNr�)7r+r�typesrrr��zope.interface._compatrrr��zope.interface.exceptionsr�zope.interface.rorr��zope.interface�__all__rzr{rr��objectrr�rr#r%�SpecificationBasePyrMrcr{rr
r�r�r�r�r	rHr�r�rSr�r�rrSr
r�r�r�rZrVrr^r�r@rr�<module>r�sQ�����
�
�
�����������������.�.�.�.�.�.�1�1�1�1�1�1�-�-�-�-�-�-�0�0�0�0�0�0������������
���+��+�������
�&�(�(��!�!�!�!�!�!�:2�:2�:2�:2�:2�f�:2�:2�:2�z��
�+�+�+�+�+��+�+�
��+�\K�K�K�K�K�6�K�K�K�\
�M�M�M�M�M�0�2E�M�M�
��M�^��B��0�0�
�T1�T1�T1�T1�T1�%�T1�T1�T1�ne
�e
�e
�e
�e
�$�e
�e
�e
�P*�)���M�7�+��"��	���!�!�!�$Y�Y�Y�Y�Y�(�Y�Y�Y�v
�N�;�3C�D�D�D�	�/�/�	��	���)������Y�L�(�(�(�(��
����������~����
�
�
�
�
��
�
�
�>0'�0'�0'�0'�0'�Y�0'�0'�0'�f1�1�1�1�h?�?�?�?�0�0�0�*6�5�5�5�5�5�2�2�2�2�2�2�6�6�6�6�6�6�:�:�:�:�:�:�
/�.�.�.�.�.�
���f�f�%�%�%�%�%r