'gddlmZddlmZddlZddlmZddl m Z ddl m Z ddl mZdd l mZdd l mZdd l mZej$rddlZej*d Zej*d Zej*dZ d*dZGddeeeZGddeeefZGddeeefeeefZGddeeefZGddej@eefZ!GddeeefZ"GddeeefeeefZ#GddeeefeeefZ$Gd d!eeefeeefZ%Gd"d#eeefe"eefZ&Gd$d%eeefeeefZ'Gd&d'ejPe)Z*dd(l m+Z+d+d)Z,y),) annotationsNdeepcopy) exceptions)_missing)ImmutableDictMixin)ImmutableListMixin)ImmutableMultiDictMixin)UpdateDictMixinKVTc#BKt|tr|jdEd{yt|tjrH|jD]4\}}t|t t tfr|D]}||f /||f6y|Ed{y7r7w)zyIterates over the items of a mapping yielding keys and values without dropping any from more complex structures. TmultiN) isinstance MultiDictitemscabcMappinglisttupleset)mappingkeyvaluevs Z/var/www/html/knws/venv/lib/python3.12/site-packages/werkzeug/datastructures/structures.pyiter_multi_itemsr!s'9%==t=,,, GT\\ *!--/ !JC%$s!34!Aq&L!5j  ! - s"&BBA,BBBBceZdZdZddZy) ImmutableListzJAn immutable :class:`list`. .. versionadded:: 0.5 :private: c^t|jdtj|dSN())type__name__r__repr__selfs r r*zImmutableList.__repr__5*t*%%&a d(;'>Nreturnstr)r) __module__ __qualname____doc__r*r.r r#r#-s ?r.r#ceZdZdZej d dZej d dZej d dZej d dZej d dZ d ddZy)TypeConversionDictzWorks like a regular dict but the :meth:`get` method can perform type conversions. :class:`MultiDict` and :class:`CombinedMultiDict` are subclasses of this class and provide the same feature. .. versionadded:: 0.5 cyNr5r,rs r getzTypeConversionDict.getA'*r.cyr9r5r,rdefaults r r;zTypeConversionDict.getC,/r.cyr9r5r>s r r;zTypeConversionDict.getE03r.cyr9r5r,rr(s r r;zTypeConversionDict.getGFIr.cyr9r5r,rr?r(s r r;zTypeConversionDict.getIKNr.Ncx ||}||S ||S#t$r|cYSwxYw#ttf$r|cYSwxYw)aReturn the default value if the requested data doesn't exist. If `type` is provided and is a callable it should convert the value, return it or raise a :exc:`ValueError` if that is not possible. In this case the function will return the default as if the value was not found: >>> d = TypeConversionDict(foo='42', bar='blub') >>> d.get('foo', type=int) 42 >>> d.get('bar', -1, type=int) -1 :param key: The key to be looked up. :param default: The default value to be returned if the key can't be looked up. If not further specified `None` is returned. :param type: A callable that is used to cast the value in the :class:`MultiDict`. If a :exc:`ValueError` or a :exc:`TypeError` is raised by this callable the default value is returned. .. versionchanged:: 3.0.2 Returns the default value on :exc:`TypeError`, too. )KeyError ValueError TypeError)r,rr?r(rvs r r;zTypeConversionDict.getKsZ< cB <I 8O N I& N s% ""99rrr0V | Nonerrr?rr0rrrr?rr0V | Trr1r(cabc.Callable[[V], T]r0zT | Nonerr1r?rr(rTr0rNNrrr? V | T | Noner(cabc.Callable[[V], T] | Noner0rX)r)r2r3r4toverloadr;r5r.r r7r79sZZ**ZZ//ZZ33ZZIIZZNN!%-1 ) ))+ )  )r.r7c eZdZdZddZddZy)ImmutableTypeConversionDictzpWorks like a :class:`TypeConversionDict` but does not support modifications. .. versionadded:: 0.5 ct|SzReturn a shallow mutable copy of this object. Keep in mind that the standard library's :func:`copy` function is a no-op for this class like for any other python immutable type (eg: :class:`tuple`). )r7r+s r copyz ImmutableTypeConversionDict.copy~s "$''r.c|Sr9r5r+s r __copy__z$ImmutableTypeConversionDict.__copy__ r.N)r0zTypeConversionDict[K, V]r0te.Selfr)r2r3r4r`rbr5r.r r]r]ws (r.r]ceZdZdZ d' d(fd Zd)dZd*fd Zd+fd Zd,fd Zd-fd Z d-fd Z e jd.d Z e jd/d Z d' d0fd Z d1fd Ze jd2d Ze jd3dZd'd4dZ d' d5fd Zd6d7fd Zd8fd Zd9fd Zd:fd Zd;dZd'ddZd?d@dZ dAdZ dBdZ dCdZe jd,dZe jd3dZe jdDdZef dEfd ZdFfd! Zd.fd" ZdGfd# Zd;d$Z d>> d = MultiDict([('a', 'b'), ('a', 'c')]) >>> d MultiDict([('a', 'b'), ('a', 'c')]) >>> d['a'] 'b' >>> d.getlist('a') ['b', 'c'] >>> 'a' in d True It behaves like a normal dict thus all dict functions will only return the first value when multiple values for one key are found. From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP exceptions. A :class:`MultiDict` can be constructed from an iterable of ``(key, value)`` tuples, a dict, a :class:`MultiDict` or from Werkzeug 0.2 onwards some keyword parameters. :param mapping: the initial value for the :class:`MultiDict`. Either a regular dict, an iterable of ``(key, value)`` tuples or `None`. .. versionchanged:: 3.1 Implement ``|`` and ``|=`` operators. c|t|yt|tr%t|d|j Dyt|t j r[i}|jD]6\}}t|tttfrt|}|s/|g}|||<8t||yi}|D]&\}}|j|gj|(t||y)Nc30K|]\}}||ddfywr9r5).0kvss r z%MultiDict.__init__..sEEAraAZEs) super__init__rrlistsrrrrrr setdefaultappend)r,rtmprr __class__s r rozMultiDict.__init__s ? G    + G EW]]_E E  .C%mmo ! UedE3%78 KE  "GE C ! G S !C% 6 UsB'..u5 6 G S !r.c4t|jSr9)dictrpr+s r __getstate__zMultiDict.__getstate__sDJJL!!r.c@t|t| |yr9)rnclearupdate)r,rrts r __setstate__zMultiDict.__setstate__s   ur.c t|Sr9)rn__iter__r,rts r r}zMultiDict.__iter__s w!!r.cz||vr"t||}t|dkDr|dStj|)zReturn the first data value for this key; raises KeyError if not found. :param key: The key to be looked up. :raise KeyError: if the key does not exist. r)rn __getitem__lenrBadRequestKeyError)r,rlstrts r rzMultiDict.__getitem__s@ $;'%c*C3x!|1v ++C00r.c(t|||gy)zLike :meth:`add` but removes an existing key first. :param key: the key for the value. :param value: the value to set. N)rn __setitem__r,rrrts r rzMultiDict.__setitem__s C%)r.cDt||gj|y)zAdds a new value for the key. .. versionadded:: 0.6 :param key: the key for the value. :param value: the value to add. N)rnrqrrrs r addz MultiDict.adds 3#**51r.cyr9r5r:s r getlistzMultiDict.getlist*-r.cyr9r5rDs r rzMultiDict.getlistGJr.c t||}| t|Sg}|D]} |j |||S#t$rgcYSwxYw#t t f$rYAwxYw)afReturn the list of items for a given key. If that key is not in the `MultiDict`, the return value will be an empty list. Just like `get`, `getlist` accepts a `type` parameter. All items will be converted with the callable defined there. :param key: The key to be looked up. :param type: Callable to convert each value. If a ``ValueError`` or ``TypeError`` is raised, the value is omitted. :return: a :class:`list` of all the values for the key. .. versionchanged:: 3.1 Catches ``TypeError`` in addition to ``ValueError``. )rnrrJrrrrKrL)r,rr(rMresultitemrts r rzMultiDict.getlists  '-c2B <8O D  d4j)    I  *  s"AA AAA%$A%c8t||t|y)aRemove the old values for a key and add new ones. Note that the list you pass the values in will be shallow-copied before it is inserted in the dictionary. >>> d = MultiDict() >>> d.setlist('foo', ['1', '2']) >>> d['foo'] '1' >>> d.getlist('foo') ['1', '2'] :param key: The key for which the values are set. :param new_list: An iterable with the new values for the key. Old values are removed first. N)rnrr)r,rnew_listrts r setlistzMultiDict.setlist$s Ch0r.cyr9r5r:s r rqzMultiDict.setdefault6rr.cyr9r5r>s r rqzMultiDict.setdefault836r.c||vr|||<||S)aGReturns the value for the key if it is in the dict, otherwise it returns `default` and sets that value for `key`. :param key: The key to be looked up. :param default: The default value to be returned if the key is not in the dict. If not further specified it's `None`. r5r>s r rqzMultiDict.setdefault:s d?DICyr.cd||vrt||t|xsdt| |S)aLike `setdefault` but sets multiple values. The list returned is not a copy, but the list that is actually used internally. This means that you can put new values into the dict by appending items to the list: >>> d = MultiDict({"foo": 1}) >>> d.setlistdefault("foo").extend([2, 3]) >>> d.getlist("foo") [1, 2, 3] :param key: The key to be looked up. :param default_list: An iterable of default values. It is either copied (in case it was a list) or converted into a list before returned. :return: a :class:`list` r5)rnrrr)r,r default_listrts r setlistdefaultzMultiDict.setlistdefaultGs5& d? G T,*<"%= >w"3''r.c#lKt|D]\}}|r|D]}||f ||df yw)aReturn an iterator of ``(key, value)`` pairs. :param multi: If set to `True` the iterator returned will have a pair for each value of each key. Otherwise it will only contain pairs for the first value of each key. rN)rnr)r,rrvaluesrrts r rzMultiDict.items_sN!7=? %KC#%Eu*$%6!9n$  %s14c#XKt|D]\}}|t|fyw)zuReturn a iterator of ``(key, values)`` pairs, where values is the list of all values associated with the key.N)rnrr)r,rrrts r rpzMultiDict.listsos1 !7=? $KCtF|# # $s'*c#BKt|D] }|d yw)zAReturns an iterator of the first value on every key's value list.rNrnr)r,rrts r rzMultiDict.valuesws(gn& F)O sc t|S)aReturn an iterator of all values associated with a key. Zipping :meth:`keys` and this is the same as calling :meth:`lists`: >>> d = MultiDict({"foo": [1, 2, 3]}) >>> zip(d.keys(), d.listvalues()) == d.lists() True rr~s r listvalueszMultiDict.listvalues~sw~r.c$|j|S)z%Return a shallow copy of this object.rtr+s r r`zMultiDict.copys~~d##r.cX|jt|jd|S)z"Return a deep copy of this object.F)flat)rtrto_dictr,memos r rzMultiDict.deepcopys#~~ht|||'?FGGr.cyr9r5r+s r rzMultiDict.to_dicts%(r.cyr9r5r,rs r rzMultiDict.to_dictsCFr.cj|rt|jSt|jS)aReturn the contents as regular dict. If `flat` is `True` the returned dict will only have the first item present, if `flat` is `False` all values will be returned as lists. :param flat: If set to `False` the dict returned will have lists with all the values in it. Otherwise it will only contain the first value for each key. :return: a :class:`dict` )rvrrprs r rzMultiDict.to_dicts)  % %DJJL!!r.cNt|D]\}}|j||y)aupdate() extends rather than replaces existing key lists: >>> a = MultiDict({'x': 1}) >>> b = MultiDict({'x': 2, 'y': 3}) >>> a.update(b) >>> a MultiDict([('y', 3), ('x', 1), ('x', 2)]) If the value list for a key in ``other_dict`` is empty, no new values will be added to the dict and the key will not be created: >>> x = {'empty_list': []} >>> y = MultiDict() >>> y.update(x) >>> y MultiDict([]) Nr!rr,rrrs r rzzMultiDict.updates*2+73 !JC HHS%  !r.ct|tjstS|j }|j ||Sr9)rrrNotImplementedr`rz)r,otherrMs r __or__zMultiDict.__or__s4%.! ! YY[ % r.ct|tjtjfstS|j ||Sr9)rrrIterablerrz)r,rs r __ior__zMultiDict.__ior__s2%$,, !>?! ! E r.cyr9r5r:s r popz MultiDict.pop #r.cyr9r5r>s r rz MultiDict.popr@r.cyr9r5r>s r rz MultiDict.poprBr.c t||}t|dk(rtj||dS#t $r#|t ur|cYStj|dwxYw)aPop the first item for a list on the dict. Afterwards the key is removed from the dict, so additional values are discarded: >>> d = MultiDict({"foo": [1, 2, 3]}) >>> d.pop("foo") 1 >>> "foo" in d False :param key: the key to pop. :param default: if provided the value to return if the key was not in the dictionary. rN)rnrrrrrJr)r,rr?rrts r rz MultiDict.popsj( ?'+c"C3x1} 33C88q6M ?h&//4$ >  ?s6:A&A&c t|}t|ddk(rtj|d|d|ddfS#t $r(}tj|j ddd}~wwxYw)zPop an item from the dict.r rN)rnpopitemrrrrJargs)r,rerts r rzMultiDict.popitems~ E7?$D47|q  33DG<<7DGAJ& & E//q : D EsAA A8#A33A8c$t||gS)zPop the list for a key from the dict. If the key is not in the dict an empty list is returned. .. versionchanged:: 0.5 If the key does no longer exist a list is returned instead of raising an error. )rnr)r,rrts r poplistzMultiDict.poplist sw{3##r.c t|S#t$r(}tj|j ddd}~wwxYw)z*Pop a ``(key, list)`` tuple from the dict.rN)rnrrJrrr)r,rrts r popitemlistzMultiDict.popitemlistsC E7?$ $ E//q : D Es  A#=Ac"|jSr9)r`r+s r rbzMultiDict.__copy__syy{r.c&|j|S)N)rrrs r __deepcopy__zMultiDict.__deepcopy__s}}$}''r.cjt|jdt|jddS)Nr&Trr')r(r)rrr+s r r*zMultiDict.__repr__!s1t*%%&aTZZdZ-C(D'GqIIr.r9rzkMultiDict[K, V] | cabc.Mapping[K, V | list[V] | tuple[V, ...] | set[V]] | cabc.Iterable[tuple[K, V]] | Noner0Noner0t.Any)rrr0rr0zcabc.Iterator[K]rrr0rrrrrr0rrrr0list[V]rrr(rTr0zlist[T]rrr(rYr0zlist[V] | list[T]rrrcabc.Iterable[V]r0rrrr0rrP)rrr?rOr0rO)rrrzcabc.Iterable[V] | Noner0rFrboolr0cabc.Iterable[tuple[K, V]]r0 cabc.Iterable[tuple[K, list[V]]]r0rr0zcabc.Iterable[list[V]]rd)rrr0rer0z dict[K, V])rzt.Literal[False]r0zdict[K, list[V]])T)rrr0zdict[K, V] | dict[K, list[V]]rdMultiDict[K, V] | cabc.Mapping[K, V | list[V] | tuple[V, ...] | set[V]] | cabc.Iterable[tuple[K, V]]r0r)rz5cabc.Mapping[K, V | list[V] | tuple[V, ...] | set[V]]r0MultiDict[K, V])rzRcabc.Mapping[K, V | list[V] | tuple[V, ...] | set[V]] | cabc.Iterable[tuple[K, V]]r0rerQrrr?rRr0rRr0z tuple[K, V]r0ztuple[K, list[V]]r/)$r)r2r3r4rorwr{r}rrrrZr[rrrqrrrprrr`rrrzrrrrrrrrbrr* __classcell__rs@r rrs)d " " ">"" 1*2ZZ--ZZJJ;?8 <1$ZZ--ZZ66 ?C(($;( (0% $ $HZZ((ZZFF "! )! !8J   )   ZZ##ZZ//ZZ33"? ??  ?B E$E(Jr.rc$eZdZdZdZddZddZy) _omd_bucketa Wraps values in the :class:`OrderedMultiDict`. This makes it possible to keep an order over multiple different keys. It requires a lot of extra memory and slows down access a lot, but makes it possible to access elements in O(1) and iterate in O(n). )prevrrnextc|j|_||_||_d|_|j ||_|j||j_||_yr9) _last_bucketrrrr _first_bucket)r,omdrrs r roz_omd_bucket.__init__.sZ.1.>.>  .2    $ $C     '$(C   !r.c|jr|j|j_|jr|j|j_|j|ur|j|_|j|ur|j|_yyr9)rrrr)r,rs r unlinkz_omd_bucket.unlink:sg 99!YYDIIN 99!YYDIIN    $ $ C    t ##yyC  $r.N)r_OrderedMultiDict[K, V]rrrrr0r)rrr0r)r)r2r3r4 __slots__rorr5r.r rr%s 1I  )r.rceZdZdZ d d fd Zd!dZdZd"dZd#dZd$dZ d%dZ d&d Z d'd Z d(d Z d)d Zd*d Zd+d,dZd-dZd.dZd&dZej*d/dZej*d0dZ d d1dZd2dZdd3dZ d4dZd/dZej*d%dZej*d5dZej*d6dZef d7dZd8dZd9dZxZS):_OrderedMultiDictaWorks like a regular :class:`MultiDict` but preserves the order of the fields. To convert the ordered multi dict into a list you can use the :meth:`items` method and pass it ``multi=True``. In general an :class:`OrderedMultiDict` is an order of magnitude slower than a :class:`MultiDict`. .. admonition:: note Due to a limitation in Python you cannot convert an ordered multi dict into a regular dict by using ``dict(multidict)``. Instead you have to use the :meth:`to_dict` method, otherwise the internal bucket objects are exposed. .. deprecated:: 3.1 Will be removed in Werkzeug 3.2. Use ``MultiDict`` instead. Ncddl}|jdtdt|d|_d|_||j|yy)Nr^'OrderedMultiDict' is deprecated and will be removed in Werkzeug 3.2. Use 'MultiDict' instead.r stacklevel)warningswarnDeprecationWarningrnrorrrz)r,rrrts r roz_OrderedMultiDict.__init__XsX   -   7;6:   KK  r.ct|tstSt|trit |j d}t |j d} |D]\}}t |\}}||k7s||k7sy t |yt|t|k7ry|jD]\}} |j|| k7syy#t$rYywxYw#t$rYywxYw)NTrF) rrrriterrr StopIterationrrpr) r,riter1iter2k1v1k2v2rrs r __eq__z_OrderedMultiDict.__eq__os%+! ! e. /$/0E401E #%FB!%[FBRx28$%  U  t9E "::< KC}}S!V+ !  !  s0 C?CC C& C#"C#& C21C2cPt|t|jdffSNTr)r(rrr,protocols r __reduce_ex__z_OrderedMultiDict.__reduce_ex__s$DzD$!78:::r.c8t|jdSr)rrr+s r rwz_OrderedMultiDict.__getstate__sDJJTJ*++r.c\|j|D]\}}|j||yr9)ryr)r,rrrs r r{z_OrderedMultiDict.__setstate__s,   !JC HHS%  !r.cz||vr#tj||djStj|Nr)rvrrrrr:s r rz_OrderedMultiDict.__getitem__s8 $;##D#.q177 7++C00r.cJ|j||j||yr9rrr,rrs r rz_OrderedMultiDict.__setitem__s S er.c&|j|yr9)rr:s r __delitem__z_OrderedMultiDict.__delitem__s   r.c0d|jDS)Nc3&K|] \}}| ywr9r5)rjr_s r rmz)_OrderedMultiDict.keys..s/Q/rr+s r keysz_OrderedMultiDict.keyss/$**,//r.c4t|jSr9)rrr+s r r}z_OrderedMultiDict.__iter__sDIIK  r.c0d|jDS)Nc3&K|] \}}| ywr9r5)rjrrs r rmz+_OrderedMultiDict.values..s5*#u5rrr+s r rz_OrderedMultiDict.valuess5 55r.c#@K|j}|r-|*|j|jf|j}|)yyt }|S|j|vr5|j |j|j|jf|j}|Ryywr9)rrrrrr)r,rptr returned_keyss r rz_OrderedMultiDict.itemss   /ggsyy((hh/ EM/77-/!%%cgg.''399,,hh /s9BABBc#Kt}|j}|b|j|vrD|j|j|jf|j |j|j }|ayywr9)rrrrrr)r,rrs r rpz_OrderedMultiDict.listssg   owwm+ggt||CGG444!!#''*((C os A9A><A>c#DK|jD] \}}| ywr9rp)r,_keyrs r rz_OrderedMultiDict.listvaluess$ JJL LD&L  cftj||gjt|||yr9)rvrqrrrrs r rz_OrderedMultiDict.adds& c2&--k$U.KLr.cyr9r5r:s r rz_OrderedMultiDict.getlistrr.cyr9r5rDs r rz_OrderedMultiDict.getlistrr.c tj||}||Dcgc]}|jc}Sg}|D]$} |j ||j&|S#t$rgcYSwxYwcc}w#t t f$rYPwxYwr9)rvrrJrrrrKrL)r,rr(rMxrrs r rz_OrderedMultiDict.getlists  !!$,B <%'(AGG( ( D  d4::./    I )  *  s'A!A2!A7! A/.A/7B B cX|j||D]}|j||yr9r)r,rrrs r rz_OrderedMultiDict.setlists+ S !E HHS%  !r.ctd)Nz5setlistdefault is unsupported for ordered multi dicts)rL)r,rrs r rz _OrderedMultiDict.setlistdefaultsOPPr.cNt|D]\}}|j||yr9rrs r rzz_OrderedMultiDict.updates*+73 !JC HHS%  !r.ctj||d}|D]}|j||Dcgc]}|jc}Scc}wNr5)rvrrr)r,rbucketsbucketr)s r rz_OrderedMultiDict.poplistsG48HHT34K F MM$  !()A)))sA cyr9r5r:s r rz_OrderedMultiDict.poprr.cyr9r5r>s r rz_OrderedMultiDict.popr@r.cyr9r5r>s r rz_OrderedMultiDict.poprBr.c tj||}|D]}|j ||djS#t$r#|tur|cYSt j |dwxYwr)rvrrJrrrrr)r,rr?r/r0s r rz_OrderedMultiDict.popsw ?hhtS)G F MM$  qz ?h&//4$ >  ?s?A+A+c tj|\}}|D]}|j |||djfS#t$r(}tj|j ddd}~wwxYwrrvrrJrrrrr)r,rr/rr0s r rz_OrderedMultiDict.popitems} E<<-LC F MM$  GAJ$$$$  E//q : D EsA A4 #A//A4c tj|\}}|D]}|j |||Dcgc]}|jc}fS#t$r(}tj|j ddd}~wwxYwcc}wrr6)r,rr/rr0r)s r rz_OrderedMultiDict.popitemlist!s E<<-LC F MM$  g.QWW...  E//q : D E /sAB A?#A::A?r9r)robjectr0rr t.SupportsIndexr0rr)rrr0rrrrr0zcabc.Iterable[K]rrrrrrrrrr)rrrrr0 t.NoReturnrrPrQrrr) r)r2r3r4ror__hash__r rwr{rrrrr}rrrprrrZr[rrrrzrrrrrrrs@r rrEsK2 ! ! !.2H;,! 1 0!6 MZZ--ZZJJ;?8 &! Q ! ) !  !* ZZ##ZZ//ZZ33"      ( % /r.rc4eZdZdZddZddfd ZedddZd dZe jd!dZ e jd"dZ e jd#dZ e jd$d Z e jd%d Z d& d'd Z e jd(d Z e jd)d Z d d*dZ d+dZ d,dZd-dZe jd.dZe jd/dZ d0 d1dZd2dZd3dZd4dZd5dZd6dZd7dZd8dZxZS)9CombinedMultiDicta>A read only :class:`MultiDict` that you can pass multiple :class:`MultiDict` instances as sequence and it will combine the return values of all wrapped dicts: >>> from werkzeug.datastructures import CombinedMultiDict, MultiDict >>> post = MultiDict([('foo', 'bar')]) >>> get = MultiDict([('blub', 'blah')]) >>> combined = CombinedMultiDict([get, post]) >>> combined['foo'] 'bar' >>> combined['blub'] 'blah' This works for all read operations and will raise a `TypeError` for methods that usually change data which isn't possible. From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP exceptions. c2t||jffSr9)r(dictsrs r r zCombinedMultiDict.__reduce_ex__GsDzDJJ=((r.cJt|t|xsd|_yr.)rnrorrA)r,rArts r rozCombinedMultiDict.__init__Js ,0",= r.c4td|jd)Nzcannot create z instances by fromkeys)rLr))clsrrs r fromkeyszCombinedMultiDict.fromkeysNs.(88NOPPr.cd|jD] }||vs||cStj|r9)rArrr,rds r rzCombinedMultiDict.__getitem__Rs8 Aaxv  ++C00r.cyr9r5r:s r r;zCombinedMultiDict.getXr<r.cyr9r5r>s r r;zCombinedMultiDict.getZr@r.cyr9r5r>s r r;zCombinedMultiDict.get\rBr.cyr9r5rDs r r;zCombinedMultiDict.get^rEr.cyr9r5rGs r r;zCombinedMultiDict.get`rHr.c|jD]}||vs| |||cS||cS|S#ttf$rY3wxYwr9)rArKrL)r,rr?r(rHs r r;zCombinedMultiDict.getbsb  Aax#!#AcF|+v  ' 2! !s /AAcyr9r5r:s r rzCombinedMultiDict.getlistrrr.cyr9r5rDs r rzCombinedMultiDict.getlisttrr.cng}|jD]#}|j|j||%|Sr9)rAextendr)r,rr(rMrHs r rzCombinedMultiDict.getlistvs8 ,A IIaiiT* + , r.c:td|jDS)zThis function exists so __len__ can be implemented more efficiently, saving one list creation from an iterator. c3.K|] }|D]}|ywr9r5)rjrHrks r rmz/CombinedMultiDict._keys_impl..s4!4Q1414s)rrAr+s r _keys_implzCombinedMultiDict._keys_impl~s4djj444r.c"|jSr9)rUr+s r rzCombinedMultiDict.keyss  r.c4t|jSr9)rrUr+s r r}zCombinedMultiDict.__iter__sDOO%&&r.cyr9r5r+s r rzCombinedMultiDict.itemsrr.cyr9r5)r,rs r rzCombinedMultiDict.itemssQTr.c#Kt}|jD]@}|j|D]*\}}|r||f||vs|j|||f,Bywr9)rrArr)r,rfoundrHrrs r rzCombinedMultiDict.itemssg %Aggen % Uu*$%IIcNu*$  % %s >AAc#DK|jD] \}}| ywr9r)r,rrs r rzCombinedMultiDict.valuess$  HAuK r$ci}|jD];}|jD]&\}}|j|gj|(=|j Sr9)rArprqrRr)r,rMrHrrs r rpzCombinedMultiDict.listssZ! 6A wwy 6 V c2&--f5 6 6xxzr.c0d|jDS)Nc3&K|] }|d yw)r Nr5)rjr)s r rmz/CombinedMultiDict.listvalues..s+!+rr"r+s r rzCombinedMultiDict.listvaluess+djjl++r.ct|S)a0Return a shallow mutable copy of this object. This returns a :class:`MultiDict` representing the data at the time of copying. The copy will no longer reflect changes to the wrapped dicts. .. versionchanged:: 0.15 Return a mutable :class:`MultiDict`. rr+s r r`zCombinedMultiDict.copysr.c4t|jSr9)rrUr+s r __len__zCombinedMultiDict.__len__s4??$%%r.c2|jD]}||vsyy)NTF)rArGs r __contains__zCombinedMultiDict.__contains__s$ Aax r.cLt|jd|jdSr%)r(r)rAr+s r r*zCombinedMultiDict.__repr__s$t*%%&a ~Q77r.r9r9)rAz%cabc.Iterable[MultiDict[K, V]] | Noner0r)rrrrr0r<rrNrPrQrSrUrVrWrrr)r0zset[K]r;r)r0r)rzt.Literal[True]r0rr)rrr0z=cabc.Iterable[tuple[K, V]] | cabc.Iterable[tuple[K, list[V]]]rrrr0rr0int)rrr0rr/)r)r2r3r4r ro classmethodrErrZr[r;rrUrr}rrrprr`rcrer*rrs@r r?r?0sr,)>QQ1 ZZ**ZZ//ZZ33ZZIIZZNN!%-1  +    ZZ--ZZJJ;?8 5 !'ZZ66ZZTT! % % F %, & 8r.r?c(eZdZdZddZddZddZy) ImmutableDictz;An immutable :class:`dict`. .. versionadded:: 0.5 c^t|jdtj|dSr%)r(r)rvr*r+s r r*zImmutableDict.__repr__r-r.ct|Sr_)rvr+s r r`zImmutableDict.copys Dzr.c|Sr9r5r+s r rbzImmutableDict.__copy__rcr.Nr/rrd)r)r2r3r4r*r`rbr5r.r rlrls ?r.rlc eZdZdZddZddZy)ImmutableMultiDictz@An immutable :class:`MultiDict`. .. versionadded:: 0.5 ct|Sr_rar+s r r`zImmutableMultiDict.copys r.c|Sr9r5r+s r rbzImmutableMultiDict.__copy__rcr.Nrgrdrfr5r.r rqrqs r.rqcFeZdZdZ d dfd ZddZd dZd dZxZS) _ImmutableOrderedMultiDictzAn immutable :class:`OrderedMultiDict`. .. deprecated:: 3.1 Will be removed in Werkzeug 3.2. Use ``ImmutableMultiDict`` instead. .. versionadded:: 0.6 c|t||+t|D]\}}tj |||yyr9)rnror!rr)r,rrkrrts r roz#_ImmutableOrderedMultiDict.__init__sE   (1 21!%%dAq1 2 r.c8t|jdSr) enumeraterr+s r _iter_hashitemsz*_ImmutableOrderedMultiDict._iter_hashitemss$/00r.ct|Sr_)rr+s r r`z_ImmutableOrderedMultiDict.copys !&&r.c|Sr9r5r+s r rbz#_ImmutableOrderedMultiDict.__copy__ rcr.r9r)r0zcabc.Iterable[t.Any])r0rrd) r)r2r3r4roryr`rbrrs@r rurus5  2  2  21'r.ruc@eZdZdZ d dfd Zdfd ZxZS) CallbackDictzwA dict that calls a function passed every time something is changed. The function is passed the dict instance. cb|t|||_yt||||_yr9)rnro on_update)r,initialrrts r rozCallbackDict.__init__s4 ? G  # G W %"r.cTdt|jdt| dS)N< >)r(r)rnr*r~s r r*zCallbackDict.__repr__s,4:&&'q)9);(>r.rV)rz6cabc.Mapping[K, V] | cabc.Iterable[tuple[K, V]] | Noner%cabc.Callable[[te.Self], None] | Noner0rr/)r)r2r3r4ror*rrs@r r}r}s= KO;? #G #9 #  #??r.r}ceZdZdZ d ddZddZddZddZddZddZ dd Z dd Z ddd Z dd Z d d Zd!dZd"dZd#dZd$dZd%dZd&dZddZddZy)' HeaderSetaSimilar to the :class:`ETags` class this implements a set-like structure. Unlike :class:`ETags` this is case insensitive and used for vary, allow, and content-language headers. If not constructed using the :func:`parse_set_header` function the instantiation works like this: >>> hs = HeaderSet(['foo', 'bar', 'baz']) >>> hs HeaderSet(['foo', 'bar', 'baz']) Nct|xsd|_|jDchc]}|jc}|_||_ycc}wr.)r_headerslower_setr)r,headersrr)s r rozHeaderSet.__init__0s< W]+ (, 61QWWY6 "7sA c(|j|fy)zAdd a new header to the set.N)rzr,headers r rz HeaderSet.add9s VIr.cF|j}||jvr t||jj|t |j D]'\}}|j|k(s|j |=n|j |j |yy)aCRemove a header from the set. This raises an :exc:`KeyError` if the header is not in the set. .. versionchanged:: 0.5 In older versions a :exc:`IndexError` was raised instead of a :exc:`KeyError` if the object was missing. :param header: the header to be removed. N)rrrJremoverxrr)r,rridxs r rzHeaderSet.remove=slln dii 6" " !$--0 HCyy{f$MM#&  >> % NN4  &r.cd}|D]Y}|j}||jvs"|jj||jj |d}[|r|j |j |yyy)zAdd all the headers from the iterable to the set. :param iterable: updates the set with the items from the iterable. FTN)rrrrrrr)r,iterable inserted_anyrrs r rzzHeaderSet.updateRsw   $F,,.C$))# $$V, c"#  $ DNN6 NN4 7> % NN4  &r.cZ|rt|jSt|jS)aReturn the set as real python set type. When calling this, all the items are converted to lowercase and the ordering is lost. :param preserve_casing: if set to `True` the items in the set returned will have the original case like in the :class:`HeaderSet`, otherwise they will be lowercase. )rrr)r,preserve_casings r as_setzHeaderSet.as_sets$ t}}% %499~r.chdjttj|jS)z2Convert the header set into an HTTP header string.z, )joinmaphttpquote_header_valuerr+s r to_headerzHeaderSet.to_headers"yyT44dmmDEEr.c |j|Sr9)r)r,rs r rzHeaderSet.__getitem__s}}S!!r.c|jj|}|jj|j |j |j |yyr9)rrrrrr)r,rrMs r rzHeaderSet.__delitem__sI ]]  s # $ >> % NN4  &r.c |j|}|jj|j||j|<|jj |j|j |j |yyr9)rrrrrr)r,rrolds r rzHeaderSet.__setitem__sgmmC  %" c ekkm$ >> % NN4  &r.c:|j|jvSr9)rrrs r rezHeaderSet.__contains__s||~**r.c,t|jSr9)rrr+s r rczHeaderSet.__len__s499~r.c,t|jSr9)rrr+s r r}zHeaderSet.__iter__sDMM""r.c,t|jSr9)rrr+s r __bool__zHeaderSet.__bool__sDIIr.c"|jSr9)rr+s r __str__zHeaderSet.__str__s~~r.cLt|jd|jdSr%)r(r)rr+s r r*zHeaderSet.__repr__s%t*%%&a '8::r.rV)rzcabc.Iterable[str] | Nonerrr0r)rr1r0r)r,rerr1r0r)r,rerzcabc.Iterable[str]r0r)rr1r0ri)r,rer0rr)rrr0zset[str]r/)rr:r0r1)r,rerr:r0r)r,rerr:rr1r0r)rr1r0rrh)r0zcabc.Iterator[str])r0r)r)r2r3r4rorrrzrrrryrrrrrrercr}rrr*r5r.r rr#s .2;?#*#9#  #!* !  ! F"! !+# ;r.r)rcddl}|dk(r|jdtdtS|dk(r|jdtdtSt |)NrOrderedMultiDictrrrImmutableOrderedMultiDictzp'ImmutableOrderedMultiDict' is deprecated and will be removed in Werkzeug 3.2. Use 'ImmutableMultiDict' instead.)rrrrruAttributeError)namers r __getattr__rsj !!  -   !  **  ?   *)  r.)rrr0zcabc.Iterator[tuple[K, V]])rr1r0r)- __future__rcollections.abcabcrtypingrZr`rr _internalrmixinsr r r r TYPE_CHECKINGtyping_extensionsteTypeVarrrrr!rr#rvr7r]rGenericrrr?rlrqrur} MutableSetr1rrrr5r.r rs" &&+#??" AIIcN AIIcN AIIcN %  . ?&Q ?;ad;|"4QT":