python (3.12.0)

(root)/
lib/
python3.12/
__pycache__/
_collections_abc.cpython-312.pyc

ˑeR}Z
dZddlmZmZddlZeeeZedZ	dZ
ee
Z[
gdZdZ
eedZeeeZeeij%Zeeij)Zeeij-ZeegZeeegZeeedZeeed	d
zZeeeZeedZ eedZ!eee"Z#eij%Z$eij)Z%eij-Z&eejNZ(ed
Z)dZ*e*Z*ee*Z+e*jY[*dZ-e-Z-ee-Z.[-dZ/GddeZ0GddeZ1Gdde1Z2e2jge+GddeZ4Gdde4Z5Gdde5Z6e6jge.GddeZ7Gd d!e7Z8e8jgee8jgee8jgee8jgee8jgee8jgee8jgee8jgee8jgee8jgee8jge e8jge!e8jge#Gd"d#e7Z9Gd$d%e8Z:e:jge)Gd&d'eZ;Gd(d)eZ<Gd*d+e;e7e<Z=Gd,d-eZ>Gd.d/eZ?d0Z@d1ZAGd2d3eZBGd4d5e=ZCeCjgeDGd6d7eCZEeEjgeGd8d9e=ZFeFjge(Gd:d;e;ZGGd<d=eGeCZHeHjge$Gd>d?eGeCZIeIjge&Gd@dAeGe=ZJeJjge%GdBdCeFZKeKjgeLGdDdEe9e=ZMeMjgeNeMjgeOeMjgeeMjgePGdFdGeZQGdHdIeMeQZReRjgeSeRjgeGdJdKeMZTeTjgeeTjgey)LzjAbstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
)ABCMetaabstractmethodN.cyNrD/BuggyBox/python/3.12.0/bootstrap/lib/python3.12/_collections_abc.py_fr
(sr)	Awaitable	Coroutine
AsyncIterable
AsyncIteratorAsyncGeneratorHashableIterableIterator	Generator
ReversibleSized	ContainerCallable
CollectionSet
MutableSetMappingMutableMappingMappingViewKeysView	ItemsView
ValuesViewSequenceMutableSequence
ByteStringBufferzcollections.abcrirc#KdSrrrrr	<lambda>r(Xs5rcKywrrrrr	_coror*ZscKdywrrrrr	_agr-`s	c|j}|D]9}|D]+}||jvs|j|
tccS2tcSy)NT)__mro____dict__NotImplemented)CmethodsmromethodBs     r	_check_methodsr8hsZ
))C"	"A#::f%-))		""!"rc0eZdZdZedZedZy)rrcyNrrselfs r	__hash__zHashable.__hash__xrc6|turt|dStS)Nr>)rr8r2clsr3s  r	__subclasshook__zHashable.__subclasshook__|(?!!Z00rN)__name__
__module____qualname__	__slots__rr>classmethodrCrrr	rrt-Irr)	metaclassc@eZdZdZedZedZeeZ	y)rrc#Kdywrrr<s r		__await__zAwaitable.__await__s	
sc6|turt|dStS)NrN)rr8r2rAs  r	rCzAwaitable.__subclasshook__s)!![11rN)
rErFrGrHrrNrIrCGenericAlias__class_getitem__rrr	rrs:I
$L1rrcHeZdZdZedZeddZdZedZ	y)rrct)zcSend a value into the coroutine.
        Return next yielded value or raise StopIteration.
        
StopIterationr=values  r	sendzCoroutine.send

rNcF||||}||j|}|)zgRaise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        with_tracebackr=typvaltbs    r	throwzCoroutine.throw4
;z	%C
>$$R(C	rcn	|jttd#ttf$rYywxYw).Raise GeneratorExit inside coroutine.
        zcoroutine ignored GeneratorExitNra
GeneratorExitRuntimeErrorrUr<s r	closezCoroutine.close;	BJJ}%@AA}-		"44c<|turt|ddddStS)NrNrXrarh)rr8r2rAs  r	rCzCoroutine.__subclasshook__s#)!![&'7KKrNN)
rErFrGrHrrXrarhrIrCrrr	rrsGI

