Ë
|
@ñúhh ã ó¶ d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dlm
|
Z
|
m Z m Z d dl mZmZmZmZmZmZmZ d dlZer d dlmZ d dlmZ d dlm Z ede¬ « Z n ed« Z ed
|
« Z ed « Z eee
|
e e j@ f Z!d9d Z" G d dejF j « Z$ G d de$« Z%d Z& G d dee e f « Z'd Z(e(dfdZ) G d de*« Z+ G d de+« Z, G d d « Z- G d d « Z.d Z/ G d d!e*« Z0 G d" d#e1ejF jd « Z3 G d$ d%e*« Z4 G d& d'ejF j ejF jj « Z6 G d( d)e.e4« Z7 G d* d+« Z8 G d, d-ejr « Z: G d. d/« Z; G d0 d1« Z<d2 Z= G d3 d4ej| « Z? G d5 d6« Z@ G d7 d8e'« ZAy):é )Ú annotationsN)Ú ContainerÚIterableÚMapping)Ú TYPE_CHECKINGÚAnyÚCallableÚDictÚTypeVarÚUnionÚoverload)Ú_SupportsComparison)ÚSupportsKeysAndGetItem)ÚSelfÚ _RangeMapKT)ÚboundÚ_TÚ_VTc óÀ t | t j « r | j S t | t « s't | t
|
« s t | « } | j } | S ©N)Ú
|
isinstanceÚreÚPatternÚ fullmatchr r ÚsetÚ __contains__)Úobjs úaH:\Change_password\venv_build\Lib\site-packages\setuptools/_vendor/jaraco/collections/__init__.pyÚ _dispatchr ! sI ô #rzzÔ"Ø}}Ð ä c8Ô $Ü#yÔ)Üc(CØ× Ñ Ø Jó c ó0 e Zd ZdZddZd Zd Zd Zd Zy) Ú
|
ProjectionaT
|
Project a set of keys over a mapping
|
|
>>> 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}
|
c ó2 t |« | _ || _ y r )r Ú_matchÚ_space)ÚselfÚkeysÚspaces r Ú__init__zProjection.__init__] s Ü o Ø r c óX | j |« s t |« | j | S r )r$ ÚKeyErrorr% ©r& Úkeys r Ú __getitem__zProjection.__getitem__a s' Ø{{3Ô Ü3-Ð Ø{{3Ñ Ð r c óB t | j | j « S r )Úfilterr$ r% ©r& s r Ú_keys_resolvedzProjection._keys_resolvedf s Üdkk 4§;¡;Ó/Ð/r c ó" | j « S r )r2 r1 s r Ú__iter__zProjection.__iter__i s Ø×"Ñ"Ó$Ð$r c óF t t | j « « « S r )ÚlenÚtupler2 r1 s r Ú__len__zProjection.__len__l s Ü5×,Ñ,Ó.Ó/Ó0Ð0r N)r' Ú
|
_Matchabler( r ) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r) r. r2 r4 r8 © r r r" r" / s! ñ+óZ ò ò
|
0ò%ó1r r" c ó" e Zd ZdZ fdZ xZS )Ú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}
|
c óL t | |i |¤ | j fd| _ y )Nc ó || « S r r> )r- Úorigs r ú<lambda>z Mask.__init__.<locals>.<lambda>} s ¹¸S» °M r )Úsuperr) r$ ©r& ÚargsÚkwargsÚ __class__s r r) z Mask.__init__z s# ø Ü Ñ$Ð) &Ò)à'+§{¡{ÒA r ©r: r; r< r= r) Ú __classcell__©rI s @r r@ r@ p s ø ñ÷Bð Br r@ c óH t fd|j « D « « S )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}
|
c 3 ó8 K | ] \ }}| |« f y wr r> )Ú.0r- ÚvalueÚfunctions r ú <genexpr>zdict_map.<locals>.<genexpr> s øè ø ÒL©:¨3°huoÔ&ÑLùs )ÚdictÚitems)rQ Ú
|
dictionarys ` r Údict_maprV s ø ô ÓL¸×9IÑ9IÓ9KÔLÓ LÐLr c óþ e Zd ZdZi ej
|
f ddZe dd« ZddZ e
|
dd« Z e
|
ddd« Z dddZ dd Z dd
|
Z ed d i « « Z G d de« Z ed« Z ed« Zy)Ú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')
|
|
c óL t j | |« || _ || _ y r )rS r) Ú sort_paramsÚmatch)r& ÚsourcerZ Úkey_match_comparators r r) zRangeMap.__init__Û s! ô dFÔ#Ø&ÔØ)
|
r c óH | |t d¬« t j ¬« S )NT)Úreverse)rZ r] )rS ÚoperatorÚge)Úclsr\ s r Úleftz RangeMap.leftç s! ñ Ø ¤¨TÔ 2ÌÏÉô
|
ð
|
r c ó8 t | j « fi | j ¤}t |t j
|
« r| j || « }|S | j ||« }t j | |« }|t j u r t |« |S r ) Úsortedr' rZ r rX ÚItemr. Ú_find_first_match_rS Úundefined_valuer+ )r& ÚitemÚ sorted_keysÚresultr- s r r. zRangeMap.__getitem__ò s Ü TYY[Ñ=¨D×,<Ñ,<Ñ= Ü dHMMÔ *Ø×%Ñ% k°$Ñ&7Ó8Fð ð ×)Ñ)¨+°tÓ<CÜ×%Ñ% d¨CÓ0FØ×1Ñ1Ñ1Ü smÐ#Ø r c ó y r r> ©r& r- Údefaults r Úgetz RangeMap.getý s Ø>Ar Nc ó y r r> rm s r ro z RangeMap.getÿ s ØILr c ó0 | | S # t $ r |cY S w xY w)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+ rm s r ro z RangeMap.get s% ð Ø9Ð øÜò ØNð úó c ó¤ t j | j |« }t ||« } t |« S # t
|
$ r t |« d w xY wr )Ú functoolsÚpartialr[ r0 ÚnextÚ StopIterationr+ )r& r' ri Úis_matchÚmatchess r rg zRangeMap._find_first_match_ sP ô ×$Ñ$ T§Z¡Z°Ó6Ü 4Ó(ð +Ü=Ð øÜ ò +Ü4. dÐ *ð +ús ®
|
9 ¹Ac ó t | j « fi | j ¤}|t j |t j
|
fS r )re r' rZ rX Ú
|
first_itemÚ last_item)r& rj s r ÚboundszRangeMap.bounds s> Ü TYY[Ñ=¨D×,<Ñ,<Ñ= ØH× /Ñ /Ñ0°+¼h×>PÑ>PÑ2QÐRÐRr ÚRangeValueUndefinedr> c ó e Zd ZdZy)ú RangeMap.Itemz RangeMap ItemN)r: r; r< r= r> r r rf r s Úr rf r éÿÿÿÿ)r\ úLSupportsKeysAndGetItem[_RangeMapKT, _VT] | Iterable[tuple[_RangeMapKT, _VT]]rZ zMapping[str, Any]r] z*Callable[[_RangeMapKT, _RangeMapKT], bool])r\ r Úreturnr )ri r r r )r- r rn r r z_VT | _Tr )r- r rn ÚNoner z
|
_VT | None)r- r rn z _T | Noner z_VT | _T | None)r' zIterable[_RangeMapKT]ri r r r )r z tuple[_RangeMapKT, _RangeMapKT])r: r; r< r= r` Úler) Ú classmethodrc r. r ro rg r~ Útyperh Úintrf r| r} r> r r rX rX sä ñNðj *,ØKSÏ;É;ð
|
*ð Yð
|
*ð
|
'ð
|
*ð Ió
|
*ð ð
|
ð Yð
|
ð
|
|
ò
|
ó ð
|
ó ð ÚAó ØAØ ÛLó ØLô ð+Ø)ð+Ø1<ð+à ó+óSð
|
:dÐ0°"°bÓ9Ó;Oô sô ñ aJÙRIr rX c ó | S r r> )Úxs r Ú
|
__identityr $ s Ø Hr Fc óF fd}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 ó | d « S )Nr r> )ri r- s r Ú pairkey_keyz!sorted_items.<locals>.pairkey_key9 s ø Ù47|Ðr )r- r_ )re rT )Údr- r_ r s ` r Ú sorted_itemsr ( s ø ô" ô !'') °gÔ >Ð>r c ó~ e Zd ZdZed « Z fdZ fdZ fdZ fdZ fdZ
|
fdZ fd Z fd
|
Z d Z xZS ) ÚKeyTransformingDictz
|
A dict subclass that transforms the keys before they're used.
|
Subclasses may override the default transform_key to customize behavior.
|
c ó | S r r> ©r- s r Ú transform_keyz!KeyTransformingDict.transform_keyE s à
|
r c ó t | « t |i |¤}|j « D ] } | j | y r )rE r) rS rT Ú __setitem__)r& rG Úkargsr ri rI s r r) z KeyTransformingDict.__init__I sB ø Ü ÑÔä $Ð %Ñ àGGIò $DØ D× Ñ dÒ #ñ $r c óH | j |« }t | ||« y r )r rE r )r& r- ÚvalrI s r r z KeyTransformingDict.__setitem__Q s" ø Ø× Ñ Ó%Ü ÑC Õ%r c óD | j |« }t | |« S r )r rE r. ©r& r- rI s r r. z KeyTransformingDict.__getitem__U ó# ø Ø× Ñ Ó%ÜwÑ" 3Ó'Ð'r c óD | j |« }t | |« S r )r rE r r s r r z KeyTransformingDict.__contains__Y s# ø Ø× Ñ Ó%ÜwÑ# CÓ(Ð(r c óD | j |« }t | |« S r )r rE Ú __delitem__r s r r¡ z KeyTransformingDict.__delitem__] r r c óL | j |« }t | |g|¢i |¤S r )r rE ro ©r& r- rG rH rI s r ro zKeyTransformingDict.geta ó, ø Ø× Ñ Ó%Üw{3Ð0 Ò0¨Ñ0Ð0r c óL | j |« }t | |g|¢i |¤S r )r rE Ú
|
setdefaultr£ s r r¦ z KeyTransformingDict.setdefaulte s- ø Ø× Ñ Ó%ÜwÑ! #Ð7¨Ò7°Ñ7Ð7r c óL | j |« }t | |g|¢i |¤S r )r rE Úpopr£ s r r¨ zKeyTransformingDict.popi r¤ r c ó t fd| j « D « « S # t $ r}t « |d}~ww xY w)z
|
Given a key, return the actual key stored in self that matches.
|
Raise KeyError if the key isn't found.
|
c 3 ó. K | ] }|k( s | y wr r> )rO Úe_keyr- s r rR z7KeyTransformingDict.matching_key_for.<locals>.<genexpr>s s øè ø ÒG %¸%À3»,ÑGùs
|
N)rw r' rx r+ )r& r- Úerrs ` r Úmatching_key_forz$KeyTransformingDict.matching_key_form s; ø ð
|
)ÜÓG¨4¯9©9«;ÔGÓGÐ GøÜ ò )Ü3- SÐ (ûð )ús !% ¥ ?® :º?)r: r; r< r= Ú staticmethodr r) r r. r r¡ ro r¦ r¨ r rK rL s @r r r ? sI ø ñð
|
ñó ðô$ô&ô(ô)ô(ô1ô8ô1ö)r r c ó e Zd ZdZed « Zy)Ú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 ó@ t j j | « S r )ÚjaracoÚtextÚ
|
FoldedCaser s r r z!FoldedCaseKeyedDict.transform_keyà s ä{{×%Ñ% cÓ*Ð*r N)r: r; r< r= r® r r> r r r° r° x s ñHðT ñ+ó ñ+r r° c ó e Zd ZdZd Zd Zy)Ú 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 ó || _ y r )Úobject)r& Ú
|
wrapped_obs r r) zDictAdapter.__init__Ô s Ø r c ó. t | j |« S r )Úgetattrr¸ )r& Únames r r. zDictAdapter.__getitem__× s Üt{{ DÓ)Ð)r N)r: r; r< r= r) r. r> r r r¶ r¶ È s ñ ò!ó*r r¶ c ó" e Zd ZdZ fdZ xZS )Ú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 ó t t « |« S # t $ re}t « }d } || ||« }||ur|cY d }~S |j \ }|j d| j j d« }|f|_ d }~ww xY w)Nc ó0 | | S # t $ r |cY S w xY wr rr )Úcontr- Úmissing_results r Ú _safe_getitemz4ItemsAsAttributes.__getattr__.<locals>._safe_getitem s& ð*Ø 9Ð$øÜ ò *Ø)Ò)ð*úrs rE é )r» rE ÚAttributeErrorr¸ rG ÚreplacerI r: )r& r- ÚeÚnovalrà rk ÚmessagerI s r Ú __getattr__z ItemsAsAttributes.__getattr__ s ø ð Ü57 CÓ(Ð (øÜ ò ô HEò *ñ # 4¨¨eÓ4FØUÑ"Ø ð JWØ oo g¨t¯~©~×/FÑ/FÈÓJGØ ZAFØ ûð' ús B B ¼BÁ>B  B)r: r; r< r= rÊ rK rL s @r r¾ r¾ Û s ø ñ*÷Xð r r¾ c ó t d | j « D « « }t |« t | « k( s t d« |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
|
c 3 ó* K | ] \ }}||f y wr r> )rO ÚkÚvs r rR z invert_map.<locals>.<genexpr>1 s è ø Ò.$!Q1vÑ.ùs z Key conflict in inverted mapping)rS rT r6 Ú
|
ValueError)ÚmapÚress r Ú
|
invert_maprÒ ! s; ô Ñ. #§)¡)£+Ô.Ó
|
.CÜ s8s3xÒ ÜÐ;Ó<Ð<Ø Jr c ó e Zd ZdZd Zy)Ú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 ó |S r r> r, s r Ú __missing__z IdentityOverrideMap.__missing__D s Ø
|
r N)r: r; r< r= rÖ r> r r rÔ rÔ 7 s ñ
|
ór rÔ c óR e Zd ZdZd Zd Zej Zd Z d Z
|
d Z d Z d Z 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}
|
c ó t j | « }t t t j
|
j d |D « « « « S )Nc 3 ó< K | ] }|j « y wr )r' )rO Úcs r rR z%DictStack.__iter__.<locals>.<genexpr>p s è ø Ò5NÀ1°a·f±f·hÑ5Nùs )Úlistr4 Úiterr Ú itertoolsÚchainÚ from_iterable)r& Údictss r r4 zDictStack.__iter__n s5 Ü dÓ#ÜC ×5Ñ5Ñ5NÈÔ5NÓNÓOÓPÐPr c ó t t t j | « « « D ] }||v s|| c S t |« r )Úreversedr7 rÜ r4 r+ )r& r- Úscopes r r. zDictStack.__getitem__r sA Ü e¤D§M¡M°$Ó$7Ó 8Ó9ò "EØe|Ø SzÒ!ð "ô smÐr c óV t j j j | |« S r )Ú collectionsÚabcr r ©r& Úothers r r zDictStack.__contains__z s Ü×&Ñ&×3Ñ3°D¸%Ó@Ð@r c ó< t t t | « « « S r )r6 rÜ rÝ r1 s r r8 zDictStack.__len__} s Ü4T
|
Ó#Ó$Ð$r c óR t j | d« }|j ||« S ©Nr )rÜ r. r )r& r- ri Úlasts r r zDictStack.__setitem__ s' Ü× Ñ bÓ)Ø× Ñ TÓ*Ð*r c óP t j | d« }|j |« S rì )rÜ r. r¡ )r& r- rí s r r¡ zDictStack.__delitem__ s% Ü× Ñ bÓ)Ø× Ñ Ó$Ð$r c ó4 t j | g|¢i |¤S r )rÜ r¨ ©r& rG rH s r r¨ z DictStack.pop s ÜxxÐ.tÒ. vÑ.Ð.r N)r: r; r< r= r4 r. rÜ ÚappendÚpushr r8 r r¡ r¨ r> r r rØ rØ H s8 ñ#òJQò ð ;;DòAò%ò+ò%ó
|
/r rØ c óL e Zd ZdZ fdZ fdZd Z fdZ fdZd Z 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
|
c óF t | « | j |i |¤ y r )rE r) ÚupdaterF s r r) zBijectiveMap.__init__Ë s! ø Ü ÑÔØ TÐ$VÓ$r c ó¼ ||k( r t d« || v xr | | |k7 xs || v xr | | |k7 }|r t d« t | ||« t | ||« y )NzKey cannot map to itselfz Key/Value pairs may not overlap)rÏ rE r )r& ri rP ÚoverlaprI s r r zBijectiveMap.__setitem__Ï s ø Ø 5=Ü Ð 7Ó8Ð 8à DLò $ØT
|
eÑ#ò $à}ò $ØU tÑ#ð ñ Ü Ð >Ó?Ð ?Ü ÑD %Ô(Ü ÑE 4Õ(r c ó& | j |« y r )r¨ )r& ri s r r¡ zBijectiveMap.__delitem__Ý s Ø r c ó& t | « dz S )Né )rE r8 )r& rI s r r8 zBijectiveMap.__len__à s ø ÜwÓ AÑ%Ð%r c óR | | }t | |« t | |g|¢i |¤S r )rE r¡ r¨ )r& r- rG rH ÚmirrorrI s r r¨ zBijectiveMap.popã s2 ø ØcÜ ÑFÔ#Üw{3Ð0 Ò0¨Ñ0Ð0r c ób t |i |¤}|j « D ] } | j | y r )rS rT r )r& rG rH r ri s r rö zBijectiveMap.updateè s6 ä $Ð !&Ñ !àGGIò $DØ D× Ñ dÒ #ñ $r ) r: r; r< r= r) r r¡ r8 r¨ rö rK rL s @r rô rô s' ø ñ;ôz%ô )ò ô&ô1ö
|
$r rô c óX e Zd ZdZdgZ fdZd Zd Zd Zd Z d Z
|
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
|
Ú__datac óF t | | « }t |i |¤|_ |S r )rE Ú__new__rS Ú_FrozenDict__data)rb rG rH r& rI s r r zFrozenDict.__new__' s' ø ÜwsÓ#ÜDÐ+ FÑ+ Ø r c ó || j v S r ©r r, s r r zFrozenDict.__contains__- s ØdkkÐ!Ð!r c ól t t t | j j « « « « S r )Úhashr7 re r rT r1 s r Ú__hash__zFrozenDict.__hash__1 s$ ÜE& §¡×!2Ñ!2Ó!4Ó5Ó6Ó7Ð7r c ó, t | j « S r )rÝ r r1 s r r4 zFrozenDict.__iter__5 s ÜDKKÓ Ð r c ó, t | j « S r )r6 r r1 s r r8 zFrozenDict.__len__8 s Ü4;;Ó Ð r c ó | j | S r r r, s r r. zFrozenDict.__getitem__; s Ø{{3Ñ Ð r c ó: | j j |i |¤S r )r ro rð s r ro zFrozenDict.get? s Ø t{{ Ð/¨Ñ/Ð/r c óp t |t « r |j }| j j |« S r )r r r Ú__eq__rè s r r zFrozenDict.__eq__C s* Ü eZÔ (ØLLEØ{{×!Ñ! %Ó(Ð(r c ó, t j | « S )z Return a shallow copy of self)Úcopyr1 s r r zFrozenDict.copyH s äyyÐ r )r: r; r< r= Ú __slots__r r r r4 r8 r. ro r r rK rL s @r r r ð s? ø ñ2ðh
|
Iôò "ò8ò!ò ò ò0ò)ö
|
r r c óD e Zd ZdZd fd Zed « Zed « Z xZS )Ú 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'
|
c ó¤ t |t « r|j « }|t j « }t
|
| t ||« « y r )r ÚstrÚsplitrÞ ÚcountrE r) Úzip)r& ÚnamesÚcodesrI s r r) zEnumeration.__init__n s= ø Ü eSÔ !ØKKMEØ =Ü OOÓ%EÜ ÑU EÓ*Õ+r c ó d | D « S )Nc 3 óB K | ] }t |t « s| y wr )r r )rO r- s r rR z$Enumeration.names.<locals>.<genexpr>w s è ø Ò<¤z°#´sÕ';Ñ<ùs r> r1 s r r zEnumeration.namesu s á<tÔ<Ð<r c ó. fd j D « S )Nc 3 ó( K | ] }| y wr r> )rO r¼ r& s r rR z$Enumeration.codes.<locals>.<genexpr>{ s øè ø Ò2tT
|
Ñ2ùs )r r1 s `r r zEnumeration.codesy s ø ã2 t§z¡zÔ2Ð2r r ) r: r; r< r= r) Úpropertyr r rK rL s @r r r M s6 ø ñ õ@,ð ñ=ó ð=ð ñ3ó ô3r r c ó e Zd ZdZd Zy)Ú
|
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
|
c ó y©NTr> rè s r r zEverything.__contains__ ó Ør N)r: r; r< r= r r> r r r" r" ~ s ñ ó r r" c ó" e Zd ZdZ fdZ xZS )Ú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
|
c ó0 t | « || _ y r )rE r) Údata)r& r) rI s r r) zInstrumentedDict.__init__¢ s ø Ü ÑÔØ r rJ rL s @r r' r' s ø ñ÷ ð r r' c ó$ e Zd ZdZd ZeZd ZeZy)Ú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
|
c ó yr$ r> rè s r Ú__le__z Least.__le__¼ r% r c ó y©NFr> rè s r Ú__ge__z Least.__ge__Á ó Ør N)r: r; r< r= r- Ú__lt__r0 Ú__gt__r> r r r+ r+ § ó ñò(ð Fòð Fr r+ c ó$ e Zd ZdZd ZeZd ZeZy)Ú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
|
c ó yr$ r> rè s r r0 zGreatest.__ge__Ü r% r c ó yr/ r> rè s r r- zGreatest.__le__á r1 r N)r: r; r< r= r0 r3 r- r2 r> r r r6 r6 Ç r4 r r6 c ó | dd g c}| 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> )rT rk s r Úpop_allr: ç s ð Qx ÐFE!HØ Mr c ó( e Zd ZdZ fdZd Z xZS )Ú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)r» rE rÖ r s r rÖ z FreezableDefaultDict.__missing__ s ø Ø<wtY¬©Ñ(;Ó<¸SÓAÐAr c ó fd _ y )Nc ó$ j « S r )Údefault_factory)r- r& s r rD z-FreezableDefaultDict.freeze.<locals>.<lambda> s ø 4×#7Ñ#7Ó#9 r )r> r1 s `r ÚfreezezFreezableDefaultDict.freeze
|
s
|
ø Û9 r )r: r; r< r= rÖ rB rK rL s @r r< r< ø s ø ñ ô Bö:r r< c ó e Zd ZddZd Zy)Ú Accumulatorc ó || _ y r ©r )r& Úinitials r r) zAccumulator.__init__ s Ør c óD | xj |z c_ | j S r rF )r& r s r Ú__call__zAccumulator.__call__ s Ø CØxxr N)r )r: r; r< r) rI r> r r rD rD s óór rD c ó( e Zd ZdZ fdZd Z xZS )Ú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
|
c óÎ t |i |¤}t t « |j « « }t | t ||j « « t j ¬« y )N)r] )
|
rS rÐ rD ÚvaluesrE r) r r' r` Últ)r& rG rH ÚrawÚindexesrI s r r) zWeightedLookup.__init__9 sK ø ÜDÐ#FÑ#ô km S§Z¡Z£\Ó2Ü ÑW c§h¡h£jÓ1ÌÏ É ÐÕTr c ó` | j « \ }}t j « |z }| | S r )r~ Úrandom)r& ÚlowerÚupperÚselectors r rR zWeightedLookup.random@ s+ Ø{{} uÜ==? UÑ*ØH~Ð r )r: r; r< r= r) rR rK rL s @r rK rK s ø ñ ôBUö r rK )r r9 r r )BÚ
|
__future__r Úcollections.abcræ r ru rÞ r` rR r r r r Útypingr r r r
|
r r r Ú jaraco.textr² Ú _operatorr Ú _typeshedr Útyping_extensionsr r r r r r9 r rç r" r@ rV rX r r rS r r° r¶ r¾ rÒ rÔ rÜ ÚMutableMappingrØ rô ÚHashabler r r" ÚUserDictr' r+ r6 r: Ú defaultdictr< rD rK r> r r ú<module>ra sÚ ðÝ "ã Û Û Û Û Û Û ß 8Ñ 8ß O× OÑ Oã áÝ-å0Ý&á-Ð/BÔCKñ -Ó(Ká T]Ù enà 8Y¨°"·*±*Ð<Ñ =
|
ó ô >1 ×(Ñ(ô >1ôB B:ô Bò MôWtK Ð$Ñ%ô Wòt ð #¨Eó ?ô.6)$ô 6)ôrM+Ð-ô M+÷`*ñ *÷&Cñ CòLô,$ô ô"B/koo×4Ñ4ô B/ôJ`$4ô `$ôFZ ×(Ñ(¨+¯/©/×*BÑ*Bô Z ôz.3Ð# \ô .3÷bñ ô&{×+Ñ+ô ÷, ñ ÷@ ñ ò@ô":;×2Ñ2ô :÷,ñ ô, Xõ , r
|
