o .jY@sddlmZddlZddlmZddlmZddlm Z m Z ddl m Z ddl mZejr;ddlmZGd d d eZgd Zed Zed ZedZejdejeefejejeefd fZGddde Ze ddd*ddZd+ddZGdddej eefej!eefZ"Gd d!d!ej#ejeefZ$Gd"ddej!eefZ%ejd#ej&d$Z'ed%Z(Gd&d'd'ej)e'Z*Gd(d)d)ej+e'e(fZ,dS),) annotationsN) OrderedDict)Mapping)Enumauto) lru_cache)RLock)Protocolc@s eZdZd ddZd ddZd S) HasGettableStringKeysreturntyping.Iterator[str]cCdSNselfrrP/home/thesage/.local/lib/python3.10/site-packages/urllib3_future/_collections.pykeyszHasGettableStringKeys.keyskeystrcCr rrrrrrr __getitem__rz!HasGettableStringKeys.__getitem__Nr r rrr r)__name__ __module__ __qualname__rrrrrrr s r )RecentlyUsedContainerHTTPHeaderDict GroupedDict_KT_VT_DTrc@seZdZeZdS) _SentinelN)rrrr not_passedrrrrr$+s r$@)maxsizestringrr cC|S)zjReasoning: We are often calling lower on repetitive identical header key. This was unnecessary exhausting!)lower)r(rrr_lower_wrapper/sr+ potentialobjectValidHTTPHeaderSource | NonecCs|t|tr|St|tjrttjttf|St|tjr,ttjtjttf|St|dr>> d['X-Header-Name'] 'Value1, Value2, Value3' However, if we iterate over an HTTPHeaderDict's items, we will optionally combine these values based on whether combine=True was called when building up the dictionary >>> d = HTTPHeaderDict({"A": "1", "B": "foo"}) >>> d.add("A", "2", combine=True) >>> d.add("B", "bar") >>> list(d.items()) [ ('A', '1, 2'), ('B', 'foo'), ('B', 'bar'), ] This class conforms to the interface required by the MutableMapping ABC while also giving us the nonstandard iteration behavior we want; items with duplicate keys, ordered by time of first insertion. r_headersheadersr r=cC ||_dSr)r])rr^rrrr? zHTTPHeaderDictItemView.__init__r7cCstt|jSr)rGrRr] iteritemsrrrrrNszHTTPHeaderDictItemView.__len__ typing.Iterator[tuple[str, str]]cCs |jSr)r]rarrrrrQr`zHTTPHeaderDictItemView.__iter__rCr-boolcCsDt|tr t|dkr |\}}t|tr t|tr |j||SdS)NF)r/tuplerGrr]_has_value_for_header)rrC passed_key passed_valrrr __contains__s z#HTTPHeaderDictItemView.__contains__N)r^rr r=rWr rb)rCr-r rc) rrrrYrZr?rNrQrirrrrr\s    r\cs8eZdZUdZded<dMdNfd d ZdOddZdPddZdQddZdRddZ dSdTfdd Z dUddZ dUd d!Z dVd#d$Z dWd&d'ZdQd(d)Zd*d+dXd-d.ZdYd1d2ZejdZd4d5Zejd[d8d5Zejfd\d:d5ZeZeZeZeZd]d;d<Zd^d=d>Zd_d?d@Zd`dBdCZd`dDdEZdadGdHZ dbdKdLZ!Z"S)crap :param headers: An iterable of field-value pairs. Must not contain multiple field names when compared case-insensitively. :param kwargs: Additional field-value pairs to pass in to ``dict.update``. A ``dict`` like container for storing HTTP Headers. Field names are stored and compared case-insensitively in compliance with RFC 7230. Iteration provides the first case-sensitive key seen for each case-insensitive pair. Using ``__setitem__`` syntax overwrites fields that compare equal case-insensitively in order to maintain ``dict``'s api. For fields that compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add`` in a loop. If multiple fields that are equal case-insensitively are passed to the constructor or ``.update``, the behavior is undefined and some will be lost. >>> headers = HTTPHeaderDict() >>> headers.add('Set-Cookie', 'foo=bar') >>> headers.add('set-cookie', 'baz=quxx') >>> headers['content-length'] = '7' >>> headers['SET-cookie'] 'foo=bar, baz=quxx' >>> headers['Content-Length'] '7' z%typing.MutableMapping[str, list[str]]r6Nr^r.kwargsrc sNti|_|durt|tr||n|||r%||dSdSr)r>r?r6r/r _copy_fromextend)rr^rkr@rrr?s    zHTTPHeaderDict.__init__rvalr r=cCs||g|jt|<dSrr6r+rrrnrrrrLszHTTPHeaderDict.__setitem__cCs4t|tr |d}|jt|}d|ddS)Nlatin-1, )r/bytesdecoder6r+joinrprrrr s  zHTTPHeaderDict.__getitem__cCs$t|tr |d}|jt|=dS)Nrq)r/rtrur6r+rrrrrMs  zHTTPHeaderDict.__delitem__r-rccCs0t|tr |d}t|trt||jvSdS)NrqF)r/rtrurr+r6rrrrris   zHTTPHeaderDict.__contains__defaultcst||Sr)r> setdefaultrrrxr@rrryszHTTPHeaderDict.setdefaultothercCsDt|}|dur dSt||}dd|Ddd|DkS)NFcSsi|] \}}t||qSr)r+).0kvrrr 'sz)HTTPHeaderDict.__eq__..)r5type itermerged)rr{maybe_constructableother_as_http_header_dictrrr__eq__ s zHTTPHeaderDict.__eq__cCs || Sr)r)rr{rrr__ne__+s zHTTPHeaderDict.__ne__r7cCs t|jSr)rGr6rrrrrN.r`zHTTPHeaderDict.__len__r ccs |jD]}|dVqdSNr)r6rS)rvalsrrrrQ1s zHTTPHeaderDict.__iter__cCs"z||=WdStyYdSwr)rFrrrrdiscard6s   zHTTPHeaderDict.discardF)combinercCsTt|}||g}|j||}||ur(|r!|dd||d<dS||dSdS)aAdds a (name, value) pair, doesn't overwrite the value if it already exists. If this is called with combine=True, instead of adding a new header value as a distinct item during iteration, this will instead append the value to any existing header value with a comma. If no existing header value exists for the key, then the value will simply be added, ignoring the combine parameter. >>> headers = HTTPHeaderDict(foo='bar') >>> headers.add('Foo', 'baz') >>> headers['foo'] 'bar, baz' >>> list(headers.items()) [('foo', 'bar'), ('foo', 'baz')] >>> headers.add('foo', 'quz', combine=True) >>> list(headers.items()) [('foo', 'bar, baz, quz')] rrN)r+r6ryappend)rrrnr key_lowernew_valsrrrradd<szHTTPHeaderDict.addargsValidHTTPHeaderSourcecOs t|dkrtdt|dt|dkr|dnd}t|tr1|D] \}}|||q%nCt|tjrG|D] \}}|||q;n-t|tj r[|D] \}}|||qOnt |drtt |drt| D] }||||qi|D] \}}|||qxdS) zGeneric import function for any type of header-like object. Adapted version of MutableMapping.update in order to insert items with self.add instead of self.__setitem__ rsz/extend() takes at most 1 positional arguments (z given)rrrrN) rG TypeErrorr/rrarr0ritemsr2r4r)rrrkr{rrnrDrrrrm[s.      zHTTPHeaderDict.extend list[str]cCr rrrrrrgetlist{zHTTPHeaderDict.getlistr#list[str] | _DTcCr rrrzrrrr~r_Sentinel | _DTcCs\t|tr |d}z |jt|}Wnty'|tjur#gYS|YSw|ddS)zmReturns a list of all the values for the named field. Returns an empty list if the key doesn't exist.rqrsN)r/rtrur6r+rFr$r%)rrrxrrrrrs     cCst|jdt|dS)N())rrdictrrrrr__repr__szHTTPHeaderDict.__repr__cCs,|D]}||}|g||jt|<qdSr)rr6r+)rr{rrnrrrrls zHTTPHeaderDict._copy_fromcCst|}|||Sr)rrl)rclonerrrcopys  zHTTPHeaderDict.copyrbccs>|D]}|jt|}|ddD] }|d|fVqqdS)z8Iterate over all header lines, including duplicate ones.rsNrro)rrrrnrrrraszHTTPHeaderDict.iteritemsccs:|D]}|jt|}|dd|ddfVqdS)z:Iterate over all headers, merging duplicate ones together.rrrrsN)r6r+rvrprrrrs zHTTPHeaderDict.itermergedr\cCst|Sr)r\rrrrrzHTTPHeaderDict.items header_namepotential_valuecCs&||vr||jt|ddvSdS)NrsFro)rrrrrrrfsz$HTTPHeaderDict._has_value_for_headerr)r^r.rkr)rrrnrr r=r)rrr r=rr-r rc)rw)rrrxrr r)r{r-r rcrWr)rrrnrrrcr r=)rrrkrr r=)rrr r)rrrxr#r r)rrrxrr rr r)r{rr r=)r rrj)r r\)rrrrr rc)#rrrrYrZr?rLrrMriryrrrNrQrrrmr0overloadrr$r% getheadersgetallmatchingheadersigetget_allrrlrrarrrfr[rrr@rrsB !                 _GK)bound_GVc@sFeZdZdZdZdddZdd d Zdd dZdddZdddZ dS)ReverseKeysViewaNA read-only ``KeysView`` over the keys mapped to a single value. Returned by :meth:`GroupedDict.keys_for`. Backed by reference to an internal bucket so the view is live (mirrors ``dict.keys()`` semantics): subsequent mutations of the parent :class:`GroupedDict` are reflected on next iteration / membership test. _bucketbucket typing.Optional[typing.Set[_GK]]r r=cCr_rr)rrrrrr?s zReverseKeysView.__init__typing.Iterator[_GK]cCs|jdur tdSt|jS)Nr)riterrrrrrQs  zReverseKeysView.__iter__r7cCs|jdurdSt|jSr)rrGrrrrrN  zReverseKeysView.__len__rr-rccCs|jdurdS||jvS)NFrrrrrrirzReverseKeysView.__contains__rcCs"d|jr t|dStdS)NzReverseKeysView(r)rrVrrrrrs"zReverseKeysView.__repr__N)rrr r=)r rrWrr) rrrrY __slots__r?rQrNrirrrrrrs    rcseZdZdZdZddd/fd d Zd0fdd Zd1fdd Zd2fdd Zd3fdd Z d4fdd Z d5d6fdd Z d7d d!Z d8d#d$Z d9d&d'Zd9d(d)Ze d5d:d-d.ZZS);r uuA ``dict`` subclass that maintains a reverse "value to keys" index. Optimized for the case where many keys share a small number of distinct values. Reverse lookups via :meth:`keys_for` are O(1) average time and return a live :class:`ReverseKeysView`. A ``key_fn`` may be supplied to control how values are hashed for the reverse index. By default, the value itself is used (identity over equality). Pass ``key_fn=id`` to index by object identity instead — this is the right choice when values may override ``__eq__`` / ``__hash__`` in ways you don't want to collapse buckets on, or when values are not hashable themselves. All standard ``dict`` mutation entry points are overridden to keep the reverse index coherent. Empty buckets are pruned eagerly so that long-lived instances do not accumulate stale entries on value churn. )_index_key_fnNkey_fnr typing.Anyr.typing.Callable[[_GV], typing.Hashable] | Nonerkr r=csbtj|i||dur|ndd|_i|_tD]\}}|j||t|qdS)NcSs|Srr)xrrrrz&GroupedDict.__init__..)r>r?rrrryrVr)rrrrkr}r~r@rrr?szGroupedDict.__init__rrrDrcs||vrJt|}||}||}||kr!t||dS|j|}|dur6|||s6|j|=t|||j|t |dSt|||j||t |dSr) r>rrrLrgetrryrVr)rrrDoldold_hnew_hrr@rrrL s"      zGroupedDict.__setitem__csXt|}t|||}|j|}|dur(|||s*|j|=dSdSdSr)r>rrMrrrr)rrrrrr@rrrMs      zGroupedDict.__delitem__cst|dkrtddt|||vr|r|dSt|t|}||}|j|}|dur?|||s?|j|=|S)Nrsz&pop expected at most 2 arguments, got r) rGrrFr>rBrrrr)rrrrDhrr@rrrB's     zGroupedDict.poptuple[_GK, _GV]csJt\}}||}|j|}|dur!|||s!|j|=||fSr)r>rHrrrr)rrrDrrr@rrrH7s   zGroupedDict.popitemcst|jdSr)r>rTrrr@rrrTAs zGroupedDict.clearrxcs ||vr t|S|||<|Sr)r>rrzr@rrryEs zGroupedDict.setdefaultcOst|dkrtdt||rD|d}t|tr&|D]}||||<qnt|dr9|D]}||||<q/n |D]\}}|||<q;|D]\}}|||<qHdS)Nrsz3update expected at most 1 positional argument, got rr)rGrr/_Mappingr4rr)rrrkr{r}r~rrrupdateLs&        zGroupedDict.updateReverseKeysView[_GK]cCs|j||}t|S)a?Return a live read-only view over all keys mapped to ``value``. Lookup is O(1) average time. The returned :class:`ReverseKeysView` reflects the current bucket contents and updates as the parent :class:`GroupedDict` is mutated. Returns an empty view if no key maps to ``value``. )rrrr)rrDrrrrkeys_for`szGroupedDict.keys_forGroupedDict[_GK, _GV]cCst||jd}|S)Nr)r r)rnewrrrrkszGroupedDict.copycCr)r)rrrrr__copy__przGroupedDict.__copy__iterabletyping.Iterable[_GK]GroupedDict[_GK, typing.Any]cs|fdd|DS)Ncsi|]}|qSrr)r|r}rDrrrysz(GroupedDict.fromkeys..r)clsrrDrrrfromkeyssszGroupedDict.fromkeys)rrrrrkrr r=)rrrDrr r=)rrr r=)rrrrr r)r rrXr)rrrxrr r)rrrkrr r=)rDrr r)r r)rrrDrr r)rrrrYrr?rLrMrBrHrTryrrrr classmethodrr[rrr@rr s$     r )r(rr r)r,r-r r.)- __future__rr0 collectionsrcollections.abcrrenumrr functoolsr threadingr TYPE_CHECKINGtyping_extensionsr r __all__TypeVarr!r"r#Unionrr2r3rr$r+r5GenericMutableMappingrSetr\rHashablerrKeysViewrDictr rrrrsB            & _0i #