ok

Mini Shell

Direktori : /opt/alt/python311/lib64/python3.11/__pycache__/
Upload File :
Current File : //opt/alt/python311/lib64/python3.11/__pycache__/_collections_abc.cpython-311.pyc

�

�f�u��
�dZddlmZmZddlZeee��Zed��Z	d�Z
ee
��Z[
gd�ZdZ
eed����Zeee������Zeei�������Zeei�������Zeei�������Zeeg����Zeeeg������Zeeed������Zeeed	d
z������Zeee������Zeed����Z eed����Z!eee"������Z#ei�����Z$ei�����Z%ei�����Z&eej'��Z(ed
�����Z)d�Z*e*��Z*ee*��Z+e*�,��[*d�Z-e-��Z-ee-��Z.[-d�Z/Gd�de���Z0Gd�de���Z1Gd�de1��Z2e2�3e+��Gd�de���Z4Gd�de4��Z5Gd�de5��Z6e6�3e.��Gd�de���Z7Gd �d!e7��Z8e8�3e��e8�3e��e8�3e��e8�3e��e8�3e��e8�3e��e8�3e��e8�3e��e8�3e��e8�3e��e8�3e ��e8�3e!��e8�3e#��Gd"�d#e7��Z9Gd$�d%e8��Z:e:�3e)��Gd&�d'e���Z;Gd(�d)e���Z<Gd*�d+e;e7e<��Z=Gd,�d-e��Z>d.�Z?d/�Z@Gd0�d1e���ZAGd2�d3e=��ZBeB�3eC��Gd4�d5eB��ZDeD�3e��Gd6�d7e=��ZEeE�3e(��Gd8�d9e;��ZFGd:�d;eFeB��ZGeG�3e$��Gd<�d=eFeB��ZHeH�3e&��Gd>�d?eFe=��ZIeI�3e%��Gd@�dAeE��ZJeJ�3eK��GdB�dCe9e=��ZLeL�3eM��eL�3eN��eL�3e��eL�3eO��GdD�dEeL��ZPeP�3eQ��eP�3e��GdF�dGeL��ZReR�3e��eR�3e��dS)HzjAbstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
�)�ABCMeta�abstractmethodN.c��dS�N�r��7/opt/alt/python311/lib64/python3.11/_collections_abc.py�_fr
s���r)�	Awaitable�	Coroutine�
AsyncIterable�
AsyncIterator�AsyncGenerator�Hashable�Iterable�Iterator�	Generator�
Reversible�Sized�	Container�Callable�
Collection�Set�
MutableSet�Mapping�MutableMapping�MappingView�KeysView�	ItemsView�
ValuesView�Sequence�MutableSequence�
ByteStringzcollections.abcr�i��rc#�K�dV�Srrrrr	�<lambda>r'>s����5�5�5�5rc��
K�dSrrrrr	�_coror)@s
�����rc�K�dWV�dSrrrrr	�_agr+Fs����������rc��|j}|D]3}|D]%}||jvr|j|�tccSn
�&tcS�4dS)NT)�__mro__�__dict__�NotImplemented)�C�methods�mro�method�Bs     r	�_check_methodsr5Nsw��
�)�C��"�"���	"�	"�A����#�#��:�f�%�-�)�)�)�)�)�)���$�
"�!�!�!���4rc�>�eZdZdZed���Zed���ZdS)rrc��dS�Nrr��selfs r	�__hash__zHashable.__hash__^����qrc�B�|turt|d��StS)Nr;)rr5r/��clsr0s  r	�__subclasshook__zHashable.__subclasshook__b�!���(�?�?�!�!�Z�0�0�0��rN)�__name__�
__module__�__qualname__�	__slots__rr;�classmethodr@rrr	rrZ�M�������I�����^������[���rr)�	metaclassc�T�eZdZdZed���Zed���Zee��Z	dS)rrc#�K�dV�dSrrr9s r	�	__await__zAwaitable.__await__ms����
�����rc�B�|turt|d��StS)NrK)rr5r/r>s  r	r@zAwaitable.__subclasshook__qs#���)���!�!�[�1�1�1��rN)
rBrCrDrErrKrFr@�GenericAlias�__class_getitem__rrr	rris[�������I�����^������[��
$��L�1�1���rrc�\�eZdZdZed���Zedd���Zd�Zed���Z	dS)rrc��t�)zcSend a value into the coroutine.
        Return next yielded value or raise StopIteration.
        ��
StopIteration�r:�values  r	�sendzCoroutine.send~�
��
�rNc�T�|�|�|�|��}|�|�|��}|�)zgRaise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        ��with_traceback�r:�typ�val�tbs    r	�throwzCoroutine.throw��;��
�;��z��	��#�%�%�C�
�>��$�$�R�(�(�C��	rc��	|�t��td���#ttf$rYdSwxYw)�.Raise GeneratorExit inside coroutine.
        zcoroutine ignored GeneratorExitN�r^�
GeneratorExit�RuntimeErrorrRr9s r	�closezCoroutine.close��T��	B��J�J�}�%�%�%��@�A�A�A���}�-�	�	�	��D�D�	�����+�A�Ac�H�|turt|dddd��StS)NrKrUr^re)rr5r/r>s  r	r@zCoroutine.__subclasshook__�s)���)���!�!�[�&�'�7�K�K�K��r�NN)
rBrCrDrErrUr^rerFr@rrr	rrzs�������I�����^���
�
�
��^�
�B�B�B�����[���rrc�T�eZdZdZed���Zed���Zee��Z	dS)r
rc��t��Sr)rr9s r	�	__aiter__zAsyncIterable.__aiter__�s�����rc�B�|turt|d��StS)Nrl)r
r5r/r>s  r	r@zAsyncIterable.__subclasshook__�s#���-���!�!�[�1�1�1��rN)
rBrCrDrErrlrFr@rMrNrrr	r
r
�s[�������I�����^������[��
$��L�1�1���rr
c�D�eZdZdZed���Zd�Zed���ZdS)rrc��K�t�)z@Return the next item or raise StopAsyncIteration when exhausted.��StopAsyncIterationr9s r	�	__anext__zAsyncIterator.__anext__�s����!� rc��|Srrr9s r	rlzAsyncIterator.__aiter__�����rc�D�|turt|dd��StS)Nrrrl)rr5r/r>s  r	r@zAsyncIterator.__subclasshook__�s%���-���!�!�[�+�>�>�>��rN)	rBrCrDrErrrrlrFr@rrr	rr�s\�������I��!�!��^�!��������[���rrc�b�eZdZdZd�Zed���Zedd���Zd�Ze	d���Z
dS)	rrc��<K�|�d���d{V��S)zpReturn the next item from the asynchronous generator.
        When exhausted, raise StopAsyncIteration.
        N)�asendr9s r	rrzAsyncGenerator.__anext__�s,�����Z�Z��%�%�%�%�%�%�%�%�%rc��K�t�)zuSend a value into the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        rprSs  r	rxzAsyncGenerator.asend�s����
!� rNc��XK�|�|�|�|��}|�|�|��}|�)zyRaise an exception in the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        rXrZs    r	�athrowzAsyncGenerator.athrow�s?����
�;��z��	��#�%�%�C�
�>��$�$�R�(�(�C��	rc��K�	|�t���d{V��td���#ttf$rYdSwxYw)raNz,asynchronous generator ignored GeneratorExit)r{rcrdrqr9s r	�aclosezAsyncGenerator.aclose�sk����	O��+�+�m�,�,�,�,�,�,�,�,�,��M�N�N�N���1�2�	�	�	��D�D�	���s� 3�A�Ac�J�|turt|ddddd��StS)Nrlrrrxr{r})rr5r/r>s  r	r@zAsyncGenerator.__subclasshook__�s2���.� � �!�!�[�+�")�8�X�?�?�
?��rri)rBrCrDrErrrrxr{r}rFr@rrr	rr�s��������I�&�&�&��!�!��^�!��
�
�
��^�
�O�O�O�����[���rrc�T�eZdZdZed���Zed���Zee��Z	dS)rrc#�
K�dSrrr9s r	�__iter__zIterable.__iter__�����	�	rc�B�|turt|d��StS)Nr�)rr5r/r>s  r	r@zIterable.__subclasshook__rArN)
rBrCrDrErr�rFr@rMrNrrr	rr�s[�������I�����^������[��
$��L�1�1���rrc�D�eZdZdZed���Zd�Zed���ZdS)rrc��t�)zKReturn the next item from the iterator. When exhausted, raise StopIterationrQr9s r	�__next__zIterator.__next__s
���rc��|Srrr9s r	r�zIterator.__iter__rtrc�D�|turt|dd��StS)Nr�r�)rr5r/r>s  r	r@zIterator.__subclasshook__s#���(�?�?�!�!�Z��<�<�<��rN)	rBrCrDrErr�r�rFr@rrr	rrs\�������I�����^���������[���rrc�>�eZdZdZed���Zed���ZdS)rrc#�
K�dSrrr9s r	�__reversed__zReversible.__reversed__6r�rc�D�|turt|dd��StS)Nr�r�)rr5r/r>s  r	r@zReversible.__subclasshook__;s%���*���!�!�^�Z�@�@�@��rN)rBrCrDrErr�rFr@rrr	rr2sM�������I�����^������[���rrc�b�eZdZdZd�Zed���Zedd���Zd�Ze	d���Z
dS)	rrc�,�|�d��S)z^Return the next item from the generator.
        When exhausted, raise StopIteration.
        N)rUr9s r	r�zGenerator.__next__Fs���y�y����rc��t�)zcSend a value into the generator.
        Return next yielded value or raise StopIteration.
        rQrSs  r	rUzGenerator.sendLrVrNc�T�|�|�|�|��}|�|�|��}|�)zgRaise an exception in the generator.
        Return next yielded value or raise StopIteration.
        rXrZs    r	r^zGenerator.throwSr_rc��	|�t��td���#ttf$rYdSwxYw)z.Raise GeneratorExit inside generator.
        zgenerator ignored GeneratorExitNrbr9s r	rezGenerator.close`rfrgc�J�|turt|ddddd��StS)Nr�r�rUr^re)rr5r/r>s  r	r@zGenerator.__subclasshook__js2���)���!�!�Z��"(�'�7�<�<�
<��rri)rBrCrDrEr�rrUr^rerFr@rrr	rrBs��������I��������^���
�
�
��^�
�B�B�B�����[���rrc�>�eZdZdZed���Zed���ZdS)rrc��dSr8rr9s r	�__len__z
Sized.__len__yr<rc�B�|turt|d��StS)Nr�)rr5r/r>s  r	r@zSized.__subclasshook__}s!���%�<�<�!�!�Y�/�/�/��rN)rBrCrDrErr�rFr@rrr	rrurGrrc�T�eZdZdZed���Zed���Zee��Z	dS)rrc��dS�NFr)r:�xs  r	�__contains__zContainer.__contains__�����urc�B�|turt|d��StS)Nr�)rr5r/r>s  r	r@zContainer.__subclasshook__�s#���)���!�!�^�4�4�4��rN)
rBrCrDrErr�rFr@rMrNrrr	rr�s[�������I�����^������[��
$��L�1�1���rrc�(�eZdZdZed���ZdS)rrc�F�|turt|ddd��StS)Nr�r�r�)rr5r/r>s  r	r@zCollection.__subclasshook__�s'���*���!�!�i��^�L�L�L��rN)rBrCrDrErFr@rrr	rr�s2�������I�����[���rrc�@��eZdZdZdZ�fd�Z�fd�Zd�Z�fd�Z�xZ	S)�_CallableGenericAliasz� Represent `Callable[argtypes, resulttype]`.

    This sets ``__args__`` to a tuple containing the flattened ``argtypes``
    followed by ``resulttype``.

    Example: ``Callable[[int, str], float]`` sets ``__args__`` to
    ``(int, str, float)``.
    rc�L��t|t��rt|��dkstd���|\}}t|ttf��rg|�|�R}n!t|��std|�����t
���|||��S)N�z6Callable must be used as Callable[[arg, ...], result].zFExpected a list of types, an ellipsis, ParamSpec, or Concatenate. Got )�
isinstance�tuple�len�	TypeError�list�_is_param_expr�super�__new__)r?�origin�args�t_args�t_result�	__class__s     �r	r�z_CallableGenericAlias.__new__�s�����4��'�'�	J�C��I�I��N�N��H�J�J�
J������f�u�d�m�,�,�	H�&�V�&�X�&�&�D�D���'�'�	H��G�>D�G�G�H�H�
H��w�w���s�F�D�1�1�1rc�>��t|j��dkr:t|jd��r t�����Sdd�d�|jdd�D�����dt
|jd���d�S)	Nr�rzcollections.abc.Callable[[z, c�,�g|]}t|����Sr)�
_type_repr)�.0�as  r	�
<listcomp>z2_CallableGenericAlias.__repr__.<locals>.<listcomp>�s��J�J�J�!�
�1�
�
�J�J�Jr���z], �])r��__args__r�r��__repr__�joinr�)r:r�s �r	r�z_CallableGenericAlias.__repr__�s�����t�}����"�"�~�d�m�A�6F�'G�'G�"��7�7�#�#�%�%�%�4��Y�Y�J�J�t�}�S�b�S�7I�J�J�J�K�K�4�4��d�m�B�/�0�0�4�4�4�	5rc��|j}t|��dkrt|d��st|dd���|df}tt
|ffS)Nr�rr�)r�r�r�r�r�r)r:r�s  r	�
__reduce__z _CallableGenericAlias.__reduce__�sT���}���D�	�	�Q���>�$�q�'�#:�#:����S�b�S�	�?�?�D��H�,�D�$�x��&6�6�6rc����t|t��s|f}t|j��dkr4t	|jd��r|rt	|d��s|f}t���|��j}t|dttf��s|d}|dd�}||f}ttt|����S)Nr$rr�)r�r�r��__parameters__r�r��__getitem__r�r�r�r)r:�item�new_argsr�r�r�s     �r	r�z!_CallableGenericAlias.__getitem__�s�����$��&�&�	��7�D�
��#�$�$��)�)�"�4�#6�q�#9�:�:�
*��
*�!/��Q��!8�!8�
*��7�D��7�7�&�&�t�,�,�5���(�1�+��t�}�5�5�	*���|�H��c�r�c�]�F���)�H�$�X�u�X���?�?�?r)
rBrCrD�__doc__rEr�r�r�r��
__classcell__)r�s@r	r�r��s�����������I�
2�
2�
2�
2�
2�5�5�5�5�5�7�7�7�@�@�@�@�@�@�@�@�@rr�c����turdSt�t��rdSt����d}�jdkot�fd�|D����S)z|Checks if obj matches either a list of types, ``...``, ``ParamSpec`` or
    ``_ConcatenateGenericAlias`` from typing.py
    T)�	ParamSpec�_ConcatenateGenericAlias�typingc3�.�K�|]}�j|kV��dSr)rB)r��name�objs  �r	�	<genexpr>z!_is_param_expr.<locals>.<genexpr>�s*�����-U�-U�t�c�l�d�.B�-U�-U�-U�-U�-U�-Ur)�Ellipsisr�r��typerC�any)r��namess` r	r�r��si����h����t��#�t�����t�
�s�)�)�C�5�E��>�X�%�U�#�-U�-U�-U�-U�u�-U�-U�-U�*U�*U�Urc�&�t|t��rt|��St|t��r#|jdkr|jS|j�d|j��S|turdSt|t��r|jSt|��S)z�Return the repr() of an object, special-casing types (internal helper).

    Copied from :mod:`typing` since collections.abc
    shouldn't depend on that module.
    �builtins�.z...)	r�rM�reprr�rCrDr��FunctionTyperB)r�s r	r�r��s����#�|�$�$���C�y�y���#�t���6��>�Z�'�'��#�#��.�5�5�3�#3�5�5�5�
�h����u��#�|�$�$���|����9�9�rc�T�eZdZdZed���Zed���Zee��Z	dS)rrc��dSr�r)r:r��kwdss   r	�__call__zCallable.__call__r�rc�B�|turt|d��StS)Nr�)rr5r/r>s  r	r@zCallable.__subclasshook__rArN)
rBrCrDrErr�rFr@r�rNrrr	rr�s\�������I�����^������[��
$��$9�:�:���rrc��eZdZdZdZd�Zd�Zd�Zd�Zd�Z	e
d���Zd	�ZeZ
d
�Zd�ZeZd�Zd
�Zd�ZeZd�ZdS)raZA set is a finite, iterable container.

    This class provides concrete generic implementations of all
    methods except for __contains__, __iter__ and __len__.

    To override the comparisons (presumably for speed, as the
    semantics are fixed), redefine __le__ and __ge__,
    then the other operations will automatically follow suit.
    rc��t|t��stSt|��t|��krdS|D]	}||vrdS�
dS�NFT�r�rr/r��r:�other�elems   r	�__le__z
Set.__le__sa���%��%�%�	"�!�!��t�9�9�s�5�z�z�!�!��5��	�	�D��5� � ��u�u�!��trc��t|t��stSt|��t|��ko|�|��Sr�r�rr/r�r��r:r�s  r	�__lt__z
Set.__lt__'�B���%��%�%�	"�!�!��4�y�y�3�u�:�:�%�<�$�+�+�e�*<�*<�<rc��t|t��stSt|��t|��ko|�|��Sr)r�rr/r��__ge__r�s  r	�__gt__z
Set.__gt__,r�rc��t|t��stSt|��t|��krdS|D]	}||vrdS�
dSr�r�r�s   r	r�z
Set.__ge__1sa���%��%�%�	"�!�!��t�9�9�s�5�z�z�!�!��5��	�	�D��4����u�u� ��trc��t|t��stSt|��t|��ko|�|��Srr�r�s  r	�__eq__z
Set.__eq__;sB���%��%�%�	"�!�!��4�y�y�C��J�J�&�=�4�;�;�u�+=�+=�=rc��||��S)z�Construct an instance of the class from any iterable input.

        Must override this method if the class constructor signature
        does not accept an iterable for an input.
        r�r?�its  r	�_from_iterablezSet._from_iterable@s���s�2�w�w�rc�~��t|t��stS���fd�|D����S)Nc3�$�K�|]
}|�v�|V��dSrr�r�rTr:s  �r	r�zSet.__and__.<locals>.<genexpr>Ls'�����"M�"M�U�u��}�}�5�}�}�}�}�"M�"Mr�r�rr/r�r�s` r	�__and__zSet.__and__IsD����%��*�*�	"�!�!��"�"�"M�"M�"M�"M�e�"M�"M�"M�M�M�Mrc��|D]	}||vrdS�
dS)z1Return True if two sets have a null intersection.FTr)r:r�rTs   r	�
isdisjointzSet.isdisjointPs+���	�	�E���}�}��u�u���trc��t|t��stSd�||fD��}|�|��S)Nc3�$K�|]}|D]}|V���dSrr)r��s�es   r	r�zSet.__or__.<locals>.<genexpr>Zs/����5�5�q�1�5�5�a��5�5�5�5�5�5�5rr�)r:r��chains   r	�__or__z
Set.__or__WsE���%��*�*�	"�!�!�5�5�T�5�M�5�5�5���"�"�5�)�)�)rc����t�t��s1t�t��stS|�����|��fd�|D����S)Nc3�$�K�|]
}|�v�|V��dSrr)r�rTr�s  �r	r�zSet.__sub__.<locals>.<genexpr>ds9�����#:�#:�U�&+�5�&8�&8�$)�&8�&8�&8�&8�#:�#:r�r�rrr/r�r�s `r	�__sub__zSet.__sub___s}����%��%�%�	/��e�X�.�.�
&�%�%��'�'��.�.�E��"�"�#:�#:�#:�#:�d�#:�#:�#:�:�:�	:rc����t|t��s1t|t��stS��|��}���fd�|D����S)Nc3�$�K�|]
}|�v�|V��dSrrr�s  �r	r�zSet.__rsub__.<locals>.<genexpr>ls9�����#9�#9�U�&+�4�&7�&7�$)�&7�&7�&7�&7�#9�#9rrr�s` r	�__rsub__zSet.__rsub__gs}����%��%�%�	/��e�X�.�.�
&�%�%��'�'��.�.�E��"�"�#9�#9�#9�#9�e�#9�#9�#9�9�9�	9rc��t|t��s1t|t��stS|�|��}||z
||z
zSrrr�s  r	�__xor__zSet.__xor__osR���%��%�%�	/��e�X�.�.�
&�%�%��'�'��.�.�E��u�����.�.rc��tj}d|zdz}t|��}d|dzz}||z}|D]'}t|��}|||dzzdzdzz}||z}�(||dz	|dz	zz}|d	zd
z}||z}||kr||dzz}|dkrd}|S)
a+Compute the hash value of a set.

        Note that we don't define __hash__: not all sets are hashable.
        But if you define a hashable set type, its __hash__ should
        call this function.

        This must be compatible __eq__.

        All sets ought to compare equal if they contain the same
        elements, regardless of how they are implemented, and
        regardless of the order of the elements; so there's not much
        freedom for __eq__ or __hash__.  We match the algorithm used
        by the built-in frozenset type.
        r�r$iM��r�i�M[l�4~2��i�
i��6r�i��8#)�sys�maxsizer��hash)r:�MAX�MASK�n�hr��hxs       r	�_hashz	Set._hashxs����k���3�w��{����I�I���!�a�%� ��	�T�	���	�	�A��a���B�
�"��b��/�H�,��;�;�A�
��I�A�A�	�a�2�g�!�r�'�
"�"��
��I�	�!��	�T�	���s�7�7�
����M�A���7�7��A��rN)rBrCrDr�rEr�r�r�r�r�rFr�r��__rand__r�r��__ror__rrr�__rxor__rrrr	rrs���������I����=�=�=�
=�=�=�
���>�>�>�
����[��N�N�N�
�H����*�*�*��G�:�:�:�9�9�9�/�/�/��H�����rrc�l�eZdZdZdZed���Zed���Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�ZdS)
ra�A mutable set is a finite, iterable container.

    This class provides concrete generic implementations of all
    methods except for __contains__, __iter__, __len__,
    add(), and discard().

    To override the comparisons (presumably for speed, as the
    semantics are fixed), all you have to do is redefine __le__ and
    then the other operations will automatically follow suit.
    rc��t�)zAdd an element.��NotImplementedErrorrSs  r	�addzMutableSet.add��
��"�!rc��t�)z8Remove an element.  Do not raise an exception if absent.rrSs  r	�discardzMutableSet.discard�rrc�V�||vrt|���|�|��dS)z5Remove an element. If not a member, raise a KeyError.N)�KeyErrorrrSs  r	�removezMutableSet.remove�s1�������5�/�/�!����U�����rc��t|��}	t|��}n#t$r	td�wxYw|�|��|S)z2Return the popped value.  Raise KeyError if empty.N)�iter�nextrRr!r�r:r�rTs   r	�popzMutableSet.pop�sY��
�$�Z�Z��	%���H�H�E�E���	%�	%�	%���$�	%�������U�����s�!�4c�R�		|����#t$rYdSwxYw)z6This is slow (creates N new iterators!) but effective.TN)r'r!r9s r	�clearzMutableSet.clear�s@��	�
����
�
�
�
���	�	�	��D�D�	������
&�&c�:�|D]}|�|���|Sr)rr&s   r	�__ior__zMutableSet.__ior__�s'���	�	�E��H�H�U�O�O�O�O��rc�@�||z
D]}|�|���|Sr)rr&s   r	�__iand__zMutableSet.__iand__�s/���R�i�	 �	 �E��L�L�������rc���||ur|���n^t|t��s|�|��}|D]1}||vr|�|���|�|���2|Sr)r)r�rr�rrr&s   r	�__ixor__zMutableSet.__ixor__�s���
��:�:��J�J�L�L�L�L��b�#�&�&�
-��(�(��,�,���
$�
$���D�=�=��L�L��'�'�'�'��H�H�U�O�O�O�O��rc�l�||ur|���n|D]}|�|���|Sr)r)rr&s   r	�__isub__zMutableSet.__isub__�sC��
��:�:��J�J�L�L�L�L��
$�
$�����U�#�#�#�#��rN)rBrCrDr�rErrrr"r'r)r,r.r0r2rrr	rr�s�������	�	��I��"�"��^�"��"�"��^�"�������������
���
�������rrc�Z�eZdZdZdZdZed���Zdd�Zd�Z	d�Z
d	�Zd
�Zd�Z
dZdS)
rz�A Mapping is a generic container for associating key/value
    pairs.

    This class provides concrete generic implementations of all
    methods except for __getitem__, __iter__, and __len__.
    r�@c��t�r�r!�r:�keys  r	r�zMapping.__getitem__�����rNc�8�	||S#t$r|cYSwxYw)z<D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.r6�r:r8�defaults   r	�getzMapping.gets5��	���9����	�	�	��N�N�N�	���s�
��c�:�	||dS#t$rYdSwxYw�NTFr6r7s  r	r�zMapping.__contains__
s;��	���I�I��4���	�	�	��5�5�	���s��
�c� �t|��S)z:D.keys() -> a set-like object providing a view on D's keys)rr9s r	�keyszMapping.keyss����~�~�rc� �t|��S)z<D.items() -> a set-like object providing a view on D's items)rr9s r	�itemsz
Mapping.itemss������rc� �t|��S)z6D.values() -> an object providing a view on D's values)r r9s r	�valueszMapping.valuess���$���rc���t|t��stSt|�����t|�����kSr)r�rr/�dictrCr�s  r	r�zMapping.__eq__sE���%��)�)�	"�!�!��D�J�J�L�L�!�!�T�%�+�+�-�-�%8�%8�8�8rr)rBrCrDr�rE�__abc_tpflags__rr�r=r�rArCrEr�r�rrr	rr�s����������I��O�����^��������������� � � �9�9�9�
�L�L�Lrrc�:�eZdZdZd�Zd�Zd�Zee��Z	dS)r��_mappingc��||_dSrrJ)r:�mappings  r	�__init__zMappingView.__init__,s
����
�
�
rc�*�t|j��Sr)r�rKr9s r	r�zMappingView.__len__/s���4�=�!�!�!rc�,�d�|��S)Nz&{0.__class__.__name__}({0._mapping!r}))�formatr9s r	r�zMappingView.__repr__2s��7�>�>�t�D�D�DrN)
rBrCrDrErNr�r�rFrMrNrrr	rr(sW�������I� � � �"�"�"�E�E�E�$��L�1�1���rrc�4�eZdZdZed���Zd�Zd�ZdS)rrc� �t|��Sr��setr�s  r	r�zKeysView._from_iterable<�
���2�w�w�rc��||jvSrrJr7s  r	r�zKeysView.__contains__@s���d�m�#�#rc#�$K�|jEd{V��dSrrJr9s r	r�zKeysView.__iter__Cs&�����=� � � � � � � � � rN�rBrCrDrErFr�r�r�rrr	rr8sP�������I�����[��$�$�$�!�!�!�!�!rrc�4�eZdZdZed���Zd�Zd�ZdS)rrc� �t|��SrrTr�s  r	r�zItemsView._from_iterableNrVrc�^�|\}}	|j|}||up||kS#t$rYdSwxYwr�)rKr!)r:r�r8rT�vs     r	r�zItemsView.__contains__RsU���
��U�	,��
�c�"�A���:�+��e��+���	�	�	��5�5�	���s�
�
,�,c#�@K�|jD]}||j|fV��dSrrJr7s  r	r�zItemsView.__iter__[s<�����=�	,�	,�C���
�c�*�+�+�+�+�+�	,�	,rNrYrrr	rrJsP�������I�����[��,�,�,�,�,�,�,�,rrc��eZdZdZd�Zd�ZdS)r rc�N�|jD]}|j|}||us||krdS�dSr?rJ)r:rTr8r]s    r	r�zValuesView.__contains__gsA���=�	�	�C��
�c�"�A��E�z�z�Q�%�Z�Z��t�t�(��urc#�<K�|jD]}|j|V��dSrrJr7s  r	r�zValuesView.__iter__ns7�����=�	%�	%�C��-��$�$�$�$�$�	%�	%rN)rBrCrDrEr�r�rrr	r r cs7�������I����%�%�%�%�%rr c�|�eZdZdZdZed���Zed���Ze��Z	e	fd�Z
d�Zd�Zdd�Z
dd
�Zd	S)
rz�A MutableMapping is a generic container for associating
    key/value pairs.

    This class provides concrete generic implementations of all
    methods except for __getitem__, __setitem__, __delitem__,
    __iter__, and __len__.
    rc��t�rr6�r:r8rTs   r	�__setitem__zMutableMapping.__setitem__�r9rc��t�rr6r7s  r	�__delitem__zMutableMapping.__delitem__�r9rc�V�	||}||=|S#t$r||jur�|cYSwxYw)z�D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
          If key is not found, d is returned if given, otherwise KeyError is raised.
        )r!�_MutableMapping__marker)r:r8r<rTs    r	r'zMutableMapping.pop�sT��	���I�E��S�	��L��
�	�	�	��$�-�'�'���N�N�N�	���s��(�(c��	tt|����}n#t$r	td�wxYw||}||=||fS)z�D.popitem() -> (k, v), remove and return some (key, value) pair
           as a 2-tuple; but raise KeyError if D is empty.
        N)r%r$rRr!rds   r	�popitemzMutableMapping.popitem�sY��	%��t�D�z�z�"�"�C�C���	%�	%�	%���$�	%�����S�	����I��E�z�s��2c�R�		|����#t$rYdSwxYw)z,D.clear() -> None.  Remove all items from D.TN)rkr!r9s r	r)zMutableMapping.clear�s@��	�
�������
���	�	�	��D�D�	���r*c��t|t��r|D]
}||||<�n@t|d��r#|���D]
}||||<�n
|D]
\}}|||<�|���D]
\}}|||<�dS)aK D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
            If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
            In either case, this is followed by: for k, v in F.items(): D[k] = v
        rAN)r�r�hasattrrArC)r:r�r�r8rTs     r	�updatezMutableMapping.update�s����e�W�%�%�	"��
'�
'��!�#�J��S�	�	�
'�
�U�F�
#�
#�	"��z�z�|�|�
'�
'��!�#�J��S�	�	�
'�$�
"�
"�
��U�!��S�	�	��*�*�,�,�	�	�J�C���D��I�I�	�	rNc�B�	||S#t$r|||<YnwxYw|S)z@D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in Dr6r;s   r	�
setdefaultzMutableMapping.setdefault�s>��	 ���9����	 �	 �	 ��D��I�I�I�	 �����s�
��)rr)rBrCrDr�rErrerg�objectrir'rkr)rorqrrr	rrvs����������I�����^������^���v�x�x�H�'�����
�
�
��������$�����rrc�P�eZdZdZdZdZed���Zd�Zd�Z	d�Z
dd
�Zd�Zd	S)
r!z�All the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    r� c��t�r��
IndexError�r:�indexs  r	r�zSequence.__getitem__�����rc#�TK�d}		||}|V�|dz
}�#t$rYdSwxYw)NrTr$rv)r:�ir]s   r	r�zSequence.__iter__�sY����
��	�
���G�������Q���
���	�	�	��F�F�	���s��
'�'c�*�|D]}||us||krdS�dSr?r)r:rTr]s   r	r�zSequence.__contains__�s3���	�	�A��E�z�z�Q�%�Z�Z��t�t�(��urc#�vK�ttt|������D]}||V��
dSr)�reversed�ranger�)r:r|s  r	r�zSequence.__reversed__�sD�����%��D�	�	�*�*�+�+�	�	�A��q�'�M�M�M�M�	�	rrNc��|�&|dkr tt|��|zd��}|�|dkr|t|��z
}|}|�||kr3	||}n#t$rYnwxYw||us||kr|S|dz
}|�-||k�3t�)z�S.index(value, [start, [stop]]) -> integer -- return first index of value.
           Raises ValueError if the value is not present.

           Supporting start and stop arguments is optional, but
           recommended.
        Nrr$)�maxr�rw�
ValueError)r:rT�start�stopr|r]s      r	ryzSequence.index�s�����������D�	�	�E�)�1�-�-�E����q����C��I�I��D����l�a�$�h�h�
���G�����
�
�
���
�����E�z�z�Q�%�Z�Z���
��F�A��l�a�$�h�h��s�A�
A$�#A$c�:��t�fd�|D����S)zBS.count(value) -> integer -- return number of occurrences of valuec3�0�K�|]}|�us|�k�dV��dS)r$Nr)r�r]rTs  �r	r�z!Sequence.count.<locals>.<genexpr>
s/�����?�?��a�5�j�j�A��J�J�1�J�J�J�J�?�?r)�sumrSs `r	�countzSequence.counts&����?�?�?�?�d�?�?�?�?�?�?r)rN)
rBrCrDr�rErHrr�r�r�r�ryr�rrr	r!r!�s����������I��O�����^���������������.@�@�@�@�@rr!c��eZdZdZdZdS)r#zMThis unifies bytes and bytearray.

    XXX Should add all their methods.
    rN)rBrCrDr�rErrr	r#r#s��������
�I�I�Irr#c��eZdZdZdZed���Zed���Zed���Zd�Z	d�Z
d�Zd	�Zdd�Z
d�Zd
�ZdS)r"z�All the operations on a read-write sequence.

    Concrete subclasses must provide __new__ or __init__,
    __getitem__, __setitem__, __delitem__, __len__, and insert().
    rc��t�rrv�r:ryrTs   r	rezMutableSequence.__setitem__'rzrc��t�rrvrxs  r	rgzMutableSequence.__delitem__+rzrc��t�)z3S.insert(index, value) -- insert value before indexrvr�s   r	�insertzMutableSequence.insert/s
���rc�L�|�t|��|��dS)z:S.append(value) -- append value to the end of the sequenceN)r�r�rSs  r	�appendzMutableSequence.append4s"�����C��I�I�u�%�%�%�%�%rc�R�		|����#t$rYdSwxYw)z,S.clear() -> None -- remove all items from STN)r'rwr9s r	r)zMutableSequence.clear8s@��	�
����
�
�
�
���	�	�	��D�D�	���r*c��t|��}t|dz��D]%}|||z
dz
||c||<|||z
dz
<�&dS)z!S.reverse() -- reverse *IN PLACE*r�r$N)r�r�)r:rr|s   r	�reversezMutableSequence.reverse@s^����I�I���q�!�t���	8�	8�A�#'��!��A��;��Q�� �D��G�T�!�A�#�a�%�[�[�	8�	8rc�`�||urt|��}|D]}|�|���dS)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)r�r�)r:rEr]s   r	�extendzMutableSequence.extendFs@���T�>�>��&�\�\�F��	�	�A��K�K��N�N�N�N�	�	rr�c��||}||=|S)z�S.pop([index]) -> item -- remove and return item at index (default last).
           Raise IndexError if list is empty or index is out of range.
        r)r:ryr]s   r	r'zMutableSequence.popMs��
��K����K��rc�2�||�|��=dS)zvS.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        N)ryrSs  r	r"zMutableSequence.removeUs��
����E�"�"�#�#�#rc�0�|�|��|Sr)r�)r:rEs  r	�__iadd__zMutableSequence.__iadd__[s�����F�����rN)r�)rBrCrDr�rErrergr�r�r)r�r�r'r"r�rrr	r"r"s����������I�����^������^������^��&�&�&����8�8�8��������$�$�$�����rr")Sr��abcrrrr�r��intrM�EllipsisTyper
r��__all__rBr$�bytes_iterator�	bytearray�bytearray_iteratorrA�dict_keyiteratorrE�dict_valueiteratorrC�dict_itemiterator�
list_iteratorr�list_reverseiteratorr��range_iterator�longrange_iteratorrU�set_iterator�str_iterator�tuple_iterator�zip�zip_iterator�	dict_keys�dict_values�
dict_itemsr.�mappingproxy�	generatorr)�	coroutinerer+�async_generatorr5rrr�registerr
rrrrrrrrrr�r�r�rr�	frozensetrrrrrr rrGr!r��str�
memoryviewr#�bytesr"rrr	�<module>r�s%
����
(�'�'�'�'�'�'�'�
�
�
�
��t�D��I�����t�C�y�y������t�B�x�x���	
�	
�	
������d�d�3�i�i�����T�$�$�y�y�{�{�+�+�,�,���4���R�W�W�Y�Y���(�(���T�$�$�r�y�y�{�{�+�+�,�,���D���b�h�h�j�j�)�)�*�*����T�T�"�X�X���
��t�D�D���"���.�.�/�/����d�d�5�5��8�8�n�n�%�%���T�$�$�u�u�Q�$�Y�/�/�0�0�1�1���t�D�D�����K�K� � ���t�D�D��H�H�~�~����d�d�2�h�h�����t�D�D�����K�K� � ���D������O�O�	��d�2�9�9�;�;����
�T�"�(�(�*�*�
�
�
��t�D�M�"�"���D�/�/�/�$�$�%�%�	����
������D��K�K�	����
�
�
�	����	�c�e�e���$�s�)�)���

�
�
�����������2�2�2�2�2�'�2�2�2�2�"&�&�&�&�&�	�&�&�&�R
���9����2�2�2�2�2�g�2�2�2�2�"�����M����&-�-�-�-�-�]�-�-�-�`����(�(�(�2�2�2�2�2��2�2�2�2�$�����x����&	���.�!�!�!����$�%�%�%����"�#�#�#����$�%�%�%����#�$�$�$����-� � � ����&�'�'�'����.�!�!�!����$�%�%�%����,�������,�������.�!�!�!����,����
�
�
�
�
��
�
�
� -�-�-�-�-��-�-�-�`
���9���������g�����2�2�2�2�2�'�2�2�2�2�"�������)����;@�;@�;@�;@�;@�L�;@�;@�;@�z
V�
V�
V����&;�;�;�;�;��;�;�;�;�(G�G�G�G�G�*�G�G�G�T���Y����M�M�M�M�M��M�M�M�`���C����
1�1�1�1�1�j�1�1�1�f�������
2�
2�
2�
2�
2�%�
2�
2�
2� !�!�!�!�!�{�C�!�!�!�	���)����,�,�,�,�,��S�,�,�,�,
���:����
%�
%�
%�
%�
%��j�
%�
%�
%� ���K� � � �O�O�O�O�O�W�O�O�O�d�������
=@�=@�=@�=@�=@�z�:�=@�=@�=@�~	���%�������#�������%�������*����������������E����
���I����?�?�?�?�?�h�?�?�?�D�����������#�#�#�#�#r

Zerion Mini Shell 1.0