ViSrSSKJrJrJr SSKrSSKJr SSK J r \ "SS9r \"S 5urrrrrr/S Qr\ "S S \5r\r\r"SS\5r\ "5r\ "5r"SS\5r\ "5r "SS\ 5r!SSjr""SS\#5r$"SS\5r%g!\a SSKJrJrJr Nf=f!\a SSKJ r Nf=f!\a \ "5r Nf=f!\a S rNf=f)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 ItemsViewN) izip_longest) zip_longest) make_sentinel_MISSING)var_name) MultiDictOMDOrderedMultiDictOneToOne ManyToManysubdict FrozenDictcU$N)xs d/home/james-whalen/.local/share/pipx/venvs/semgrep/lib/python3.13/site-packages/boltons/dictutils.pyrcsc^\rSrSrSrU4SjrSrSrU4SjrU4Sjr S,U4Sjjr \ 4U4S jjr U4S jr \ 4U4S jjrS r\S,S j5rSrSrU4SjrU4SjrU4SjrSrSr\ 4Sjr\ 4U4Sjjr\ \ 4U4SjjrSrSrS-SjrS-SjrS-Sjr S-Sjr!S.Sjr"S.U4Sjjr#S r$U4S!jr%S-S"jr&S-S#jr'S-S$jr(S%r)U4S&jr*S'r+S(r,S)r-S*r.S+r/U=r0$)/rfaA 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()`. c.>[U5S:a/[URR<S[U5<35e[[ U]5 UR5 U(aURUS5 U(aURU5 gg)Nz" expected at most 1 argument, got r) len TypeError __class____name__superr__init__ _clear_ll update_extendupdate)selfargskwargsr s rr#OrderedMultiDict.__init__sw t9q=#~~66D CD D .0     tAw '  KK  rcURnUR5 URURS/URSS&g![a 0=ol/UlNRf=fr_mapAttributeErrorrootclearr'r-s rr$OrderedMultiDict._clear_llsY 99D  499d3 !  ! !D9DI s AA! A!cURnURRU/5nU[nXSX/nU=U['U['UR U5 gr)r/r- setdefaultPREVNEXTappend)r'kvr/cellslastcells r_insertOrderedMultiDict._insertsRyy $$Q+DzA!"&&T T$Z Trcr>[[U] U/5nURX5 UR U5 g)zQAdd a single value *v* under a key *k*. Existing values under *k* are preserved. N)r"rr4r=r7)r'r8r9valuesr s raddOrderedMultiDict.adds1'9!R@ Q arc>U(dgURn[[U]U/5nUH nU"X5 M UR U5 g)a\Add 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)r=r"rr4extend)r'r8r9 self_insertr@subvr s raddlistOrderedMultiDict.addlistsF ll '9!R@D   arc2>[[U] X/5S$)zReturn 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`. )r"rgetr'r8defaultr s rrKOrderedMultiDict.gets%t0I>rBBrcp>[[U] U5SS$![a U[La/s$Us$f=f)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"r __getitem__KeyErrorr rLs rgetlistOrderedMultiDict.getlistsA  )4[[U] 5 UR5 g)zEmpty the dictionary.N)r"rr0r$)r'r s rr0OrderedMultiDict.clears +- rcZ>[[U] U5(dU[LaSOUX'X$)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"r __contains__r rLs rr4OrderedMultiDict.setdefaults/ %t9!<<%1dwDGwrc>URURSS95$)z(Return a shallow copy of the dictionary.Tmultir iteritemsr's rcopyOrderedMultiDict.copys~~dnn4n899rc@U"UVs/sHo3U4PM sn5$s snf)ztCreate a dictionary from a list of keys, with all the values set to *default*, or ``None`` if *default* is not set. r)clskeysrMr8s rfromkeysOrderedMultiDict.fromkeyss# $/$QL$/00/s c XLagURn[U[5(a3UH nX@;dM X M URSS9H upEU"XE5 M Ov[ [ USS55(aUR 5H nXX'M O=[5nURnUH!upEXF;aX@;a X U"U5 U"XE5 M# UH nX$X'M g)zAdd items from a dictionary or iterable (and/or keyword arguments), overwriting values under an existing key. See :meth:`dict.update` for more details. NTrZrc)rA isinstancerr]callablegetattrrcset)r'EFself_addr8r9seenseen_adds rr&OrderedMultiDict.updates 9 88 a) * *9 $ /0 ga. / /VVX$5DxxH=QYQK  AdDGrc (^TULa[TR55nOS[T[5(aTR SS9nO.[ TS5(aU4SjTR 55nOTnURnUH upVU"XV5 M g)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. TrZrcc30># UH oTU4v M g7frr).0r8rks r 1OrderedMultiDict.update_extend..Bs48aAaD 8sN)iteritemsrgrr]hasattrrcrA)r'rkrliteratorrmr8r9s ` rr%OrderedMultiDict.update_extend7sw 9AGGIH + , ,{{{.H Q  416684HH88DA QNrc>[[U] U5(aURU5 UR X5 [[U]X/5 gr)r"rrW _remove_allr= __setitem__)r'r8r9r s rr}OrderedMultiDict.__setitem__JsB !4 5a 8 8   Q  Q 1!S9rc0>[[U] U5S$)NrJ)r"rrPr'r8r s rrPOrderedMultiDict.__getitem__Ps%t8;B??rcN>[[U] U5 URU5 gr)r"r __delitem__r|rs rrOrderedMultiDict.__delitem__Ss! 1!4 rcXLag[U5[U5:wag[U[5(atUR SS9nUR SS9n[ X#SS9nUHuupVupxXW:wdXh:wdM g [ U[5[La[ U[5[Ldgg[US5(aUH nXX:H M gg![a gf=f![a  gf=f)NTFrZNN) fillvaluerc) rrrgrr]rnextr rxrQ) r'otherselfiotheri zipped_itemsselfkselfvotherkothervs r__eq__OrderedMultiDict.__eq__Ws = 5zSY&' e- . .NNN.E__4_0F'NL4@0 0?eo 5Ax(H4FH-9 UF # #!LDK/ +  $ ! !s#C C  CC C.-C.c X:X+$rrr'rs r__ne__OrderedMultiDict.__ne__ts ""rcvURU5S$![a U[La [U5eU$f=f)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. rJ)popallrQr )r'r8rMs rpopOrderedMultiDict.popwsE  ";;q>"% % "("qk!# "s 88c>[[U5nURU5(aURU5 U[LaUR U5$UR X5$)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. )r"rrWr|r r)r'r8rM super_selfr s rrOrderedMultiDict.popallsW +T2  " "1 % %   Q  h >>!$ $~~a))rc>U[LaDU(aUR[[nO"U[La[ S[ U5-5eU$UR U5 [[U]'U5nUR5nU(d[[U]/U5 U$![a U[La [ U5eUs$f=f)aRemove 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/r5KEYrQtype_remover"rrPrr)r'r8rMr@r9r s rpoplastOrderedMultiDict.poplasts =IIdOC(h&":T #:;;  LLO ':1= JJL "D 5a 8 ("qk!N sB CCcURUnUR5nU[U[sU[['U[['U(dURU ggrr-rr6r5r'r8r@r<s rrOrderedMultiDict._removesS1zz|-1$Zd*T 4$t*T* ! rcURUnU(aHUR5nU[U[sU[['U[['U(aMHURU grrrs rr|OrderedMultiDict._remove_allsW1::>> 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')]) TrZrreverse)r sortedr])r'rrrbs rrOrderedMultiDict.sorteds*,nn6$..t.4#OPPrc l>[[U] 5n[ UVVs/sHupEU[ XQU(+S94PM snn5nUR5nURSS9H%nURXFUR55 M' U$![a [[U]5nNf=fs snnf)aReturns 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. rTrZ) r"rr]r.rwrrr rrAr) r'rrsuperself_iteritemsr8r9sorted_val_mapretr s r sortedvaluesOrderedMultiDict.sortedvalues s< H"'(8$"I"K +>@+>41!"6!7{#LM+>@AnnT*A GGAa(,,. /+  H"'(8$"E"G  H@sBB0 B-,B-cLURSURSS955$)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,# UH upX!4v M g7frr)rsr8r9s rrt,OrderedMultiDict.inverted..DsL1Kqf1KsTrZr\r^s rinvertedOrderedMultiDict.inverted5s$~~Ld1KLLLrcX>^[[U] mURU4SjU55$)zReturns a mapping from key to number of values inserted under that key. Like :py:class:`collections.Counter`, but returns a new :class:`OrderedMultiDict`. c3H># UHo[T"U554v M g7fr)r)rsr8 super_getitems rrt*OrderedMultiDict.counts..NsG$Q#mA&6"78$s")r"rrPr )r'rr s @rcountsOrderedMultiDict.countsFs'.A ~~G$GGGrc2[URUS95$)zdReturns a list containing the output of :meth:`iterkeys`. See that method's docs for more details. rZ)listrr'r[s rrcOrderedMultiDict.keysPsDMMM.//rc2[URUS95$)zfReturns a list containing the output of :meth:`itervalues`. See that method's docs for more details. rZ)rrrs rr@OrderedMultiDict.valuesVsDOO%O011rc2[URUS95$)zeReturns a list containing the output of :meth:`iteritems`. See that method's docs for more details. rZ)rr]rs rrwOrderedMultiDict.items\sDNNN/00rc"UR5$r)rr^s r__iter__OrderedMultiDict.__iter__bs}}rc#># URnU[n0nURn[[U]nX!LaGU[ nU"U5nU"US5[U5:XaUv X6==S- ss'U[nX!LaMFgg7f)Nr)r/r5r4r"rrPrr) r'r/rlengths lengths_sd get_valuesr8valsr s r __reversed__OrderedMultiDict.__reversed__esyyDz'' +T> S Aa=D!Q3t9, J!OJ:D s A:B?Bc URRnSRURSS9VVs/sHup#[ X#45PM snn5nU<SU<S3$s snnf)Nz, TrZz([z]))r r!joinr]repr)r'cnr8r9kvss r__repr__OrderedMultiDict.__repr__ssT ^^ $ $ii$..t.2LM2L$!qf2LMN%%NsA c[U5$)zBOMD.viewkeys() -> a set-like object providing a view on OMD's keys)rr^s rviewkeysOrderedMultiDict.viewkeysxs ~rc[U5$)z>OMD.viewvalues() -> an object providing a view on OMD's values)rr^s r viewvaluesOrderedMultiDict.viewvalues|s $rc[U5$)zDOMD.viewitems() -> a set-like object providing a view on OMD's items)rr^s r viewitemsOrderedMultiDict.viewitemss rr-r/rF)NF)1r! __module__ __qualname____firstlineno____doc__r#r$r=rArGrKr rRr0r4r_ classmethodrdr&r%r}rPrrrrrrrr|r]rrrrrrrrcr@rwrrrrrr__static_attributes__ __classcell__r s@rrrfsHR  4(C"*  %-:11 <&: @:#& !) *!(4 %", 2Q2(TM"H0 2 1  &  rrcJ\rSrSrSrSrSrSrSrS Sjr S Sjr S r S r g ) FastIterOrderedMultiDictizAn 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. cURnUR5 URURSSURUR/URSS&g![a 0=ol/UlNif=frr,r1s rr$"FastIterOrderedMultiDict._clear_llsk 99D  499d 499. !  ! !D9DI s AA87A8cURn/nURRX5nU[nXTLa]XcXXc/nU[[ ULaXv[[ 'U=U[ '=U[ '=U['U['URU5 gU[[ ULa U[OUnXcXX/nX6[ 'U=U[ '=U['U['URU5 gr)r/r-r4r5SPREVSNEXTr6r7) r'r8r9r/emptyr:r;r<sprevs rr= FastIterOrderedMultiDict._insertsyy $$Q.Dz > DE{5!T)%)U E"BF FDJ Fe FtDzDK LL %)K$6d$BDKE!DK48 8DJ 8dd5k LL rcURUnUR5nU(d$URU U[U[['U[[[ULaU[ U[[['OBU[U[ La/U[U[sU[['U[['U[ U[sU[[ 'U[ ['gr)r-rrr5rr6r'r8r:r<s rr FastIterOrderedMultiDict._removes ! yy{ ! $U DJu  :e U #t +'+DzDJu e $ %[DJ &59%[$u+ 2DK U E 2-1$Zd*T 4$t*T*rcURRU5nU(aUR5nU[[[ULaU[ U[[['OBU[U[ La/U[U[sU[['U[['U[ U[sU[[ 'U[ ['U(aMW[U[['gr)r-rr5rrr6rs rr|$FastIterOrderedMultiDict._remove_alls a 99;DDz% '4/+/:T 5!%(eT *9=ed5k6U E"DK$615dT$Z .DJt d4j.e!KT 5rc## U(a[O[nURnX2nXCLaU[U[4v XBnXCLaMgg7fr)r6rr/rrr'r[ next_linkr/rs rr]"FastIterOrderedMultiDict.iteritemssF!Du yys)T%[( (?Ds AA A c## U(a[O[nURnX2nXCLaU[v XBnXCLaMgg7fr)r6rr/rr s rr!FastIterOrderedMultiDict.iterkeyss<!Du yys)O?Ds ;AAc## URnU[nX!La<U[[ULaU[nX!LagU[v U[nX!LaM;gg7fr)r/r5rrr)r'r/rs rr%FastIterOrderedMultiDict.__reversed__sYyyDzE{5!-E{<s)O:D s AAArNr) r!rrrrr$r=rr|r]rrrrrrrrs+ .6 D (## rrcr\rSrSrSrSrSr\S5rSr Sr Sr S r \ 4S jrS rSS jrSrSrSrg )riaImplements 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 `_. )invc SnU(alUS[LaNUSUl[RXRR 5VVs/sHupEXT4PM snn5 gUS[ LaUSSSp1[R"U/UQ70UD6 UR [U5Ul[U5[UR5:XagU(dY[RU5 [RXRR 5VVs/sHupEXT4PM snn5 g0nUR 5H&upEURU/5RU5 M( [UR 5VVs/sHupW[U5S:dMXW4PM snn5n[SU-5es snnfs snnfs snnf)NFrrTzFexpected unique values, got multiple keys for the following values: %r) _OTO_INV_MARKERrrr#rw_OTO_UNIQUE_MARKERr rr0r&r4r7 ValueError) r'akw raise_on_duper8r9 val_multidictk_listdupess rr#OneToOne.__init__s t&Q4 d8H$I8HaV8H$IJ1++#$QR5$= d%Q%"%>>/48 t9DHH %  JJt  KK((..2BC2B$!v2BC D  JJLDA  $ $Q + 2 21 5!#))+@+'0a/26{Q"qk+@A57<=> >5%JD@s F8 F> G G c"U"[/UQ70UD6$)aThis 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)rbrrs runiqueOneToOne.unique0s$%00R00rc [U5 X;a"[RURX5 X R;a URU [R XU5 [R URX!5 gr)hashrrrr}r'rvals rr}OneToOne.__setitem__Ds\ S ;   TXXty 1 ((?  C( 3,rcr[RURX5 [RX5 gr)rrrr'rs rrOneToOne.__delitem__Ms& 49- #rcl[RU5 [RUR5 gr)rr0rr^s rr0OneToOne.clearQs 4 488rc$URU5$rrr^s rr_ OneToOne.copyUs~~d##rcX;a7[RURX5 [RX5$U[LaU$[ 5er)rrrrr rQr'rrMs rr OneToOne.popXsA ;   TXXty 188D& & ( "Njrcv[RU5up[RURU5 X4$r)rpopitemrrr&s rr4OneToOne.popitem`s-<<% 3'xrNcX;aX U'X$rrr1s rr4OneToOne.setdefaultes ?Iyrc [U[5(a<UR5H'n[U5 [ UR 55nM) O,UH&upS[U5 [U5 [ U5nM( UR5Hn[U5 M WR UR 55 UH upSX0U'M gr)rgrr@r%rrwrD)r'dict_or_iterablerr' keys_valsrs rr&OneToOne.updatejs & - -'..0S  !1!7!7!9: 1-S S  !12 -99;C I$!HCI"rclURRn[RU5nU<SU<S3$N()r r!rr)r'r dict_reprs rrOneToOne.__repr__zs* ^^ $ $MM$' y))rr)r!rrrr __slots__r#rr"r}rr0r_r rr4r4r&rrrrrrrsZ6I >D11&-$$ (   *rrc\rSrSrSrSSjr\"54SjrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrg)ria 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 Nc0Ul[U5[LaU(aUS[La USUlgUR [U45UlU(aUR U5 g)Nrr)datartuple_PAIRINGrr r&)r'rws rr#ManyToMany.__init__s[ ;% EeAh(.BQxDH ~~x&67DH E"rc0X$![a Us$f=fr)rQr1s rrKManyToMany.gets# 9  N s  c2[URU5$r) frozensetrFr*s rrPManyToMany.__getitem__s3((rc[U5nX;a=URUU- nX RU-nUHnURX5 M UHnURX5 M gr)rjrFremoverA)r'rr to_remover's rr}ManyToMany.__setitem__s^4y ; #-I IIcN "D  C%!C HHS rcURRU5HbnURRURU5 URRU(aMKURRU Md gr)rFrrrPr&s rrManyToMany.__delitem__sW99==%C HHMM#  % %c *88==%%HHMM#&&rc$[U5[U5LGaUnURH[nX0R;aURUURU'M0URURURU5 M] URRHnX0RR;a2URRUURRU'MNURRURURRU5 M g[ [ USS55(a,UR 5HnURX1U5 M gUHupEURXE5 M g)z-given an iterable of (key, val), add them allrcN)rrFr&rrhrircrA)r'iterablerr8rr's rr&ManyToMany.updates( >T$Z 'EZZII%#(::a=DIIaLIIaL'' 1 6  YY^^HHMM)',yy~~a'8DHHMM!$HHMM!$++EIINN1,=> $  gh5 6 6]]_QK(% %"%rcPXR;a[5URU'URURU5 X RR;a![5URRU'URRURU5 gr)rFrjrArr&s rrAManyToMany.addsn ii  UDIIcN #3 hhmm #!$DHHMM#   cs#rc>URURU5 URU(d URU URRURU5 URRU(dURRU ggr)rFrPrr&s rrPManyToMany.removesn #c"yy~ #  c!!#&xx}}S! c""rcXR;agURRU5=URU'nUH>nURRUnURU5 UR U5 M@ g)z$ replace instances of key by newkey N)rFrrrPrA)r'rnewkeyfwdsetr'revsets rreplaceManyToMany.replacese ii  %)YY]]3%77 &FCXX]]3'F MM#  JJv rc#h# URHnURUHnX4v M M g7frrFr&s rr]ManyToMany.iteritemss,99Cyy~h&s02c6URR5$r)rFrcr^s rrcManyToMany.keyssyy~~rcXR;$rrcr*s rrWManyToMany.__contains__siirc6URR5$r)rFrr^s rrManyToMany.__iter__syy!!##rc6URR5$r)rF__len__r^s rrlManyToMany.__len__syy  ""rcp[U5[U5:H=(a URUR:H$r)rrFrs rrManyToMany.__eq__s'DzT%[(DTYY%**-DDrcpURRnU<S[UR55<S3$r=)r r!rr]r'rs rrManyToMany.__repr__s( ^^ $ $tDNN$4566r)rFrr)r!rrrrr#rMrKrPr}rr&rArPr`r]rcrWrrlrrrrrrrrs_ ){ )' ,$#    $#E7rrcUcUR5nUc/n[U5[U5- n[U5"UR5VVs/sHupEXC;dM XE4PM snn5$s snnf)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} )rcrjrrw)dkeepdroprcr8r9s rrrsa, |vvx | t9s4y D 7qwwy>ytqAIFQFy> ??>s  A, A, c\rSrSrSrg)FrozenHashErrorirN)r!rrrrrrrrxrxsrrxcv\rSrSrSrSrSr\S Sj5rSr Sr S r S r S r \ =r=r=rr\ =r=r=rrC Srg) ri aAn 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. )_hashc^[U5nUR"U0UD6 [U5"U5$)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'rrrFs rupdatedFrozenDict.updated/s- Dz Q"Dz$rNc8U"[RX55$r)rrd)rbrcvalues rrdFrozenDict.fromkeys8s4==-..rchURRnU<S[RU5<S3$r=r@rqs rrFrozenDict.__repr__=s% ^^ $ $t}}T233rc0[U5[U544$r)rr)r'protocols r __reduce_ex__FrozenDict.__reduce_ex__AsDzDJ=((rcURnUR[ LaUeU$![aU [[UR 555=olNL![ an[ U5=olSnANmSnAff=ff=fr)rzr.r%rMrw Exceptionrxr )r'res r__hash__FrozenDict.__hash__Dsy 6**C ==O +I  6 6#' $**,(?#@@j 6#21#55jj 6 6s, % B(A B$A;5B;BBcU$rrr^s r__copy__FrozenDict.__copy__Rs rcF[SURR-5e)z5raises a TypeError, because FrozenDicts are immutablez%s object is immutable)rr r!)r'rrs r_raise_frozen_typeerror"FrozenDict._raise_frozen_typeerrorVs04>>3J3JJKKrr)r!rrrrrCr|rrdrrrrr__ior__r}rr&r4rr4r0rrrrrr so I //4) L4KJGJkJK&)@@J@@wrrr)&rcollections.abcrrr ImportError collections itertoolsrr typeutilsrr objectranger5r6rrrr__all__profile NameErrorrrr r rrrrrHrrrrxrrrrrs7B%N<??6&'j1H (-Qx$dCu f \t\@  _/_D(XM*tM*b 8u7u7p@@ i = = m<;;<656 xHGsD BB3 CCB0/B03 CC CC C$#C$