.-.-.-.-.-

e5d�e�@stdZddlmZmZddlZdddddd	d
ddd
dddddddddddddddgZdZeed��Z	eee
���Zeei����Z
eei����Zeei����Zeeg��Zeeeg���Zeeed���Zeeedd >���Zeee���Zeed!��Zeed"��Zeee���Zei���Zei���Zei���Z eej!�Z"ed#d$���Z#d%d&�Z$e$�Z$ee$�Z%e$�&�[$d'd(�Z'e'�Z'ee'�Z(['d)d*�Z)Gd+d	�d	ed,�Z*Gd-d�ded,�Z+Gd.d�de+�Z,e,�-e%�Gd/d�ded,�Z.Gd0d�de.�Z/Gd1d�de/�Z0e0�-e(�Gd2d
�d
ed,�Z1Gd3d�de1�Z2e2�-e	�e2�-e�e2�-e
�e2�-e�e2�-e�e2�-e�e2�-e�e2�-e�e2�-e�e2�-e�e2�-e�e2�-e�e2�-e�Gd4d
�d
e1�Z3Gd5d�de2�Z4e4�-e#�Gd6d�ded,�Z5Gd7d�ded,�Z6Gd8d�de5e1e6�Z7Gd9d�ded,�Z8Gd:d�de7�Z9e9�-e:�Gd;d�de9�Z;e;�-e�Gd<d�de7�Z<e<�-e"�Gd=d�de5�Z=Gd>d�de=e9�Z>e>�-e�Gd?d�de=e9�Z?e?�-e �Gd@d�de=e7�Z@e@�-e�GdAd�de<�ZAeA�-eB�GdBd�de3e7�ZCeC�-eD�eC�-eE�eC�-e�eC�-eF�GdCd�deC�ZGeG�-eH�eG�-e
�GdDd�deC�ZIeI�-eJ�eI�-e
�dS)EzjAbstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
�)�ABCMeta�abstractmethodN�	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.abc��i���ccsdVS�Nr r r r �(/usr/lib64/python3.8/_collections_abc.py�<lambda>8rr#c�sdSr!r r r r r"�_coro:rr$cCs
dVdSr!r r r r r"�_ag@rr%cGsN|j}|D]>}|D],}||jkr|j|dkr:tSq
qtSq
dS)NT)�__mro__�__dict__�NotImplemented)�C�methods�mro�method�Br r r"�_check_methodsHs

r.c@s(eZdZdZedd��Zedd��ZdS)r	r cCsdS�Nrr ��selfr r r"�__hash__XszHashable.__hash__cCs|tkrt|d�StS)Nr2)r	r.r(��clsr)r r r"�__subclasshook__\s
zHashable.__subclasshook__N)�__name__�
__module__�__qualname__�	__slots__rr2�classmethodr5r r r r"r	Ts

)�	metaclassc@s(eZdZdZedd��Zedd��ZdS)rr ccs
dVdSr!r r0r r r"�	__await__gszAwaitable.__await__cCs|tkrt|d�StS)Nr<)rr.r(r3r r r"r5ks
zAwaitable.__subclasshook__N)r6r7r8r9rr<r:r5r r r r"rcs

c@s>eZdZdZedd��Zeddd��Zdd�Zed	d
��Z	dS)rr cCst�dS)zcSend a value into the coroutine.
        Return next yielded value or raise StopIteration.
        N��
StopIteration�r1�valuer r r"�sendvszCoroutine.sendNcCs4|dkr|dkr|�|�}|dk	r,|�|�}|�dS)zgRaise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        N��with_traceback�r1�typ�val�tbr r r"�throw}s
zCoroutine.throwc	Cs4z|�t�Wnttfk
r&Yn
Xtd��dS)�.Raise GeneratorExit inside coroutine.
        zcoroutine ignored GeneratorExitN�rH�
GeneratorExitr>�RuntimeErrorr0r r r"�close�s
zCoroutine.closecCs|tkrt|dddd�StS)Nr<rArHrM)rr.r(r3r r r"r5�szCoroutine.__subclasshook__)NN)
r6r7r8r9rrArHrMr:r5r r r r"rrs

c@s(eZdZdZedd��Zedd��ZdS)rr cCst�Sr!)rr0r r r"�	__aiter__�szAsyncIterable.__aiter__cCs|tkrt|d�StS)NrN)rr.r(r3r r r"r5�s
zAsyncIterable.__subclasshook__N)r6r7r8r9rrNr:r5r r r r"r�s

