%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /snap/core/current/usr/lib/python3.5/__pycache__/
Upload File :
Create Path :
Current File : //snap/core/current/usr/lib/python3.5/__pycache__/_collections_abc.cpython-35.pyc



|�g�`�@s�dZddlmZmZddlZdddddd	d
ddd
ddddddddddddgZdZeed��Z	eee
���Zeeij���Z
eeij���Zeeij���Zeeg��Zeeeg���Zeeed���Zeee���Zeed��Zeef��Zeee���Zeij��Zeij��Zeij��Zeej �Z!edd���Z"dd �Z#e#�Z#ee#�Z$e#j%�[#Gd!d�dd"e�Z&Gd#d�dd"e�Z'Gd$d�de'�Z(e(j)e$�Gd%d�dd"e�Z*Gd&d�de*�Z+Gd'd	�d	d"e�Z,Gd(d
�d
e,�Z-e-j)e	�e-j)e�e-j)e
�e-j)e�e-j)e�e-j)e�e-j)e�e-j)e�e-j)e�e-j)e�e-j)e�e-j)e�Gd)d�de-�Z.e.j)e"�Gd*d�dd"e�Z/Gd+d
�d
d"e�Z0Gd,d�dd"e�Z1Gd-d�de/e,e0�Z2e2j)e3�Gd.d�de2�Z4e4j)e�Gd/d�de/e,e0�Z5e5j)e!�Gd0d�de/�Z6Gd1d�de6e2�Z7e7j)e�Gd2d�de6e2�Z8e8j)e�Gd3d�de6�Z9e9j)e�Gd4d�de5�Z:e:j)e;�Gd5d�de/e,e0�Z<e<j)e=�e<j)e>�e<j)e�e<j)e?�Gd6d�de<�Z@e@j)eA�e@j)e
�Gd7d�de<�ZBeBj)eC�eBj)e
�dS)8zjAbstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
�)�ABCMeta�abstractmethodN�	Awaitable�	Coroutine�
AsyncIterable�
AsyncIterator�Hashable�Iterable�Iterator�	Generator�Sized�	Container�Callable�Set�
MutableSet�Mapping�MutableMapping�MappingView�KeysView�	ItemsView�
ValuesView�Sequence�MutableSequence�
ByteStringzcollections.abc��ccsdVS)N�rrr�&/usr/lib/python3.5/_collections_abc.py�<lambda>6src�sdS)Nrrrrr�_coro8src@s:eZdZfZedd��Zedd��ZdS)rcCsdS)Nrr)�selfrrr�__hash__EszHashable.__hash__cCsE|tkrAx2|jD]'}d|jkr|jdr<dSPqWtS)Nr!T)r�__mro__�__dict__�NotImplemented)�cls�C�Brrr�__subclasshook__Is
zHashable.__subclasshook__N)�__name__�
__module__�__qualname__�	__slots__rr!�classmethodr(rrrrrAs�	metaclassc@s:eZdZfZedd��Zedd��ZdS)rccs	dVdS)Nr)r rrr�	__await__XszAwaitable.__await__cCsE|tkrAx2|jD]'}d|jkr|jdr<dSPqWtS)Nr/T)rr"r#r$)r%r&r'rrrr(\s
zAwaitable.__subclasshook__N)r)r*r+r,rr/r-r(rrrrrTsc@s^eZdZfZedd��Zedddd��Zdd�Zedd	��Z	dS)
rcCs
t�dS)zcSend a value into the coroutine.
        Return next yielded value or raise StopIteration.
        N)�
StopIteration)r �valuerrr�sendkszCoroutine.sendNcCsL|dkr'|dkr|�|�}|dk	rB|j|�}|�dS)zgRaise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        N)�with_traceback)r �typ�val�tbrrr�throwrs	zCoroutine.throwcCs<y|jt�Wnttfk
r+Yn
Xtd��dS)z.Raise GeneratorExit inside coroutine.
        zcoroutine ignored GeneratorExitN)r7�
GeneratorExitr0�RuntimeError)r rrr�closes
zCoroutine.closecCsS|tkrO|j}x3dD]+}x"|D]}||jkr)Pq)WtSqWdStS)Nr/r2r7r:T)z	__await__zsendzthrowzclose)rr"r#r$)r%r&�mro�method�baserrrr(�s	

zCoroutine.__subclasshook__)
r)r*r+r,rr2r7r:r-r(rrrrrgs
c@s:eZdZfZedd��Zedd��ZdS)rcCst�S)N)r)r rrr�	__aiter__�szAsyncIterable.__aiter__cCs0|tkr,tdd�|jD��r,dStS)Ncss|]}d|jkVqdS)r>N)r#)�.0r'rrr�	<genexpr>�sz1AsyncIterable.__subclasshook__.<locals>.<genexpr>T)r�anyr"r$)r%r&rrrr(�szAsyncIterable.__subclasshook__N)r)r*r+r,rr>r-r(rrrrr�sc@sFeZdZfZedd��Zdd�Zedd��ZdS)rc�s
t�dS)z@Return the next item or raise StopAsyncIteration when exhausted.N)�StopAsyncIteration)r rrr�	__anext__�szAsyncIterator.__anext__cCs|S)Nr)r rrrr>�szAsyncIterator.__aiter__cCsL|tkrHtdd�|jD��rHtdd�|jD��rHdStS)Ncss|]}d|jkVqdS)rCN)r#)r?r'rrrr@�sz1AsyncIterator.__subclasshook__.<locals>.<genexpr>css|]}d|jkVqdS)r>N)r#)r?r'rrrr@�sT)rrAr"r$)r%r&rrrr(�s
zAsyncIterator.__subclasshook__N)	r)r*r+r,rrCr>r-r(rrrrr�sc@s:eZdZfZedd��Zedd��ZdS)r	ccsdS)Nr)r rrr�__iter__�szIterable.__iter__cCs0|tkr,tdd�|jD��r,dStS)Ncss|]}d|jkVqdS)rDN)r#)r?r'rrrr@�sz,Iterable.__subclasshook__.<locals>.<genexpr>T)r	rAr"r$)r%r&rrrr(�szIterable.__subclasshook__N)r)r*r+r,rrDr-r(rrrrr	�sc@sFeZdZfZedd��Zdd�Zedd��ZdS)r
cCs
t�dS)zKReturn the next item from the iterator. When exhausted, raise StopIterationN)r0)r rrr�__next__�szIterator.__next__cCs|S)Nr)r rrrrD�szIterator.__iter__cCsL|tkrHtdd�|jD��rHtdd�|jD��rHdStS)Ncss|]}d|jkVqdS)rEN)r#)r?r'rrrr@�sz,Iterator.__subclasshook__.<locals>.<genexpr>css|]}d|jkVqdS)rDN)r#)r?r'rrrr@�sT)r
rAr"r$)r%r&rrrr(�s
zIterator.__subclasshook__N)	r)r*r+r,rrErDr-r(rrrrr
�sc@sjeZdZfZdd�Zedd��Zedddd��Zdd	�Ze	d
d��Z
dS)rcCs
|jd�S)z^Return the next item from the generator.
        When exhausted, raise StopIteration.
        N)r2)r rrrrE�szGenerator.__next__cCs
t�dS)zcSend a value into the generator.
        Return next yielded value or raise StopIteration.
        N)r0)r r1rrrr2�szGenerator.sendNcCsL|dkr'|dkr|�|�}|dk	rB|j|�}|�dS)zgRaise an exception in the generator.
        Return next yielded value or raise StopIteration.
        N)r3)r r4r5r6rrrr7s	zGenerator.throwcCs<y|jt�Wnttfk
r+Yn
Xtd��dS)z.Raise GeneratorExit inside generator.
        zgenerator ignored GeneratorExitN)r7r8r0r9)r rrrr:s
zGenerator.closecCsS|tkrO|j}x3dD]+}x"|D]}||jkr)Pq)WtSqWdStS)NrDrEr2r7r:T)z__iter__z__next__zsendzthrowzclose)rr"r#r$)r%r&r;r<r=rrrr(s	

zGenerator.__subclasshook__)r)r*r+r,rErr2r7r:r-r(rrrrr�s
c@s:eZdZfZedd��Zedd��ZdS)rcCsdS)Nrr)r rrr�__len__0sz
Sized.__len__cCs0|tkr,tdd�|jD��r,dStS)Ncss|]}d|jkVqdS)rFN)r#)r?r'rrrr@7sz)Sized.__subclasshook__.<locals>.<genexpr>T)rrAr"r$)r%r&rrrr(4szSized.__subclasshook__N)r)r*r+r,rrFr-r(rrrrr,sc@s:eZdZfZedd��Zedd��ZdS)r
cCsdS)NFr)r �xrrr�__contains__@szContainer.__contains__cCs0|tkr,tdd�|jD��r,dStS)Ncss|]}d|jkVqdS)rHN)r#)r?r'rrrr@Gsz-Container.__subclasshook__.<locals>.<genexpr>T)r
rAr"r$)r%r&rrrr(DszContainer.__subclasshook__N)r)r*r+r,rrHr-r(rrrrr
<sc@s:eZdZfZedd��Zedd��ZdS)rcOsdS)NFr)r �args�kwdsrrr�__call__PszCallable.__call__cCs0|tkr,tdd�|jD��r,dStS)Ncss|]}d|jkVqdS)rKN)r#)r?r'rrrr@Wsz,Callable.__subclasshook__.<locals>.<genexpr>T)rrAr"r$)r%r&rrrr(TszCallable.__subclasshook__N)r)r*r+r,rrKr-r(rrrrrLsc@s�eZdZdZfZdd�Zdd�Zdd�Zdd	�Zd
d�Z	e
dd
��Zdd�ZeZ
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.
    cCsTt|t�stSt|�t|�kr/dSx|D]}||kr6dSq6WdS)NFT)�
isinstancerr$�len)r �other�elemrrr�__le__ms
z
Set.__le__cCs8t|t�stSt|�t|�ko7|j|�S)N)rLrr$rMrP)r rNrrr�__lt__wsz
Set.__lt__cCs8t|t�stSt|�t|�ko7|j|�S)N)rLrr$rM�__ge__)r rNrrr�__gt__|sz
Set.__gt__cCsTt|t�stSt|�t|�kr/dSx|D]}||kr6dSq6WdS)NFT)rLrr$rM)r rNrOrrrrR�s
z
Set.__ge__cCs8t|t�stSt|�t|�ko7|j|�S)N)rLrr$rMrP)r rNrrr�__eq__�sz
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)r%�itrrr�_from_iterable�szSet._from_iterablecs3t|t�stS�j�fdd�|D��S)Nc3s!|]}|�kr|VqdS)Nr)r?r1)r rrr@�szSet.__and__.<locals>.<genexpr>)rLr	r$rV)r rNr)r r�__and__�szSet.__and__cCs%x|D]}||krdSqWdS)z1Return True if two sets have a null intersection.FTr)r rNr1rrr�
isdisjoint�s
zSet.isdisjointcCs9t|t�stSdd�||fD�}|j|�S)Ncss"|]}|D]}|Vq
qdS)Nr)r?�s�errrr@�szSet.__or__.<locals>.<genexpr>)rLr	r$rV)r rN�chainrrr�__or__�sz
Set.__or__csQt�t�s1t�t�s"tS|j���|j�fdd�|D��S)Nc3s!|]}|�kr|VqdS)Nr)r?r1)rNrrr@�szSet.__sub__.<locals>.<genexpr>)rLrr	r$rV)r rNr)rNr�__sub__�s
zSet.__sub__csQt|t�s1t|t�s"tS�j|�}�j�fdd�|D��S)Nc3s!|]}|�kr|VqdS)Nr)r?r1)r rrr@�szSet.__rsub__.<locals>.<genexpr>)rLrr	r$rV)r rNr)r r�__rsub__�s
zSet.__rsub__cCsAt|t�s1t|t�s"tS|j|�}||||BS)N)rLrr	r$rV)r rNrrr�__xor__�s
zSet.__xor__cCs�tj}d|d}t|�}d|d}||M}x>|D]6}t|�}|||d>AdAdN}||M}qBW|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.
        ��iM��r�i�M[l�4~2i�
i��6i��8#���)�sys�maxsizerM�hash)r �MAX�MASK�n�hrG�hxrrr�_hash�s 	


z	Set._hashN)r)r*r+�__doc__r,rPrQrSrRrTr-rVrW�__rand__rXr\�__ror__r]r^r_�__rxor__rlrrrrr_s$


	c@s�eZdZdZfZedd��Zedd��Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�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.
    cCs
t�dS)zAdd an element.N)�NotImplementedError)r r1rrr�add�szMutableSet.addcCs
t�dS)z8Remove an element.  Do not raise an exception if absent.N)rq)r r1rrr�discard�szMutableSet.discardcCs)||krt|��|j|�dS)z5Remove an element. If not a member, raise a KeyError.N)�KeyErrorrs)r r1rrr�removeszMutableSet.removecCsHt|�}yt|�}Wntk
r6t�YnX|j|�|S)z2Return the popped value.  Raise KeyError if empty.)�iter�nextr0rtrs)r rUr1rrr�pop	s

zMutableSet.popcCs.yx|j�qWWntk
r)YnXdS)z6This is slow (creates N new iterators!) but effective.N)rxrt)r rrr�clears

zMutableSet.clearcCs"x|D]}|j|�qW|S)N)rr)r rUr1rrr�__ior__s
zMutableSet.__ior__cCs&x||D]}|j|�qW|S)N)rs)r rUr1rrr�__iand__ szMutableSet.__iand__cCsu||kr|j�nXt|t�s7|j|�}x7|D]/}||kr`|j|�q>|j|�q>W|S)N)ryrLrrVrsrr)r rUr1rrr�__ixor__%s

