� c��jY}��Z �dZddlmZmZddlZeee�Zed�Z d�Z ee �Z [ gd�Z dZ eed��Zeee���Zeeij%���Zeeij)���Zeeij-���Zeeg��Zeeeg���Zeeed���Zeeed d z���Zeee���Zeed ��Z eed ��Z!eee"���Z#eij%��Z$eij)��Z%eij-��Z&eejN�Z(ed ���Z)d�Z*e*�Z*ee*�Z+e*jY�[*d�Z-e-�Z-ee-�Z.[-d�Z/Gd�de��Z0Gd�de��Z1Gd�de1�Z2e2jge+�Gd�de��Z4Gd�de4�Z5Gd�de5�Z6e6jge.�Gd�de��Z7Gd �d!e7�Z8e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge �e8jge!�e8jge#�Gd"�d#e7�Z9Gd$�d%e8�Z:e:jge)�Gd&�d'e��Z;Gd(�d)e��Z<Gd*�d+e;e7e<�Z=Gd,�d-e��Z>Gd.�d/e�Z?d0�Z@d1�ZAGd2�d3e��ZBGd4�d5e=�ZCeCjgeD�Gd6�d7eC�ZEeEjge�Gd8�d9e=�ZFeFjge(�Gd:�d;e;�ZGGd<�d=eGeC�ZHeHjge$�Gd>�d?eGeC�ZIeIjge&�Gd@�dAeGe=�ZJeJjge%�GdB�dCeF�ZKeKjgeL�GdD�dEe9e=�ZMeMjgeN�eMjgeO�eMjge�eMjgeP�GdF�dGe�ZQGdH�dIeMeQ��ZReRjgeS�eRjge�GdJ�dKeM�ZTeTjge�eTjge�y)LzjAbstract Base Classes (ABCs) for collections, according to PEP 3119. Unit tests are in test_collections. �)�ABCMeta�abstractmethodN.c��y�N�r��)/usr/lib64/python3.12/_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#�K�d��Srrrrr �r(Xs����5rc�� K�y�wrrrrr �_coror*Zs����4���c�K�d���y�wrrrrr �_agr-`s������� c��|j}|D]9}|D]+}||jvs�|j|� tccS�2tcSy)NT)�__mro__�__dict__�NotImplemented)�C�methods�mro�method�Bs r �_check_methodsr8hsP�� �)�)�C����A�����#��:�:�f�%�-�)�)�� � "� !�� rc�0�eZdZdZed��Zed��Zy)rrc��y�Nrr��selfs r �__hash__zHashable.__hash__x���rc�6�|tur t|d�StS)Nr>)rr8r2��clsr3s r �__subclasshook__zHashable.__subclasshook__|��� �(�?�!�!�Z�0� 0��rN)�__name__� __module__� __qualname__� __slots__rr>� classmethodrCrrr rrt�-���I��������rr)� metaclassc�@�eZdZdZed��Zed��Zee�Z y)r rc#�K�d��y�wrrr<s r � __await__zAwaitable.__await__�s ���� �s�c�6�|tur t|d�StS)NrN)r r8r2rAs r rCzAwaitable.__subclasshook__�s�� �)� �!�!�[�1� 1��rN) rErFrGrHrrNrIrC� GenericAlias�__class_getitem__rrr r r �s:���I��������� $�L�1�rr c�H�eZdZdZed��Zedd��Zd�Zed��Z y)r rc��t�)zcSend a value into the coroutine. Return next yielded value or raise StopIteration. �� StopIteration�r=�values r �sendzCoroutine.send�� �� �rNc�F�|� |�|�|�}|�|j|�}|�)zgRaise an exception in the coroutine. Return next yielded value or raise StopIteration. ��with_traceback�r=�typ�val�tbs r �throwzCoroutine.throw��4�� �;��z�� ��%�C� �>��$�$�R�(�C�� rc�n� |jt�td��#ttf$rYywxYw)�.Raise GeneratorExit inside coroutine. zcoroutine ignored GeneratorExitN�ra� GeneratorExit� RuntimeErrorrUr<s r �closezCoroutine.close��;�� B� �J�J�}� %��@�A� A���}�-� � � �� �"�4�4c�<�|turt|dddd�StS)NrNrXrarh)r r8r2rAs r rCzCoroutine.__subclasshook__�s#�� �)� �!�!�[�&�'�7�K� K��r�NN) rErFrGrHrrXrarhrIrCrrr r r �sG���I����� � �� �B����rr c�@�eZdZdZed��Zed��Zee�Z y)r rc��t�Sr)rr<s r � __aiter__zAsyncIterable.__aiter__�s ����rc�6�|tur t|d�StS)Nro)r r8r2rAs r rCzAsyncIterable.__subclasshook__�s�� �-� �!�!�[�1� 1��rN) rErFrGrHrrorIrCrPrQrrr r r �s:���I��������� $�L�1�rr c�6�eZdZdZed��Zd�Zed��Zy)rrc��K�t��w)z@Return the next item or raise StopAsyncIteration when exhausted.��StopAsyncIterationr<s r � __anext__zAsyncIterator.__anext__�s����!� �r.c��|Srrr<s r rozAsyncIterator.__aiter__����� rc�8�|tur t|dd�StS)Nruro)rr8r2rAs r rCzAsyncIterator.__subclasshook__�s�� �-� �!�!�[�+�>� >��rN) rErFrGrHrrurorIrCrrr rr�s2���I��!��!�����rrc�N�eZdZdZd�Zed��Zedd��Zd�Ze d��Z y) rrc��@K�|jd��d{���S7��w)zpReturn the next item from the asynchronous generator. When exhausted, raise StopAsyncIteration. N)�asendr<s r ruzAsyncGenerator.__anext__�s�����Z�Z��%�%�%�%�s ���c��K�t��w)zuSend a value into the asynchronous generator. Return next yielded value or raise StopAsyncIteration. rsrVs r r{zAsyncGenerator.asend�s���� !� �r.Nc��NK�|� |�|�|�}|�|j|�}|��w)zyRaise an exception in the asynchronous generator. Return next yielded value or raise StopAsyncIteration. r[r]s r �athrowzAsyncGenerator.athrow�s8���� �;��z�� ��%�C� �>��$�$�R�(�C�� �s�#%c��K� |jt��d{���td��7�#ttf$rYywxYw�w)rdNz,asynchronous generator ignored GeneratorExit)r~rfrgrtr<s r �aclosezAsyncGenerator.aclosesH���� O��+�+�m�,� ,� ,��M�N� N� -���1�2� � � �s/�A�.�,�.� A�.�A�A�A�Ac�>�|turt|ddddd�StS)Nrorur{r~r�)rr8r2rAs r rCzAsyncGenerator.__subclasshook__ s*�� �.� �!�!�[�+�")�8�X�?� ?��rrl) rErFrGrHrurr{r~r�rIrCrrr rr�sN���I�&� �!��!� � �� �O����rrc�@�eZdZdZed��Zed��Zee�Z y)rrc#� K�y�wrrr<s r �__iter__zIterable.__iter__� �����r+c�6�|tur t|d�StS)Nr�)rr8r2rAs r rCzIterable.__subclasshook__ rDrN) rErFrGrHrr�rIrCrPrQrrr rrs:���I��������� $�L�1�rrc�6�eZdZdZed��Zd�Zed��Zy)rrc��t�)zKReturn the next item from the iterator. When exhausted, raise StopIterationrTr<s r �__next__zIterator.__next__-s ���rc��|Srrr<s r r�zIterator.__iter__2rwrc�8�|tur t|dd�StS)Nr�r�)rr8r2rAs r rCzIterator.__subclasshook__5s�� �(�?�!�!�Z��<� <��rN) rErFrGrHrr�r�rIrCrrr rr)s2���I���������rrc�0�eZdZdZed��Zed��Zy)rrc#� K�y�wrrr<s r � __reversed__zReversible.__reversed__Pr�r+c�8�|tur t|dd�StS)Nr�r�)rr8r2rAs r rCzReversible.__subclasshook__Us�� �*� �!�!�^�Z�@� @��rN)rErFrGrHrr�rIrCrrr rrLs-���I��������rrc�N�eZdZdZd�Zed��Zedd��Zd�Ze d��Z y) rrc�$�|jd�S)z^Return the next item from the generator. When exhausted, raise StopIteration. N)rXr<s r r�zGenerator.__next__`s���y�y���rc��t�)zcSend a value into the generator. Return next yielded value or raise StopIteration. rTrVs r rXzGenerator.sendfrYrNc�F�|� |�|�|�}|�|j|�}|�)zgRaise an exception in the generator. Return next yielded value or raise StopIteration. r[r]s r razGenerator.throwmrbrc�n� |jt�td��#ttf$rYywxYw)z.Raise GeneratorExit inside generator. zgenerator ignored GeneratorExitNrer<s r rhzGenerator.closezrirjc�>�|turt|ddddd�StS)Nr�r�rXrarh)rr8r2rAs r rCzGenerator.__subclasshook__�s*�� �)� �!�!�Z��"(�'�7�<� <��rrl) rErFrGrHr�rrXrarhrIrCrrr rr\sN���I�� ���� � �� �B����rrc�0�eZdZdZed��Zed��Zy)rrc��yr;rr<s r �__len__z Sized.__len__�r?rc�6�|tur t|d�StS)Nr�)rr8r2rAs r rCzSized.__subclasshook__�s�� �%�<�!�!�Y�/� /��rN)rErFrGrHrr�rIrCrrr rr�rJrrc�@�eZdZdZed��Zed��Zee�Z y)rrc��y�NFr)r=�xs r � __contains__zContainer.__contains__����rc�6�|tur t|d�StS)Nr�)rr8r2rAs r rCzContainer.__subclasshook__�s�� �)� �!�!�^�4� 4��rN) rErFrGrHrr�rIrCrPrQrrr rr�s:���I��������� $�L�1�rrc� �eZdZdZed��Zy)rrc�:�|turt|ddd�StS)Nr�r�r�)rr8r2rAs r rCzCollection.__subclasshook__�s!�� �*� �!�!�i��^�L� L��rN)rErFrGrHrIrCrrr rr�s���I����rrc�:�eZdZdZededefd��Zed��Z y)r$r�flags�returnc��t�r��NotImplementedError)r=r�s r � __buffer__zBuffer.__buffer__�s��!�!rc�6�|tur t|d�StS)Nr�)r$r8r2rAs r rCzBuffer.__subclasshook__�s�� �&�=�!�!�\�2� 2��rN) rErFrGrHr�int� memoryviewr�rIrCrrr r$r$�s;���I��"��"�:�"��"����rr$c�@��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����t|t�rt|�dk(s td��|\}}t|ttf�rg|�|��}nt |�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__)rB�origin�args�t_args�t_result� __class__s �r r�z_CallableGenericAlias.__new__�s�����4��'�C��I��N��H�J� J����� �f�u�d�m� ,�&�V�&�X�&�D���'��>�>D�X�G�H� H��w��s�F�D�1�1rc �.��t|j�dk(r&t|jd�rt�|��Sddj |jddD�cgc] }t |���c}��dt |jd��d�Scc}w)Nr�rzcollections.abc.Callable[[z, �����z], �])r��__args__r�r��__repr__�join� _type_repr)r=�ar�s �r r�z_CallableGenericAlias.__repr__�s���� �t�}�}� �� "�~�d�m�m�A�6F�'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��|j}t|�dk(rt|d�st|dd�|df}tt |ffS)Nr�rr�)r�r�r�r�r�r)r=r�s r � __reduce__z _CallableGenericAlias.__reduce__�sI���}�}���D� �Q��>�$�q�'�#:���S�b� �?�D��H�,�D�$�x��&6�6�6rc����t|t�s|f}t�|� |�j}t|dtt f�s|d}|dd}||f}t tt|��S)Nrr�)r�r�r�� __getitem__r�r�r�r)r=�item�new_argsr�r�r�s �r r�z!_CallableGenericAlias.__getitem__�sn��� �$��&��7�D��7�&�t�,�5�5���(�1�+��t�}�5���|�H��c�r�]�F���)�H�$�X�u�X��?�?r) rErFrG�__doc__rHr�r�r�r�� __classcell__�r�s@r r�r��s*�����I� 2�5�7� @�@rr�c����turyt�t�ryt���d}�jdk(xrt �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|k(���y�wr)rE)�.0�name�objs �r � z!_is_param_expr.. s�����-U�u�t�c�l�l�d�.B�u�s�)�Ellipsisr�r��typerF�any)r��namess` r r�r��sI��� �h����#�t��� �s�)�C� 5�E� �>�>�X� %� U�#�-U�u�-U�*U�Urc���t|t�r6|jdk(r |jS|j�d|j��S|turyt|t �r |j St|�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. (Keep this roughly in sync with the typing version.) �builtins�.z...)r�r�rFrGr�� FunctionTyperE�repr)r�s r r�r� sk���#�t�� �>�>�Z� '��#�#� #��.�.�!��3�#3�#3�"4�5�5� �h����#�|�$��|�|�� ��9�rc�@�eZdZdZed��Zed��Zee�Z y)rrc��yr�r)r=r��kwdss r �__call__zCallable.__call__!r�rc�6�|tur t|d�StS)Nr�)rr8r2rAs r rCzCallable.__subclasshook__%rDrN) rErFrGrHrr�rIrCr�rQrrr rrs;���I��������� $�$9�:�rrc�x�eZdZdZdZd�Zd�Zd�Zd�Zd�Z e d��Z d �Z e Z d �Zd �ZeZd �Zd �Zd�ZeZd�Zy)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�z�t|t�stSt|�t|�kDry|D]}||vs�yy�NFT�r�rr2r��r=�other�elems r �__le__z Set.__le__>s?���%��%�!� !� �t�9�s�5�z� !���D��5� ���rc��t|t�stSt|�t|�kxr|j |�Sr�r�rr2r�r��r=r�s r �__lt__z Set.__lt__H�3���%��%�!� !��4�y�3�u�:�%�<�$�+�+�e�*<�.ms�����"M�e�U�u��}�5�e�s� ��r�rr2r�r�s` r �__and__z Set.__and__js*����%��*�!� !��"�"�"M�e�"M�M�Mrc��|D]}||vs�yy)z1Return True if two sets have a null intersection.FTr)r=r�rWs r � isdisjointzSet.isdisjointqs���E���}���rc�f�t|t�stSd�||fD�}|j|�S)Nc3�.K�|] }|D]}|����y�wrr)r��s�es r r�zSet.__or__..{s����5�M�q�1�a��1��M�s�r)r=r��chains r �__or__z Set.__or__xs1���%��*�!� !�5�T�5�M�5���"�"�5�)�)rc���t�t�s't�t�stS|j ���|j �fd�|D��S)Nc3�*�K�|] }|�vr|��� y�wrr)r�rWr�s �r r�zSet.__sub__..�s�����#:�d�U�&+�5�&8�$)�d����r�rrr2r�r�s `r �__sub__z Set.__sub__�sL����%��%��e�X�.�%�%��'�'��.�E��"�"�#:�d�#:�:� :rc���t|t�s't|t�stS�j |�}�j �fd�|D��S)Nc3�*�K�|] }|�vr|��� y�wrrr�s �r r�zSet.__rsub__..�s�����#9�e�U�&+�4�&7�$)�e�r r r�s` r �__rsub__z Set.__rsub__�sL����%��%��e�X�.�%�%��'�'��.�E��"�"�#9�e�#9�9� 9rc��t|t�s't|t�stS|j |�}||z ||z zSrr r�s r �__xor__z Set.__xor__�s?���%��%��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}||kDr||dzz}|d k(rd }|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._hash�s����k�k���3�w��{�� ��I�� �!�a�%� �� �T� ���A��a��B� �"��b��/�H�,��;� ;�A� ��I�A�� �a�2�g�!�r�'� "�"�� ��I� � !�� �T� �� �s�7� ����M�A� ��7��A��rN)rErFrGr�rHr�r�r�r�r�rIr�r�__rand__rr �__ror__rrr�__rxor__r rrr rr1st����I��=� =� �>� ����N� �H��*� �G�:�9�/��H�rrc�^�eZdZdZdZed��Zed��Zd�Zd�Z d�Z d�Z d �Z d �Z d �Zy ) 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.r�rVs r �addzMutableSet.add�� ��"�!rc��t�)z8Remove an element. Do not raise an exception if absent.r�rVs r �discardzMutableSet.discard�r'rc�D�||vr t|��|j|�y)z5Remove an element. If not a member, raise a KeyError.N)�KeyErrorr)rVs r �removezMutableSet.remove�s �� �� ��5�/� !� � � �U�rc�~�t|�} t|�}|j |�|S#t$rtd�wxYw)z2Return the popped value. Raise KeyError if empty.N)�iter�nextrUr+r)�r=r�rWs r �popzMutableSet.pop�sE�� �$�Z�� %���H�E� � � �U��� ��� %��� $� %�s� +�<c�F� |j��#t$rYywxYw)z6This is slow (creates N new iterators!) but effective.N)r1r+r<s r �clearzMutableSet.clear�s*�� ����� ���� � � �� �� � c�6�|D]}|j|��|Sr)r&r0s r �__ior__zMutableSet.__ior__�s���E� �H�H�U�O��� rc�<�||z D]}|j|��|Sr)r)r0s r �__iand__zMutableSet.__iand__�s!���R�i�E� �L�L�� � �� rc���||ur|j�|St|t�s|j|�}|D])}||vr|j |��|j |��+|Sr)r3r�rr�r)r&r0s r �__ixor__zMutableSet.__ixor__�sd�� ��:� �J�J�L�� ��b�#�&��(�(��,�����D�=��L�L��'��H�H�U�O� � � rc�b�||ur|j�|S|D]}|j|��|Sr)r3r)r0s r �__isub__zMutableSet.__isub__s6�� ��:� �J�J�L�� ���� � �U�#��� rN)rErFrGr�rHrr&r)r,r1r3r6r8r:r<rrr rr�sW�� ��I��"��"��"��"�� ��� � �rrc�R�eZdZdZdZdZed��Zd d�Zd�Z d�Z d �Z d �Z d �Z dZy) 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�0� ||S#t$r|cYSwxYw)z D[k] if k in D, else d. d defaults to None.r@�r=rB�defaults r �getz Mapping.get$s%�� ���9� ��� ��N� �s �� �c�.� ||y#t$rYywxYw�NTFr@rAs r r�zMapping.__contains__+s'�� � ��I���� �� �s �� �c��t|�S)z:D.keys() -> a set-like object providing a view on D's keys)rr<s r �keysz Mapping.keys3s ����~�rc��t|�S)z a set-like object providing a view on D's items)rr<s r �itemsz Mapping.items7s �����rc��t|�S)z6D.values() -> an object providing a view on D's values)r r<s r �valueszMapping.values;s ���$��rc��t|t�stSt|j ��t|j ��k(Sr)r�rr2�dictrMr�s r r�zMapping.__eq__?s3���%��)�!� !��D�J�J�L�!�T�%�+�+�-�%8�8�8rr)rErFrGr�rH�__abc_tpflags__rr�rGr�rKrMrOr�r�rrr rrsL����I��O��������� �9� �Lrrc�2�eZdZdZd�Zd�Zd�Zee�Z y)r��_mappingc��||_yrrT)r=�mappings r �__init__zMappingView.__init__Ms ���� rc�,�t|j�Sr)r�rUr<s r r�zMappingView.__len__Ps���4�=�=�!�!rc�$�dj|�S)Nz&{0.__class__.__name__}({0._mapping!r}))�formatr<s r r�zMappingView.__repr__Ss��7�>�>�t�D�DrN) rErFrGrHrXr�r�rIrPrQrrr rrIs$���I� �"�E�$�L�1�rrc�,�eZdZdZed��Zd�Zd�Zy)rrc��t|�Sr��setr�s r r�zKeysView._from_iterable]� ���2�w�rc��||jvSrrTrAs r r�zKeysView.__contains__as���d�m�m�#�#rc#�8K�|jEd{���y7��wrrTr<s r r�zKeysView.__iter__ds�����=�=� � �s ���N�rErFrGrHrIr�r�r�rrr rrYs#���I�����$�!rrc�,�eZdZdZed��Zd�Zd�Zy)rrc��t|�Srr^r�s r r�zItemsView._from_iterableor`rc�`�|\}} |j|}||uxs||k(S#t$rYywxYwr�)rUr+)r=r�rBrW�vs r r�zItemsView.__contains__ssG��� ��U� ,�� � �c�"�A���:�+��e�� +��� �� �s �!� -�-c#�TK�|jD]}||j|f���y�wrrTrAs r r�zItemsView.__iter__|s(�����=�=�C��� � �c�*�+� +�!�s�&(Nrcrrr rrks#���I�����,�,rrc��eZdZdZd�Zd�Zy)r rc�Z�|jD]}|j|}||us||k(s�yyrIrT)r=rWrBrgs r r�zValuesView.__contains__�s3���=�=�C�� � �c�"�A��E�z�Q�%�Z��!�rc#�PK�|jD]}|j|���y�wrrTrAs r r�zValuesView.__iter__�s#�����=�=�C��-�-��$� $�!�s�$&N)rErFrGrHr�r�rrr r r �s���I��%rr c�h�eZdZdZdZed��Zed��Ze�Z e fd�Z d�Z d�Z d d�Z d d �Zy ) 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�rr@�r=rBrWs r � __setitem__zMutableMapping.__setitem__�rCrc��t�rr@rAs r � __delitem__zMutableMapping.__delitem__�rCrc�X� ||}||=|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=rBrFrWs r r1zMutableMapping.pop�sC�� ���I�E� �S� ��L�� � ��$�-�-�'���N� �s � �)�)c�l� tt|��}||}||=||fS#t$rtd�wxYw)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.rUr+rns r �popitemzMutableMapping.popitem�sJ�� %��t�D�z�"�C��S� �� ��I��E�z��� � %��� $� %�s�"�3c�F� |j��#t$rYywxYw)z,D.clear() -> None. Remove all items from D.N)rur+r<s r r3zMutableMapping.clear�s*�� ��� � ����� � � �r4c ���t|t�r|D] }||||<� n9t|d�r|j�D] }||||<� n|D] \}}|||<� |j �D] \}}|||<� y)aR 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 rKN)r�r�hasattrrKrM)r=r�r�rBrWs r �updatezMutableMapping.update�s��� �e�W� %���!�#�J��S� �� �U�F� #��z�z�|��!�#�J��S� �$�$� ��U�!��S� �$��*�*�,�J�C���D��I�'rNc�8� ||S#t$r |||<Y|SwxYw)[email protected](k[,d]) -> D.get(k,d), also set D[k]=d if k not in Dr@rEs r � setdefaultzMutableMapping.setdefault�s.�� ���9� ��� ��D��I��� �s ���)rr)rErFrGr�rHrrorq�objectrsr1rur3ryr{rrr rr�sY����I����������x�H�'� � ���$rrc�H�eZdZdZdZdZed��Zd�Zd�Z d�Z d d �Z d �Z y) 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#�NK�d} ||}|��|dz }�#t$rYywxYw�w)Nrr%r�)r=�irgs r r�zSequence.__iter__�sB���� �� ����G�����Q������ � � �s�%�� "�%�"�%c�(�|D] }||us||k(s� yyrIr)r=rWrgs r r�zSequence.__contains__s!���A��E�z�Q�%�Z���rc#�^K�ttt|���D] }||��� y�wr)�reversed�ranger�)r=r�s r r�zSequence.__reversed__s'�����%��D� �*�+�A��q�'�M�,�s�+-Nc���|�|dkrtt|�|zd�}|�|dkr|t|�z }|}|�||kr ||}||us||k(r|S|dz }|��||kr�t�#t$rYt�wxYw)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)r=rW�start�stopr�rgs r r�zSequence.indexs��� � ������D� �E�)�1�-�E� � ��q�� �C��I� �D� ���l�a�$�h� ���G���E�z�Q�%�Z��� ��F�A��l�a�$�h���� � ����  �s�A#�# A4�3A4c�,��t�fd�|D��S)zBS.count(value) -> integer -- return number of occurrences of valuec3�6�K�|]}|�us|�k(s� d���y�w)r%Nr)r�rgrWs �r r�z!Sequence.count..+s�����?�d��a�5�j�A��J�1�d�s��)�sumrVs `r �countzSequence.count)s����?�d�?�?�?r)rN) rErFrGr�rHrRrr�r�r�r�r�r�rrr r!r!�sA��� �I��O������� ��.@rr!c�(��eZdZ�fd�Z�fd�Z�xZS)�_DeprecateByteStringMetac �b��|dk7rddl}|jdd��t�|� ||||fi|��S)Nr#r�collections.abc.ByteString����r,)�warnings� _deprecatedr�r�)rBr��bases� namespace�kwargsr�r�s �r r�z _DeprecateByteStringMeta.__new__3sC��� �<� � � � � �,�� !� ��w��s�D�%��E�f�E�Erc�P��ddl}|jdd��t�|� |�S)Nrr�r�r�)r�r�r��__instancecheck__)rB�instancer�r�s �r r�z*_DeprecateByteStringMeta.__instancecheck__=s1������� (�� � ��w�(��2�2r)rErFrGr�r�r�r�s@r r�r�2s���F�3�3rr�c��eZdZdZdZy)r#zMThis unifies bytes and bytearray. XXX Should add all their methods. rN)rErFrGr�rHrrr r#r#Fs��� �Irr#c�p�eZdZdZdZed��Zed��Zed��Zd�Z d�Z d�Z d �Z dd �Z d �Zd �Zy )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�rr��r=r�rWs r rozMutableSequence.__setitem__[r�rc��t�rr�r�s r rqzMutableSequence.__delitem___r�rc��t�)z3S.insert(index, value) -- insert value before indexr�r�s r �insertzMutableSequence.insertcs ���rc�:�|jt|�|�y)z:S.append(value) -- append value to the end of the sequenceN)r�r�rVs r �appendzMutableSequence.appendhs�� � � �C��I�u�%rc�F� |j��#t$rYywxYw)z,S.clear() -> None -- remove all items from SN)r1r�r<s r r3zMutableSequence.clearls*�� ����� ���� � � �r4c�z�t|�}t|dz�D]}|||z dz ||c||<|||z dz <�!y)z!S.reverse() -- reverse *IN PLACE*r�r%N)r�r�)r=rr�s r �reversezMutableSequence.reversetsI�� ��I���q�!�t��A�#'��!��A��;��Q�� �D��G�T�!�A�#�a�%�[�rc�R�||ur t|�}|D]}|j|��y)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)r�r�)r=rOrgs r �extendzMutableSequence.extendzs'�� �T�>��&�\�F��A� �K�K��N�rc��||}||=|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=r�rgs r r1zMutableSequence.pop�s�� ��K�� ��K��rc�(�||j|�=y)zvS.remove(value) -- remove first occurrence of value. Raise ValueError if the value is not present. N)r�rVs r r,zMutableSequence.remove�s�� ����E�"� #rc�(�|j|�|Sr)r�)r=rOs r �__iadd__zMutableSequence.__iadd__�s�� � � �F��� rN)r�)rErFrGr�rHrrorqr�r�r3r�r�r1r,r�rrr r"r"Rsk��� �I�������������&��8� ��$� rr")Ur��abcrrrr�r�r�rP� EllipsisTyper r��__all__rEr.�bytes_iterator� bytearray�bytearray_iteratorrK�dict_keyiteratorrO�dict_valueiteratorrM�dict_itemiterator� list_iteratorr��list_reverseiteratorr��range_iterator�longrange_iteratorr_� set_iterator� str_iterator�tuple_iterator�zip� zip_iterator� dict_keys� dict_values� dict_itemsr1� mappingproxy� generatorr*� coroutinerhr-�async_generatorr8rr r �registerr rrrrrrrrrr$r�r�r�rr� frozensetrrrrrr rrQr!r��strr�r�r#�bytesr"rrr �r�s���>(� ��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