Brrc@eZdZdZedZedZeeZ	y)r
rctSr)rr<s r		__aiter__zAsyncIterable.__aiter__s
rc6|turt|dStS)Nro)r
r8r2rAs  r	rCzAsyncIterable.__subclasshook__s-!![11rN)
rErFrGrHrrorIrCrPrQrrr	r
r
s:I
$L1rr
c6eZdZdZedZdZedZy)rrcKtw)z@Return the next item or raise StopAsyncIteration when exhausted.StopAsyncIterationr<s r		__anext__zAsyncIterator.__anext__s! r.c|Srrr<s r	rozAsyncIterator.__aiter__rc8|tur
t|ddStS)Nruro)rr8r2rAs  r	rCzAsyncIterator.__subclasshook__s-!![+>>rN)	rErFrGrHrrurorIrCrrr	rrs2I!!rrcNeZdZdZdZedZeddZdZe	dZ
y)	rrc@K|jdd{S7w)zpReturn the next item from the asynchronous generator.
        When exhausted, raise StopAsyncIteration.
        N)asendr<s r	ruzAsyncGenerator.__anext__sZZ%%%%scKtw)zuSend a value into the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        rsrVs  r	r{zAsyncGenerator.asends
! r.NcNK||||}||j|}|w)zyRaise an exception in the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        r[r]s    r	athrowzAsyncGenerator.athrows8
;z	%C
>$$R(C	s#%cK	|jtd{td7#ttf$rYywxYww)rdNz,asynchronous generator ignored GeneratorExit)r~rfrgrtr<s r	aclosezAsyncGenerator.aclosesH	O++m,,,MNN	
-12		s/A.,.A.AAAAc>|turt|dddddStS)Nrorur{r~r)rr8r2rAs  r	rCzAsyncGenerator.__subclasshook__s*. !![+")8X?
?rrl)rErFrGrHrurr{r~rrIrCrrr	rrsNI&!!

Orrc@eZdZdZedZedZeeZ	y)rrc#Kywrrr<s r	__iter__zIterable.__iter__	r+c6|turt|dStS)Nr)rr8r2rAs  r	rCzIterable.__subclasshook__ rDrN)
rErFrGrHrrrIrCrPrQrrr	rrs:I
$L1rrc6eZdZdZedZdZedZy)rrct)zKReturn the next item from the iterator. When exhausted, raise StopIterationrTr<s r	__next__zIterator.__next__-s
rc|Srrr<s r	rzIterator.__iter__2rwrc8|tur
t|ddStS)Nrr)rr8r2rAs  r	rCzIterator.__subclasshook__5s(?!!Z<<rN)	rErFrGrHrrrrIrCrrr	rr)s2Irrc0eZdZdZedZedZy)rrc#Kywrrr<s r	__reversed__zReversible.__reversed__Prr+c8|tur
t|ddStS)Nrr)rr8r2rAs  r	rCzReversible.__subclasshook__Us*!!^Z@@rN)rErFrGrHrrrIrCrrr	rrLs-IrrcNeZdZdZdZedZeddZdZe	dZ
y)	rrc$|jdS)z^Return the next item from the generator.
        When exhausted, raise StopIteration.
        N)rXr<s r	rzGenerator.__next__`syyrct)zcSend a value into the generator.
        Return next yielded value or raise StopIteration.
        rTrVs  r	rXzGenerator.sendfrYrNcF||||}||j|}|)zgRaise an exception in the generator.
        Return next yielded value or raise StopIteration.
        r[r]s    r	razGenerator.throwmrbrcn	|jttd#ttf$rYywxYw)z.Raise GeneratorExit inside generator.
        zgenerator ignored GeneratorExitNrer<s r	rhzGenerator.closezrirjc>|turt|dddddStS)NrrrXrarh)rr8r2rAs  r	rCzGenerator.__subclasshook__s*)!!Z"('7<
<rrl)rErFrGrHrrrXrarhrIrCrrr	rr\sNI

Brrc0eZdZdZedZedZy)rrcyr;rr<s r	__len__z
Sized.__len__r?rc6|turt|dStS)Nr)rr8r2rAs  r	rCzSized.__subclasshook__s%<!!Y//rN)rErFrGrHrrrIrCrrr	rrrJrrc@eZdZdZedZedZeeZ	y)rrcyNFr)r=xs  r	__contains__zContainer.__contains__rc6|turt|dStS)Nr)rr8r2rAs  r	rCzContainer.__subclasshook__s)!!^44rN)
rErFrGrHrrrIrCrPrQrrr	rrs:I
$L1rrc eZdZdZedZy)rrc:|turt|dddStS)Nrrr)rr8r2rAs  r	rCzCollection.__subclasshook__s!*!!i^LLrN)rErFrGrHrIrCrrr	rrsIrrc:eZdZdZededefdZedZ	y)r$rflagsreturnctrNotImplementedError)r=rs  r	
__buffer__zBuffer.__buffer__s!!rc6|turt|dStS)Nr)r$r8r2rAs  r	rCzBuffer.__subclasshook__s&=!!\22rN)
rErFrGrHrint
memoryviewrrIrCrrr	r$r$s;I"":""rr$c@eZdZdZdZfdZfdZdZfdZxZ	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)``.
    rct|trt|dk(std|\}}t|ttfrg||}nt|std|t||||S)Nz6Callable must be used as Callable[[arg, ...], result].zFExpected a list of types, an ellipsis, ParamSpec, or Concatenate. Got )
isinstancetuplelen	TypeErrorlist_is_param_exprsuper__new__)rBoriginargst_argst_result	__class__s     r	rz_CallableGenericAlias.__new__s4'CINHJ
Jfudm,&V&X&D'>>DXGH
HwsFD11rc	.t|jdk(r&t|jdrt|Sddj|jddDcgc]
}t
|c}dt
|jddScc}w)Nrrzcollections.abc.Callable[[z, z], ])r__args__rr__repr__join
_type_repr)r=ars  r	rz_CallableGenericAlias.__repr__st}}"~dmmA6F'G7#%%YYt}}Sb7IJ!
1
JKLCdmmB/014	5JsB
c|j}t|dk(rt|dst|dd|df}tt
|ffS)Nrrr)rrrrrr)r=rs  r	
__reduce__z _CallableGenericAlias.__reduce__sI}}D	Q>$q'#:Sb	?DH,D$x&666rct|ts|f}t|
|j}t|dtt
fs|d}|dd}||f}t
tt|S)Nrr)rrr__getitem__rrrr)r=itemnew_argsrrrs     r	rz!_CallableGenericAlias.__getitem__sn
$&7D7&t,55(1+t}5|Hcr]F)H$XuX??r)
rErFrG__doc__rHrrrr
__classcell__rs@r	rrs*I
257@@rrcturyttrytd}jdk(xrtfd|DS)z|Checks if obj matches either a list of types, ``...``, ``ParamSpec`` or
    ``_ConcatenateGenericAlias`` from typing.py
    T)	ParamSpec_ConcatenateGenericAliastypingc3<K|]}j|k(ywr)rE).0nameobjs  r		<genexpr>z!_is_param_expr.<locals>.<genexpr>	s-Utclld.B-Us)EllipsisrrtyperFany)rnamess` r	rrsIh#t
