.Ph dZddlmZmZmZddlmZ ddlmZedZ n#e $r e Z YnwxYwe d\Z ZZZZZgd ZGd d eZeZeZGd d eZe Ze ZGddeZe ZGddZddZGddeZ GddeZ!dS)a^Python has a very powerful mapping type at its core: the :class:`dict` type. While versatile and featureful, the :class:`dict` prioritizes simplicity and performance. As a result, it does not retain the order of item insertion [1]_, nor does it store multiple values per key. It is a fast, unordered 1:1 mapping. The :class:`OrderedMultiDict` contrasts to the built-in :class:`dict`, as a relatively maximalist, ordered 1:n subtype of :class:`dict`. Virtually every feature of :class:`dict` has been retooled to be intuitive in the face of this added complexity. Additional methods have been added, such as :class:`collections.Counter`-like functionality. A prime advantage of the :class:`OrderedMultiDict` (OMD) is its non-destructive nature. Data can be added to an :class:`OMD` without being rearranged or overwritten. The property can allow the developer to work more freely with the data, as well as make more assumptions about where input data will end up in the output, all without any extra work. One great example of this is the :meth:`OMD.inverted()` method, which returns a new OMD with the values as keys and the keys as values. All the data and the respective order is still represented in the inverted form, all from an operation which would be outright wrong and reckless with a built-in :class:`dict` or :class:`collections.OrderedDict`. The OMD has been performance tuned to be suitable for a wide range of usages, including as a basic unordered MultiDict. Special thanks to `Mark Williams`_ for all his help. .. [1] As of 2015, `basic dicts on PyPy are ordered `_, and as of December 2017, `basic dicts in CPython 3 are now ordered `_, as well. .. _Mark Williams: https://github.com/markrwilliams )KeysView ValuesView ItemsView) zip_longest) make_sentinel_MISSING)var_name) MultiDictOMDOrderedMultiDictOneToOne ManyToManysubdict FrozenDictceZdZdZfdZfdZdZdZdZdZ fdZ fd Z d0fd Z e ffd Zfd Ze ffd ZdZed0dZdZdZfdZfdZfdZdZdZdZe fdZe ffd Ze e ffd ZdZdZ d1dZ!d1d Z"d1d!Z#d1d"Z$d2d#Z%d2fd$ Z&d%Z'fd&Z(d1d'Z)d1d(Z*d1d)Z+d*Z,fd+Z-d,Z.d-Z/d.Z0d/Z1xZ2S)3ra A MultiDict is a dictionary that can have multiple values per key and the OrderedMultiDict (OMD) is a MultiDict that retains original insertion order. Common use cases include: * handling query strings parsed from URLs * inverting a dictionary to create a reverse index (values to keys) * stacking data from multiple dictionaries in a non-destructive way The OrderedMultiDict constructor is identical to the built-in :class:`dict`, and overall the API constitutes an intuitive superset of the built-in type: >>> omd = OrderedMultiDict() >>> omd['a'] = 1 >>> omd['b'] = 2 >>> omd.add('a', 3) >>> omd.get('a') 3 >>> omd.getlist('a') [1, 3] Some non-:class:`dict`-like behaviors also make an appearance, such as support for :func:`reversed`: >>> list(reversed(omd)) ['b', 'a'] Note that unlike some other MultiDicts, this OMD gives precedence to the most recent value added. ``omd['a']`` refers to ``3``, not ``1``. >>> omd OrderedMultiDict([('a', 1), ('b', 2), ('a', 3)]) >>> omd.poplast('a') 3 >>> omd OrderedMultiDict([('a', 1), ('b', 2)]) >>> omd.pop('a') 1 >>> omd OrderedMultiDict([('b', 2)]) If you want a safe-to-modify or flat dictionary, use :meth:`OrderedMultiDict.todict()`. >>> from pprint import pprint as pp # preserve printed ordering >>> omd = OrderedMultiDict([('a', 1), ('b', 2), ('a', 3)]) >>> pp(omd.todict()) {'a': 3, 'b': 2} >>> pp(omd.todict(multi=True)) {'a': [1, 3], 'b': [2]} With ``multi=False``, items appear with the keys in to original insertion order, alongside the most-recently inserted value for that key. >>> OrderedMultiDict([('a', 1), ('b', 2), ('a', 3)]).items(multi=False) [('a', 3), ('b', 2)] .. warning:: ``dict(omd)`` changed behavior `in Python 3.7 `_ due to changes made to support the transition from :class:`collections.OrderedDict` to the built-in dictionary being ordered. Before 3.7, the result would be a new dictionary, with values that were lists, similar to ``omd.todict(multi=True)`` (but only shallow-copy; the lists were direct references to OMD internal structures). From 3.7 onward, the values became singular, like ``omd.todict(multi=False)``. For reliable cross-version behavior, just use :meth:`~OrderedMultiDict.todict()`. crt|}||SN)super__new__ _clear_ll)clsakwret __class__s Q/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/boltons/dictutils.pyrzOrderedMultiDict.__new__s*ggooc""  c0t|dkr+t|jjdt|t |r||d|r||dSdS)Nrz" expected at most 1 argument, got r)len TypeErrorr__name__r__init__ update_extendupdate)selfargskwargsrs rr$zOrderedMultiDict.__init__s t99q==#~666D CDD D   (   tAw ' ' '  KK       rcHt|dS)NTmultilist iteritemsr's r __getstate__zOrderedMultiDict.__getstate__sDNNN..///rcX|||dSr)clearr%)r'states r __setstate__zOrderedMultiDict.__setstate__s)  5!!!!!rc |j}n #t$rix}|_g|_YnwxYw||j|jdg|jdd<dSr_mapAttributeErrorrootr3r'r8s rrzOrderedMultiDict._clear_llso 9DD   ! !D49DIII   49d3 !!!  ''c|j}|j|g}|t}||||g}|x|t<|t<||dSr)r:r8 setdefaultPREVNEXTappend)r'kvr:cellslastcells r_insertzOrderedMultiDict._insertsay $$Q++DzdAq!"&&T T$Z Trct|g}|||||dS)zaAdd a single value *v* under a key *k*. Existing values under *k* are preserved. N)rr>rGrA)r'rBrCvaluesrs raddzOrderedMultiDict.addsJ##Ar** Q arc|sdS|j}t|g}|D]}|||||dS)aAdd an iterable of values underneath a specific key, preserving any values already under that key. >>> omd = OrderedMultiDict([('a', -1)]) >>> omd.addlist('a', range(3)) >>> omd OrderedMultiDict([('a', -1), ('a', 0), ('a', 1), ('a', 2)]) Called ``addlist`` for consistency with :meth:`getlist`, but tuples and other sequences and iterables work. N)rGrr>extend)r'rBrC self_insertrIsubvrs raddlistzOrderedMultiDict.addlistsn  Fl ##Ar** ! !D K4  arNcVt||gdS)aReturn the value for key *k* if present in the dictionary, else *default*. If *default* is not given, ``None`` is returned. This method never raises a :exc:`KeyError`. To get all values under a key, use :meth:`OrderedMultiDict.getlist`. )rgetr'rBdefaultrs rrRzOrderedMultiDict.gets$ww{{1wi((,,rc t|ddS#t$r|turgcYS|cYSwxYw)zGet all values for key *k* as a list, if *k* is in the dictionary, else *default*. The list returned is a copy and can be safely mutated. If *default* is not given, an empty :class:`list` is returned. N)r __getitem__KeyErrorr rSs rgetlistzOrderedMultiDict.getlistsa  77&&q))!!!, ,   ("" NNN s(,AAAcpt|dS)zEmpty the dictionary.N)rr3r)r'rs rr3zOrderedMultiDict.clears*   rcvt|s|turdn|||<||S)zIf key *k* is in the dictionary, return its value. If not, insert *k* with a value of *default* and return *default*. *default* defaults to ``None``. See :meth:`dict.setdefault` for more information. N)r __contains__r rSs rr>zOrderedMultiDict.setdefaults? ww##A&& ?%11ddwDGAwrcT||dS)z(Return a shallow copy of the dictionary.Tr+rr/r0s rcopyzOrderedMultiDict.copy s"~~dnn4n88999rc2|fd|DS)zCreate a dictionary from a list of keys, with all the values set to *default*, or ``None`` if *default* is not set. cg|]}|fSra).0rBrTs r z-OrderedMultiDict.fromkeys..s///QQL///rra)rkeysrTs `rfromkeyszOrderedMultiDict.fromkeys s* s////$///000rc ||urdS|j}t|tr5|D] }||vr||= |dD]\}}|||nt t |ddr#|D] }||||<n?t}|j}|D]'\}}||vr||vr||=|||||(|D] }||||<dS)zAdd items from a dictionary or iterable (and/or keyword arguments), overwriting values under an existing key. See :meth:`dict.update` for more details. NTr+rd)rJ isinstancerr/callablegetattrrdset)r'EFself_addrBrCseenseen_adds rr&zOrderedMultiDict.updatesH 99 F8 a) * *   99Q $ //  1A  ga.. / / VVXX  A$Q 55DxH  1D==Q$YYQHQKKKA  AdDGGrc H|ur"t}n_ttrd}n3t dr!fdD}n}|j}|D]\}}|||dS)zAdd items from a dictionary, iterable, and/or keyword arguments without overwriting existing items present in the dictionary. Like :meth:`update`, but adds to existing keys instead of overwriting them. Tr+rdc3,K|]}||fVdSrra)rbrBrks r z1OrderedMultiDict.update_extend..=s+44aAaD 444444rN)iteritemsrgrr/hasattrrdrJ)r'rkrliteratorrmrBrCs ` rr%zOrderedMultiDict.update_extend2s 99AGGIIHH + , , {{{..HH Q   444416688444HHH8  DAq HQNNNN  rct|r|||||t||gdSr)rr[ _remove_allrG __setitem__)r'rBrCrs rryzOrderedMultiDict.__setitem__Esg 77   " "   Q    Q As#####rcRt|dS)NrQ)rrVr'rBrs rrVzOrderedMultiDict.__getitem__Ks ww""1%%b))rctt|||dSr)r __delitem__rxr{s rr}zOrderedMultiDict.__delitem__Ns5 A rcL||urdS t|t|krdSn#t$rYdSwxYwt|tr|d}|d}t ||d}|D]\\}}\}}||ks||krdSt |tturt |ttusdSdSt|dr,|D]'} ||||k#t$rYdSwxYwdSdS)NTFr+NN) fillvaluerd) r!r"rgrr/rnextr rurW) r'otherselfiotheri zipped_itemsselfkselfvotherkothervs r__eq__zOrderedMultiDict.__eq__Rs} 5==4 5zzSYY&&u'   55  e- . . NNN..E__4_00F&uf MMML4@ ! !0 0F??evoo 55'6x((H44FH--99u4 UF # #  ! !!%LDK///!!! 555!4us + 99=D DDc||k Srrar'rs r__ne__zOrderedMultiDict.__ne__osEM""rc0|||Sr)r&rs r__ior__zOrderedMultiDict.__ior__rs E rc ||dS#t$r|turt|YnwxYw|S)zRemove all values under key *k*, returning the most-recently inserted value. Raises :exc:`KeyError` if the key is not present and no *default* is provided. rQ)popallrWr )r'rBrTs rpopzOrderedMultiDict.popvs]  ";;q>>"% % " " "(""qkk!#" "s"AAct}||r|||tur||S|||S)zRemove all values under key *k*, returning them in the form of a list. Raises :exc:`KeyError` if the key is not present and no *default* is provided. )rr[rxr r)r'rBrT super_selfrs rrzOrderedMultiDict.popallsi WW  " "1 % %   Q    h  >>!$$ $~~a)))rc|turJ|r|jtt}n*|turt dt |z|S ||n*#t$r|turt ||cYSwxYwt|}| }|s!t ||S)aERemove and return the most-recently inserted value under the key *k*, or the most-recently inserted key if *k* is not provided. If no values remain under *k*, it will be removed from the OMD. Raises :exc:`KeyError` if *k* is not present in the dictionary, or the dictionary is empty. zempty %r) r r:r?KEYrWtype_removerrVrr})r'rBrTrIrCrs rpoplastzOrderedMultiDict.poplasts == IdOC(h&&":T #:;;;  LLOOOO   (""qkk!NNN $$Q'' JJLL # GG   " " "sA,,$BBc|j|}|}|t|tc|tt<|tt<|s |j|=dSdSrr8rr@r?r'rBrIrFs rrzOrderedMultiDict._removes_1zz||-1$Zd*T 4$t*T*  !   rc|j|}|rW|}|t|tc|tt<|tt<|W|j|=dSrrrs rrxzOrderedMultiDict._remove_allsc1 H::< NNN//  DAqGGGG  rc@|rfdDSfdDS)apGets a basic :class:`dict` of the items in this dictionary. Keys are the same as the OMD, values are the most recently inserted values for each key. Setting the *multi* arg to ``True`` is yields the same result as calling :class:`dict` on the OMD, except that all the value lists are copies that can be safely mutated. c<i|]}||Sra)rXrbrBr's r z+OrderedMultiDict.todict..s%5551At||A555rc"i|] }|| Srarars rrz+OrderedMultiDict.todict..s)))q47)))rrar'r,s` rtodictzOrderedMultiDict.todictsA  65555555 5))))D))))rcn|j}|t|d||S)aSimilar to the built-in :func:`sorted`, except this method returns a new :class:`OrderedMultiDict` sorted by the provided key function, optionally reversed. Args: key (callable): A callable to determine the sort key of each element. The callable should expect an **item** (key-value pair tuple). reverse (bool): Set to ``True`` to reverse the ordering. >>> omd = OrderedMultiDict(zip(range(3), range(3))) >>> omd.sorted(reverse=True) OrderedMultiDict([(2, 2), (1, 1), (0, 0)]) Note that the key function receives an **item** (key-value tuple), so the recommended signature looks like: >>> omd = OrderedMultiDict(zip('hello', 'world')) >>> omd.sorted(key=lambda i: i[1]) # i[0] is the key, i[1] is the val OrderedMultiDict([('o', 'd'), ('l', 'l'), ('e', 'o'), ('l', 'r'), ('h', 'w')]) Tr+rreverse)rsortedr/)r'rrrs rrzOrderedMultiDict.sorteds8,ns6$..t.44#wOOOPPPrc t}n0#t$r#t}YnwxYwfd|D}|}|dD]0}||||1|S)aHReturns a copy of the :class:`OrderedMultiDict` with the same keys in the same order as the original OMD, but the values within each keyspace have been sorted according to *key* and *reverse*. Args: key (callable): A single-argument callable to determine the sort key of each element. The callable should expect an **item** (key-value pair tuple). reverse (bool): Set to ``True`` to reverse the ordering. >>> omd = OrderedMultiDict() >>> omd.addlist('even', [6, 2]) >>> omd.addlist('odd', [1, 5]) >>> omd.add('even', 4) >>> omd.add('odd', 3) >>> somd = omd.sortedvalues() >>> somd.getlist('even') [2, 4, 6] >>> somd.keys(multi=True) == omd.keys(multi=True) True >>> omd == somd False >>> somd OrderedMultiDict([('even', 2), ('even', 4), ('odd', 1), ('odd', 3), ('even', 6), ('odd', 5)]) As demonstrated above, contents and key order are retained. Only value order changes. c>i|]\}}|t| S)r)r)rbrBrCrrs rrz1OrderedMultiDict.sortedvalues..-sF@@@#'1aVA3WFFF@@@rTr+)rr/r9rtrrrJr)r'rrsuperself_iteritemssorted_val_maprrBrs `` r sortedvalueszOrderedMultiDict.sortedvalues s< 2"'''"3"3"5"5   2 2 2"'''--//    2@@@@@+>@@@nnT** 0 0A GGA~a(,,.. / / / / s &*AAch|d|dDS)aReturns a new :class:`OrderedMultiDict` with values and keys swapped, like creating dictionary transposition or reverse index. Insertion order is retained and all keys and values are represented in the output. >>> omd = OMD([(0, 2), (1, 2)]) >>> omd.inverted().getlist(2) [0, 1] Inverting twice yields a copy of the original: >>> omd.inverted().inverted() OrderedMultiDict([(0, 2), (1, 2)]) c3$K|] \}}||fV dSrrarbrBrCs rrrz,OrderedMultiDict.inverted..Cs*LLAq!fLLLLLLrTr+r]r0s rinvertedzOrderedMultiDict.inverted4s3~~LLd1K1KLLLLLLrcntj|fd|DS)zReturns a mapping from key to number of values inserted under that key. Like :py:class:`collections.Counter`, but returns a new :class:`OrderedMultiDict`. c3LK|]}|t|fVdSrr!)rbrB super_getitems rrrz*OrderedMultiDict.counts..Ms:GGQq#mmA&6&6"7"78GGGGGGr)rrVr)r'rrs @rcountszOrderedMultiDict.countsEs9+ ~~GGGG$GGGGGGrcHt||S)ztReturns a list containing the output of :meth:`iterkeys`. See that method's docs for more details. r+)r.rrs rrdzOrderedMultiDict.keysOs DMMM..///rcHt||S)zvReturns a list containing the output of :meth:`itervalues`. See that method's docs for more details. r+)r.rrs rrIzOrderedMultiDict.valuesUs DOO%O00111rcHt||S)zuReturns a list containing the output of :meth:`iteritems`. See that method's docs for more details. r+r-rs rrtzOrderedMultiDict.items[s DNNN//000rc*|Sr)rr0s r__iter__zOrderedMultiDict.__iter__as}}rc#,K|j}|t}i}|j}tj}||ur\|t }||}||dt |kr|V||xxdz cc<|t}||uZdSdS)Nr)r:r?r>rrVrr!) r'r:rlengths lengths_sd get_valuesrBvalsrs r __reversed__zOrderedMultiDict.__reversed__dsyDz' WW( $S A:a==Dz!Q3t99,, AJJJ!OJJJ:D $rc|jj}dd|dD}|d|dS)Nz, c6g|]\}}t||fSra)reprrs rrcz-OrderedMultiDict.__repr__..ts&MMM$!Qq!fMMMrTr+z([z]))rr#joinr/)r'cnkvss r__repr__zOrderedMultiDict.__repr__rsQ ^ $iiMM$..t.2L2LMMMNNrc t|S)zBOMD.viewkeys() -> a set-like object providing a view on OMD's keys)rr0s rviewkeyszOrderedMultiDict.viewkeysws~~rc t|S)z>OMD.viewvalues() -> an object providing a view on OMD's values)rr0s r viewvalueszOrderedMultiDict.viewvalues{s$rc t|S)zDOMD.viewitems() -> a set-like object providing a view on OMD's items)rr0s r viewitemszOrderedMultiDict.viewitemssrrF)NF)3r# __module__ __qualname____doc__rr$r1r5rrGrJrOrRr rXr3r>r^ classmethodrer&r%ryrVr}rrrrrrrrxr/rrrrrrrrdrIrtrrrrrr __classcell__rs@rrrVsHHR      000"""444(------"*       %-:::111[1 <&$$$$$ *****:###&    !) * * * * * *!(4 % % % %"""", * * * *QQQQ2((((((TMMM"HHHHH0000 2222 1111            rrc@eZdZdZdZdZdZdZd dZd dZ d Z d S) FastIterOrderedMultiDictzAn OrderedMultiDict backed by a skip list. Iteration over keys is faster and uses constant memory but adding duplicate key-value pairs is slower. Brainchild of Mark Williams. c |j}n #t$rix}|_g|_YnwxYw||j|jdd|j|jg|jdd<dSrr7r;s rrz"FastIterOrderedMultiDict._clear_lls} 9DD   ! !D49DIII   49d 49. !!! r<c8|j}g}|j||}|t}||urv||||||g}|tt |ur||tt <|x|t <x|t <x|t<|t<||dS|tt |ur |tn|}||||||g}||t <|x|t <x|t<|t<||dSr)r:r8r>r?SPREVSNEXTr@rA) r'rBrCr:emptyrDrErFsprevs rrGz FastIterOrderedMultiDict._inserts#y $$Q..Dz E>>$q$ DE{5!T))%)U E"BF FDJ Fe FtDzDK LL     %)K$6d$B$BDKKE$q4!DDK48 8DJ 8dd5k LL     rcv|j|}|}|s(|j|=|t|tt<|ttt|ur,|t |ttt<n[|t|t urA|t|tc|tt<|tt<|t |tc|tt <|t t<dSr)r8rrr?rr@r'rBrDrFs rrz FastIterOrderedMultiDict._removes ! yy{{ , ! $U DJu  :e U #t + +'+DzDJu e $ $ %[DJ & &59%[$u+ 2DK U E 2-1$Zd*T 4$t*T***rc|j|}|r|}|ttt|ur,|t |ttt<n[|t|t urA|t|tc|tt<|tt<|t |tc|tt <|t t<||t|tt<dSr)r8rr?rrr@rs rrxz$FastIterOrderedMultiDict._remove_alls a   H99;;DDz% '4//+/:T 5!%((eT **9=ed5k6U E"DK$615dT$Z .DJt d4j. H!KT 5rFc#K|rtnt}|j}||}||ur*|t|tfV||}||u(dSdSr)r@rr:rrr'r, next_linkr:rs rr/z"FastIterOrderedMultiDict.iteritemssj!,DDu yI$s)T%[( ( ( ( ?D$rc#K|rtnt}|j}||}||ur|tV||}||udSdSr)r@rr:rrs rrz!FastIterOrderedMultiDict.iterkeyss^!,DDu yI$s)OOO ?D$rc#K|j}|t}||urO|tt|ur|t}||urdS|tV|t}||uMdSdSr)r:r?rrr)r'r:rs rrz%FastIterOrderedMultiDict.__reversed__s{yDz$E{5!--E{4<<Es)OOO:D $rNr) r#rrrrrGrrxr/rrrarrrrs . . .6 D D D ( ( (########     rrcneZdZdZdZdZedZdZdZ dZ dZ e fd Z d Zdd Zd ZdZd S)raImplements a one-to-one mapping dictionary. In addition to inheriting from and behaving exactly like the builtin :class:`dict`, all values are automatically added as keys on a reverse mapping, available as the `inv` attribute. This arrangement keeps key and value namespaces distinct. Basic operations are intuitive: >>> oto = OneToOne({'a': 1, 'b': 2}) >>> print(oto['a']) 1 >>> print(oto.inv[1]) a >>> len(oto) 2 Overwrites happens in both directions: >>> oto.inv[1] = 'c' >>> print(oto.get('a')) None >>> len(oto) 2 For a very similar project, with even more one-to-one functionality, check out `bidict `_. )invcJd}|ru|dturK|d|_t|d|jDdS|dt ur |ddd}}tj|g|Ri||t||_t|t|jkrdS|sXt|t |d|jDdSi}|D].\}}| |g |/d|D}td|z) NFrrcg|] \}}||f Srarars rrcz%OneToOne.__init__..s $I$I$I1aV$I$I$IrTcg|] \}}||f Srarars rrcz%OneToOne.__init__.. s CCC$!Q1vCCCrc@i|]\}}t|dk||S)rr)rbrCk_lists rrz%OneToOne.__init__..)s7@@@yq&/26{{QF/>rzFexpected unique values, got multiple keys for the following values: %r) _OTO_INV_MARKERrdictr$rt_OTO_UNIQUE_MARKERrr!r3r&r>rA ValueError)r'rr raise_on_dupe val_multidictrBrCdupess rr$zOneToOne.__init__ s  /t&&Q4 d$I$I8H8H$I$I$IJJJ1+++#$QRR5$= d%Q%%%"%%%>>/488 t99DH % % F  JJt    KKCC$(..2B2BCCC D D D F JJLL 6 6DAq  $ $Q + + 2 21 5 5 5 5@@#))++@@@57<=>> >rc$|tg|Ri|S)a>This alternate constructor for OneToOne will raise an exception when input values overlap. For instance: >>> OneToOne.unique({'a': 1, 'b': 1}) Traceback (most recent call last): ... ValueError: expected unique values, got multiple keys for the following values: ... This even works across inputs: >>> a_dict = {'a': 2} >>> OneToOne.unique(a_dict, b=2) Traceback (most recent call last): ... ValueError: expected unique values, got multiple keys for the following values: ... )r)rrrs runiquezOneToOne.unique/s%$s%0000R000rct|||vr&t|j||||jvr|j|=t|||t|j||dSr)hashrr}rryr'rvals rryzOneToOne.__setitem__Cs~ S $;;   TXtCy 1 1 1 $(??  sC((( 3,,,,,rct|j||t||dSr)rr}rr'rs rr}zOneToOne.__delitem__Ls: 49--- s#####rcxt|t|jdSr)rr3rr0s rr3zOneToOne.clearPs. 4 48rc,||Srrr0s rr^z OneToOne.copyTs~~d###rc||vrAt|j||t||S|tur|St r)rr}rrr rWr'rrTs rrz OneToOne.popWsU $;;   TXtCy 1 1 188D#&& & ( " "Njjrct|\}}t|j|||fSr)rpopitemr}rrs rr zOneToOne.popitem_s8<<%%S 3'''CxrNc$||vr|||<||Srrar s rr>zOneToOne.setdefaultds d??DICyrc g}t|trH|D]2}t|t |}3n5|D]2\}}t|t|t |}3|D]}t||||D] \}}|||< dSr)rgrrIrr.rtrL)r'dict_or_iterabler keys_valsrrs rr&zOneToOne.updateis & - - 3'..00 ; ;S  !1!7!7!9!9::  ;- 3 3SS S  !122 99;;  C IIII$$$!  HCDII  rc^|jj}t|}|d|dSN()rr#rr)r'r dict_reprs rrzOneToOne.__repr__zs4 ^ $MM$'' ##y####rr)r#rrr __slots__r$rrryr}r3r^r rr r>r&rrarrrrs6I > > >D11[1&---$$$$$$ (  "$$$$$rrceZdZdZddZefdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdS)ra3 a dict-like entity that represents a many-to-many relationship between two groups of objects behaves like a dict-of-tuples; also has .inv which is kept up to date which is a dict-of-tuples in the other direction also, can be used as a directed graph among hashable python objects Nci|_t|tur|r|dtur|d|_n8|t|f|_|r||dS)Nrr)datartuple_PAIRINGrrr&)r'rts rr$zManyToMany.__init__sq ;;%  E eAh(.B.BQxDHH~~x&677DH # E"""rc8 ||S#t$r|cYSwxYwr)rWr s rrRzManyToMany.gets5 9    NNN s  c6t|j|Sr) frozensetrrs rrVzManyToMany.__getitem__s3(((rct|}||vr;|j||z }||j|z}|D]}||||D]}|||dSr)rjrremoverJ)r'rr to_removers rryzManyToMany.__setitem__s4yy $;; #-I DIcN "D  & & C%%%%  C HHS#      rc|j|D]F}|jj|||jj|s |jj|=GdSr)rrrr rs rr}zManyToMany.__delitem__sd9==%% ' 'C HM#  % %c * * *8=% 'HM#& ' 'rct|t|ur|}|jD]L}||jvr|j||j|<!|j||j|M|jjD]e}||jjvr |jj||jj|<0|jj||jj|fnpt t |ddr4|D]}||||n|D]\}}|||dS)z-given an iterable of (key, val), add them allrdN)rrr&rrhrirdrJ)r'iterablerrBrrs rr&zManyToMany.updatesb >>T$ZZ ' 'EZ 7 7DI%%#(:a=DIaLLIaL'' 1 6666Y^ ? ?DHM))',y~a'8DHM!$$HM!$++EIN1,=>>>>  ? gh55 6 6 #]]__ ) )HQK(((( )% # #Sc""""rc ||jvrt|j|<|j||||jjvrt|jj|<|jj||dSr)rrjrJrrs rrJzManyToMany.adds| di   UUDIcN #3 dhm # #!$DHM#   cs#####rc|j|||j|s|j|=|jj|||jj|s|jj|=dSdSr)rr rrs rr zManyToMany.removes} #c"""y~  #  c!!#&&&x}S! # c""" # #rc||jvrdS|j|x|j|<}|D]>}|jj|}||||?dS)z4 replace instances of key by newkey N)rrrr rJ)r'rnewkeyfwdsetrrevsets rreplacezManyToMany.replaces di   F%)Y]]3%7%77 &F  CX]3'F MM#    JJv      rc#JK|jD]}|j|D]}||fV dSrrrs rr/zManyToMany.iteritemssJ9  Cy~  3h   rc4|jSr)rrdr0s rrdzManyToMany.keyssy~~rc||jvSrr-rs rr[zManyToMany.__contains__sdirc4|jSr)rrr0s rrzManyToMany.__iter__sy!!###rc4|jSr)r__len__r0s rr2zManyToMany.__len__sy  """rcbt|t|ko|j|jkSr)rrrs rrzManyToMany.__eq__s'DzzT%[[(DTY%*-DDrch|jj}|dt|dSr)rr#r.r/r'rs rrzManyToMany.__repr__s5 ^ $22tDNN,,--2222rr)r#rrrr$rrRrVryr}r&rJr r+r/rdr[rr2rrrarrrrs& )y{{ )))''' ,$$$###          $$$###EEE33333rrNc||}|g}t|t|z t|fd|DS)aCompute the "subdictionary" of a dict, *d*. A subdict is to a dict what a subset is a to set. If *A* is a subdict of *B*, that means that all keys of *A* are present in *B*. Returns a new dict with any keys in *drop* removed, and any keys in *keep* still present, provided they were in the original dict. *keep* defaults to all keys, *drop* defaults to empty, so without one of these arguments, calling this function is equivalent to calling ``dict()``. >>> from pprint import pprint as pp >>> pp(subdict({'a': 1, 'b': 2})) {'a': 1, 'b': 2} >>> subdict({'a': 1, 'b': 2, 'c': 3}, drop=['b', 'c']) {'a': 1} >>> pp(subdict({'a': 1, 'b': 2, 'c': 3}, keep=['a', 'c'])) {'a': 1, 'c': 3} Nc&g|] \}}|v ||fSrara)rbrBrCrds rrczsubdict..s&>>>tq!AIIQFIIIr)rdrjrrt)dkeepdroprds @rrrsj, |vvxx | t99s4yy D 477>>>>qwwyy>>> ? ??rceZdZdS)FrozenHashErrorN)r#rrrarrr<r<sDrr<cteZdZdZdZdZed dZdZdZ dZ d Z d Z e xZ xZxZZe xZxZxZZ[ dS) raAn immutable dict subtype that is hashable and can itself be used as a :class:`dict` key or :class:`set` entry. What :class:`frozenset` is to :class:`set`, FrozenDict is to :class:`dict`. There was once an attempt to introduce such a type to the standard library, but it was rejected: `PEP 416 `_. Because FrozenDict is a :class:`dict` subtype, it automatically works everywhere a dict would, including JSON serialization. )_hashcjt|}|j|i|t||S)zMake a copy and add items from a dictionary or iterable (and/or keyword arguments), overwriting values under an existing key. See :meth:`dict.update` for more details. )rr&r)r'rrrs rupdatedzFrozenDict.updated/s< Dzz Q"tDzz$rNcJ|t||Sr)rre)rrdvalues rrezFrozenDict.fromkeys8s"s4==u--...rcZ|jj}|dt|dSrrr5s rrzFrozenDict.__repr__=s/ ^ $--t}}T**----rc@t|t|ffSr)rr)r'protocols r __reduce_ex__zFrozenDict.__reduce_ex__AsDzzDJJ=((rc  |j}nt#t$rg tt|x}|_n-#t $r }t |x}|_Yd}~nd}~wwxYwYnwxYw|jt ur||Sr)r>r9rrrt Exceptionr<r)r'res r__hash__zFrozenDict.__hash__Ds 6*CC 6 6 6 6#' $**,,(?(?#@#@@djj 6 6 6#21#5#55djjjjjj 6 6 =O + +I s8 A;5A  A; A5A0+A;0A55A;:A;c|Srrar0s r__copy__zFrozenDict.__copy__Rs rc:td|jjz)z5raises a TypeError, because FrozenDicts are immutablez%s object is immutable)r"rr#)r'rrs r_raise_frozen_typeerrorz"FrozenDict._raise_frozen_typeerrorVs04>3JJKKKrr)r#rrrrr@rrerrFrJrLrNrryr}r&r>rr r3rarrrr s  I   ///[/...)))   LLL4KJGJkJK&)@@J@@wrrr)"rcollections.abcrrr itertoolsr typeutilsrr ImportErrorobjectranger?r@rrrr__all__rrr r rrrrrrrr"r<rrarrrVs5>%%N<;;;;;;;;;!!!!!!((((((}j111HHvxxHHH(-uQxx$dCu f e ekkkkktkkk^  _____/___D&((VXXN$N$N$N$N$tN$N$N$d 688u3u3u3u3u3u3u3u3p@@@@@     i   = = = = = = = = = = s '99