zMutableSet.__ixor__cCs;||kr|j�nx|D]}|j|�q W|S)N)ryrs)r rUr1rrr�__isub__2s


zMutableSet.__isub__N)r)r*r+rmr,rrrrsrurxryrzr{r|r}rrrrr�s


c@sseZdZfZedd��Zddd�Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�ZdS)rcCs
t�dS)N)rt)r �keyrrr�__getitem__LszMapping.__getitem__NcCs)y||SWntk
r$|SYnXdS)z<D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.N)rt)r r~�defaultrrr�getPs
zMapping.getcCs-y||Wntk
r$dSYnXdSdS)NFT)rt)r r~rrrrHWs

	zMapping.__contains__cCs
t|�S)z:D.keys() -> a set-like object providing a view on D's keys)r)r rrr�keys_szMapping.keyscCs
t|�S)z<D.items() -> a set-like object providing a view on D's items)r)r rrr�itemscsz
Mapping.itemscCs
t|�S)z6D.values() -> an object providing a view on D's values)r)r rrr�valuesgszMapping.valuescCs5t|t�stSt|j��t|j��kS)N)rLrr$�dictr�)r rNrrrrTkszMapping.__eq__)r)r*r+r,rrr�rHr�r�r�rTrrrrr@s
c@s:eZdZd	Zdd�Zdd�Zdd�ZdS)
r�_mappingcCs
||_dS)N)r�)r �mappingrrr�__init__wszMappingView.__init__cCs
t|j�S)N)rMr�)r rrrrFzszMappingView.__len__cCs
dj|�S)Nz&{0.__class__.__name__}({0._mapping!r}))�format)r rrr�__repr__}szMappingView.__repr__N)z_mapping)r)r*r+r,r�rFr�rrrrrssc@s@eZdZfZedd��Zdd�Zdd�ZdS)rcCs
t|�S)N)�set)r rUrrrrV�szKeysView._from_iterablecCs
||jkS)N)r�)r r~rrrrH�szKeysView.__contains__ccs|jEdHdS)N)r�)r rrrrD�szKeysView.__iter__N)r)r*r+r,r-rVrHrDrrrrr�sc@s@eZdZfZedd��Zdd�Zdd�ZdS)rcCs
t|�S)N)r�)r rUrrrrV�szItemsView._from_iterablecCsD|\}}y|j|}Wntk
r5dSYnX||kSdS)NF)r�rt)r �itemr~r1�vrrrrH�s
	zItemsView.__contains__ccs*x#|jD]}||j|fVq