s)C5E>>X%U#-Uu-U*UUrct|tr6|jdk(r|jS|jd|jS|turyt|t
r|jSt|S)zReturn 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...)rrrFrGrFunctionTyperErepr)rs r	rrsk#t>>Z'###..!3#3#3"455
h#|$||9rc@eZdZdZedZedZeeZ	y)rrcyrr)r=rkwdss   r	__call__zCallable.__call__!rrc6|turt|dStS)Nr)rr8r2rAs  r	rCzCallable.__subclasshook__%rDrN)
rErFrGrHrrrIrCrrQrrr	rrs;I
$$9:rrcxeZdZdZdZdZdZdZdZdZ	e
dZd	ZeZ
d
ZdZeZdZd
ZdZeZdZy)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.
    rczt|tstSt|t|kDry|D]}||vsyyNFTrrr2rr=otherelems   r	__le__z
Set.__le__>sD%%!!t9s5z!	D5 	rct|tstSt|t|kxr|j	|Srrrr2rrr=rs  r	__lt__z
Set.__lt__H3%%!!4y3u:%<$++e*<<rct|tstSt|t|kDxr|j	|Sr)rrr2r__ge__rs  r	__gt__z
Set.__gt__Mrrczt|tstSt|t|kry|D]}||vsyyrrrs   r	rz
Set.__ge__RsD%%!!t9s5z!	D4	rct|tstSt|t|k(xr|j	|Srrrs  r	__eq__z
Set.__eq__\s3%%!!4yCJ&=4;;u+==rc||S)zConstruct 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.
        rrBits  r	_from_iterablezSet._from_iterableas
