OhhddlmZddlZddlZddlZddlZddlZddlZddl Z ddlm Z m Z m Z ddl mZmZmZmZmZmZmZddlZerddlmZddlmZddlmZede ZnedZed Zed Zeee e e j@fZ!d9d Z"Gd dejFjZ$Gdde$Z%dZ&GddeeefZ'dZ(e(dfdZ)Gdde*Z+Gdde+Z,GddZ-GddZ.dZ/Gd d!e*Z0Gd"d#e1ejFjdZ3Gd$d%e*Z4Gd&d'ejFjejFjjZ6Gd(d)e.e4Z7Gd*d+Z8Gd,d-ejrZ:Gd.d/Z;Gd0d1Z>> sample = {'a': 1, 'b': 2, 'c': 3} >>> prj = Projection(['a', 'c', 'd'], sample) >>> dict(prj) {'a': 1, 'c': 3} Projection also accepts an iterable or callable or pattern. >>> iter_prj = Projection(iter('acd'), sample) >>> call_prj = Projection(lambda k: ord(k) in (97, 99, 100), sample) >>> pat_prj = Projection(re.compile(r'[acd]'), sample) >>> prj == iter_prj == call_prj == pat_prj True Keys should only appear if they were specified and exist in the space. Order is retained. >>> list(prj) ['a', 'c'] Attempting to access a key not in the projection results in a KeyError. >>> prj['b'] Traceback (most recent call last): ... KeyError: 'b' Use the projection to update another dict. >>> target = {'a': 2, 'b': 2} >>> target.update(prj) >>> target {'a': 1, 'b': 2, 'c': 3} Projection keeps a reference to the original dict, so modifying the original dict may modify the Projection. >>> del sample['a'] >>> dict(prj) {'c': 3} c2t||_||_yr)r_match_space)selfkeysspaces r__init__zProjection.__init__]so  r cX|j|s t||j|Sr)r$KeyErrorr%r&keys r __getitem__zProjection.__getitem__as'{{33- {{3r cBt|j|jSr)filterr$r%r&s r_keys_resolvedzProjection._keys_resolvedfsdkk4;;//r c"|jSr)r2r1s r__iter__zProjection.__iter__is""$$r cFtt|jSr)lentupler2r1s r__len__zProjection.__len__ls5,,./00r N)r' _Matchabler(r) __name__ __module__ __qualname____doc__r)r.r2r4r8r rr"r"/s!+Z 0%1r r"c"eZdZdZfdZxZS)Maskz The inverse of a :class:`Projection`, masking out keys. >>> sample = {'a': 1, 'b': 2, 'c': 3} >>> msk = Mask(['a', 'c', 'd'], sample) >>> dict(msk) {'b': 2} cLt||i||jfd|_y)Nc|| Srr>)r-origs rzMask.__init__..}s S Mr )superr)r$r&argskwargs __class__s rr)z Mask.__init__zs# $)&)'+{{A r r:r;r<r=r) __classcell__rIs@rr@r@psBBr r@cHtfd|jDS)z Return a new dict with function applied to values of dictionary. >>> dict_map(lambda x: x+1, dict(a=1, b=2)) {'a': 2, 'b': 3} c38K|]\}}||fywrr>).0r-valuefunctions r zdict_map..sL:3huo&Ls)dictitems)rQ dictionarys` rdict_maprVs L9I9I9KL LLr ceZdZdZiej f ddZe ddZddZ e ddZ e dddZ dddZ dd Z dd Z ed d iZGd deZedZedZy)RangeMapaP A dictionary-like object that uses the keys as bounds for a range. Inclusion of the value for that range is determined by the key_match_comparator, which defaults to less-than-or-equal. A value is returned for a key if it is the first key that matches in the sorted list of keys. One may supply keyword parameters to be passed to the sort function used to sort keys (i.e. key, reverse) as sort_params. Create a map that maps 1-3 -> 'a', 4-6 -> 'b' >>> r = RangeMap({3: 'a', 6: 'b'}) # boy, that was easy >>> r[1], r[2], r[3], r[4], r[5], r[6] ('a', 'a', 'a', 'b', 'b', 'b') Even float values should work so long as the comparison operator supports it. >>> r[4.5] 'b' Notice that the way rangemap is defined, it must be open-ended on one side. >>> r[0] 'a' >>> r[-1] 'a' One can close the open-end of the RangeMap by using undefined_value >>> r = RangeMap({0: RangeMap.undefined_value, 3: 'a', 6: 'b'}) >>> r[0] Traceback (most recent call last): ... KeyError: 0 One can get the first or last elements in the range by using RangeMap.Item >>> last_item = RangeMap.Item(-1) >>> r[last_item] 'b' .last_item is a shortcut for Item(-1) >>> r[RangeMap.last_item] 'b' Sometimes it's useful to find the bounds for a RangeMap >>> r.bounds() (0, 6) RangeMap supports .get(key, default) >>> r.get(0, 'not found') 'not found' >>> r.get(7, 'not found') 'not found' One often wishes to define the ranges by their left-most values, which requires use of sort params and a key_match_comparator. >>> r = RangeMap({1: 'a', 4: 'b'}, ... sort_params=dict(reverse=True), ... key_match_comparator=operator.ge) >>> r[1], r[2], r[3], r[4], r[5], r[6] ('a', 'a', 'a', 'b', 'b', 'b') That wasn't nearly as easy as before, so an alternate constructor is provided: >>> r = RangeMap.left({1: 'a', 4: 'b', 7: RangeMap.undefined_value}) >>> r[1], r[2], r[3], r[4], r[5], r[6] ('a', 'a', 'a', 'b', 'b', 'b') cLtj||||_||_yr)rSr) sort_paramsmatch)r&sourcerZkey_match_comparators rr)zRangeMap.__init__s! dF#&) r cH||tdtjS)NT)reverse)rZr])rSoperatorge)clsr\s rleftz RangeMap.lefts! T 2  r c8t|jfi|j}t|tj r|j ||}|S|j||}tj ||}|tjur t||Sr) sortedr'rZrrXItemr._find_first_match_rSundefined_valuer+)r&item sorted_keysresultr-s rr.zRangeMap.__getitem__sTYY[=D,<,<= dHMM *%%k$&78F  ))+tr&r-defaults rgetz RangeMap.gets>Ar Ncyrr>rms rroz RangeMap.getsILr c0 ||S#t$r|cYSwxYw)z Return the value for key if key is in the dictionary, else default. If default is not given, it defaults to None, so that this method never raises a KeyError. r+rms rroz RangeMap.gets%  9  N   ctj|j|}t||} t |S#t $r t |dwxYwr) functoolspartialr[r0next StopIterationr+)r&r'riis_matchmatchess rrgzRangeMap._find_first_match_ sP$$TZZ64( +=  +4.d * +s 9Act|jfi|j}|tj|tj fSr)rer'rZrX first_item last_item)r&rjs rboundszRangeMap.boundss>TYY[=D,<,<= H//0+h>P>P2QRRr RangeValueUndefinedr>ceZdZdZy) RangeMap.Itemz RangeMap ItemN)r:r;r<r=r>r rrfrsr rfr)r\LSupportsKeysAndGetItem[_RangeMapKT, _VT] | Iterable[tuple[_RangeMapKT, _VT]]rZzMapping[str, Any]r]z*Callable[[_RangeMapKT, _RangeMapKT], bool])r\rreturnr)rirrr)r-rrnrrz_VT | _Tr)r-rrnNonerz _VT | None)r-rrnz _T | Nonerz_VT | _T | None)r'zIterable[_RangeMapKT]rirrr)rztuple[_RangeMapKT, _RangeMapKT])r:r;r<r=r`ler) classmethodrcr.r rorgr~typerhintrfr|r}r>r rrXrXsNj*,KS;; * Y * ' * I *  Y     AA LL +)+1<+ +S :d0"b9;OsaJRIr rXc|Srr>)xs r __identityr$s Hr FcFfd}t|j||S)a Return the items of the dictionary sorted by the keys. >>> sample = dict(foo=20, bar=42, baz=10) >>> tuple(sorted_items(sample)) (('bar', 42), ('baz', 10), ('foo', 20)) >>> reverse_string = lambda s: ''.join(reversed(s)) >>> tuple(sorted_items(sample, key=reverse_string)) (('foo', 20), ('bar', 42), ('baz', 10)) >>> tuple(sorted_items(sample, reverse=True)) (('foo', 20), ('baz', 10), ('bar', 42)) c|dS)Nrr>)rir-s r pairkey_keyz!sorted_items..pairkey_key9s47|r )r-r_)rerT)dr-r_rs ` r sorted_itemsr(s" !'')g >>r c~eZdZdZedZfdZfdZfdZfdZ fdZ fdZ fd Z fd Z d ZxZS) KeyTransformingDictz A dict subclass that transforms the keys before they're used. Subclasses may override the default transform_key to customize behavior. c|Srr>r-s r transform_keyz!KeyTransformingDict.transform_keyEs r ct|t|i|}|jD]}|j|yr)rEr)rSrT __setitem__)r&rGkargsrrirIs rr)zKeyTransformingDict.__init__IsB  $ % GGI $D D  d # $r cH|j|}t| ||yr)rrEr)r&r-valrIs rrzKeyTransformingDict.__setitem__Qs"  % C%r cD|j|}t| |Sr)rrEr.r&r-rIs rr.zKeyTransformingDict.__getitem__U#  %w"3''r cD|j|}t| |Sr)rrErrs rrz KeyTransformingDict.__contains__Ys#  %w#C((r cD|j|}t| |Sr)rrE __delitem__rs rrzKeyTransformingDict.__delitem__]rr cL|j|}t||g|i|Sr)rrEror&r-rGrHrIs rrozKeyTransformingDict.geta,  %w{30000r cL|j|}t||g|i|Sr)rrE setdefaultrs rrzKeyTransformingDict.setdefaultes-  %w!#7777r cL|j|}t||g|i|Sr)rrEpoprs rrzKeyTransformingDict.popirr c tfd|jDS#t$r}t|d}~wwxYw)z Given a key, return the actual key stored in self that matches. Raise KeyError if the key isn't found. c3.K|] }|k(s |ywrr>)rOe_keyr-s rrRz7KeyTransformingDict.matching_key_for..ssG%%3,Gs N)rwr'rxr+)r&r-errs ` rmatching_key_forz$KeyTransformingDict.matching_key_forms;  )G499;GG G )3-S ( )s!% ? :?)r:r;r<r= staticmethodrr)rr.rrrorrrrKrLs@rrr?sI $&()(181)r rc eZdZdZedZy)FoldedCaseKeyedDicta A case-insensitive dictionary (keys are compared as insensitive if they are strings). >>> d = FoldedCaseKeyedDict() >>> d['heLlo'] = 'world' >>> list(d.keys()) == ['heLlo'] True >>> list(d.values()) == ['world'] True >>> d['hello'] == 'world' True >>> 'hello' in d True >>> 'HELLO' in d True >>> print(repr(FoldedCaseKeyedDict({'heLlo': 'world'}))) {'heLlo': 'world'} >>> d = FoldedCaseKeyedDict({'heLlo': 'world'}) >>> print(d['hello']) world >>> print(d['Hello']) world >>> list(d.keys()) ['heLlo'] >>> d = FoldedCaseKeyedDict({'heLlo': 'world', 'Hello': 'world'}) >>> list(d.values()) ['world'] >>> key, = d.keys() >>> key in ['heLlo', 'Hello'] True >>> del d['HELLO'] >>> d {} get should work >>> d['Sumthin'] = 'else' >>> d.get('SUMTHIN') 'else' >>> d.get('OTHER', 'thing') 'thing' >>> del d['sumthin'] setdefault should also work >>> d['This'] = 'that' >>> print(d.setdefault('this', 'other')) that >>> len(d) 1 >>> print(d['this']) that >>> print(d.setdefault('That', 'other')) other >>> print(d['THAT']) other Make it pop! >>> print(d.pop('THAT')) other To retrieve the key in its originally-supplied form, use matching_key_for >>> print(d.matching_key_for('this')) This >>> d.matching_key_for('missing') Traceback (most recent call last): ... KeyError: 'missing' c@tjj|Sr)jaracotext FoldedCasers rrz!FoldedCaseKeyedDict.transform_keys{{%%c**r N)r:r;r<r=rrr>r rrrxsHT++r rceZdZdZdZdZy) DictAdapteraD Provide a getitem interface for attributes of an object. Let's say you want to get at the string.lowercase property in a formatted string. It's easy with DictAdapter. >>> import string >>> print("lowercase is %(ascii_lowercase)s" % DictAdapter(string)) lowercase is abcdefghijklmnopqrstuvwxyz c||_yr)object)r& wrapped_obs rr)zDictAdapter.__init__s   r c.t|j|Sr)getattrr)r&names rr.zDictAdapter.__getitem__st{{D))r N)r:r;r<r=r)r.r>r rrrs !*r rc"eZdZdZfdZxZS)ItemsAsAttributesa Mix-in class to enable a mapping object to provide items as attributes. >>> C = type('C', (dict, ItemsAsAttributes), dict()) >>> i = C() >>> i['foo'] = 'bar' >>> i.foo 'bar' Natural attribute access takes precedence >>> i.foo = 'henry' >>> i.foo 'henry' But as you might expect, the mapping functionality is preserved. >>> i['foo'] 'bar' A normal attribute error should be raised if an attribute is requested that doesn't exist. >>> i.missing Traceback (most recent call last): ... AttributeError: 'C' object has no attribute 'missing' It also works on dicts that customize __getitem__ >>> missing_func = lambda self, key: 'missing item' >>> C = type( ... 'C', ... (dict, ItemsAsAttributes), ... dict(__missing__ = missing_func), ... ) >>> i = C() >>> i.missing 'missing item' >>> i.foo 'missing item' c tt|S#t$re}t}d}||||}||ur|cYd}~S|j\}|j d|j jd}|f|_d}~wwxYw)Nc0 ||S#t$r|cYSwxYwrrr)contr-missing_results r _safe_getitemz4ItemsAsAttributes.__getattr__.._safe_getitems&*9$*))*rsrE)rrEAttributeErrorrrGreplacerIr:)r&r-enovalrrkmessagerIs r __getattr__zItemsAsAttributes.__getattr__s 57C( ( HE * #4e4FU" JWoogt~~/F/FJGZAF ' s BBB>BB)r:r;r<r=rrKrLs@rrrs*Xr rctd|jD}t|t|k(s td|S)a Given a dictionary, return another dictionary with keys and values switched. If any of the values resolve to the same key, raises a ValueError. >>> numbers = dict(a=1, b=2, c=3) >>> letters = invert_map(numbers) >>> letters[1] 'a' >>> numbers['d'] = 3 >>> invert_map(numbers) Traceback (most recent call last): ... ValueError: Key conflict in inverted mapping c3*K|] \}}||f ywrr>)rOkvs rrRzinvert_map..1s.$!Q1v.sz Key conflict in inverted mapping)rSrTr6 ValueError)mapress r invert_mapr!s; .#))+. .C s8s3x ;<< Jr ceZdZdZdZy)IdentityOverrideMapz A dictionary that by default maps each key to itself, but otherwise acts like a normal dictionary. >>> d = IdentityOverrideMap() >>> d[42] 42 >>> d['speed'] = 'speedo' >>> print(d['speed']) speedo c|Srr>r,s r __missing__zIdentityOverrideMap.__missing__Ds r N)r:r;r<r=rr>r rrr7s  r rcReZdZdZdZdZejZdZ dZ dZ dZ dZ y ) DictStacka A stack of dictionaries that behaves as a view on those dictionaries, giving preference to the last. >>> stack = DictStack([dict(a=1, c=2), dict(b=2, a=2)]) >>> stack['a'] 2 >>> stack['b'] 2 >>> stack['c'] 2 >>> len(stack) 3 >>> stack.push(dict(a=3)) >>> stack['a'] 3 >>> stack['a'] = 4 >>> set(stack.keys()) == set(['a', 'b', 'c']) True >>> set(stack.items()) == set([('a', 4), ('b', 2), ('c', 2)]) True >>> dict(**stack) == dict(stack) == dict(a=4, c=2, b=2) True >>> d = stack.pop() >>> stack['a'] 2 >>> d = stack.pop() >>> stack['a'] 1 >>> stack.get('b', None) >>> 'c' in stack True >>> del stack['c'] >>> dict(stack) {'a': 1} ctj|}tttj j d|DS)Nc3<K|]}|jywr)r')rOcs rrRz%DictStack.__iter__..ps5N1affh5Ns)listr4iterr itertoolschain from_iterable)r&dictss rr4zDictStack.__iter__ns5 d#C 555N5NNOPPr ctttj|D] }||vs||cSt |r)reversedr7rr4r+)r&r-scopes rr.zDictStack.__getitem__rsAeDMM$$789 "Ee|Sz! "smr cVtjjj||Sr) collectionsabcrrr&others rrzDictStack.__contains__zs&&33D%@@r c<ttt|Sr)r6rrr1s rr8zDictStack.__len__}s4T #$$r cRtj|d}|j||SNr)rr.r)r&r-rilasts rrzDictStack.__setitem__s'b)T**r cPtj|d}|j|Sr)rr.r)r&r-rs rrzDictStack.__delitem__s%b)$$r c4tj|g|i|Sr)rrr&rGrHs rrz DictStack.popsxx.t.v..r N)r:r;r<r=r4r.rappendpushrr8rrrr>r rrrHs8#JQ ;;DA%+% /r rcLeZdZdZfdZfdZdZfdZfdZdZ xZ S) BijectiveMapa A Bijective Map (two-way mapping). Implemented as a simple dictionary of 2x the size, mapping values back to keys. Note, this implementation may be incomplete. If there's not a test for your use case below, it's likely to fail, so please test and send pull requests or patches for additional functionality needed. >>> m = BijectiveMap() >>> m['a'] = 'b' >>> m == {'a': 'b', 'b': 'a'} True >>> print(m['b']) a >>> m['c'] = 'd' >>> len(m) 2 Some weird things happen if you map an item to itself or overwrite a single key of a pair, so it's disallowed. >>> m['e'] = 'e' Traceback (most recent call last): ValueError: Key cannot map to itself >>> m['d'] = 'e' Traceback (most recent call last): ValueError: Key/Value pairs may not overlap >>> m['e'] = 'd' Traceback (most recent call last): ValueError: Key/Value pairs may not overlap >>> print(m.pop('d')) c >>> 'c' in m False >>> m = BijectiveMap(dict(a='b')) >>> len(m) 1 >>> print(m['b']) a >>> m = BijectiveMap() >>> m.update(a='b') >>> m['b'] 'a' >>> del m['b'] >>> len(m) 0 >>> 'a' in m False cFt||j|i|yr)rEr)updaterFs rr)zBijectiveMap.__init__s!  T$V$r c||k(r td||vxr|||k7xs||vxr|||k7}|r tdt| ||t| ||y)NzKey cannot map to itselfzKey/Value pairs may not overlap)rrEr)r&rirPoverlaprIs rrzBijectiveMap.__setitem__s 5=78 8 DL $T e# $}$U t#  >? ? D%( E4(r c&|j|yr)r)r&ris rrzBijectiveMap.__delitem__s  r c&t|dzS)N)rEr8)r&rIs rr8zBijectiveMap.__len__sw A%%r cR||}t||t||g|i|Sr)rErr)r&r-rGrHmirrorrIs rrzBijectiveMap.pops2c F#w{30000r cbt|i|}|jD]}|j|yr)rSrTr)r&rGrHrris rrzBijectiveMap.updates6 $ !& !GGI $D D  d # $r ) r:r;r<r=r)rrr8rrrKrLs@rrrs';z% )&1 $r rcXeZdZdZdgZfdZdZdZdZdZ dZ d Z d Z d Z xZS) FrozenDicta An immutable mapping. >>> a = FrozenDict(a=1, b=2) >>> b = FrozenDict(a=1, b=2) >>> a == b True >>> a == dict(a=1, b=2) True >>> dict(a=1, b=2) == a True >>> 'a' in a True >>> type(hash(a)) is type(0) True >>> set(iter(a)) == {'a', 'b'} True >>> len(a) 2 >>> a['a'] == a.get('a') == 1 True >>> a['c'] = 3 Traceback (most recent call last): ... TypeError: 'FrozenDict' object does not support item assignment >>> a.update(y=3) Traceback (most recent call last): ... AttributeError: 'FrozenDict' object has no attribute 'update' Copies should compare equal >>> copy.copy(a) == a True Copies should be the same type >>> isinstance(copy.copy(a), FrozenDict) True FrozenDict supplies .copy(), even though collections.abc.Mapping doesn't demand it. >>> a.copy() == a True >>> a.copy() is not a True __datacFt||}t|i||_|Sr)rE__new__rS_FrozenDict__data)rbrGrHr&rIs rrzFrozenDict.__new__'s'ws#D+F+  r c||jvSrrr,s rrzFrozenDict.__contains__-sdkk!!r clttt|jj Sr)hashr7rerrTr1s r__hash__zFrozenDict.__hash__1s$E&!2!2!45677r c,t|jSr)rrr1s rr4zFrozenDict.__iter__5sDKK  r c,t|jSr)r6rr1s rr8zFrozenDict.__len__8s4;;r c |j|Srrr,s rr.zFrozenDict.__getitem__;s{{3r c:|jj|i|Sr)rrors rrozFrozenDict.get?st{{///r cpt|tr |j}|jj|Sr)rrr__eq__rs rrzFrozenDict.__eq__Cs* eZ (LLE{{!!%((r c,tj|S)zReturn a shallow copy of self)copyr1s rrzFrozenDict.copyHsyyr )r:r;r<r= __slots__rrr r4r8r.rorrrKrLs@rrrs?2h I "8!  0) r rcDeZdZdZdfd ZedZedZxZS) Enumerationa A convenient way to provide enumerated values >>> e = Enumeration('a b c') >>> e['a'] 0 >>> e.a 0 >>> e[1] 'b' >>> set(e.names) == set('abc') True >>> set(e.codes) == set(range(3)) True >>> e.get('d') is None True Codes need not start with 0 >>> e = Enumeration('a b c', range(1, 4)) >>> e['a'] 1 >>> e[3] 'c' ct|tr|j}|tj}t |t||yr)rstrsplitrcountrEr)zip)r&namescodesrIs rr)zEnumeration.__init__ns= eS !KKME =OO%E UE*+r cd|DS)Nc3BK|]}t|ts|ywr)rr)rOr-s rrRz$Enumeration.names..ws<z#s';r1s rrzEnumeration.namesus )rOrr&s rrRz$Enumeration.codes..{s2tT 2s)rr1s`rrzEnumeration.codesys2tzz22r r) r:r;r<r=r)propertyrrrKrLs@rrrMs6@,==33r rceZdZdZdZy) Everythinga A collection "containing" every possible thing. >>> 'foo' in Everything() True >>> import random >>> random.randint(1, 999) in Everything() True >>> random.choice([None, 'foo', 42, ('a', 'b', 'c')]) in Everything() True cyNTr>rs rrzEverything.__contains__r N)r:r;r<r=rr>r rr"r"~s  r r"c"eZdZdZfdZxZS)InstrumentedDictaD Instrument an existing dictionary with additional functionality, but always reference and mutate the original dictionary. >>> orig = {'a': 1, 'b': 2} >>> inst = InstrumentedDict(orig) >>> inst['a'] 1 >>> inst['c'] = 3 >>> orig['c'] 3 >>> inst.keys() == orig.keys() True c0t|||_yr)rEr)data)r&r)rIs rr)zInstrumentedDict.__init__s  r rJrLs@rr'r's r r'c$eZdZdZdZeZdZeZy)Leasta A value that is always lesser than any other >>> least = Least() >>> 3 < least False >>> 3 > least True >>> least < 3 True >>> least <= 3 True >>> least > 3 False >>> 'x' > least True >>> None > least True cyr$r>rs r__le__z Least.__le__r%r cyNFr>rs r__ge__z Least.__ge__r N)r:r;r<r=r-__lt__r0__gt__r>r rr+r+(FFr r+c$eZdZdZdZeZdZeZy)Greatesta2 A value that is always greater than any other >>> greatest = Greatest() >>> 3 < greatest True >>> 3 > greatest False >>> greatest < 3 False >>> greatest > 3 True >>> greatest >= 3 True >>> 'x' > greatest False >>> None > greatest False cyr$r>rs rr0zGreatest.__ge__r%r cyr/r>rs rr-zGreatest.__le__r1r N)r:r;r<r=r0r3r-r2r>r rr6r6r4r r6c|ddgc}|dd|S)z Clear items in place and return a copy of items. >>> items = [1, 2, 3] >>> popped = pop_all(items) >>> popped is items False >>> popped [1, 2, 3] >>> items [] Nr>)rTrks rpop_allr:sQxFE!H Mr c(eZdZdZfdZdZxZS)FreezableDefaultDicta! Often it is desirable to prevent the mutation of a default dict after its initial construction, such as to prevent mutation during iteration. >>> dd = FreezableDefaultDict(list) >>> dd[0].append('1') >>> dd.freeze() >>> dd[1] [] >>> len(dd) 1 c:t|dt||S)N_frozen)rrErrs rrz FreezableDefaultDict.__missing__s. s4#7#7#9r )r>r1s`rfreezezFreezableDefaultDict.freeze s 9 r )r:r;r<r=rrBrKrLs@rr<r<s B:r r<ceZdZddZdZy) Accumulatorc||_yrr)r&initials rr)zAccumulator.__init__s r cD|xj|z c_|jSrrF)r&rs r__call__zAccumulator.__call__s Cxxr N)r)r:r;r<r)rIr>r rrDrDs r rDc(eZdZdZfdZdZxZS)WeightedLookupa Given parameters suitable for a dict representing keys and a weighted proportion, return a RangeMap representing spans of values proportial to the weights: >>> even = WeightedLookup(a=1, b=1) [0, 1) -> a [1, 2) -> b >>> lk = WeightedLookup(a=1, b=2) [0, 1) -> a [1, 3) -> b >>> lk[.5] 'a' >>> lk[1.5] 'b' Adds ``.random()`` to select a random weighted value: >>> lk.random() in ['a', 'b'] True >>> choices = [lk.random() for x in range(1000)] Statistically speaking, choices should be .5 a:b >>> ratio = choices.count('a') / choices.count('b') >>> .4 < ratio < .6 True ct|i|}tt|j}t|t ||jtjy)N)r]) rSrrDvaluesrEr)rr'r`lt)r&rGrHrawindexesrIs rr)zWeightedLookup.__init__9sKD#F#kmSZZ\2 Wchhj1 Tr c`|j\}}tj|z}||Sr)r~random)r&lowerupperselectors rrRzWeightedLookup.random@s+{{} u==?U*H~r )r:r;r<r=r)rRrKrLs@rrKrKsBUr rK)rr9rr )B __future__rcollections.abcrrrurr`rRrrrrtypingrrr r r r r jaraco.textr _operatorr _typeshedrtyping_extensionsrrrrrr9rrr"r@rVrXrrrSrrrrrrrMutableMappingrrHashablerrr"UserDictr'r+r6r: defaultdictr<rDrKr>r rras"  88OOO-0&-/BCK-(K T] en 8Y"**< =  >1((>1B B: B MWtK$%Wt #E?.6)$6)rM+-M+`**&CCL,$"B/koo44B/J`$4`$FZ((+//*B*BZz.3#\.3b&{++,@@":;22:,,X,r