U
|
Z ±d¸X ã @ sà d Z ddlZddlZddlmZ ddlmZmZ ddlm Z z ddl
|
m Z m Z m Z mZmZ W n0 ek
|
r ddlm Z m Z m Z mZmZ Y nX G dd d eZd
|
d ZG d d d e eZG dd de eZG dd deeZdS )a Sorted Dict
|
==============
|
|
:doc:`Sorted Containers<index>` is an Apache2 licensed Python sorted
|
collections library, written in pure-Python, and fast as C-extensions. The
|
:doc:`introduction<introduction>` is the best way to get started.
|
|
Sorted dict implementations:
|
|
.. currentmodule:: sortedcontainers
|
|
* :class:`SortedDict`
|
* :class:`SortedKeysView`
|
* :class:`SortedItemsView`
|
* :class:`SortedValuesView`
|
|
é N)Úchainé )Ú
|
SortedListÚrecursive_repr©Ú SortedSet)Ú ItemsViewÚKeysViewÚMappingÚ
|
ValuesViewÚSequencec @ s^ e Zd ZdZdd Zedd Zedd Zdd Zd
|
d Z d d Z
|
dd Z dd Z e Z dd Zdd Zdd Zdd ZeZedBdd Zd d Zd d Zd!d" Zejd#k rðd$d% Zed&d'Zed(d)Z ed*d+Z ed,d'Z ed-d)Z ed.d+Z G d/d0 d0e!Z"e" Z#e#fd1d2Z$dCd4d5Z%dDd6d7Z&dEd8d9Z'd:d; Z(e(Z)d<d= Z*e+ d>d? Z,d@dA Z-dS )FÚ
|
SortedDictaä Sorted dict is a sorted mutable mapping.
|
|
Sorted dict keys are maintained in sorted order. The design of sorted dict
|
is simple: sorted dict inherits from dict to store items and maintains a
|
sorted list of keys.
|
|
Sorted dict keys must be hashable and comparable. The hash and total
|
ordering of keys must not change while they are stored in the sorted dict.
|
|
Mutable mapping methods:
|
|
* :func:`SortedDict.__getitem__` (inherited from dict)
|
* :func:`SortedDict.__setitem__`
|
* :func:`SortedDict.__delitem__`
|
* :func:`SortedDict.__iter__`
|
* :func:`SortedDict.__len__` (inherited from dict)
|
|
Methods for adding items:
|
|
* :func:`SortedDict.setdefault`
|
* :func:`SortedDict.update`
|
|
Methods for removing items:
|
|
* :func:`SortedDict.clear`
|
* :func:`SortedDict.pop`
|
* :func:`SortedDict.popitem`
|
|
Methods for looking up items:
|
|
* :func:`SortedDict.__contains__` (inherited from dict)
|
* :func:`SortedDict.get` (inherited from dict)
|
* :func:`SortedDict.peekitem`
|
|
Methods for views:
|
|
* :func:`SortedDict.keys`
|
* :func:`SortedDict.items`
|
* :func:`SortedDict.values`
|
|
Methods for miscellany:
|
|
* :func:`SortedDict.copy`
|
* :func:`SortedDict.fromkeys`
|
* :func:`SortedDict.__reversed__`
|
* :func:`SortedDict.__eq__` (inherited from dict)
|
* :func:`SortedDict.__ne__` (inherited from dict)
|
* :func:`SortedDict.__repr__`
|
* :func:`SortedDict._check`
|
|
Sorted list methods available (applies to keys):
|
|
* :func:`SortedList.bisect_left`
|
* :func:`SortedList.bisect_right`
|
* :func:`SortedList.count`
|
* :func:`SortedList.index`
|
* :func:`SortedList.irange`
|
* :func:`SortedList.islice`
|
* :func:`SortedList._reset`
|
|
Additional sorted list methods available, if key-function used:
|
|
* :func:`SortedKeyList.bisect_key_left`
|
* :func:`SortedKeyList.bisect_key_right`
|
* :func:`SortedKeyList.irange_key`
|
|
Sorted dicts may only be compared for equality and inequality.
|
|
c O sü |r8|d dks t |d r8|d }| _|dd
}n
|
d }| _t|d| _| j}|j| _|j| _|j| _ |j
|
| _ |j | _ |j| _|j| _|j| _|j| _|j| _|j| _|j| _|j| _|j| _|dk rì|j| _|j| _|j| _|j | _ | j || dS )aQ Initialize sorted dict instance.
|
|
Optional key-function argument defines a callable that, like the `key`
|
argument to the built-in `sorted` function, extracts a comparison key
|
from each dictionary key. If no function is specified, the default
|
compares the dictionary keys directly. The key-function argument must
|
be provided as a positional argument and must come before all other
|
arguments.
|
|
Optional iterable argument provides an initial sequence of pairs to
|
initialize the sorted dict. Each pair in the sequence defines the key
|
and corresponding value. If a key is seen more than once, the last
|
value associated with it is stored in the new sorted dict.
|
|
Optional mapping argument provides an initial mapping of items to
|
initialize the sorted dict.
|
|
If keyword arguments are given, the keywords themselves, with their
|
associated values, are added as items to the dictionary. If a key is
|
specified both in the positional argument and as a keyword argument,
|
the value associated with the keyword is stored in the
|
sorted dict.
|
|
Sorted dict keys must be hashable, per the requirement for Python's
|
dictionaries. Keys (or the result of the key-function) must also be
|
comparable, per the requirement for sorted lists.
|
|
>>> d = {'alpha': 1, 'beta': 2}
|
>>> SortedDict([('alpha', 1), ('beta', 2)]) == d
|
True
|
>>> SortedDict({'alpha': 1, 'beta': 2}) == d
|
True
|
>>> SortedDict(alpha=1, beta=2) == d
|
True
|
|
r Nr )Úkey) ÚcallableÚ_keyr Ú_listÚaddÚ _list_addÚclearÚ _list_clearÚ__iter__Ú
|
_list_iterÚ __reversed__Ú_list_reversedÚpopÚ _list_popÚremoveÚ _list_removeÚupdateÚ _list_updateÚ bisect_leftÚ bisect_rightÚbisectÚindexZirangeÚisliceZ_resetZbisect_key_leftZbisect_key_rightZ
|
bisect_keyZ
|
irange_keyÚ_update)ÚselfÚargsÚkwargsr r © r) úRd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sortedcontainers/sorteddict.pyÚ__init__q s4 %
|
zSortedDict.__init__c C s | j S )zFunction used to extract comparison key from keys.
|
|
Sorted dict compares keys directly when the key function is none.
|
|
)r ©r& r) r) r* r ½ s zSortedDict.keyc C sD z| j W S tk
|
r> tjdtdd t| }| _ | Y S X dS )zCached reference of sorted keys view.
|
|
Deprecated in version 2 of Sorted Containers. Use
|
:func:`SortedDict.keys` instead.
|
|
z>sorted_dict.iloc is deprecated. Use SortedDict.keys() instead.é )Ú
|
stacklevelN)Ú_ilocÚAttributeErrorÚwarningsÚwarnÚDeprecationWarningÚSortedKeysView)r& r/ r) r) r* ÚilocÇ s üzSortedDict.ilocc C s t | ¡ | ¡ dS )zPRemove all items from sorted dict.
|
|
Runtime complexity: `O(n)`
|
|
N)Údictr r r, r) r) r* r Ý s
|
zSortedDict.clearc C s t | |¡ | |¡ dS )aê Remove item from sorted dict identified by `key`.
|
|
``sd.__delitem__(key)`` <==> ``del sd[key]``
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
|
>>> del sd['b']
|
>>> sd
|
SortedDict({'a': 1, 'c': 3})
|
>>> del sd['z']
|
Traceback (most recent call last):
|
...
|
KeyError: 'z'
|
|
:param key: `key` for item lookup
|
:raises KeyError: if key not found
|
|
N)r6 Ú __delitem__r )r& r r) r) r* r7 è s zSortedDict.__delitem__c C s | ¡ S )z÷Return an iterator over the keys of the sorted dict.
|
|
``sd.__iter__()`` <==> ``iter(sd)``
|
|
Iterating the sorted dict while adding or deleting items may raise a
|
:exc:`RuntimeError` or fail to iterate over all keys.
|
|
)r r, r) r) r* r s zSortedDict.__iter__c C s | ¡ S )a Return a reverse iterator over the keys of the sorted dict.
|
|
``sd.__reversed__()`` <==> ``reversed(sd)``
|
|
Iterating the sorted dict while adding or deleting items may raise a
|
:exc:`RuntimeError` or fail to iterate over all keys.
|
|
)r r, r) r) r* r s zSortedDict.__reversed__c C s$ || kr| |¡ t | ||¡ dS )a Store item in sorted dict with `key` and corresponding `value`.
|
|
``sd.__setitem__(key, value)`` <==> ``sd[key] = value``
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sd = SortedDict()
|
>>> sd['c'] = 3
|
>>> sd['a'] = 1
|
>>> sd['b'] = 2
|
>>> sd
|
SortedDict({'a': 1, 'b': 2, 'c': 3})
|
|
:param key: key for item
|
:param value: value for item
|
|
N)r r6 Ú __setitem__)r& r Úvaluer) r) r* r8 s
|
zSortedDict.__setitem__c C s. t |tstS t| ¡ | ¡ }| | j|¡S ©N©Ú
|
isinstancer
|
ÚNotImplementedr ÚitemsÚ __class__r ©r& Úotherr> r) r) r* Ú__or__1 s
|
zSortedDict.__or__c C s. t |tstS t| ¡ | ¡ }| | j|¡S r: r; r@ r) r) r* Ú__ror__8 s
|
zSortedDict.__ror__c C s | |¡ | S r: )r% )r& rA r) r) r* Ú__ior__? s
|
zSortedDict.__ior__c C s | | j| ¡ ¡S )zyReturn a shallow copy of the sorted dict.
|
|
Runtime complexity: `O(n)`
|
|
:return: new sorted dict
|
|
)r? r r> r, r) r) r* ÚcopyD s zSortedDict.copyNc s | fdd|D S )zùReturn a new sorted dict initailized from `iterable` and `value`.
|
|
Items in the sorted dict have keys from `iterable` and values equal to
|
`value`.
|
|
Runtime complexity: `O(n*log(n))`
|
|
:return: new sorted dict
|
|
c 3 s | ]}| fV qd S r: r) ©Ú.0r ©r9 r) r* Ú <genexpr>] s z&SortedDict.fromkeys.<locals>.<genexpr>r) )ÚclsÚiterabler9 r) rH r* ÚfromkeysQ s zSortedDict.fromkeysc C s t | S )zReturn new sorted keys view of the sorted dict's keys.
|
|
See :class:`SortedKeysView` for details.
|
|
:return: new sorted keys view
|
|
)r4 r, r) r) r* Úkeys` s zSortedDict.keysc C s t | S )zReturn new sorted items view of the sorted dict's items.
|
|
See :class:`SortedItemsView` for details.
|
|
:return: new sorted items view
|
|
)ÚSortedItemsViewr, r) r) r* r> k s zSortedDict.itemsc C s t | S )z¡Return new sorted values view of the sorted dict's values.
|
|
See :class:`SortedValuesView` for details.
|
|
:return: new sorted values view
|
|
)ÚSortedValuesViewr, r) r) r* Úvaluesv s zSortedDict.valuesi c s. dj | |d fdd}| |_ |_t|S )NzQSortedDict.{original}() is not implemented. Use SortedDict.{alternate}() instead.)ÚoriginalÚ alternatec s t d S r: )r0 r, ©Úmessager) r* Úmethod s z6SortedDict.__make_raise_attributeerror.<locals>.method)ÚformatÚ__name__Ú__doc__Úproperty)rQ rR rU r) rS r* Z__make_raise_attributeerror s ÿ ý z&SortedDict.__make_raise_attributeerrorÚ iteritemsr> ÚiterkeysrM Ú
|
itervaluesrP Ú viewitemsÚviewkeysÚ
|
viewvaluesc @ s e Zd Zdd ZdS )zSortedDict._NotGivenc C s dS )Nz <not-given>r) r, r) r) r* Ú__repr__ s z SortedDict._NotGiven.__repr__N)rW Ú
|
__module__Ú __qualname__r` r) r) r) r* Ú _NotGiven s rc c C s8 || kr | |¡ t | |¡S || jkr0t||S dS )a Remove and return value for item identified by `key`.
|
|
If the `key` is not found then return `default` if given. If `default`
|
is not given then raise :exc:`KeyError`.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
|
>>> sd.pop('c')
|
3
|
>>> sd.pop('z', 26)
|
26
|
>>> sd.pop('y')
|
Traceback (most recent call last):
|
...
|
KeyError: 'y'
|
|
:param key: `key` for item
|
:param default: `default` value if key not found (optional)
|
:return: value for item
|
:raises KeyError: if `key` not found and `default` not given
|
|
N)r r6 r Ú_SortedDict__not_givenÚKeyError©r& r Údefaultr) r) r* r s
|
|
zSortedDict.popéÿÿÿÿc C s* | s t d| |¡}t | |¡}||fS )a_ Remove and return ``(key, value)`` pair at `index` from sorted dict.
|
|
Optional argument `index` defaults to -1, the last item in the sorted
|
dict. Specify ``index=0`` for the first item in the sorted dict.
|
|
If the sorted dict is empty, raises :exc:`KeyError`.
|
|
If the `index` is out of range, raises :exc:`IndexError`.
|
|
Runtime complexity: `O(log(n))`
|
|
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
|
>>> sd.popitem()
|
('c', 3)
|
>>> sd.popitem(0)
|
('a', 1)
|
>>> sd.popitem(100)
|
Traceback (most recent call last):
|
...
|
IndexError: list index out of range
|
|
:param int index: `index` of item (default -1)
|
:return: key and value pair
|
:raises KeyError: if sorted dict is empty
|
:raises IndexError: if `index` out of range
|
|
z popitem(): dictionary is empty)re r r6 r )r& r# r r9 r) r) r* Úpopitem¿ s
|
|
zSortedDict.popitemc C s | j | }|| | fS )a0 Return ``(key, value)`` pair at `index` in sorted dict.
|
|
Optional argument `index` defaults to -1, the last item in the sorted
|
dict. Specify ``index=0`` for the first item in the sorted dict.
|
|
Unlike :func:`SortedDict.popitem`, the sorted dict is not modified.
|
|
If the `index` is out of range, raises :exc:`IndexError`.
|
|
Runtime complexity: `O(log(n))`
|
|
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
|
>>> sd.peekitem()
|
('c', 3)
|
>>> sd.peekitem(0)
|
('a', 1)
|
>>> sd.peekitem(100)
|
Traceback (most recent call last):
|
...
|
IndexError: list index out of range
|
|
:param int index: index of item (default -1)
|
:return: key and value pair
|
:raises IndexError: if `index` out of range
|
|
)r )r& r# r r) r) r* Úpeekitemã s
|
zSortedDict.peekitemc C s, || kr| | S t | ||¡ | |¡ |S )a Return value for item identified by `key` in sorted dict.
|
|
If `key` is in the sorted dict then return its value. If `key` is not
|
in the sorted dict then insert `key` with value `default` and return
|
`default`.
|
|
Optional argument `default` defaults to none.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sd = SortedDict()
|
>>> sd.setdefault('a', 1)
|
1
|
>>> sd.setdefault('a', 10)
|
1
|
>>> sd
|
SortedDict({'a': 1})
|
|
:param key: key for item
|
:param default: value for item (default None)
|
:return: value for item identified by `key`
|
|
)r6 r8 r rf r) r) r* Ú
|
setdefault s
|
|
zSortedDict.setdefaultc O s´ | s*t j| f|| | t | ¡¡ dS |sRt|dkrRt|d t rR|d }n
|
t ||}dt| t| krt | |¡ | ¡ | t | ¡¡ n|D ]}| ||| ¡ qdS )as Update sorted dict with items from `args` and `kwargs`.
|
|
Overwrites existing items.
|
|
Optional arguments `args` and `kwargs` may be a mapping, an iterable of
|
pairs or keyword arguments. See :func:`SortedDict.__init__` for
|
details.
|
|
:param args: mapping or iterable of pairs
|
:param kwargs: keyword arguments mapping
|
|
Nr r é
|
)r6 r r r Úlenr< r Ú_setitem)r& r' r( Úpairsr r) r) r* r ! s
|
|
zSortedDict.updatec C s t | ¡}t| | j|ffS )z Support for pickle.
|
|
The tricks played with caching references in
|
:func:`SortedDict.__init__` confuse pickle so customize the reducer.
|
|
)r6 rE Útyper )r& r> r) r) r* Ú
|
__reduce__C s
|
zSortedDict.__reduce__c sV j }tj}|dkr dnd |¡}dj d fddjD ¡}d |||¡S ) zReturn string representation of sorted dict.
|
|
``sd.__repr__()`` <==> ``repr(sd)``
|
|
:return: string representation
|
|
NÚ z{0!r}, z {0!r}: {1!r}z, c 3 s | ]} || V qd S r: r) rF ©Z item_formatr& r) r* rI [ s z&SortedDict.__repr__.<locals>.<genexpr>z{0}({1}{{{2}}}))r rp rW rV Újoinr )r& r Z type_nameZkey_argr> r) rs r* r` N s
|
zSortedDict.__repr__c s@ j }| ¡ t t|ks"tt fdd|D s<tdS )zNCheck invariants of sorted dict.
|
|
Runtime complexity: `O(n)`
|
|
c 3 s | ]}| kV qd S r: r) rF r, r) r* rI h s z$SortedDict._check.<locals>.<genexpr>N)r Ú_checkrm ÚAssertionErrorÚall)r& r r) r, r* ru _ s zSortedDict._check)N)rh )rh )N).rW ra rb rX r+ rY r r5 r r7 r r r8 rn rB rC rD rE Ú__copy__Ú classmethodrL rM r> rP ÚsysÚ
|
hexversionZ&_SortedDict__make_raise_attributeerrorrZ r[ r\ r] r^ r_ Úobjectrc rd r ri rj rk r r% rq r r` ru r) r) r) r* r + sT EL
|
|
|
|
|
|
|
|
|
|
!
|
$
|
|
|
r c C sX | j }|j}tj}t|tr@|| }||= |D ]}||| q.n| |¡}||| dS )a
|
Remove item at `index` from sorted dict.
|
|
``view.__delitem__(index)`` <==> ``del view[index]``
|
|
Supports slicing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
|
>>> view = sd.keys()
|
>>> del view[0]
|
>>> sd
|
SortedDict({'b': 2, 'c': 3})
|
>>> del view[-1]
|
>>> sd
|
SortedDict({'b': 2})
|
>>> del view[:]
|
>>> sd
|
SortedDict({})
|
|
:param index: integer or slice for indexing
|
:raises IndexError: if index out of range
|
|
N)Ú_mappingr r6 r7 r< Úslicer )r& r# r} r Z dict_delitemrM r r) r) r* Ú _view_delitemk s
|
|
r c @ s, e Zd ZdZdZedd Zdd ZeZ dS )r4 z×Sorted keys view is a dynamic view of the sorted dict's keys.
|
|
When the sorted dict's keys change, the view reflects those changes.
|
|
The keys view implements the set and sequence abstract base classes.
|
|
r) c C s t |S r: r ©rJ Úitr) r) r* Ú_from_iterable s z SortedKeysView._from_iterablec C s | j j| S )a Lookup key at `index` in sorted keys views.
|
|
``skv.__getitem__(index)`` <==> ``skv[index]``
|
|
Supports slicing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
|
>>> skv = sd.keys()
|
>>> skv[0]
|
'a'
|
>>> skv[-1]
|
'c'
|
>>> skv[:]
|
['a', 'b', 'c']
|
>>> skv[100]
|
Traceback (most recent call last):
|
...
|
IndexError: list index out of range
|
|
:param index: integer or slice for indexing
|
:return: key or list of keys
|
:raises IndexError: if index out of range
|
|
)r} r )r& r# r) r) r* Ú __getitem__¡ s zSortedKeysView.__getitem__N©
|
rW ra rb rX Ú __slots__ry r r r r7 r) r) r) r* r4 s
|
r4 c @ s, e Zd ZdZdZedd Zdd ZeZ dS )rN zÛSorted items view is a dynamic view of the sorted dict's items.
|
|
When the sorted dict's items change, the view reflects those changes.
|
|
The items view implements the set and sequence abstract base classes.
|
|
r) c C s t |S r: r r r) r) r* r Í s z SortedItemsView._from_iterablec sD | j j}t|tr0|| } fdd|D S || }| | fS )a¡ Lookup item at `index` in sorted items view.
|
|
``siv.__getitem__(index)`` <==> ``siv[index]``
|
|
Supports slicing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
|
>>> siv = sd.items()
|
>>> siv[0]
|
('a', 1)
|
>>> siv[-1]
|
('c', 3)
|
>>> siv[:]
|
[('a', 1), ('b', 2), ('c', 3)]
|
>>> siv[100]
|
Traceback (most recent call last):
|
...
|
IndexError: list index out of range
|
|
:param index: integer or slice for indexing
|
:return: item or list of items
|
:raises IndexError: if index out of range
|
|
c s g | ]}| | fqS r) r) rF ©r} r) r* Ú
|
<listcomp>ò s z/SortedItemsView.__getitem__.<locals>.<listcomp>©r} r r< r~ ©r& r# Z _mapping_listrM r r) r r* r Ò s
|
zSortedItemsView.__getitem__Nr r) r) r) r* rN Â s
|
&rN c @ s e Zd ZdZdZdd ZeZdS )rO zÕSorted values view is a dynamic view of the sorted dict's values.
|
|
When the sorted dict's values change, the view reflects those changes.
|
|
The values view implements the sequence abstract base class.
|
|
r) c s@ | j j}t|tr0|| } fdd|D S || } | S )a Lookup value at `index` in sorted values view.
|
|
``siv.__getitem__(index)`` <==> ``siv[index]``
|
|
Supports slicing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
|
>>> svv = sd.values()
|
>>> svv[0]
|
1
|
>>> svv[-1]
|
3
|
>>> svv[:]
|
[1, 2, 3]
|
>>> svv[100]
|
Traceback (most recent call last):
|
...
|
IndexError: list index out of range
|
|
:param index: integer or slice for indexing
|
:return: value or list of values
|
:raises IndexError: if index out of range
|
|
c s g | ] } | qS r) r) rF r r) r* r & s z0SortedValuesView.__getitem__.<locals>.<listcomp>r r r) r r* r s
|
z SortedValuesView.__getitem__N)rW ra rb rX r
r r r7 r) r) r) r* rO û s &rO )rX rz r1 Ú itertoolsr Z
|
sortedlistr r Z sortedsetr Úcollections.abcr r r
|
r r Ú ImportErrorÚ collectionsr6 r r r4 rN rO r) r) r) r* Ú<module> s$ " D&19
|
