golden hour
/opt/saltstack/salt/lib/python3.10/site-packages/jaraco/__pycache__
⬆️ Go Up
Upload
File/Folder
Size
Actions
__init__.cpython-310.pyc
227 B
Del
OK
collections.cpython-310.pyc
30.11 KB
Del
OK
functools.cpython-310.pyc
13.44 KB
Del
OK
Edit: collections.cpython-310.pyc
o �xe�b � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlm Z d dl Z G dd� dej j �ZG dd� de�Zdd� ZG d d � d e�Zd d � Zed fdd�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Zdd� ZG dd� de�ZG d d � d e ej j �Z G d d � d e�Z G d d!� d!ej j ej j �Z G d"d#� d#ee �Z!G d$d%� d%e�Z"G d&d'� d'ej#�Z$G d(d)� d)e�Z%G d*d+� d+e�Z&d,d-� Z'G d.d/� d/ej(�Z)G d0d1� d1�Z*G d2d3� d3e�Z+dS )4� N)�NonDataPropertyc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � Projectiona@ Project a set of keys over a mapping >>> sample = {'a': 1, 'b': 2, 'c': 3} >>> prj = Projection(['a', 'c', 'd'], sample) >>> prj == {'a': 1, 'c': 3} True Keys should only appear if they were specified and exist in the space. >>> sorted(list(prj.keys())) ['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} True Also note that Projection keeps a reference to the original dict, so if you modify the original dict, that could modify the Projection. >>> del sample['a'] >>> dict(prj) {'c': 3} c C s t |�| _|| _d S �N)�tuple�_keys�_space)�self�keys�space� r �F/opt/saltstack/salt/lib/python3.10/site-packages/jaraco/collections.py�__init__2 � zProjection.__init__c C � || j vr t|��| j| S r )r �KeyErrorr �r �keyr r r � __getitem__6 � zProjection.__getitem__c C s t t| j��| j��S r )�iter�setr � intersectionr �r r r r �__iter__; � zProjection.__iter__c C s t tt| ���S r )�lenr r r r r r �__len__> s zProjection.__len__N)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s $ r c @ sj e Zd ZdZg dfdd�Zdd� Zee�Zedd� �Z d d � Z d d � Z d d� Z dd� Z dd� Zdd� ZdS )� DictFiltera� Takes a dict, and simulates a sub-dict based on the keys. >>> sample = {'a': 1, 'b': 2, 'c': 3} >>> filtered = DictFilter(sample, ['a', 'c']) >>> filtered == {'a': 1, 'c': 3} True >>> set(filtered.values()) == {1, 3} True >>> set(filtered.items()) == {('a', 1), ('c', 3)} True One can also filter by a regular expression pattern >>> sample['d'] = 4 >>> sample['ef'] = 5 Here we filter for only single-character keys >>> filtered = DictFilter(sample, include_pattern='.$') >>> filtered == {'a': 1, 'b': 2, 'c': 3, 'd': 4} True >>> filtered['e'] Traceback (most recent call last): ... KeyError: 'e' Also note that DictFilter keeps a reference to the original dict, so if you modify the original dict, that could modify the filtered dict. >>> del sample['d'] >>> del sample['a'] >>> filtered == {'b': 2, 'c': 3} True >>> filtered != {'b': 2, 'c': 3} False Nc C s4 || _ t|�| _|d urt�|�| _d S t� | _d S r )�dictr �specified_keys�re�compile�include_pattern� pattern_keys)r r" � include_keysr& r r r r j s zDictFilter.__init__c C s t | jj| j�� �}t|�S r )�filterr& �matchr" r r )r r r r r �get_pattern_keyss s zDictFilter.get_pattern_keysc C s | j �| j�S r )r# �unionr' r r r r r( y � zDictFilter.include_keysc C s | j �| j�� �S r )r( r r" r r r r r r } � zDictFilter.keysc C s t | jj| �� �S r )�mapr" �getr r r r r �values� r. zDictFilter.valuesc C r r )r( r r" )r �ir r r r � r zDictFilter.__getitem__c C s | � � }t| jj|�}t||�S r )r r/ r" r0 �zip)r r r1 r r r �items� s zDictFilter.itemsc C s t | �|kS r �r" �r �otherr r r �__eq__� � zDictFilter.__eq__c C s t | �|kS r r5 r6 r r r �__ne__� r9 zDictFilter.__ne__)r r r r r r+ r r' �propertyr( r r1 r r4 r8 r: r r r r r! B s ' r! c s t � fdd�|�� D ��S )a1 dict_map is much like the built-in function map. It takes a dictionary and applys a function to the values of that dictionary, returning a new dictionary with the mapped values in the original keys. >>> d = dict_map(lambda x:x+1, dict(a=1, b=2)) >>> d == dict(a=2,b=3) True c 3 s � | ] \}}|� |�fV qd S r r )�.0r �value��functionr r � <genexpr>� s � zdict_map.<locals>.<genexpr>)r" r4 )r? Z dictionaryr r> r �dict_map� s rA c @ sv e Zd ZdZi ejfdd�Zdd� Zddd�Zd d � Z d d � Z e e d �e fi �� ZG dd� de�Zed�Zed�ZdS )�RangeMapa. 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. cmp [python 2 only], keys, reverse) as sort_params. Let's 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' But you'll 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' c C s t �| |� || _|| _d S r )r" r � sort_paramsr* )r �sourcerC �key_match_comparatorr r r r � s zRangeMap.__init__c C sb t | �� fi | j��}t|tj�r| �|| �}|S | �||�}t�| |�}|tj u r/t |��|S r ) �sortedr rC � isinstancerB �Itemr �_find_first_match_r" �undefined_valuer )r �item� sorted_keys�resultr r r r r � s � zRangeMap.__getitem__Nc C �" z| | W S t y | Y S 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 )r r �defaultr r r r0 � s �z RangeMap.getc C s0 t �| j|�}tt||��}|r|d S t|���Nr )� functools�partialr* �listr) r )r r rK Zis_match�matchesr r r rI � s zRangeMap._find_first_match_c C s* t | �� fi | j��}|tj |tj fS r )rF r rC rB � first_item� last_item)r rL r r r �bounds s zRangeMap.boundsZRangeValueUndefinedc @ s e Zd ZdZdS )z RangeMap.Itemz RangeMap ItemN)r r r r r r r r rH s rH r ���r )r r r r �operator�ler r r0 rI rX �type�str�objectrJ �intrH rV rW r r r r rB � s ? rB c C � | S r r )�xr r r � __identity � rb Fc s � fdd�}t | �� ||d�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 s � | d �S rQ r )rK �r r r � pairkey_key% r9 z!sorted_items.<locals>.pairkey_key)r �reverse)rF r4 )�dr rf re r rd r � sorted_items s rh c s� e Zd ZdZedd� �Z� fdd�Z� fdd�Z� fdd �Z� fd d �Z � fd d �Z � fdd�Z � fdd�Z � fdd�Z dd� Z� ZS )�KeyTransformingDictz� A dict subclass that transforms the keys before they're used. Subclasses may override the default transform_key to customize behavior. c C r` r r rd r r r � transform_key1 s z!KeyTransformingDict.transform_keyc s8 t t| ��� t|i |��}|�� D ]}| j|� qd S r )�superri r r" r4 � __setitem__)r �argsZkargsrg rK �� __class__r r r 5 s �z KeyTransformingDict.__init__c s | � |�}tt| ��||� d S r )rj rk ri rl )r r �valrn r r rl = s z KeyTransformingDict.__setitem__c � | � |�}tt| ��|�S r )rj rk ri r r rn r r r A � z KeyTransformingDict.__getitem__c rq r )rj rk ri � __contains__r rn r r rs E rr z KeyTransformingDict.__contains__c rq r )rj rk ri � __delitem__r rn r r rt I rr z KeyTransformingDict.__delitem__c �( | � |�}tt| �j|g|�R i |��S r )rj rk ri r0 �r r rm �kwargsrn r r r0 M � zKeyTransformingDict.getc ru r )rj rk ri � setdefaultrv rn r r ry Q rx z KeyTransformingDict.setdefaultc ru r )rj rk ri �poprv rn r r rz U rx zKeyTransformingDict.popc s4 zt � fdd�| �� D ��W S ty t� ��w )z� Given a key, return the actual key stored in self that matches. Raise KeyError if the key isn't found. c 3 s � | ] }|� kr|V qd S r r )r< Ze_keyrd r r r@ _ � � z7KeyTransformingDict.matching_key_for.<locals>.<genexpr>)�nextr � StopIterationr r r rd r �matching_key_forY s �z$KeyTransformingDict.matching_key_for)r r r r � staticmethodrj r rl r rs rt r0 ry rz r~ � __classcell__r r rn r ri + s ri c @ s e Zd ZdZedd� �ZdS )�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'})).replace("u'", "'")) {'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 C s t j�| �S r )�jaraco�textZ FoldedCaserd r r r rj � s z!FoldedCaseKeyedDict.transform_keyN)r r r r r rj r r r r r� d s Jr� c @ s e Zd ZdZdd� Zdd� ZdS )� 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 C � || _ d S r )r^ )r Z wrapped_obr r r r � � zDictAdapter.__init__c C s t | j|�S r )�getattrr^ )r �namer r r r � r9 zDictAdapter.__getitem__N)r r r r r r r r r r r� � s r� c � e Zd ZdZ� fdd�Z� ZS )�ItemsAsAttributesa� Mix-in class to enable a mapping object to provide items as attributes. >>> C = type(str('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( ... str('C'), ... (dict, ItemsAsAttributes), ... dict(__missing__ = missing_func), ... ) >>> i = C() >>> i.missing 'missing item' >>> i.foo 'missing item' c s� z t tt| �|�W S ty@ } z+t� }dd� }|| ||�}||ur*|W Y d }~S |j\}|�d| jjd�}|f|_� d }~ww )Nc S rN r rO )Zcontr Zmissing_resultr r r � _safe_getitem� s �z4ItemsAsAttributes.__getattr__.<locals>._safe_getitemrk � ) r� rk r� �AttributeErrorr^ rm �replacero r )r r �eZnovalr� rM �messagern r r � __getattr__� s ��z ItemsAsAttributes.__getattr__)r r r r r� r� r r rn r r� � s ,r� c C s2 t dd� | �� D ��}t|�t| �kstd��|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 s s � | ] \}}||fV qd S r r )r< �k�vr r r r@ r{ z invert_map.<locals>.<genexpr>z Key conflict in inverted mapping)r" r4 r � ValueError)r/ �resr r r � invert_map s r� c @ � e Zd ZdZdd� ZdS )�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 C s |S r r r r r r � __missing__0 rc z IdentityOverrideMap.__missing__N)r r r r r� r r r r r� # s r� c @ s& e Zd ZdZdd� Zdd� ZejZdS )� 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 >>> stack.push(dict(a=3)) >>> stack['a'] 3 >>> set(stack.keys()) == set(['a', 'b', 'c']) True >>> dict(**stack) == dict(a=3, c=2, b=2) True >>> d = stack.pop() >>> stack['a'] 2 >>> d = stack.pop() >>> stack['a'] 1 >>> stack.get('b', None) c C s t ttj�dd� | D ����S )Nc s s � | ]}|� � V qd S r )r )r< �cr r r r@ Q � � z!DictStack.keys.<locals>.<genexpr>)rT r � itertools�chain� from_iterabler r r r r P s zDictStack.keysc C s* t | �D ] }||v r|| S qt|��r )�reversedr )r r Zscoper r r r S s �zDictStack.__getitem__N) r r r r r r rT �append�pushr r r r r� 4 s r� c sT e Zd ZdZ� fdd�Z� fdd�Zdd� Z� fdd �Z� fd d �Zd d � Z � Z 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 s" t t| ��� | j|i |�� d S r )rk r� r �update�r rm rw rn r r r � s zBijectiveMap.__init__c sl ||krt d��|| v r| | |kp|| v o| | |k}|r"t d��tt| ��||� tt| ��||� d S )NzKey cannot map to itselfz Key/Value pairs may not overlap)r� rk r� rl )r rK r= Zoverlaprn r r rl � s � �zBijectiveMap.__setitem__c C s | � |� d S r )rz )r rK r r r rt � s zBijectiveMap.__delitem__c s t t| ��� d S )N� )rk r� r r rn r r r � r. zBijectiveMap.__len__c s6 | | }t t| ��|� t t| �j|g|�R i |��S r )rk r� rt rz )r r rm rw Zmirrorrn r r rz � s zBijectiveMap.popc O s* t |i |��}|�� D ]}| j|� q d S r )r" r4 rl )r rm rw rg rK r r r r� � s �zBijectiveMap.update) r r r r r rl rt r rz r� r� r r rn r r� \ s = r� c sf e Zd ZdZdgZ� fdd�Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z � ZS )� 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 Z__datac s$ t t| ��| �}t|i |��|_|S r )rk r� �__new__r" �_FrozenDict__data)�clsrm rw r rn r r r� � s zFrozenDict.__new__c C s || j v S r �r� r r r r rs � r� zFrozenDict.__contains__c C s t tt| j�� ���S r )�hashr rF r� r4 r r r r �__hash__ r zFrozenDict.__hash__c C � t | j�S r )r r� r r r r r r� zFrozenDict.__iter__c C r� r )r r� r r r r r r� zFrozenDict.__len__c C s | j | S r r� r r r r r r� zFrozenDict.__getitem__c O s | j j|i |��S r )r� r0 r� r r r r0 r. zFrozenDict.getc C s t |t�r|j}| j�|�S r )rG r� r� r8 r6 r r r r8 s zFrozenDict.__eq__c C s t � | �S )z Return a shallow copy of self)�copyr r r r r� s zFrozenDict.copy)r r r r � __slots__r� rs r� r r r r0 r8 r� r� r r rn r r� � s 4 r� c s: e Zd ZdZd � fdd� Zedd� �Zedd� �Z� ZS ) � 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' Nc s< t |t�r |�� }|d u rt�� }tt| ��t||�� d S r ) rG r] �splitr� �countrk r� r r3 )r �names�codesrn r r r = s zEnumeration.__init__c C s dd� | D �S )Nc s s � | ] }t |t�r|V qd S r )rG r] )r< r r r r r@ F s � z$Enumeration.names.<locals>.<genexpr>r r r r r r� D r- zEnumeration.namesc s � fdd�� j D �S )Nc 3 s � | ]}� | V qd S r r )r< r� r r r r@ J r� z$Enumeration.codes.<locals>.<genexpr>)r� r r r r r� H s zEnumeration.codesr ) r r r r r r; r� r� r� r r rn r r� s r� c @ r� )� 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 C � dS �NTr r6 r r r rs \ rc zEverything.__contains__N)r r r r rs r r r r r� M s r� c r� )�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 s t � �� || _d S r )rk r �data)r r� rn r r r q r zInstrumentedDict.__init__)r r r r r r� r r rn r r� ` s r� c @ �( e Zd ZdZdd� ZeZdd� ZeZdS )�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 C r� r� r r6 r r r �__le__� rc z Least.__le__c C r� �NFr r6 r r r �__ge__� rc z Least.__ge__N)r r r r r� �__lt__r� �__gt__r r r r r� v � r� c @ r� )�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 C r� r� r r6 r r r r� � rc zGreatest.__ge__c C r� r� r r6 r r r r� � rc zGreatest.__le__N)r r r r r� r� r� r� r r r r r� � r� r� c C s | dd� g }| 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 )r4 rM r r r �pop_all� s r� c �( e Zd ZdZ� fdd�Zdd� Z� ZS )�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 s t | dt� j�|�S )N�_frozen)r� rk r� r rn r r r� � s z FreezableDefaultDict.__missing__c s � fdd�� _ d S )Nc s � � � S r )�default_factoryrd r r r �<lambda>� s z-FreezableDefaultDict.freeze.<locals>.<lambda>)r� r r r r �freeze� r. zFreezableDefaultDict.freeze)r r r r r� r� r� r r rn r r� � s r� c @ s e Zd Zddd�Zdd� ZdS )� Accumulatorr c C r� r �rp )r �initialr r r r � r� zAccumulator.__init__c C s | j |7 _ | j S r r� )r rp r r r �__call__� s zAccumulator.__call__N)r )r r r r r� r r r r r� � s r� c r� )�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 s> t |i |��}tt� |�� �}t� jt||�� �tj d� d S )N)rE ) r" r/ r� r1 rk r r3 r rZ �lt)r rm rw �rawZindexesrn r r r s zWeightedLookup.__init__c C s | � � \}}t�� | }| | S r )rX �random)r �lower�upper�selectorr r r r� s zWeightedLookup.random)r r r r r r� r� r r rn r r� � s !r� ),r$ rZ �collections.abc� collectionsr� r� rR r� Zjaraco.classes.propertiesr Z jaraco.textr� �abc�Mappingr r^ r! rA r" rB rb rh ri r� r� r� r� r� rT r� r� �Hashabler� r� r� �UserDictr� r� r� r� � defaultdictr� r� r� r r r r �<module> sB 5R p9PF(c]1
Save