2wrcdt|tstSjfd|DS)Nc3,K|]}|vs|
ywrrrrWr=s  r	rzSet.__and__.<locals>.<genexpr>ms"MUu}5"Ms	rrr2rrs` r	__and__zSet.__and__js*%*!!"""Me"MMMrc|D]}||vsyy)z1Return True if two sets have a null intersection.FTr)r=rrWs   r	
isdisjointzSet.isdisjointqs 	E}	rcft|tstSd||fD}|j|S)Nc3.K|]
}|D]}|ywrr)rses   r	rzSet.__or__.<locals>.<genexpr>{s5q15a55sr)r=rchains   r	__or__z
Set.__or__xs1%*!!5T5M5""5))rctts'ttstS|j	|j	fd|DS)Nc3*K|]
}|vr|ywrr)rrWrs  r	rzSet.__sub__.<locals>.<genexpr>s #:U&+5&8$)#:rrrr2rrs `r	__sub__zSet.__sub__sL%%eX.%%''.E""#:d#::	:rct|ts't|tstSj	|}j	fd|DS)Nc3*K|]
}|vr|ywrrrs  r	rzSet.__rsub__.<locals>.<genexpr>s #9U&+4&7$)#9rr
rs` r	__rsub__zSet.__rsub__sL%%eX.%%''.E""#9e#99	9rct|ts't|tstS|j	|}||z
||z
zSrr
rs  r	__xor__zSet.__xor__s?%%eX.%%''.Eu..rctj}d|zdz}t|}d|dzz}||z}|D]#}t|}|||dzzdzdzz}||z}%||dz	|dz	zz}|d	zd
z}||z}||kDr||dzz}|dk(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.
        rr%iMriM[l4~2i
i6ri8#)sysmaxsizerhash)r=MAXMASKnhrhxs       r	_hashz	Set._hashskk3w{I!a% 	T		AaB
"b/H,;;A
IA		
a2g!r'
""
I	!	T	s7
MA7ArN)rErFrGrrHrrrrrrIrr__rand__rr	__ror__rrr__rxor__r rrr	rr1stI=
=
>
N
H*G:9/Hrrc^eZdZdZdZedZedZdZdZ	dZ
dZd	Zd
Z
dZy)
raA 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.
    rct)zAdd an element.rrVs  r	addzMutableSet.add
"!rct)z8Remove an element.  Do not raise an exception if absent.rrVs  r	discardzMutableSet.discardr'rcD||vrt||j|y)z5Remove an element. If not a member, raise a KeyError.N)KeyErrorr)rVs  r	removezMutableSet.removes 5/!Urc~t|}	t|}|j	||S#t$rtdwxYw)z2Return the popped value.  Raise KeyError if empty.N)iternextrUr+r)r=rrWs   r	popzMutableSet.popsE
$Z	%HE	
U	%$	%s+<cF		|j#t$rYywxYw)z6This is slow (creates N new iterators!) but effective.N)r1r+r<s r	clearzMutableSet.clears*	
			  c6|D]}|j||Sr)r&r0s   r	__ior__zMutableSet.__ior__s!	EHHUO	rc<||z
D]}|j||Sr)r)r0s   r	__iand__zMutableSet.__iand__s&Ri	 ELL	 rc||ur|j|St|ts|j|}|D])}||vr|j	||j|+|Sr)r3rrrr)r&r0s   r	__ixor__zMutableSet.__ixor__si
:JJLb#&((,
$D=LL'HHUO	
$
rcb||ur|j|S|D]}|j||Sr)r3r)r0s   r	__isub__zMutableSet.__isub__s;
:JJL
$U#
$rN)rErFrGrrHrr&r)r,r1r3r6r8r:r<rrr	rrsW	I""""

rrcReZdZdZdZdZedZddZdZ	dZ
d	Zd
ZdZ
dZy)
rzA 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@ctrr+r=keys  r	rzMapping.__getitem__ rNc0	||S#t$r|cYSwxYw)z<D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.r@r=rBdefaults   r	getzMapping.get$s%	9	N	sc.	||y#t$rYywxYwNTFr@rAs  r	rzMapping.__contains__+s'	I		s	ct|S)z:D.keys() -> a set-like object providing a view on D's keys)rr<s r	keyszMapping.keys3s~rct|S)z<D.items() -> a set-like object providing a view on D's items)rr<s r	itemsz
Mapping.items7srct|S)z6D.values() -> an object providing a view on D's values)r r<s r	valueszMapping.values;s
$rct|tstSt|j	t|j	k(Sr)rrr2dictrMrs  r	rzMapping.__eq__?s3%)!!DJJL!T%++-%888rr)rErFrGrrH__abc_tpflags__rrrGrrKrMrOrrrrr	rrsLIO 9
Lrrc2eZdZdZdZdZdZeeZ	y)r_mappingc||_yrrT)r=mappings  r	__init__zMappingView.__init__Ms	
rc,t|jSr)rrUr<s r	rzMappingView.__len__Ps4==!!rc$dj|S)Nz&{0.__class__.__name__}({0._mapping!r}))formatr<s r	rzMappingView.__repr__Ss7>>tDDrN)
rErFrGrHrXrrrIrPrQrrr	rrIs$I "E$L1rrc,eZdZdZedZdZdZy)rrct|Srsetrs  r	rzKeysView._from_iterable]2wrc||jvSrrTrAs  r	rzKeysView.__contains__asdmm##rc#8K|jEd{y7wrrTr<s r	rzKeysView.__iter__ds==  sNrErFrGrHrIrrrrrr	rrYs#I$!rrc,eZdZdZedZdZdZy)rrct|Srr^rs  r	rzItemsView._from_iterableor`rc`|\}}	|j|}||uxs||k(S#t$rYywxYwr)rUr+)r=rrBrWvs     r	rzItemsView.__contains__ssG
U	,

c"A:+e+		s!	--c#TK|jD]}||j|fywrrTrAs  r	rzItemsView.__iter__|s-==	,C

c*++	,s&(Nrcrrr	rrks#I,,rrceZdZdZdZdZy)r rcZ|jD]}|j|}||us||k(syyrIrT)r=rWrBrgs    r	rzValuesView.__contains__s8==	C

c"AEzQ%Z	rc#PK|jD]}|j|ywrrTrAs  r	rzValuesView.__iter__s(==	%C--$$	%s$&N)rErFrGrHrrrrr	r r sI%rr cheZdZdZdZedZedZeZ	e	fdZ
dZdZddZ
dd
Zy	)
rzA 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__.
    rctrr@r=rBrWs   r	__setitem__zMutableMapping.__setitem__rCrctrr@rAs  r	__delitem__zMutableMapping.__delitem__rCrcX	||}||=|S#t$r||jur|cYSwxYw)zD.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.popsC	IES	L
	$--'N	s))cl	tt|}||}||=||fS#t$rtdwxYw)zD.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.popitemsJ	%tDz"CS	IEz		%$	%s"3cF		|j#t$rYywxYw)z,D.clear() -> None.  Remove all items from D.N)rur+r<s r	r3zMutableMapping.clears*			r4ct|tr|D]
}||||<n9t|dr|jD]
}||||<n|D]
\}}|||<|j	D]
\}}|||<y)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
        rKN)rrhasattrrKrM)r=rrrBrWs     r	updatezMutableMapping.updateseW%
'!#JS	
'
UF
#zz|
'!#JS	
'$
"
U!S	
"**,	JCDI	rNc8	||S#t$r	|||<Y|SwxYw)z@D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in Dr@rEs   r	
setdefaultzMutableMapping.setdefaults.	 9	 DI	 s)rr)rErFrGrrHrrorqobjectrsr1rur3ryr{rrr	rrsYIxH'
$rrcHeZdZdZdZdZedZdZdZ	dZ
dd	Zd
Zy)r!zAll the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    r ctr
IndexErrorr=indexs  r	rzSequence.__getitem__rc#NKd}		||}||dz
}#t$rYywxYww)Nrr%r)r=irgs   r	rzSequence.__iter__sB
	GQ		s%	"%"%c(|D]
}||us||k(s
yyrIr)r=rWrgs   r	rzSequence.__contains__s&	AEzQ%Z	rc#^Kttt|D]	}||ywr)reversedranger)r=rs  r	rzSequence.__reversed__s,%D	*+	Aq'M	s+-Nc||dkrtt||zd}||dkr|t|z
}|}|||kr	||}||us||k(r|S|dz
}|||krt#t$rYtwxYw)zS.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%)maxrr
ValueError)r=rWstartstoprrgs      r	rzSequence.indexsD	E)1-EqCIDla$h
GEzQ%Z
FAla$h

sA##	A43A4c,tfd|DS)zBS.count(value) -> integer -- return number of occurrences of valuec36K|]}|us|k(s
dyw)r%Nr)rrgrWs  r	rz!Sequence.count.<locals>.<genexpr>+s?a5jAJ1?s)sumrVs `r	countzSequence.count)s?d???r)rN)
rErFrGrrHrRrrrrrrrrrr	r!r!sAIO.@rr!c(eZdZfdZfdZxZS)_DeprecateByteStringMetacb|dk7rddl}|jddt|||||fi|S)Nr#rcollections.abc.ByteStringr,)warnings_deprecatedrr)rBrbases	namespacekwargsrrs      r	rz _DeprecateByteStringMeta.__new__3sC<  ,
!
wsD%EfEErcPddl}|jddt|
|S)Nrrrr)rrr__instancecheck__)rBinstancerrs   r	rz*_DeprecateByteStringMeta.__instancecheck__=s1(		
w(22r)rErFrGrrrrs@r	rr2sF33rrceZdZdZdZy)r#zMThis unifies bytes and bytearray.

    XXX Should add all their methods.
    rN)rErFrGrrHrrr	r#r#Fs