c@s0eZdZdZedd��Zdd�Zedd��ZdS)	rr c�st�dS)z@Return the next item or raise StopAsyncIteration when exhausted.N��StopAsyncIterationr0r r r"�	__anext__�szAsyncIterator.__anext__cCs|Sr!r r0r r r"rN�szAsyncIterator.__aiter__cCs|tkrt|dd�StS)NrQrN)rr.r(r3r r r"r5�szAsyncIterator.__subclasshook__N)	r6r7r8r9rrQrNr:r5r r r r"r�s
c@sFeZdZdZdd�Zedd��Zed
dd��Zd	d
�Ze	dd��Z
dS)rr c�s|�d�IdHS)zpReturn the next item from the asynchronous generator.
        When exhausted, raise StopAsyncIteration.
        N)�asendr0r r r"rQ�szAsyncGenerator.__anext__c�st�dS)zuSend a value into the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        NrOr?r r r"rR�szAsyncGenerator.asendNc�s4|dkr|dkr|�|�}|dk	r,|�|�}|�dS)zyRaise an exception in the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        NrBrDr r r"�athrow�s
zAsyncGenerator.athrowc	�s:z|�t�IdHWnttfk
r,Yn
Xtd��dS)rINz,asynchronous generator ignored GeneratorExit)rSrKrPrLr0r r r"�aclose�s
zAsyncGenerator.aclosecCs|tkrt|ddddd�StS)NrNrQrRrSrT)rr.r(r3r r r"r5�s�zAsyncGenerator.__subclasshook__)NN)r6r7r8r9rQrrRrSrTr:r5r r r r"r�s

c@s(eZdZdZedd��Zedd��ZdS)r
r ccsdSr!r r0r r r"�__iter__�szIterable.__iter__cCs|tkrt|d�StS)NrU)r
r.r(r3r r r"r5�s
zIterable.__subclasshook__N)r6r7r8r9rrUr:r5r r r r"r
�s

c@s0eZdZdZedd��Zdd�Zedd��ZdS)	rr cCst�dS)zKReturn the next item from the iterator. When exhausted, raise StopIterationNr=r0r r r"�__next__szIterator.__next__cCs|Sr!r r0r r r"rUszIterator.__iter__cCs|tkrt|dd�StS)NrUrV)rr.r(r3r r r"r5szIterator.__subclasshook__N)	r6r7r8r9rrVrUr:r5r r r r"rs
c@s(eZdZdZedd��Zedd��ZdS)r
r ccsdSr!r r0r r r"�__reversed__)szReversible.__reversed__cCs|tkrt|dd�StS)NrWrU)r
r.r(r3r r r"r5.szReversible.__subclasshook__N)r6r7r8r9rrWr:r5r r r r"r
%s

c@sFeZdZdZdd�Zedd��Zed
dd��Zd	d
�Ze	dd��Z
dS)rr cCs
|�d�S)z^Return the next item from the generator.
        When exhausted, raise StopIteration.
        N)rAr0r r r"rV9szGenerator.__next__cCst�dS)zcSend a value into the generator.
        Return next yielded value or raise StopIteration.
        Nr=r?r r r"rA?szGenerator.sendNcCs4|dkr|dkr|�|�}|dk	r,|�|�}|�dS)zgRaise an exception in the generator.
        Return next yielded value or raise StopIteration.
        NrBrDr r r"rHFs
zGenerator.throwc	Cs4z|�t�Wnttfk
r&Yn
Xtd��dS)z.Raise GeneratorExit inside generator.
        zgenerator ignored GeneratorExitNrJr0r r r"rMSs
zGenerator.closecCs|tkrt|ddddd�StS)NrUrVrArHrM)rr.r(r3r r r"r5]s�zGenerator.__subclasshook__)NN)r6r7r8r9rVrrArHrMr:r5r r r r"r5s

c@s(eZdZdZedd��Zedd��ZdS)rr cCsdSr/r r0r r r"�__len__ksz
Sized.__len__cCs|tkrt|d�StS)NrX)rr.r(r3r r r"r5os
zSized.__subclasshook__N)r6r7r8r9rrXr:r5r r r r"rgs