WdS)N)r�)r r~rrrrD�szItemsView.__iter__N)r)r*r+r,r-rVrHrDrrrrr�s	c@s.eZdZfZdd�Zdd�ZdS)rcCs/x(|jD]}||j|kr
dSq
WdS)NTF)r�)r r1r~rrrrH�szValuesView.__contains__ccs$x|jD]}|j|Vq
WdS)N)r�)r r~rrrrD�szValuesView.__iter__N)r)r*r+r,rHrDrrrrr�sc@s�eZdZfZedd��Zedd��Ze�Zedd�Z	dd�Z
d	d
�Zdd�Zd
dd�Z
d
S)rcCs
t�dS)N)rt)r r~r1rrr�__setitem__�szMutableMapping.__setitem__cCs
t�dS)N)rt)r r~rrr�__delitem__�szMutableMapping.__delitem__cCsHy||}Wn(tk
r8||jkr0�|SYnX||=|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)rt�_MutableMapping__marker)r r~r�r1rrrrx�s
	zMutableMapping.popcCsLytt|��}Wntk
r0t�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.
        )rwrvr0rt)r r~r1rrr�popitem�s

zMutableMapping.popitemcCs.yx|j�qWWntk
r)YnXdS)z,D.clear() -> None.  Remove all items from D.N)r�rt)r rrrry�s

