,hqMdZddlmZddlmZmZmZmZmZm Z ddl m Z ddl m Z mZ ddlmZmZmZGdd eeZy #e$r ddlmZmZmZYwxYw) aESorted Set ============= :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 set implementations: .. currentmodule:: sortedcontainers * :class:`SortedSet` )chain)eqnegtgeltle)dedent) SortedListrecursive_repr) MutableSetSequenceSetceZdZdZd+dZed,dZedZdZ dZ dZ d Z e e d d Ze ed d Ze eddZe eddZe eddZe eddZee Z dZdZdZdZeZdZdZ e Z!dZ"dZ#e#Z$d-dZ%dZ&d Z'e'Z(d!Z)e)Z*d"Z+e+Z,e,Z-d#Z.e.Z/d$Z0e0Z1e1Z2d%Z3e3Z4d&Z5e5Z6e6Z7d'Z8e8Z9e8Z:d(Z;e<d)Z=d*Z>y). SortedSetaSorted set is a sorted mutable set. Sorted set values are maintained in sorted order. The design of sorted set is simple: sorted set uses a set for set-operations and maintains a sorted list of values. Sorted set values must be hashable and comparable. The hash and total ordering of values must not change while they are stored in the sorted set. Mutable set methods: * :func:`SortedSet.__contains__` * :func:`SortedSet.__iter__` * :func:`SortedSet.__len__` * :func:`SortedSet.add` * :func:`SortedSet.discard` Sequence methods: * :func:`SortedSet.__getitem__` * :func:`SortedSet.__delitem__` * :func:`SortedSet.__reversed__` Methods for removing values: * :func:`SortedSet.clear` * :func:`SortedSet.pop` * :func:`SortedSet.remove` Set-operation methods: * :func:`SortedSet.difference` * :func:`SortedSet.difference_update` * :func:`SortedSet.intersection` * :func:`SortedSet.intersection_update` * :func:`SortedSet.symmetric_difference` * :func:`SortedSet.symmetric_difference_update` * :func:`SortedSet.union` * :func:`SortedSet.update` Methods for miscellany: * :func:`SortedSet.copy` * :func:`SortedSet.count` * :func:`SortedSet.__repr__` * :func:`SortedSet._check` Sorted list methods available: * :func:`SortedList.bisect_left` * :func:`SortedList.bisect_right` * :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 set comparisons use subset and superset relations. Two sorted sets are equal if and only if every element of each sorted set is contained in the other (each is a subset of the other). A sorted set is less than another sorted set if and only if the first sorted set is a proper subset of the second sorted set (is a subset, but is not equal). A sorted set is greater than another sorted set if and only if the first sorted set is a proper superset of the second sorted set (is a superset, but is not equal). Nc||_t|dst|_t |j||_|j}|j |_|j|_|j|_|j }|j|_ |j|_ |j|_ |j|_ |j|_ |j|_|j|_|D|j |_|j"|_|j$|_|j&|_||j)|yy)aInitialize sorted set instance. Optional `iterable` argument provides an initial iterable of values to initialize the sorted set. Optional `key` argument defines a callable that, like the `key` argument to Python's `sorted` function, extracts a comparison key from each value. The default, none, compares values directly. Runtime complexity: `O(n*log(n))` >>> ss = SortedSet([3, 1, 2, 5, 4]) >>> ss SortedSet([1, 2, 3, 4, 5]) >>> from operator import neg >>> ss = SortedSet([3, 1, 2, 5, 4], neg) >>> ss SortedSet([5, 4, 3, 2, 1], key=) :param iterable: initial values (optional) :param key: function used to extract comparison key (optional) _setkeyN)_keyhasattrsetrr _list isdisjointissubset issuperset bisect_leftbisect bisect_rightindexirangeislice_resetbisect_key_leftbisect_key_right bisect_key irange_key_update)selfiterablerrrs \/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/sortedcontainers/sortedset.py__init__zSortedSet.__init__ls0 tV$DI s3 yy//  //  ,,ll !..[[ ll ll ll ?#(#8#8D $)$:$:D !#..DO#..DO   LL " cbtj|}||_|j||S)ztInitialize sorted set from existing set. Used internally by set operations that return a new set. r)object__new__rr-)clsvaluesr sorted_sets r,_fromsetzSortedSet._fromsets0^^C(  $r.c|jS)zFunction used to extract comparison key from values. Sorted set compares values directly when the key function is none. )rr*s r,rz SortedSet.keysyyr.c||jvS)aQReturn true if `value` is an element of the sorted set. ``ss.__contains__(value)`` <==> ``value in ss`` Runtime complexity: `O(1)` >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> 3 in ss True :param value: search for value in sorted set :return: true if `value` in sorted set rr*values r, __contains__zSortedSet.__contains__s !!r.c |j|S)aLookup value at `index` in sorted set. ``ss.__getitem__(index)`` <==> ``ss[index]`` Supports slicing. Runtime complexity: `O(log(n))` -- approximate. >>> ss = SortedSet('abcde') >>> ss[2] 'c' >>> ss[-1] 'e' >>> ss[2:5] ['c', 'd', 'e'] :param index: integer or slice for indexing :return: value or list of values :raises IndexError: if index out of range )r)r*r!s r, __getitem__zSortedSet.__getitem__s,zz%  r.c|j}|j}t|tr||}|j |||=y||}|j |||=y)aRemove value at `index` from sorted set. ``ss.__delitem__(index)`` <==> ``del ss[index]`` Supports slicing. Runtime complexity: `O(log(n))` -- approximate. >>> ss = SortedSet('abcde') >>> del ss[2] >>> ss SortedSet(['a', 'b', 'd', 'e']) >>> del ss[:2] >>> ss SortedSet(['d', 'e']) :param index: integer or slice for indexing :raises IndexError: if index out of range N)rr isinstanceslicedifference_updateremove)r*r!rrr3r;s r, __delitem__zSortedSet.__delitem__s^*yy  eU #5\F  " "6 * %L%LE KK  %Lr.cfd}j}dj||_d}t|j||||_|S)zMake comparator method.ct|tr|j|jSt|tr|j|StS)z&Compare method for sorted set and set.)r@rrrNotImplemented)r*otherset_ops r,comparerz&SortedSet.__make_cmp..comparersC%+dii44E3'dii//! !r.z__{0}__a3Return true if and only if sorted set is {0} `other`. ``ss.__{1}__(other)`` <==> ``ss {2} other`` Comparisons use subset and superset semantics as with sets. Runtime complexity: `O(n)` :param other: `other` set :return: true if sorted set is {0} `other` )__name__formatr __doc__)rIsymboldocrJ set_op_namedoc_strs` r, __make_cmpzSortedSet.__make_cmp sN "oo %,,[9  "'..k6"JKr.z==zequal toz!=z not equal toza proper superset ofz<=z a subset ofz>=z a superset ofc,t|jS)z|Return the size of the sorted set. ``ss.__len__()`` <==> ``len(ss)`` :return: size of sorted set )lenrr7s r,__len__zSortedSet.__len__2s499~r.c,t|jS)zReturn an iterator over the sorted set. ``ss.__iter__()`` <==> ``iter(ss)`` Iterating the sorted set while adding or deleting values may raise a :exc:`RuntimeError` or fail to iterate over all values. )iterrr7s r,__iter__zSortedSet.__iter__=sDJJr.c,t|jS)zReturn a reverse iterator over the sorted set. ``ss.__reversed__()`` <==> ``reversed(ss)`` Iterating the sorted set while adding or deleting values may raise a :exc:`RuntimeError` or fail to iterate over all values. )reversedrr7s r, __reversed__zSortedSet.__reversed__Is ##r.c~|j}||vr-|j||jj|yy)aAdd `value` to sorted set. Runtime complexity: `O(log(n))` -- approximate. >>> ss = SortedSet() >>> ss.add(3) >>> ss.add(1) >>> ss.add(2) >>> ss SortedSet([1, 2, 3]) :param value: value to add to sorted set N)raddrr*r;rs r,r_z SortedSet.addUs5yy   HHUO JJNN5 ! r.cl|jj|jjy)zPRemove all values from sorted set. Runtime complexity: `O(n)` N)rclearrr7s r,rbzSortedSet.clearls"  r.cb|jt|j|jS)zwReturn a shallow copy of the sorted set. Runtime complexity: `O(n)` :return: new sorted set r)r5rrrr7s r,copyzSortedSet.copyvs#}}S^};;r.c&||jvrdSdS)aReturn number of occurrences of `value` in the sorted set. Runtime complexity: `O(1)` >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> ss.count(3) 1 :param value: value to count in sorted set :return: count r rr9r:s r,countzSortedSet.countsTYY&q-A-r.c~|j}||vr-|j||jj|yy)aqRemove `value` from sorted set if it is a member. If `value` is not a member, do nothing. Runtime complexity: `O(log(n))` -- approximate. >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> ss.discard(5) >>> ss.discard(0) >>> ss == set([1, 2, 3, 4]) True :param value: `value` to discard from sorted set NrrCrr`s r,discardzSortedSet.discards7 yy D= KK  JJ  e $ r.cr|jj|}|jj||S)aRemove and return value at `index` in sorted set. Raise :exc:`IndexError` if the sorted set is empty or index is out of range. Negative indices are supported. Runtime complexity: `O(log(n))` -- approximate. >>> ss = SortedSet('abcde') >>> ss.pop() 'e' >>> ss.pop(2) 'c' >>> ss SortedSet(['a', 'b', 'd']) :param int index: index of value (default -1) :return: value :raises IndexError: if index is out of range )rpoprrC)r*r!r;s r,rkz SortedSet.pops-0 u%  r.cp|jj||jj|y)aRemove `value` from sorted set; `value` must be a member. If `value` is not a member, raise :exc:`KeyError`. Runtime complexity: `O(log(n))` -- approximate. >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> ss.remove(5) >>> ss == set([1, 2, 3, 4]) True >>> ss.remove(0) Traceback (most recent call last): ... KeyError: 0 :param value: `value` to remove from sorted set :raises KeyError: if `value` is not in sorted set Nrhr:s r,rCzSortedSet.removes((  % r.cn|jj|}|j||jS)aReturn the difference of two or more sets as a new sorted set. The `difference` method also corresponds to operator ``-``. ``ss.__sub__(iterable)`` <==> ``ss - iterable`` The difference is all values that are in this sorted set but not the other `iterables`. >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> ss.difference([4, 5, 6, 7]) SortedSet([1, 2, 3]) :param iterables: iterable arguments :return: new sorted set r)r differencer5r)r* iterablesdiffs r,rnzSortedSet.differences1$$tyy##Y/}}Ttyy}11r.c*|j}|j}tt|}dt |zt |kDr4|j ||j |j||S|j}|D] }|| |S)aRemove all values of `iterables` from this sorted set. The `difference_update` method also corresponds to operator ``-=``. ``ss.__isub__(iterable)`` <==> ``ss -= iterable`` >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> _ = ss.difference_update([4, 5, 6, 7]) >>> ss SortedSet([1, 2, 3]) :param iterables: iterable arguments :return: itself ) rrrrrVrBrbupdate_discard)r*rorrr3rtr;s r,rBzSortedSet.difference_updates yy UI&' F Os4y (  " "6 * KKM LL   }}H   r.cn|jj|}|j||jS)aReturn the intersection of two or more sets as a new sorted set. The `intersection` method also corresponds to operator ``&``. ``ss.__and__(iterable)`` <==> ``ss & iterable`` The intersection is all values that are in this sorted set and each of the other `iterables`. >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> ss.intersection([4, 5, 6, 7]) SortedSet([4, 5]) :param iterables: iterable arguments :return: new sorted set r)r intersectionr5r)r*ro intersects r,rvzSortedSet.intersections1$+DII**I6 }}YDII}66r.c|j}|j}|j||j|j ||S)aUpdate the sorted set with the intersection of `iterables`. The `intersection_update` method also corresponds to operator ``&=``. ``ss.__iand__(iterable)`` <==> ``ss &= iterable`` Keep only values found in itself and all `iterables`. >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> _ = ss.intersection_update([4, 5, 6, 7]) >>> ss SortedSet([4, 5]) :param iterables: iterable arguments :return: itself )rrintersection_updaterbrs)r*rorrs r,ryzSortedSet.intersection_update1s@$yy    ),  T r.cr|jj|}|j||jS)aReturn the symmetric difference with `other` as a new sorted set. The `symmetric_difference` method also corresponds to operator ``^``. ``ss.__xor__(other)`` <==> ``ss ^ other`` The symmetric difference is all values tha are in exactly one of the sets. >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> ss.symmetric_difference([4, 5, 6, 7]) SortedSet([1, 2, 3, 6, 7]) :param other: `other` iterable :return: new sorted set r)rsymmetric_differencer5r)r*rHrps r,r{zSortedSet.symmetric_differenceMs/$yy--e4}}Ttyy}11r.c|j}|j}|j||j|j ||S)aUpdate the sorted set with the symmetric difference with `other`. The `symmetric_difference_update` method also corresponds to operator ``^=``. ``ss.__ixor__(other)`` <==> ``ss ^= other`` Keep only values found in exactly one of itself and `other`. >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> _ = ss.symmetric_difference_update([4, 5, 6, 7]) >>> ss SortedSet([1, 2, 3, 6, 7]) :param other: `other` iterable :return: itself )rrsymmetric_difference_updaterbrs)r*rHrrs r,r}z%SortedSet.symmetric_difference_updatefs>&yy  ((/  T r.cb|jtt|g||jS)aReturn new sorted set with values from itself and all `iterables`. The `union` method also corresponds to operator ``|``. ``ss.__or__(iterable)`` <==> ``ss | iterable`` >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> ss.union([4, 5, 6, 7]) SortedSet([1, 2, 3, 4, 5, 6, 7]) :param iterables: iterable arguments :return: new sorted set r) __class__rrYr)r*ros r,unionzSortedSet.unions)~~eDJ;;~KKr.cB|j}|j}tt|}dt |zt |kDr@|j}|j ||j |j ||S|j}|D] }|| |S)aUpdate the sorted set adding values from all `iterables`. The `update` method also corresponds to operator ``|=``. ``ss.__ior__(iterable)`` <==> ``ss |= iterable`` >>> ss = SortedSet([1, 2, 3, 4, 5]) >>> _ = ss.update([4, 5, 6, 7]) >>> ss SortedSet([1, 2, 3, 4, 5, 6, 7]) :param iterables: iterable arguments :return: itself rr)rrrrrVrsrb_add)r*rorrr3rr;s r,rszSortedSet.updates yy UI&' F Os4y (JJE KK  KKM LL   99D U   r.cHt||j|jffS)zSupport for pickle. The tricks played with exposing methods in :func:`SortedSet.__init__` confuse pickle so customize the reducer. )typerrr7s r, __reduce__zSortedSet.__reduce__s T TYY 233r.c|j}|dndj|}t|j}dj|t ||S)zReturn string representation of sorted set. ``ss.__repr__()`` <==> ``repr(ss)`` :return: string representation z , key={0!r}z {0}({1!r}{2}))rrLrrKlist)r*rr type_names r,__repr__zSortedSet.__repr__sKyyLbm&:&:4&@J'' %%idSAAr.c|j|j}|jtt|k(sJt fd|DsJy)zMCheck invariants of sorted set. Runtime complexity: `O(n)` c3&K|]}|v ywN).0r;rs r, z#SortedSet._check..s4U5D=4sN)rr_checkrVall)r*rrs @r,rzSortedSet._checksG yy  4yCJ&&4e4444r.)NNr))?rK __module__ __qualname__rMr- classmethodr5propertyrr<r>rD_SortedSet__make_cmpr__eq__r__ne__r__lt__r__gt__r __le__r__ge__ staticmethodrWrZr]r_rrbrd__copy__rfrirtrkrCrn__sub__rB__isub__rv__and____rand__ry__iand__r{__xor____rxor__r}__ixor__r__or____ror__rs__ior__r)rr rrrr.r,rr$sFN<#~  "$!2@8D* -F D. 1F C!5 6F C!7 8F D- 0F D/ 2Fj)J   $"( D<H . %*H:!02*G:!H7*GH2#H2*#GH4+HL"FG<GG4 B B 5r.rN)rM itertoolsroperatorrrrrrr textwrapr sortedlistr r collections.abcrrr ImportError collectionsrrr.r,rsM ++2 699y 5 Hy 56556s ?AA