c@s(eZdZdZedd��Zedd��ZdS)rr cCsdS�NFr )r1�xr r r"�__contains__zszContainer.__contains__cCs|tkrt|d�StS)Nr[)rr.r(r3r r r"r5~s
zContainer.__subclasshook__N)r6r7r8r9rr[r:r5r r r r"rvs

c@seZdZdZedd��ZdS)rr cCs|tkrt|ddd�StS)NrXrUr[)rr.r(r3r r r"r5�szCollection.__subclasshook__N)r6r7r8r9r:r5r r r r"r�sc@s(eZdZdZedd��Zedd��ZdS)rr cOsdSrYr )r1�args�kwdsr r r"�__call__�szCallable.__call__cCs|tkrt|d�StS)Nr^)rr.r(r3r r r"r5�s
zCallable.__subclasshook__N)r6r7r8r9rr^r:r5r r r r"r�s

c@s�eZdZdZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	e
d
d��Zdd�ZeZ
dd�Zdd�ZeZdd�Zdd�Zdd�ZeZdd�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.
    r cCs>t|t�stSt|�t|�kr"dS|D]}||kr&dSq&dS�NFT��
isinstancerr(�len�r1�other�elemr r r"�__le__�s
z
Set.__le__cCs(t|t�stSt|�t|�ko&|�|�Sr!�rarr(rbrf�r1rdr r r"�__lt__�s
z
Set.__lt__cCs(t|t�stSt|�t|�ko&|�|�Sr!)rarr(rb�__ge__rhr r r"�__gt__�s
z
Set.__gt__cCs>t|t�stSt|�t|�kr"dS|D]}||kr&dSq&dSr_r`rcr r r"rj�s
z
Set.__ge__cCs(t|t�stSt|�t|�ko&|�|�Sr!rgrhr r r"�__eq__�s
z
Set.__eq__cCs||�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 )r4�itr r r"�_from_iterable�szSet._from_iterablecs&t|t�stS���fdd�|D��S)Nc3s|]}|�kr|VqdSr!r ��.0r@r0r r"�	<genexpr>�szSet.__and__.<locals>.<genexpr>�rar
r(rnrhr r0r"�__and__�s
zSet.__and__cCs|D]}||krdSqdS)z1Return True if two sets have a null intersection.FTr )r1rdr@r r r"�
isdisjoint�szSet.isdisjointcCs*t|t�stSdd�||fD�}|�|�S)Ncss|]}|D]
}|Vq
qdSr!r )rp�s�er r r"rq�szSet.__or__.<locals>.<genexpr>rr)r1rd�chainr r r"�__or__�s
z
Set.__or__cs:t�t�s"t�t�stS|����|��fdd�|D��S)Nc3s|]}|�kr|VqdSr!r ro�rdr r"rq�s�zSet.__sub__.<locals>.<genexpr>�rarr
r(rnrhr ryr"�__sub__�s

zSet.__sub__cs:t|t�s"t|t�stS��|�}���fdd�|D��S)Nc3s|]}|�kr|VqdSr!r ror0r r"rq�s�zSet.__rsub__.<locals>.<genexpr>rzrhr r0r"�__rsub__�s

zSet.__rsub__cCs2t|t�s"t|t�stS|�|�}||||BSr!rzrhr r r"�__xor__s

zSet.__xor__cCs�tj}d|d}t|�}d|d}||M}|D],}t|�}|||d>AdAdN}||M}q2|dd}||M}||kr�||d8}|d	kr�d
}|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.
        �riM��r�i�M[l�4~2i�
i��6���i��8#)�sys�maxsizerb�hash)r1�MAX�MASK�n�hrZ�hxr r r"�_hash	s 
z	Set._hashN)r6r7r8�__doc__r9rfrirkrjrlr:rnrs�__rand__rtrx�__ror__r{r|r}�__rxor__r�r r r r"r�s&

c@sdeZdZdZdZedd��Zedd��Zdd�Zd	d
�Z	dd�Z
d
d�Zdd�Zdd�Z
dd�ZdS)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.
    r cCst�dS)zAdd an element.N��NotImplementedErrorr?r r r"�add:szMutableSet.addcCst�dS)z8Remove an element.  Do not raise an exception if absent.Nr�r?r r r"�discard?szMutableSet.discardcCs||krt|��|�|�dS)z5Remove an element. If not a member, raise a KeyError.N)�KeyErrorr�r?r r r"�removeDszMutableSet.removecCs>t|�}zt|�}Wntk