zMutableMapping.clearcOs
|std��|^}}t|�dkrFtdt|���|r�|d}t|t�r�xw|D]}||||<qlWnXt|d�r�xF|j�D]}||||<q�Wn!x|D]\}}|||<q�Wx$|j�D]\}}|||<q�WdS)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
        z@descriptor 'update' of 'MutableMapping' object needs an argumentraz+update expected at most 1 arguments, got %drr�N)�	TypeErrorrMrLr�hasattrr�r�)rIrJr rNr~r1rrr�update�s$

zMutableMapping.updateNcCs/y||SWntk
r*|||<YnX|S)z@D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D)rt)r r~r�rrr�
setdefaults

zMutableMapping.setdefault)r)r*r+r,rr�r��objectr�rxr�ryr�r�rrrrr�s	c@speZdZdZfZedd��Zdd�Zdd�Zdd	�Z	d
ddd
�Z
dd�ZdS)rz�All the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    cCs
t�dS)N)�
IndexError)r �indexrrrr'szSequence.__getitem__ccsGd}y$x||}|V|d7}qWWntk
rBdSYnXdS)Nrra)r�)r �ir�rrrrD+s

zSequence.__iter__cCs%x|D]}||krdSqWdS)NTFr)r r1r�rrrrH5s
zSequence.__contains__ccs0x)ttt|���D]}||VqWdS)N)�reversed�rangerM)r r�rrr�__reversed__;szSequence.__reversed__rNcCs�|dk	r1|dkr1tt|�|d�}|dk	rY|dkrY|t|�7}|}xT|dksz||kr�y|||kr�|SWntk
r�PYnX|d7}qbWt�dS)z�S.index(value, [start, [stop]]) -> integer -- return first index of value.
           Raises ValueError if the value is not present.
        Nrra)�maxrMr��
ValueError)r r1�start�stopr�rrrr�?s
zSequence.indexcst�fdd�|D��S)zBS.count(value) -> integer -- return number of occurrences of valuec3s!|]}|�krdVqdS)raNr)r?r�)r1rrr@Tsz!Sequence.count.<locals>.<genexpr>)�sum)r r1r)r1r�countRszSequence.count)r)r*r+rmr,rrrDrHr�r�r�rrrrrs
c@seZdZdZfZdS)rzMThis unifies bytes and bytearray.

    XXX Should add all their methods.
    N)r)r*r+rmr,rrrrr\sc@s�eZdZfZedd��Zedd��Zedd��Zdd�Zd	d
�Z	dd�Z
d
d�Zddd�Zdd�Z
dd�ZdS)rcCs
t�dS)N)r�)r r�r1rrrr�tszMutableSequence.__setitem__cCs
t�dS)N)r�)r r�rrrr�xszMutableSequence.__delitem__cCs
t�dS)z3S.insert(index, value) -- insert value before indexN)r�)r r�r1rrr�insert|szMutableSequence.insertcCs|jt|�|�dS)z:S.append(value) -- append value to the end of the sequenceN)r�rM)r r1rrr�append�szMutableSequence.appendcCs.yx|j�qWWntk
r)YnXdS)z,S.clear() -> None -- remove all items from SN)rxr�)r rrrry�s

zMutableSequence.clearcCsXt|�}xEt|d�D]3}|||d||||<|||d<qWdS)z!S.reverse() -- reverse *IN PLACE*r`raN)rMr�)r rir�rrr�reverse�szMutableSequence.reversecCs"x|D]}|j|�qWdS)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)r�)r r�r�rrr�extend�s
zMutableSequence.extendracCs||}||=|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�r�rrrrx�s
zMutableSequence.popcCs||j|�=dS)zvS.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        N)r�)r r1rrrru�szMutableSequence.removecCs|j|�|S)N)r�)r r�rrr�__iadd__�s
zMutableSequence.__iadd__Nrc)r)r*r+r,rr�r�r�r�ryr�r�rxrur�rrrrris	)Drm�abcrrrd�__all__r)�typerv�bytes_iterator�	bytearray�bytearray_iteratorr��dict_keyiteratorr��dict_valueiteratorr��dict_itemiterator�
list_iteratorr��list_reverseiteratorr��range_iteratorr��set_iterator�str_iterator�tuple_iterator�zip�zip_iterator�	dict_keys�dict_values�
dict_itemsr#�mappingproxy�	generatorr�	coroutiner:rrr�registerrrr	r
rrr
rr�	frozensetrrrrrrrr�r�tuple�str�
memoryviewr�bytesr�listrrrr�<module>s�				
0












6
�
O
0



\
9



	

A


Zerion Mini Shell 1.0