Your IP : 3.145.93.203


Current Path : /opt/alt/python313/lib64/python3.13/__pycache__/
Upload File :
Current File : //opt/alt/python313/lib64/python3.13/__pycache__/_collections_abc.cpython-313.opt-1.pyc

�

*}g~��\
�SrSSKJrJr SSKr\"\\5r\"S5r	Sr
\"\
5rC
/SQrSr
\"\"S55r\"\"\"555r\"\"0R%555r\"\"0R)555r\"\"0R-555r\"\"/55r\"\"\"/555r\"\"\"S555r\"\"\"S	S
-555r\"\"\"555r\"\"S55r \"\"S55r!\"\"\""555r#\"0R%55r$\"0R)55r%\"0R-55r&\"\RN5r(S
r)\)"5r*C)\"S"55r+Sr,\,"5r,\"\,5r-\,R]5 C,Sr/\/"5r/\"\/5r0C/Sr1"SS\S9r2"SS\S9r3"SS\35r4\4Rk\-5 "SS\S9r6"SS\65r7"SS\75r8\8Rk\05 "SS \S9r9"S!S"\95r:\:Rk\5 \:Rk\5 \:Rk\5 \:Rk\5 \:Rk\5 \:Rk\5 \:Rk\5 \:Rk\5 \:Rk\5 \:Rk\5 \:Rk\ 5 \:Rk\!5 \:Rk\#5 "S#S$\95r;"S%S&\:5r<\<Rk\+5 "S'S(\S9r="S)S*\S9r>"S+S,\=\9\>5r?"S-S.\S9r@"S/S0\5rAS1rBS2rC"S3S4\S9rD"S5S6\?5rE\ERk\F5 "S7S8\E5rG\GRk\5 "S9S:\?5rH\HRk\(5 \HRk\*5 "S;S<\=5rI"S=S>\I\E5rJ\JRk\$5 "S?S@\I\E5rK\KRk\&5 "SASB\I\?5rL\LRk\%5 "SCSD\H5rM\MRk\N5 "SESF\;\?5rO\ORk\P5 \ORk\Q5 \ORk\5 \ORk\R5 "SGSH\5rS"SISJ\O\SS9rT\TRk\U5 \TRk\5 "SKSL\O5rV\VRk\5 \VRk\5 g)MzjAbstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
�)�ABCMeta�abstractmethodN.c��g�N�r��7/opt/alt/python313/lib64/python3.13/_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�
ByteString�Bufferzcollections.abcr�i��rc�R�[[R"5R5$r)�type�sys�	_getframe�f_localsrrr	�_get_framelocalsproxyr,Xs����
�
��(�(�)�)rc#�# �Sv�$rrrrr	�<lambda>r.\s���5rc��# �g7frrrrr	�_coror0^s���4���c�# �S7v� g7frrrrr	�_agr3ds������	c��URnUH>nUH/nX4R;dMURUc
[s s $ M6 [s $ g)NT)�__mro__�__dict__�NotImplemented)�C�methods�mro�method�Bs     r	�_check_methodsr>lsN��
�)�)�C����A����#��:�:�f�%�-�)�)��	�"�!��rc�8�\rSrSrSr\S5r\S5rSr	g)r�xrc��g�Nrr��selfs r	�__hash__�Hashable.__hash__|���rc�8�U[La[US5$[$)NrE)rr>r8��clsr9s  r	�__subclasshook__�Hashable.__subclasshook__�����(�?�!�!�Z�0�0��rN)
�__name__�
__module__�__qualname__�__firstlineno__�	__slots__rrE�classmethodrK�__static_attributes__rrr	rrx�-���I��������rr)�	metaclassc�H�\rSrSrSr\S5r\S5r\"\	5r
Srg)r�rc#�# �Sv� g7frrrCs r	�	__await__�Awaitable.__await__�s���
�s�c�8�U[La[US5$[$)NrZ)rr>r8rIs  r	rK�Awaitable.__subclasshook__�s���)��!�!�[�1�1��rN)rNrOrPrQrRrrZrSrK�GenericAlias�__class_getitem__rTrrr	rr�s:���I���������
$�L�1�rrc�R�\rSrSrSr\S5r\SSj5rSr\	S5r
Srg)	r�rc��[e)zSSend a value into the coroutine.
Return next yielded value or raise StopIteration.
��
StopIteration�rD�values  r	�send�Coroutine.send��
��
�rNc�L�UcUcUeU"5nUbURU5nUe)zWRaise an exception in the coroutine.
Return next yielded value or raise StopIteration.
��with_traceback�rD�typ�val�tbs    r	�throw�Coroutine.throw��4��
�;��z��	��%�C�
�>��$�$�R�(�C��	rc�p�UR[5 [S5e![[4a gf=f)�.Raise GeneratorExit inside coroutine.
        zcoroutine ignored GeneratorExitN�rq�
GeneratorExit�RuntimeErrorrdrCs r	�close�Coroutine.close��;��	B��J�J�}�%��@�A�A���}�-�	��	���"�5�5c�>�U[La[USSSS5$[$)NrZrgrqry)rr>r8rIs  r	rK�Coroutine.__subclasshook__�s#���)��!�!�[�&�'�7�K�K��r�NN)rNrOrPrQrRrrgrqryrSrKrTrrr	rr�sG���I������
��
�B����rrc�H�\rSrSrSr\S5r\S5r\"\	5r
Srg)r
��rc��[5$r)rrCs r	�	__aiter__�AsyncIterable.__aiter__�s
����rc�8�U[La[US5$[$)Nr�)r
r>r8rIs  r	rK�AsyncIterable.__subclasshook__�s���-��!�!�[�1�1��rN)rNrOrPrQrRrr�rSrKr^r_rTrrr	r
r
�s:���I���������
$�L�1�rr
c�>�\rSrSrSr\S5rSr\S5r	Sr
g)r��rc��# �[e7f)z@Return the next item or raise StopAsyncIteration when exhausted.��StopAsyncIterationrCs r	�	__anext__�AsyncIterator.__anext__�s
���!� �r4c��U$rrrCs r	r��AsyncIterator.__aiter__�����rc�:�U[La
[USS5$[$)Nr�r�)rr>r8rIs  r	rK�AsyncIterator.__subclasshook__�s���-��!�!�[�+�>�>��rN)rNrOrPrQrRrr�r�rSrKrTrrr	rr�s2���I��!��!�����rrc�X�\rSrSrSrSr\S5r\S	Sj5rSr	\
S5rSrg)
r��rc��@# �URS5IShv�N$N7f)z`Return the next item from the asynchronous generator.
When exhausted, raise StopAsyncIteration.
N)�asendrCs r	r��AsyncGenerator.__anext__�s����Z�Z��%�%�%�%�s���c��# �[e7f)zeSend a value into the asynchronous generator.
Return next yielded value or raise StopAsyncIteration.
r�res  r	r��AsyncGenerator.asend�s
���
!� �r4Nc��T# �UcUcUeU"5nUbURU5nUe7f)ziRaise an exception in the asynchronous generator.
Return next yielded value or raise StopAsyncIteration.
rkrms    r	�athrow�AsyncGenerator.athrow�s7���
�;��z��	��%�C�
�>��$�$�R�(�C��	���&(c��# �UR[5IShv�N [S5eN![[4a gf=f7f)ruNz,asynchronous generator ignored GeneratorExit)r�rwrxr�rCs r	�aclose�AsyncGenerator.aclosesG���	O��+�+�m�,�,�,��M�N�N�	
-���1�2�	��	�s0�A�.�,�.�A�.�A�A�A�Ac�@�U[La[USSSSS5$[$)Nr�r�r�r�r�)rr>r8rIs  r	rK�AsyncGenerator.__subclasshook__s*���.� �!�!�[�+�")�8�X�?�
?��rr)
rNrOrPrQrRr�rr�r�r�rSrKrTrrr	rr�sN���I�&��!��!��
��
�O����rrc�H�\rSrSrSr\S5r\S5r\"\	5r
Srg)rirc#�# �g7frrrCs r	�__iter__�Iterable.__iter__�����r1c�8�U[La[US5$[$)Nr�)rr>r8rIs  r	rK�Iterable.__subclasshook__$rMrN)rNrOrPrQrRrr�rSrKr^r_rTrrr	rrs:���I���������
$�L�1�rrc�>�\rSrSrSr\S5rSr\S5r	Sr
g)ri-rc��[e)zKReturn the next item from the iterator. When exhausted, raise StopIterationrcrCs r	�__next__�Iterator.__next__1s
���rc��U$rrrCs r	r��Iterator.__iter__6r�rc�:�U[La
[USS5$[$)Nr�r�)rr>r8rIs  r	rK�Iterator.__subclasshook__9s���(�?�!�!�Z��<�<��rN)rNrOrPrQrRrr�r�rSrKrTrrr	rr-s2���I���������rrc�8�\rSrSrSr\S5r\S5rSr	g)riPrc#�# �g7frrrCs r	�__reversed__�Reversible.__reversed__Tr�r1c�:�U[La
[USS5$[$)Nr�r�)rr>r8rIs  r	rK�Reversible.__subclasshook__Ys���*��!�!�^�Z�@�@��rN)
rNrOrPrQrRrr�rSrKrTrrr	rrPs-���I��������rrc�X�\rSrSrSrSr\S5r\S	Sj5rSr	\
S5rSrg)
ri`rc�$�URS5$)zNReturn the next item from the generator.
When exhausted, raise StopIteration.
N)rgrCs r	r��Generator.__next__ds���y�y���rc��[e)zSSend a value into the generator.
Return next yielded value or raise StopIteration.
rcres  r	rg�Generator.sendjrirNc�L�UcUcUeU"5nUbURU5nUe)zWRaise an exception in the generator.
Return next yielded value or raise StopIteration.
rkrms    r	rq�Generator.throwqrsrc�p�UR[5 [S5e![[4a gf=f)z.Raise GeneratorExit inside generator.
        zgenerator ignored GeneratorExitNrvrCs r	ry�Generator.close~r{r|c�@�U[La[USSSSS5$[$)Nr�r�rgrqry)rr>r8rIs  r	rK�Generator.__subclasshook__�s*���)��!�!�Z��"(�'�7�<�
<��rr)
rNrOrPrQrRr�rrgrqryrSrKrTrrr	rr`sN���I�������
��
�B����rrc�8�\rSrSrSr\S5r\S5rSr	g)ri�rc��grBrrCs r	�__len__�
Sized.__len__�rGrc�8�U[La[US5$[$)Nr�)rr>r8rIs  r	rK�Sized.__subclasshook__�s���%�<�!�!�Y�/�/��rN)
rNrOrPrQrRrr�rSrKrTrrr	rr�rUrrc�H�\rSrSrSr\S5r\S5r\"\	5r
Srg)ri�rc��g�NFr)rD�xs  r	�__contains__�Container.__contains__����rc�8�U[La[US5$[$)Nr�)rr>r8rIs  r	rK�Container.__subclasshook__�s���)��!�!�^�4�4��rN)rNrOrPrQrRrr�rSrKr^r_rTrrr	rr�s:���I���������
$�L�1�rrc�(�\rSrSrSr\S5rSrg)ri�rc�<�U[La[USSS5$[$)Nr�r�r�)rr>r8rIs  r	rK�Collection.__subclasshook__�s!���*��!�!�i��^�L�L��rN)rNrOrPrQrRrSrKrTrrr	rr�s���I����rrc�D�\rSrSrSr\S\S\4Sj5r\	S5r
Srg)r$i�r�flags�returnc��[er��NotImplementedError)rDr�s  r	�
__buffer__�Buffer.__buffer__�s��!�!rc�8�U[La[US5$[$)Nr�)r$r>r8rIs  r	rK�Buffer.__subclasshook__�s���&�=�!�!�\�2�2��rN)rNrOrPrQrRr�int�
memoryviewr�rSrKrTrrr	r$r$�s;���I��"��"�:�"��"����rr$c�N^�\rSrSrSrSrU4SjrU4SjrSrU4Sjr	Sr
U=r$)�_CallableGenericAliasi�z�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�>�[U[5(a[U5S:Xd[S5eUup4[U[[45(a/UQUP7nO[U5(d[SU35e[TU]XU5$)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__)rJ�origin�args�t_args�t_result�	__class__s     �r	r��_CallableGenericAlias.__new__�s�����4��'�'�C��I��N��H�J�
J�����f�u�d�m�,�,�&�V�&�X�&�D���'�'��>�>D�X�G�H�
H��w��s�D�1�1rc	�@>�[UR5S:Xa+[URS5(a[TU]5$SSRURSSVs/sHn[
U5PM sn5S[
URS5S3$s snf)Nr�rzcollections.abc.Callable[[z, ���z], �])r��__args__r�r��__repr__�join�
_type_repr)rD�ar�s  �r	r��_CallableGenericAlias.__repr__�s�����t�}�}���"�~�d�m�m�A�6F�'G�'G��7�#�%�%���Y�Y�t�}�}�S�b�7I�J�7I�!�
�1�
�7I�J�K�L�C��d�m�m�B�/�0�1��4�	5��Js�#B
c��URn[U5S:Xa[US5(d[USS5US4n[[
U44$)Nr�rr�)r�r�r�r�r�r)rDr�s  r	�
__reduce__� _CallableGenericAlias.__reduce__�sL���}�}���D�	�Q��>�$�q�'�#:�#:���S�b�	�?�D��H�,�D�$�x��&6�6�6rc��>�[U[5(dU4n[TU]
U5Rn[US[[
45(d
USnUSSnXC4n[
[[U55$)Nrr�)r�r�r��__getitem__r�r�r�r)rD�item�new_argsr�r�r�s     �r	r�!_CallableGenericAlias.__getitem__�sr���
�$��&�&��7�D��7�&�t�,�5�5���(�1�+��t�}�5�5���|�H��c�r�]�F��)�H�$�X�u�X��?�?r)rNrOrPrQ�__doc__rRr�r�r�rrT�
__classcell__�r�s@r	r�r��s*�����I�
2�5�7�@�@rr�c�^�T[Lag[T[5(ag[T5mSnTRS:H=(a [U4SjU55$)ztChecks if obj matches either a list of types, ``...``, ``ParamSpec`` or
``_ConcatenateGenericAlias`` from typing.py
T)�	ParamSpec�_ConcatenateGenericAlias�typingc3�B># �UHnTRU:Hv� M g7fr)rN)�.0�name�objs  �r	�	<genexpr>�!_is_param_expr.<locals>.<genexpr>
s����-U�u�t�c�l�l�d�.B�u�s�)�Ellipsisr�r�r(rO�any)r�namess` r	r�r�sL����h����#�t����
�s�)�C�5�E��>�>�X�%�U�#�-U�u�-U�*U�Urc��[U[5(a7URS:XaUR$URSUR3$U[Lag[U[
5(aUR$[U5$)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.
(Keep this roughly in sync with the typing version.)
�builtins�.z...)r�r(rOrPr�FunctionTyperN�repr)rs r	r�r�sq���#�t����>�>�Z�'��#�#�#��.�.�!��3�#3�#3�"4�5�5�
�h����#�|�$�$��|�|����9�rc�H�\rSrSrSr\S5r\S5r\"\	5r
Srg)ri!rc��gr�r)rDr��kwdss   r	�__call__�Callable.__call__%r�rc�8�U[La[US5$[$)Nr)rr>r8rIs  r	rK�Callable.__subclasshook__)rMrN)rNrOrPrQrRrrrSrKr�r_rTrrr	rr!s;���I���������
$�$9�:�rrc��\rSrSrSrSrSrSrSrSr	Sr
\S	5rS
r
\
rSrSr\rS
rSrSr\rSrSrg)ri5aBA 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��[U[5(d[$[U5[U5:�agUH
nX!;dM
 g g�NFT�r�rr8r��rD�other�elems   r	�__le__�
Set.__le__Bs@���%��%�%�!�!��t�9�s�5�z�!���D�� ���rc��[U[5(d[$[U5[U5:=(a UR	U5$r�r�rr8r�r'�rDr%s  r	�__lt__�
Set.__lt__L�6���%��%�%�!�!��4�y�3�u�:�%�<�$�+�+�e�*<�<rc��[U[5(d[$[U5[U5:�=(a UR	U5$r)r�rr8r��__ge__r+s  r	�__gt__�
Set.__gt__Qr.rc��[U[5(d[$[U5[U5:agUH
nX ;dM
 g gr"r#r$s   r	r0�
Set.__ge__Vs@���%��%�%�!�!��t�9�s�5�z�!���D�����rc��[U[5(d[$[U5[U5:H=(a UR	U5$rr*r+s  r	�__eq__�
Set.__eq__`s6���%��%�%�!�!��4�y�C��J�&�=�4�;�;�u�+=�=rc��U"U5$)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�rJ�its  r	�_from_iterable�Set._from_iterablees
���2�w�rc�p^�[U[5(d[$TRU4SjU55$)Nc3�6># �UHoT;dM
Uv� M g7frr�rrfrDs  �r	r�Set.__and__.<locals>.<genexpr>qs����"M�e�U��}�5�5�e�s�	�	�r�rr8r;r+s` r	�__and__�Set.__and__ns-����%��*�*�!�!��"�"�"M�e�"M�M�Mrc�$�UH
nX ;dM
 g g)z1Return True if two sets have a null intersection.FTr)rDr%rfs   r	�
isdisjoint�Set.isdisjointus���E��}���rc�n�[U[5(d[$SX45nURU5$)Nc3�6# �UHoHo"v� M M g7frr)r�s�es   r	r�Set.__or__.<locals>.<genexpr>s���5�M�q�1�a��1��M�s�rA)rDr%�chains   r	�__or__�
Set.__or__|s2���%��*�*�!�!�5�T�M�5���"�"�5�)�)rc�^�[T[5(d,[T[5(d[$UR	T5mUR	U4SjU55$)Nc3�8># �UHnUT;dMUv� M g7frr)rrfr%s  �r	r�Set.__sub__.<locals>.<genexpr>�s ����#:�d�U�&+�5�&8�$)�5�d���
�	�r�rrr8r;r+s `r	�__sub__�Set.__sub__�sR����%��%�%��e�X�.�.�%�%��'�'��.�E��"�"�#:�d�#:�:�	:rc�^�[U[5(d,[U[5(d[$TR	U5nTR	U4SjU55$)Nc3�8># �UHnUT;dMUv� M g7frrr?s  �r	r�Set.__rsub__.<locals>.<genexpr>�s ����#9�e�U�&+�4�&7�$)�5�e�rRrSr+s` r	�__rsub__�Set.__rsub__�sR����%��%�%��e�X�.�.�%�%��'�'��.�E��"�"�#9�e�#9�9�	9rc��[U[5(d,[U[5(d[$UR	U5nX-
X-
-$rrSr+s  r	�__xor__�Set.__xor__�sA���%��%�%��e�X�.�.�%�%��'�'��.�E�����.�.rc��[RnSU-S-n[U5nSUS--nXB-nUH"n[U5nXFUS--S-S--nXB-nM$ XDS-	US-	--nUS	-S
-nXB-nXA:�aXBS--nUS:XaSnU$)
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#)r)�maxsizer��hash)rD�MAX�MASK�n�hr��hxs       r	�_hash�	Set._hash�s����k�k���3�w��{����I���!�a�%� ��	�	���A��a��B�
��b��/�H�,��;�;�A�
�I�A��	
�2�g�!�r�'�
"�"��
��I�	�!��	�	���7�
���M�A���7��A��rN)rNrOrPrQrrRr'r,r1r0r6rSr;rB�__rand__rErM�__ror__rTrYr\�__rxor__rirTrrr	rr5st����I��=�
=�
�>�
����N�
�H��*��G�:�9�/��H�rrc�f�\rSrSrSrSr\S5r\S5rSr	Sr
SrS	rS
r
SrSrSrg
)ri�akA 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��[e)zAdd an element.r�res  r	�add�MutableSet.add��
��"�!rc��[e)z8Remove an element.  Do not raise an exception if absent.r�res  r	�discard�MutableSet.discard�rrrc�F�X;a[U5eURU5 g)z5Remove an element. If not a member, raise a KeyError.N)�KeyErrorrtres  r	�remove�MutableSet.remove�s�����5�/�!����U�rc��[U5n[U5nUR	U5 U$![a [Sef=f)z2Return the popped value.  Raise KeyError if empty.N)�iter�nextrdrwrt�rDr:rfs   r	�pop�MutableSet.pop�sE��
�$�Z��	%���H�E�	
���U������	%���$�	%�s�+�=c�J�UR5 M![a gf=f)z6This is slow (creates N new iterators!) but effective.N)r~rwrCs r	�clear�MutableSet.clear�s*��	�����
����	��	����
"�"c�:�UHnURU5 M U$r)rpr}s   r	�__ior__�MutableSet.__ior__�s���E��H�H�U�O���rc�>�X-
HnURU5 M U$r)rtr}s   r	�__iand__�MutableSet.__iand__�s���i�E��L�L��� ��rc���XLaUR5 U$[U[5(dURU5nUH,nX ;aUR	U5 MURU5 M. U$r)r�r�rr;rtrpr}s   r	�__ixor__�MutableSet.__ixor__�sc��
�:��J�J�L����b�#�&�&��(�(��,�����=��L�L��'��H�H�U�O�	�
�rc�f�XLaUR5 U$UHnURU5 M U$r)r�rtr}s   r	�__isub__�MutableSet.__isub__	s4��
�:��J�J�L��������U�#���rN)rNrOrPrQrrRrrprtrxr~r�r�r�r�r�rTrrr	rr�sW��	��I��"��"��"��"�����
�
�rrc�\�\rSrSrSrSrSr\S5rS
Sjr	Sr
S	rS
rSr
SrSrSrg)riz�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��[er�rw�rD�keys  r	r�Mapping.__getitem__$����rNc�0�X$![a Us$f=f)z<D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.r��rDr��defaults   r	�get�Mapping.get(s#��	��9����	��N�	�s���c�.�X g![a gf=f�NTFr�r�s  r	r��Mapping.__contains__/s%��	��I����	��	�s��
�c��[U5$)z:D.keys() -> a set-like object providing a view on D's keys)rrCs r	�keys�Mapping.keys7s����~�rc��[U5$)z<D.items() -> a set-like object providing a view on D's items)rrCs r	�items�
Mapping.items;s�����rc��[U5$)z6D.values() -> an object providing a view on D's values)r rCs r	�values�Mapping.values?s
���$��rc��[U[5(d[$[UR	55[UR	55:H$r)r�rr8�dictr�r+s  r	r6�Mapping.__eq__Cs6���%��)�)�!�!��D�J�J�L�!�T�%�+�+�-�%8�8�8rr)rNrOrPrQrrR�__abc_tpflags__rrr�r�r�r�r�r6r�rTrrr	rrsL����I��O��������� �9�
�Lrrc�:�\rSrSrSrSrSrSr\"\	5r
Srg)riN��_mappingc��Xlgrr�)rD�mappings  r	�__init__�MappingView.__init__Rs���
rc�,�[UR5$r)r�r�rCs r	r��MappingView.__len__Us���4�=�=�!�!rc�$�SRU5$)Nz&{0.__class__.__name__}({0._mapping!r}))�formatrCs r	r��MappingView.__repr__Xs��7�>�>�t�D�DrN)rNrOrPrQrRr�r�r�rSr^r_rTrrr	rrNs$���I� �"�E�$�L�1�rrc�4�\rSrSrSr\S5rSrSrSr	g)ri^rc��[U5$r��setr9s  r	r;�KeysView._from_iterableb����2�w�rc��XR;$rr�r�s  r	r��KeysView.__contains__fs���m�m�#�#rc#�8# �URShv�N gN7frr�rCs r	r��KeysView.__iter__is����=�=� � �s���N�
rNrOrPrQrRrSr;r�r�rTrrr	rr^s#���I�����$�!rrc�4�\rSrSrSr\S5rSrSrSr	g)riprc��[U5$rr�r9s  r	r;�ItemsView._from_iterabletr�rc�f�Uup#URUnXCL=(d XC:H$![a gf=fr�)r�rw)rDrr�rf�vs     r	r��ItemsView.__contains__xsA���
��	,��
�
�c�"�A��:�+���+���	��	�s�#�
0�0c#�V# �URHnXRU4v� M g7frr�r�s  r	r��ItemsView.__iter__�s%����=�=�C��
�
�c�*�+�+�!�s�')Nr�rrr	rrps#���I�����,�,rrc�$�\rSrSrSrSrSrSrg)r i�rc�^�URHnURUnX1LdX1:XdM g gr�r�)rDrfr�r�s    r	r��ValuesView.__contains__�s/���=�=�C��
�
�c�"�A��z�Q�Z��!�rc#�T# �URHnURUv� M g7frr�r�s  r	r��ValuesView.__iter__�s"����=�=�C��-�-��$�$�!�r�N)rNrOrPrQrRr�r�rTrrr	r r �s���I��%rr c�v�\rSrSrSrSr\S5r\S5r\	"5r
\
4SjrSrSr
SS	jrS
SjrSrg
)ri�z�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��[err��rDr�rfs   r	�__setitem__�MutableMapping.__setitem__�r�rc��[err�r�s  r	�__delitem__�MutableMapping.__delitem__�r�rc�V�XnX	U$![a X RLaeUs$f=f)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.
)rw�_MutableMapping__marker)rDr�r�rfs    r	r~�MutableMapping.pop�s=��	��I�E��	��L��
�	��-�-�'���N�	�s�
�(�(c�h�[[U55nXnX	X4$![a [Sef=f)zpD.popitem() -> (k, v), remove and return some (key, value) pair
as a 2-tuple; but raise KeyError if D is empty.
N)r|r{rdrwr�s   r	�popitem�MutableMapping.popitem�sD��	%��t�D�z�"�C��	���I��z���	�	%���$�	%�s��1c�J�UR5 M![a gf=f)z,D.clear() -> None.  Remove all items from D.N)r�rwrCs r	r��MutableMapping.clear�s*��	���������	��	�r�c��[U[5(aUH	nXX'M O>[US5(aUR5H	nXX'M OUH	up4X@U'M UR	5H	up4X@U'M g)a%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.keys(): 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
r�N)r�r�hasattrr�r�)rDr%rr�rfs     r	�update�MutableMapping.update�sx���e�W�%�%���!�J��	��
�U�F�
#�
#��z�z�|��!�J��	�$�$�
��!�S�	�$��*�*�,�J�C���I�'rNc�6�X$![a X U'U$f=f)z@D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in Dr�r�s   r	�
setdefault�MutableMapping.setdefault�s*��	 ��9����	 ���I���	 �s���)rr)rNrOrPrQrrRrr�r��objectr�r~r�r�r�r�rTrrr	rr�sY����I����������x�H�'��
���$rrc�R�\rSrSrSrSrSr\S5rSr	Sr
SrSS
jrSr
Srg	)
r!i�z~All the operations on a read-only sequence.

Concrete subclasses must override __new__ or __init__,
__getitem__, and __len__.
r� c��[er��
IndexError�rD�indexs  r	r�Sequence.__getitem__�����rc#�P# �SnXnUv� US-
nM![a gf=f7f)Nrr%r�)rD�ir�s   r	r��Sequence.__iter__s?���
��	���G�����Q������	��	�s�&��
#�&�#�&c�,�UHnX!LdX!:XdM g gr�r)rDrfr�s   r	r��Sequence.__contains__
s���A��z�Q�Z���rc#�`# �[[[U555H	nXv� M g7fr)�reversed�ranger�)rDr�s  r	r��Sequence.__reversed__s$����%��D�	�*�+�A��'�M�,�s�,.Nc��UbUS:a[[U5U-S5nUbUS:aU[U5-
nUnUbXC:a!XnXQLdXQ:XaU$US-
nUcMXC:aM![e![a [ef=f)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.
rr%)�maxr�r��
ValueError)rDrf�start�stopr�r�s      r	r��Sequence.indexs����������D�	�E�)�1�-�E����q���C��I��D����l�a�h�
��G���z�Q�Z���
��F�A��l�a�h�����
����
�s�A*�*
A<�;A<c�.^�[U4SjU55$)zBS.count(value) -> integer -- return number of occurrences of valuec3�@># �UHoTLdUT:XdMSv� M g7f)r%Nr)rr�rfs  �r	r�!Sequence.count.<locals>.<genexpr>0s����?�d��5�j�A��J�1�1�d�s��	)�sumres `r	�count�Sequence.count.s����?�d�?�?�?r)rN)rNrOrPrQrrRr�rrr�r�r�r�rrTrrr	r!r!�sA����I��O���������.@rr!c�4^�\rSrSrU4SjrU4SjrSrU=r$)�_DeprecateByteStringMetai7c�\>�US:waSSKnURSSS9 [TU]"XX#40UD6$)Nr#r�collections.abc.ByteString����rx)�warnings�_deprecatedr�r�)rJr
�bases�	namespace�kwargsrr�s      �r	r�� _DeprecateByteStringMeta.__new__8s?����<���� � �,��
!�
��w��s�%�E�f�E�Erc�J>�SSKnURSSS9 [TU]
U5$)Nrr
rr)rrr��__instancecheck__)rJ�instancerr�s   �r	r�*_DeprecateByteStringMeta.__instancecheck__Bs1�������(��	�	
��w�(��2�2rr)rNrOrPrQr�rrTrrs@r	rr7s���F�3�3rrc��\rSrSrSrSrSrg)r#iKzEThis unifies bytes and bytearray.

XXX Should add all their methods.
rN)rNrOrPrQrrRrTrrr	r#r#Ks���
�Irr#c�z�\rSrSrSrSr\S5r\S5r\S5r	Sr
SrS	rS
r
SSjrSrS
rSrg)r"iWz�All the operations on a read-write sequence.

Concrete subclasses must provide __new__ or __init__,
__getitem__, __setitem__, __delitem__, __len__, and insert().
rc��[err��rDr�rfs   r	r��MutableSequence.__setitem__`r�rc��[err�r�s  r	r��MutableSequence.__delitem__dr�rc��[e)z3S.insert(index, value) -- insert value before indexr�rs   r	�insert�MutableSequence.inserths
���rc�:�UR[U5U5 g)z:S.append(value) -- append value to the end of the sequenceN)r!r�res  r	�append�MutableSequence.appendms�����C��I�u�%rc�J�UR5 M![a gf=f)z,S.clear() -> None -- remove all items from SN)r~r�rCs r	r��MutableSequence.clearqs*��	�����
����	��	�r�c�v�[U5n[US-5HnXU-
S-
XsX'XU-
S-
'M g)z!S.reverse() -- reverse *IN PLACE*r�r%N)r�r�)rDrfr�s   r	�reverse�MutableSequence.reverseysA����I���q�!�t��A�#'�!��A��;��� �D�G�T�A�#�a�%�[�rc�V�XLa[U5nUHnURU5 M g)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)r�r$)rDr�r�s   r	�extend�MutableSequence.extends%���>��&�\�F��A��K�K��N�rc��XnX	U$)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)rDr�r�s   r	r~�MutableSequence.pop�s��
�K���K��rc�&�XRU5	g)zcS.remove(value) -- remove first occurrence of value.
Raise ValueError if the value is not present.
N)r�res  r	rx�MutableSequence.remove�s��
���E�"�#rc�(�URU5 U$r)r,)rDr�s  r	�__iadd__�MutableSequence.__iadd__�s�����F���rN)r�)rNrOrPrQrrRrr�r�r!r$r�r)r,r~rxr3rTrrr	r"r"Wsk����I�������������&��8���$�rr")Wr�abcrrr)r(r�r�r^�EllipsisTyper
r�__all__rNr{�bytes_iterator�	bytearray�bytearray_iteratorr��dict_keyiteratorr��dict_valueiteratorr��dict_itemiterator�
list_iteratorr��list_reverseiteratorr��range_iterator�longrange_iteratorr��set_iterator�str_iterator�tuple_iterator�zip�zip_iterator�	dict_keys�dict_values�
dict_itemsr7�mappingproxyr,�framelocalsproxy�	generatorr0�	coroutineryr3�async_generatorr>rrr�registerr
rrrrrrrrrr$r�r�r�rr�	frozensetrrrrrr rr�r!r��strr�rr#�bytesr"rrr	�<module>rSs!���>(�
��D��I����C�y����B�x���	
�����d�3�i����$�y�{�+�,����R�W�W�Y��(���$�r�y�y�{�+�,����b�h�h�j�)�*���T�"�X��
��D��"��.�/���d�5��8�n�%���$�u�Q�$�Y�/�0�1���D���K� ���D��H�~���d�2�h����D���K� �������O�	��2�9�9�;���
�"�(�(�*�
�
��D�M�M�"��*�(�*����/�$�%�	��
�����K�	����
�	��	�e���s�)���

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

?>