Irr#cpeZdZdZdZedZedZedZdZ	dZ
dZd	Zdd
Z
dZdZy
)r"zAll the operations on a read-write sequence.

    Concrete subclasses must provide __new__ or __init__,
    __getitem__, __setitem__, __delitem__, __len__, and insert().
    rctrrr=rrWs   r	rozMutableSequence.__setitem__[rrctrrrs  r	rqzMutableSequence.__delitem___rrct)z3S.insert(index, value) -- insert value before indexrrs   r	insertzMutableSequence.insertcs
rc:|jt||y)z:S.append(value) -- append value to the end of the sequenceN)rrrVs  r	appendzMutableSequence.appendhsCIu%rcF		|j#t$rYywxYw)z,S.clear() -> None -- remove all items from SN)r1rr<s r	r3zMutableSequence.clearls*	
		r4czt|}t|dzD]}|||z
dz
||c||<|||z
dz
<!y)z!S.reverse() -- reverse *IN PLACE*rr%N)rr)r=rrs   r	reversezMutableSequence.reversetsNIq!t	8A#'!A;Q DGT!A#a%[	8rcR||urt|}|D]}|j|y)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)rr)r=rOrgs   r	extendzMutableSequence.extendzs,T>&\F	AKKN	rc||}||=|S)zS.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=rrgs   r	r1zMutableSequence.pops
KKrc(||j|=y)zvS.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        N)rrVs  r	r,zMutableSequence.removes
E"#rc(|j||Sr)r)r=rOs  r	__iadd__zMutableSequence.__iadd__sFrN)r)rErFrGrrHrrorqrrr3rrr1r,rrrr	r"r"RskI&8$rr")UrabcrrrrrrrPEllipsisTyper
r__all__rEr.bytes_iterator	bytearraybytearray_iteratorrKdict_keyiteratorrOdict_valueiteratorrMdict_itemiterator
list_iteratorrlist_reverseiteratorrrange_iteratorlongrange_iteratorr_set_iteratorstr_iteratortuple_iteratorzipzip_iterator	dict_keysdict_values
dict_itemsr1mappingproxy	generatorr*	coroutinerhr-async_generatorr8rrrregisterr
rrrrrrrrrr$rrrrr	frozensetrrrrrr rrQr!rstrrrr#bytesr"rrr	<module>rs>(
DICyBx	
d3i$y{+,RWWY($ryy{+,bhhj)*T"X
D"./d58n%$uQ$Y/01DK DH~d2hDK O	299;
"((*

DMM"/$%	
K	
		es)

2'2"&	&R
92g2"M&-]-`(22$x&	.!$%"#$%#$- &'.!$%,,.!,

 --`
9g2'2")w4@L4@l
V$;;(G*GTYMM`C
1j1f
2%
2 !{C!	),S,,
:
%j
% K OWOd
=@z:=@~	%#%*3w3(%=E
I?h?D#r