r.td�YnX|�|�|S)z2Return the popped value.  Raise KeyError if empty.N)�iter�nextr>r�r��r1rmr@r r r"�popJs
zMutableSet.popcCs(z|��qWntk
r"YnXdS)z6This is slow (creates N new iterators!) but effective.N)r�r�r0r r r"�clearTszMutableSet.clearcCs|D]}|�|�q|Sr!)r�r�r r r"�__ior__\szMutableSet.__ior__cCs||D]}|�|�q|Sr!)r�r�r r r"�__iand__aszMutableSet.__iand__cCsR||kr|��n<t|t�s&|�|�}|D]"}||krB|�|�q*|�|�q*|Sr!)r�rarrnr�r�r�r r r"�__ixor__fs

zMutableSet.__ixor__cCs*||kr|��n|D]}|�|�q|Sr!)r�r�r�r r r"�__isub__ss

zMutableSet.__isub__N)r6r7r8r�r9rr�r�r�r�r�r�r�r�r�r r r r"r,s

c@sReZdZdZedd��Zddd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dd�ZdZdS)rr cCst�dSr!�r��r1�keyr r r"�__getitem__�szMapping.__getitem__NcCs(z
||WStk
r"|YSXdS)z<D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.Nr��r1r��defaultr r r"�get�s
zMapping.getcCs,z||Wntk
r"YdSXdSdSr_r�r�r r r"r[�s
zMapping.__contains__cCst|�S)z:D.keys() -> a set-like object providing a view on D's keys)rr0r r r"�keys�szMapping.keyscCst|�S)z<D.items() -> a set-like object providing a view on D's items)rr0r r r"�items�sz
Mapping.itemscCst|�S)z6D.values() -> an object providing a view on D's values)rr0r r r"�values�szMapping.valuescCs&t|t�stSt|���t|���kSr!)rarr(�dictr�rhr r r"rl�s
zMapping.__eq__)N)
r6r7r8r9rr�r�r[r�r�r�rlrWr r r r"r�s

c@s(eZdZdZdd�Zdd�Zdd�ZdS)	r��_mappingcCs
||_dSr!r�)r1�mappingr r r"�__init__�szMappingView.__init__cCs
t|j�Sr!)rbr�r0r r r"rX�szMappingView.__len__cCs
d�|�S)Nz&{0.__class__.__name__}({0._mapping!r}))�formatr0r r r"�__repr__�szMappingView.__repr__N)r6r7r8r9r�rXr�r r r r"r�sc@s,eZdZdZedd��Zdd�Zdd�ZdS)	rr cCst|�Sr!��set�r1rmr r r"rn�szKeysView._from_iterablecCs
||jkSr!r�r�r r r"r[�szKeysView.__contains__ccs|jEdHdSr!r�r0r r r"rU�szKeysView.__iter__N�r6r7r8r9r:rnr[rUr r r r"r�s

c@s,eZdZdZedd��Zdd�Zdd�ZdS)	rr cCst|�Sr!r�r�r r r"rn�szItemsView._from_iterablecCsB|\}}z|j|}Wntk
r,YdSX||kp<||kSdSrY)r�r�)r1�itemr�r@�vr r r"r[�szItemsView.__contains__ccs |jD]}||j|fVqdSr!r�r�r r r"rU�s
zItemsView.__iter__Nr�r r r r"r�s

c@s eZdZdZdd�Zdd�ZdS)rr cCs0|jD]$}|j|}||ks$||krdSqdS�NTFr�)r1r@r�r�r r r"r[�s

zValuesView.__contains__ccs|jD]}|j|VqdSr!r�r�r r r"rU�s
zValuesView.__iter__N)r6r7r8r9r[rUr r r r"r�sc@s^eZdZdZedd��Zedd��Ze�Zefdd�Z	dd	�Z
d
d�Zddd
�Zddd�Z
dS)rr cCst�dSr!r��r1r�r@r r r"�__setitem__szMutableMapping.__setitem__cCst�dSr!r�r�r r r"�__delitem__szMutableMapping.__delitem__cCs@z||}Wn$tk
r0||jkr(�|YSX||=|SdS)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.
        N)r��_MutableMapping__marker)r1r�r�r@r r r"r�s

