,hXdZddlZddlZddlmZddlmZmZddlm Z  ddl m Z m Z m Z mZmZGdd eZd ZGd d e eZGd de eZGddeeZy#e$rddlm Z m Z m Z mZmZYHwxYw)aSorted Dict ============== :doc:`Sorted Containers` is an Apache2 licensed Python sorted collections library, written in pure-Python, and fast as C-extensions. The :doc:`introduction` is the best way to get started. Sorted dict implementations: .. currentmodule:: sortedcontainers * :class:`SortedDict` * :class:`SortedKeysView` * :class:`SortedItemsView` * :class:`SortedValuesView` N)chain) SortedListrecursive_repr SortedSet) ItemsViewKeysViewMapping ValuesViewSequenceceZdZdZdZedZedZdZdZ dZ dZ d Z e Z d Zd Zd Zd ZeZed(dZdZdZdZej2dkr9dZeddZeddZeddZeddZeddZeddZ Gdde!Z"e"Z#e#fd Z$d)d!Z%d)d"Z&d(d#Z'd$Z(e(Z)d%Z*e+d&Z,d'Z-y)* SortedDictaSorted 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*|r%|dt|dr|dx}|_|dd}n dx}|_t||_|j}|j|_|j |_|j|_ |j|_ |j|_ |j|_|j |_|j$|_|j&|_|j&|_|j*|_|j,|_|j.|_|j0|_|D|j2|_|j4|_|j6|_|j8|_|j:|i|y)aQInitialize 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 rNr)key)callable_keyr_listadd _list_addclear _list_clear__iter__ _list_iter __reversed___list_reversedpop _list_popremove _list_removeupdate _list_update bisect_left bisect_rightbisectindexirangeislice_resetbisect_key_leftbisect_key_right bisect_key irange_key_update)selfargskwargsrrs ]/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/sortedcontainers/sorteddict.py__init__zSortedDict.__init__qsRJ T!W_a(9#Aw &D498D# #D49D)   ;;..#00!LL!LL!,,(( !..[[ ll ll ll  #(#8#8D $)$:$:D !#..DO#..DO d%f%c|jS)zFunction used to extract comparison key from keys. Sorted dict compares keys directly when the key function is none. )rr/s r2rzSortedDict.keysyyr4c |jS#t$r3tjdtdt |x}|_|cYSwxYw)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.) stacklevel)_ilocAttributeErrorwarningswarnDeprecationWarningSortedKeysView)r/r:s r2iloczSortedDict.ilocsO ::   MM2"   "0!5 5EDJL s 9A  A cNtj||jy)zPRemove all items from sorted dict. Runtime complexity: `O(n)` N)dictrrr6s r2rzSortedDict.clears 4 r4cRtj|||j|y)aRemove 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)rB __delitem__r )r/rs r2rDzSortedDict.__delitem__s"( s# #r4c"|jS)zReturn 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. )rr6s r2rzSortedDict.__iter__s  r4c"|jS)aReturn 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. )rr6s r2rzSortedDict.__reversed__ s""$$r4c\||vr|j|tj|||y)aStore 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)rrB __setitem__)r/rvalues r2rHzSortedDict.__setitem__s)$ d? NN3  sE*r4ct|tstSt|j |j }|j |j |SN isinstancer NotImplementedritems __class__rr/otherrOs r2__or__zSortedDict.__or__1s?%)! !djjlEKKM2~~dii//r4ct|tstSt|j |j }|j |j |SrKrLrQs r2__ror__zSortedDict.__ror__8s?%)! !ekkmTZZ\2~~dii//r4c(|j||SrK)r.)r/rRs r2__ior__zSortedDict.__ior__?s U r4cV|j|j|jS)zyReturn a shallow copy of the sorted dict. Runtime complexity: `O(n)` :return: new sorted dict )rPrrOr6s r2copyzSortedDict.copyDs~~dii66r4Nc&|fd|DS)zReturn 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 c3&K|]}|f ywrK).0rrIs r2 z&SortedDict.fromkeys..]s4CC<4r\)clsiterablerIs `r2fromkeyszSortedDict.fromkeysQs48444r4ct|S)zReturn new sorted keys view of the sorted dict's keys. See :class:`SortedKeysView` for details. :return: new sorted keys view )r?r6s r2keyszSortedDict.keys`sd##r4ct|S)zReturn new sorted items view of the sorted dict's items. See :class:`SortedItemsView` for details. :return: new sorted items view )SortedItemsViewr6s r2rOzSortedDict.itemskst$$r4ct|S)zReturn new sorted values view of the sorted dict's values. See :class:`SortedValuesView` for details. :return: new sorted values view )SortedValuesViewr6s r2valueszSortedDict.valuesvs %%r4icfdj||fd}||_|_t|S)NzQSortedDict.{original}() is not implemented. Use SortedDict.{alternate}() instead.)original alternatectrK)r;)r/messages r2methodz6SortedDict.__make_raise_attributeerror..methods$W--r4)format__name____doc__property)rkrlrorns @r2__make_raise_attributeerrorz&SortedDict.__make_raise_attributeerrors;9fh)f<  .'FO$FNF# #r4 iteritemsrOiterkeysrd itervaluesri viewitemsviewkeys viewvaluesceZdZdZy)SortedDict._NotGivency)Nz r\r6s r2__repr__zSortedDict._NotGiven.__repr__s r4N)rq __module__ __qualname__r~r\r4r2 _NotGivenr|s !r4rc||vr'|j|tj||S||jur t ||S)aRemove 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 )r rBr_SortedDict__not_givenKeyErrorr/rdefaults r2rzSortedDict.popsG0 $;   c "88D#& &$***sm#Nr4cr|s td|j|}tj||}||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 zpopitem(): dictionary is empty)rrrBr)r/r&rrIs r2popitemzSortedDict.popitems;8;< <nnU#s#U|r4c.|j|}|||fS)a0Return ``(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&rs r2peekitemzSortedDict.peekitems 6jjDI~r4ch||vr||Stj||||j||S)aReturn 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` )rBrHrrs r2 setdefaultzSortedDict.setdefaults80 $;9  sG, sr4c|s>tj|g|i||jtj|y|s't |dk(rt |dtr|d}n t|i|}dt |zt |kDrKtj|||j |jtj|y|D]}|j|||y)asUpdate 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 Nrr )rBr!r"rlenrMr_setitem)r/r0r1pairsrs r2r!zSortedDict.update!s KK .t .v .   dmmD1 2 #d)q.ZQ-FGE$)&)E UOs4y ( KKe $       dmmD1 2 / c5:. /r4c^tj|}t||j|ffS)zSupport for pickle. The tricks played with caching references in :func:`SortedDict.__init__` confuse pickle so customize the reducer. )rBrYtyper)r/rOs r2 __reduce__zSortedDict.__reduce__Cs) $T TYY.//r4cj}tj}|dndj|}djdj fdj D}dj|||S)zReturn string representation of sorted dict. ``sd.__repr__()`` <==> ``repr(sd)`` :return: string representation z{0!r}, z {0!r}: {1!r}z, c36K|]}||ywrKr\)r]r item_formatr/s r2r^z&SortedDict.__repr__..[sL#+c495Lsz{0}({1}{{{2}}}))rrrqrpjoinr)r/r type_namekey_argrOrs` @r2r~zSortedDict.__repr__NskyyJ''  ")*:*:4*@$++  LLL '' 7EBBr4cj}|jtt|k(sJtfd|DsJy)zNCheck invariants of sorted dict. Runtime complexity: `O(n)` c3&K|]}|v ywrKr\)r]rr/s r2r^z$SortedDict._check..hs033$;0r_N)r_checkrall)r/rs` r2rzSortedDict._check_s>   4yCJ&&0%0000r4rK)).rqrrrrr3rsrr@rrDrrrHrrSrUrWrY__copy__ classmethodrbrdrOrisys hexversion&_SortedDict__make_raise_attributeerrorrurvrwrxryrzobjectrrrrrrr!r.rrr~rr\r4r2rr+sPDJI&X*0 ! %+,H00 7H 5 5$%& ~~ " $0 WE .z6B0xH / WE .z6B0xH !F! +K*B!H>>/>G0 C C 1r4rc|j}|j}tj}t |t r||}||=|D] }||| y|j |}|||y)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)_mappingrrBrDrMslicer)r/r&rr dict_delitemrdrs r2 _view_delitemrksn2}}H NNE##L%U| %L (C 3 ' (iiXs#r4c.eZdZdZdZedZdZeZ y)r?zSorted 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\ct|SrKrr`its r2_from_iterablezSortedKeysView._from_iterable }r4c4|jj|S)aLookup 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 )rr)r/r&s r2 __getitem__zSortedKeysView.__getitem__s6}}""5))r4N rqrrrr __slots__rrrrrDr\r4r2r?r?s.I*< Kr4r?c.eZdZdZdZedZdZeZ y)rfzSorted 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\ct|SrKrrs r2rzSortedItemsView._from_iterablerr4c|j}|j}t|tr||}|Dcgc] }|||f c}S||}|||fScc}w)aLookup 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 rrrMrr/r&r _mapping_listrdrs r2rzSortedItemsView.__getitem__sb6==  eU # 'D489SS(3-(9 9E"HSM!!:sANrr\r4r2rfrfs/I#"L Kr4rfceZdZdZdZdZeZy)rhzSorted 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|j}|j}t|tr||}|Dcgc]}|| c}S||}||Scc}w)aLookup 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 rrs r2rzSortedValuesView.__getitem__sX6==  eU # 'D-12cHSM2 2E"}3s A N)rqrrrrrrrrDr\r4r2rhrhsI#L Kr4rh)rrrr< itertoolsr sortedlistrr sortedsetrcollections.abcr r r r r ImportError collectionsrBrrr?rfrhr\r4r2rs$ 2 O}1}1@#$L. Xx. b6 i6 r1 z81 qONNOsA!!A76A7