zMutableMapping.popcCsBztt|��}Wntk
r*td�YnX||}||=||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�r>r�r�r r r"�popitem$szMutableMapping.popitemcCs(z|��qWntk
r"YnXdS)z,D.clear() -> None.  Remove all items from D.N)r�r�r0r r r"r�0szMutableMapping.clearcKs|t|t�r"|D]}||||<qn<t|d�rH|��D]}||||<q4n|D]\}}|||<qL|��D]\}}|||<qfdS)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
        r�N)rar�hasattrr�r�)r1rdr]r�r@r r r"�update8s

zMutableMapping.updateNcCs,z
||WStk
r&|||<YnX|S)z@D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in Dr�r�r r r"�
setdefaultJs

zMutableMapping.setdefault)r )N)r6r7r8r9rr�r��objectr�r�r�r�r�r�r r r r"r�s

c@sJeZdZdZdZedd��Zdd�Zdd�Zd	d
�Z	dd
d�Z
dd�ZdS)rz�All the operations on a read-only sequence.

Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    r cCst�dSr!��
IndexError�r1�indexr r r"r�bszSequence.__getitem__ccs<d}z||}|V|d7}qWntk
r6YdSXdS)Nrrr�)r1�ir�r r r"rUfszSequence.__iter__cCs$|D]}||ks||krdSqdSr�r )r1r@r�r r r"r[pszSequence.__contains__ccs$ttt|���D]}||VqdSr!)�reversed�rangerb)r1r�r r r"rWvszSequence.__reversed__rNcCs�|dk	r"|dkr"tt|�|d�}|dk	r>|dkr>|t|�7}|}|dksR||kr�z"||}||ksl||krr|WSWntk
r�Yq�YnX|d7}qBt�dS)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)�maxrbr��
ValueError)r1r@�start�stopr�r�r r r"r�zs

zSequence.indexcst�fdd�|D��S)zBS.count(value) -> integer -- return number of occurrences of valuec3s"|]}|�ks|�krdVqdS)rNr )rpr��r@r r"rq�sz!Sequence.count.<locals>.<genexpr>)�sumr?r r�r"�count�szSequence.count)rN)r6r7r8r�r9rr�rUr[rWr�r�r r r r"rXs

c@seZdZdZdZdS)rzMThis unifies bytes and bytearray.

XXX Should add all their methods.
    r N)r6r7r8r�r9r r r r"r�sc@sneZdZdZedd��Zedd��Zedd��Zdd	�Zd
d�Z	dd
�Z
dd�Zddd�Zdd�Z
dd�ZdS)rr cCst�dSr!r��r1r�r@r r r"r��szMutableSequence.__setitem__cCst�dSr!r�r�r r r"r��szMutableSequence.__delitem__cCst�dS)z3S.insert(index, value) -- insert value before indexNr�r�r r r"�insert�szMutableSequence.insertcCs|�t|�|�dS)z:S.append(value) -- append value to the end of the sequenceN)r�rbr?r r r"�append�szMutableSequence.appendcCs(z|��qWntk
r"YnXdS)z,S.clear() -> None -- remove all items from SN)r�r�r0r r r"r��szMutableSequence.clearcCsHt|�}t|d�D].}|||d||||<|||d<qdS)z!S.reverse() -- reverse *IN PLACE*r~rN)rbr�)r1r�r�r r r"�reverse�szMutableSequence.reversecCs(||krt|�}|D]}|�|�qdS)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)�listr�)r1r�r�r r r"�extend�szMutableSequence.extendr�cCs||}||=|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 )r1r�r�r r r"r��szMutableSequence.popcCs||�|�=dS)zvS.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        N)r�r?r r r"r��szMutableSequence.removecCs|�|�|Sr!)r�)r1r�r r r"�__iadd__�s
zMutableSequence.__iadd__N)r�)r6r7r8r9rr�r�r�r�r�r�r�r�r�r�r r r r"r�s

)Kr��abcrrr��__all__r6�typer��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_itemsr'�mappingproxy�	generatorr$�	coroutinerMr%�async_generatorr.r	rr�registerrrrr
rr
rrrrrr�	frozensetrrrrrrrr�r�tuple�str�
memoryviewr�bytesrr�r r r r"�<module>s��	
)
0

O
2

S
=

/home/./../lib64/pgsql/../python3.8/unittest/../__pycache__/_collections_abc.cpython-38.opt-1.pyc