"/adZddlmZddlmZddlmZddlmZddl m Z ddl m Z  dd l m Z  eGd d e Zy #e$r dd lm Z YwxYw#e$reZY&wxYw) a intervaltree: A mutable, self-balancing interval tree for Python 2 and 3. Queries may be by point, by range overlap, or by range envelopment. Core logic. Copyright 2013-2018 Chaim Leib Halbert Modifications Copyright 2014 Konstantin Tretyakov Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Interval)Node)Number) SortedDictcopy)warn) MutableSetceZdZdZedZd8dZdZdZdZ dZ e Z d8d Z e Z d Zd Zd8d Zd Zd8dZdZdZdZdZdZdZdZd8dZdZd8dZd8dZdZdZd8dZ dZ!dZ"dZ#d9d Z$d:d!Z%d"Z&d#Z'd$Z(d8d%Z)d8d&Z*d'Z+d(Z,d)Z-d*Z.d;d+Z/d,Z0d;d-Z1d.Z2d/Z3d0Z4d1Z5d8d2Z6d3Z7e7Z8d4Z9d5Z:d6Z;e;Z>> tree = IntervalTree() >>> tree IntervalTree() Initialize a tree from an iterable set of Intervals in O(n * log n):: >>> tree = IntervalTree([Interval(-10, 10), Interval(-20.0, -10.0)]) >>> tree IntervalTree([Interval(-20.0, -10.0), Interval(-10, 10)]) >>> len(tree) 2 Note that this is a set, i.e. repeated intervals are ignored. However, Intervals with different data fields are regarded as different:: >>> tree = IntervalTree([Interval(-10, 10), Interval(-10, 10), Interval(-10, 10, "x")]) >>> tree IntervalTree([Interval(-10, 10), Interval(-10, 10, 'x')]) >>> len(tree) 2 Insertions:: >>> tree = IntervalTree() >>> tree[0:1] = "data" >>> tree.add(Interval(10, 20)) >>> tree.addi(19.9, 20) >>> tree IntervalTree([Interval(0, 1, 'data'), Interval(10, 20), Interval(19.9, 20)]) >>> tree.update([Interval(19.9, 20.1), Interval(20.1, 30)]) >>> len(tree) 5 Inserting the same Interval twice does nothing:: >>> tree = IntervalTree() >>> tree[-10:20] = "arbitrary data" >>> tree[-10:20] = None # Note that this is also an insertion >>> tree IntervalTree([Interval(-10, 20), Interval(-10, 20, 'arbitrary data')]) >>> tree[-10:20] = None # This won't change anything >>> tree[-10:20] = "arbitrary data" # Neither will this >>> len(tree) 2 Deletions:: >>> tree = IntervalTree(Interval(b, e) for b, e in [(-10, 10), (-20, -10), (10, 20)]) >>> tree IntervalTree([Interval(-20, -10), Interval(-10, 10), Interval(10, 20)]) >>> tree.remove(Interval(-10, 10)) >>> tree IntervalTree([Interval(-20, -10), Interval(10, 20)]) >>> tree.remove(Interval(-10, 10)) Traceback (most recent call last): ... ValueError >>> tree.discard(Interval(-10, 10)) # Same as remove, but no exception on failure >>> tree IntervalTree([Interval(-20, -10), Interval(10, 20)]) Delete intervals, overlapping a given point:: >>> tree = IntervalTree([Interval(-1.1, 1.1), Interval(-0.5, 1.5), Interval(0.5, 1.7)]) >>> tree.remove_overlap(1.1) >>> tree IntervalTree([Interval(-1.1, 1.1)]) Delete intervals, overlapping an interval:: >>> tree = IntervalTree([Interval(-1.1, 1.1), Interval(-0.5, 1.5), Interval(0.5, 1.7)]) >>> tree.remove_overlap(0, 0.5) >>> tree IntervalTree([Interval(0.5, 1.7)]) >>> tree.remove_overlap(1.7, 1.8) >>> tree IntervalTree([Interval(0.5, 1.7)]) >>> tree.remove_overlap(1.6, 1.6) # Null interval does nothing >>> tree IntervalTree([Interval(0.5, 1.7)]) >>> tree.remove_overlap(1.6, 1.5) # Ditto >>> tree IntervalTree([Interval(0.5, 1.7)]) Delete intervals, enveloped in the range:: >>> tree = IntervalTree([Interval(-1.1, 1.1), Interval(-0.5, 1.5), Interval(0.5, 1.7)]) >>> tree.remove_envelop(-1.0, 1.5) >>> tree IntervalTree([Interval(-1.1, 1.1), Interval(0.5, 1.7)]) >>> tree.remove_envelop(-1.1, 1.5) >>> tree IntervalTree([Interval(0.5, 1.7)]) >>> tree.remove_envelop(0.5, 1.5) >>> tree IntervalTree([Interval(0.5, 1.7)]) >>> tree.remove_envelop(0.5, 1.7) >>> tree IntervalTree() Point queries:: >>> tree = IntervalTree([Interval(-1.1, 1.1), Interval(-0.5, 1.5), Interval(0.5, 1.7)]) >>> assert tree[-1.1] == set([Interval(-1.1, 1.1)]) >>> assert tree.at(1.1) == set([Interval(-0.5, 1.5), Interval(0.5, 1.7)]) # Same as tree[1.1] >>> assert tree.at(1.5) == set([Interval(0.5, 1.7)]) # Same as tree[1.5] Interval overlap queries >>> tree = IntervalTree([Interval(-1.1, 1.1), Interval(-0.5, 1.5), Interval(0.5, 1.7)]) >>> assert tree.overlap(1.7, 1.8) == set() >>> assert tree.overlap(1.5, 1.8) == set([Interval(0.5, 1.7)]) >>> assert tree[1.5:1.8] == set([Interval(0.5, 1.7)]) # same as previous >>> assert tree.overlap(1.1, 1.8) == set([Interval(-0.5, 1.5), Interval(0.5, 1.7)]) >>> assert tree[1.1:1.8] == set([Interval(-0.5, 1.5), Interval(0.5, 1.7)]) # same as previous Interval envelop queries:: >>> tree = IntervalTree([Interval(-1.1, 1.1), Interval(-0.5, 1.5), Interval(0.5, 1.7)]) >>> assert tree.envelop(-0.5, 0.5) == set() >>> assert tree.envelop(-0.5, 1.5) == set([Interval(-0.5, 1.5)]) Membership queries:: >>> tree = IntervalTree([Interval(-1.1, 1.1), Interval(-0.5, 1.5), Interval(0.5, 1.7)]) >>> Interval(-0.5, 0.5) in tree False >>> Interval(-1.1, 1.1) in tree True >>> Interval(-1.1, 1.1, "x") in tree False >>> tree.overlaps(-1.1) True >>> tree.overlaps(1.7) False >>> tree.overlaps(1.7, 1.8) False >>> tree.overlaps(-1.2, -1.1) False >>> tree.overlaps(-1.2, -1.0) True Sizing:: >>> tree = IntervalTree([Interval(-1.1, 1.1), Interval(-0.5, 1.5), Interval(0.5, 1.7)]) >>> len(tree) 3 >>> tree.is_empty() False >>> IntervalTree().is_empty() True >>> not tree False >>> not IntervalTree() True >>> print(tree.begin()) # using print() because of floats in Python 2.6 -1.1 >>> print(tree.end()) # ditto 1.7 Iteration:: >>> tree = IntervalTree([Interval(-11, 11), Interval(-5, 15), Interval(5, 17)]) >>> [iv.begin for iv in sorted(tree)] [-11, -5, 5] >>> assert tree.items() == set([Interval(-5, 15), Interval(-11, 11), Interval(5, 17)]) Copy- and typecasting, pickling:: >>> tree0 = IntervalTree([Interval(0, 1, "x"), Interval(1, 2, ["x"])]) >>> tree1 = IntervalTree(tree0) # Shares Interval objects >>> tree2 = tree0.copy() # Shallow copy (same as above, as Intervals are singletons) >>> import pickle >>> tree3 = pickle.loads(pickle.dumps(tree0)) # Deep copy >>> list(tree0[1])[0].data[0] = "y" # affects shallow copies, but not deep copies >>> tree0 IntervalTree([Interval(0, 1, 'x'), Interval(1, 2, ['y'])]) >>> tree1 IntervalTree([Interval(0, 1, 'x'), Interval(1, 2, ['y'])]) >>> tree2 IntervalTree([Interval(0, 1, 'x'), Interval(1, 2, ['y'])]) >>> tree3 IntervalTree([Interval(0, 1, 'x'), Interval(1, 2, ['x'])]) Equality testing:: >>> IntervalTree([Interval(0, 1)]) == IntervalTree([Interval(0, 1)]) True >>> IntervalTree([Interval(0, 1)]) == IntervalTree([Interval(0, 1, "x")]) False cL|Dcgc] }t| }}t|Scc}w)z Create a new IntervalTree from an iterable of 2- or 3-tuples, where the tuple lists begin, end, and optionally data. )rr)clstupstivss 9lib/python3.12/site-packages/intervaltree/intervaltree.py from_tupleszIntervalTree.from_tupless, &**Tx|T*C  +s!NcL| t|n t}|D],}|jstdj|||_t j |j|_t|_ |jD]}|j|y)z Set up a tree. If intervals is provided, add all the intervals to the tree. Completes in O(n*log n) time. NDIntervalTree: Null Interval objects not allowed in IntervalTree: {0}) setis_null ValueErrorformat all_intervalsrfrom_intervalstop_noderboundary_table_add_boundariesself intervalsivs r__init__zIntervalTree.__init__s'0&;C N Bzz| !6": '++D,>,>? (l$$B   $%c&td|DS)z Construct a new IntervalTree using shallow copies of the intervals in the source tree. Completes in O(n*log n) time. :rtype: IntervalTree c3<K|]}|jywNr ).0r$s r z$IntervalTree.copy..s5"BGGIs)rr"s rr zIntervalTree.copys5555r&c|j}|j}||jvr|j|xxdz cc<nd|j|<||jvr|j|xxdz cc<yd|j|<y)zO Records the boundaries of the interval in the boundary table. rNbeginendrr"intervalr/r0s rr zIntervalTree._add_boundariess~ll D'' '    &! + &)*D   & $%% %    $ ) $'(D   $r&c|j}|j}|j|dk(r|j|=n|j|xxdzcc<|j|dk(r|j|=y|j|xxdzcc<y)zQ Removes the boundaries of the interval from the boundary table. rNr.r1s r_remove_boundarieszIntervalTree._remove_boundaries*sll   u % *##E*    &! + &   s #q (##C(    $ ) $r&cH||vry|jrtdj||jst j ||_n |jj ||_|jj ||j|y)zl Adds an interval to the tree, if not already present. Completes in O(log n) time. Nr) rrrrr from_intervaladdrr r"r2s rr7zIntervalTree.add:s t      vh'  }} ..x8DM MM--h7DM x( X&r&c:|jt|||S)zd Shortcut for add(Interval(begin, end, data)). Completes in O(log n) time. )r7rr"r/r0datas raddizIntervalTree.addiQs xxT233r&c4|D]}|j|y)z Given an iterable of intervals, add them to the tree. Completes in O(m*log(n+m), where m = number of intervals to add. N)r7r!s rupdatezIntervalTree.updateZsB HHRLr&c||vrt|jj||_|jj||j |y)z Removes an interval from the tree, if present. If not, raises ValueError. Completes in O(log n) time. N)rrremoverr4r8s rr@zIntervalTree.removedsJ 4   ,,X6  !!(+ )r&c:|jt|||S)zg Shortcut for remove(Interval(begin, end, data)). Completes in O(log n) time. )r@rr:s rremoveizIntervalTree.removeits {{8E3566r&c||vry|jj||jj||_|j|y)z Removes an interval from the tree, if present. If not, does nothing. Completes in O(log n) time. N)rdiscardrr4r8s rrDzIntervalTree.discard|sG 4   ""8, --h7  )r&c:|jt|||S)zh Shortcut for discard(Interval(begin, end, data)). Completes in O(log n) time. )rDrr:s rdiscardizIntervalTree.discardis ||HUC677r&cft}|D]}||vs|j|t|S)z` Returns a new tree, comprising all intervals in self but not in other. )rr7rr"otherrr$s r differencezIntervalTree.differences4 eB C  r&c4|D]}|j|y)z; Removes all intervals in other from self. N)rD)r"rIr$s rdifference_updatezIntervalTree.difference_updatesB LL r&cHtt|j|S)z[ Returns a new tree, comprising all intervals from self and other. )rrunionr"rIs rrNzIntervalTree.unions CIOOE233r&ct}t||gt\}}|D]}||vs|j|t |S)z\ Returns a new tree of all intervals common to both self and other. )key)rsortedlenr7r)r"rIrshorterlongerr$s r intersectionzIntervalTree.intersectionsH e $C8BV| C  r&cTt|}|D]}||vs|j|y)zN Removes intervals from self unless they also exist in other. N)listr@rHs rintersection_updatez IntervalTree.intersection_updates)4jB Br&ct|ts t|}t|}|j|j|j|}t |S)zY Return a tree with elements only in self or other but not both. ) isinstancerrJrNr)r"rImers rsymmetric_differencez!IntervalTree.symmetric_differencesN %%s5zu YmmE"(()9)9")=>C  r&ct|}t|}|D])}||vs|j||j|+|j|y)z` Throws out all intervals except those only in self or other, not both. N)rrXr@r>rHs rsymmetric_difference_updatez(IntervalTree.symmetric_difference_updatesL E 4jBU{ B R  Er&c~||j|n|j||}|D]}|j|y)a Removes all intervals overlapping the given point or range. Completes in O((r+m)*log n) time, where: * n = size of the tree * m = number of matches * r = size of the search range (this is 1 for a point) N)atoverlapr@r"r/r0hitlistr$s rremove_overlapzIntervalTree.remove_overlaps7%(K$''%.T\\%5MB KKOr&cX|j||}|D]}|j|y)z Removes all intervals completely enveloped in the given range. Completes in O((r+m)*log n) time, where: * n = size of the tree * m = number of matches * r = size of the search range N)envelopr@rcs rremove_envelopzIntervalTree.remove_envelops),,uc*B KKOr&c  t}|j|Dcgc]}|j|ks|}}|j|Dcgc]}|j|kDs|}}|ri|D]/}|j t |j|||d1|D]/}|j t ||j||d1nn|D]2}|j t |j||j 4|D]2}|j t ||j|j 4|j|||j||j||j|ycc}wcc}w)z Like remove_envelop(), but trims back Intervals hanging into the chopped area so that nothing overlaps. TFN) rrar/r0r7rr;rhrLr>)r"r/r0datafunc insertionsr$ begin_hitsend_hitss rchopzIntervalTree.chopsB U #'775>F>RRXX5Eb> F!%>2#B>  x%"d9KLM!xRVVXb%5HIJ!x%AB!xRVVRWW=> E3' z* x( J#G>sFF F !F c :tfd|jD}t}|rb|D]\}|jt|j||d|jt|j ||d^ng|D]b}|jt|j|j |jt|j |j d|j||j|y)aX Split Intervals that overlap point into two new Intervals. if specified, uses datafunc(interval, islower=True/False) to set the data field of the new Intervals. :param point: where to slice :param datafunc(interval, isupper): callable returning a new value for the interval's data field c3BK|]}|jks|ywr))r/)r*r$points rr+z%IntervalTree.slice..sF>RRXX5Eb>sTFN) rrar7rr/r0r;rLr>)r"rqrjrdrkr$s ` rslicezIntervalTree.slice sF4775>FFU x%"d9KLMxrvvxE7JKLx%ABxrvvrww?@ w' Jr&c$|jy)zD Empties the tree. Completes in O(1) tine. N)r%r,s rclearzIntervalTree.clears r&cifd}t|jtjd}t |D]\}||dzdD] | S)z Returns a dictionary mapping parent intervals to sets of intervals overlapped by and contained in the parent. Completes in O(n^2) time. :rtype: dict of [Interval, set of Interval] ctjr&vr t<jyyr))contains_intervalrr7)childparentresultsr add_if_nestedz/IntervalTree.find_nested..add_if_nested1s;''.'%(UF6Nv""5)/r&T)rQreverserN)rRrrlength enumerate)r"r{long_ivsirxryrzs @@@r find_nestedzIntervalTree.find_nested's] * $,,(//4P"8,IAv!!a%&)*- r&c||j||St|tr|j|S|j|j|j S)z Returns whether some interval in the tree overlaps the given point or range. Completes in O(r*log n) time, where r is the size of the search range. :rtype: bool )overlaps_ranger[roverlaps_pointr/r0r"r/r0s roverlapszIntervalTree.overlaps=sR ?&&uc2 2 v &&&u- -&&u{{EII> >r&cl|jryt|jj|S)z Returns whether some interval in the tree overlaps p. Completes in O(log n) time. :rtype: bool F)is_emptyboolrcontains_point)r"ps rrzIntervalTree.overlaps_pointMs* ==?DMM00344r&cjryk\ryjrytfdjDS)a Returns whether some interval in the tree overlaps the given range. Returns False if given a null interval over which to test. Completes in O(r*log n) time, where r is the range length and n is the table size. :rtype: bool FTc3\K|]#}|cxkrkrnnj|%ywr))r)r*boundr/r0r"s rr+z.IntervalTree.overlaps_range..hs1 ,u"s"    &,s),)rranyrrs```rrzIntervalTree.overlaps_rangeXsL ==? c\   ' ,,   r&c 0|syt|jdk(ryt|j}t}t |dd|ddD]5\}}||D](}|j t |||j*7|j|y)a2 Finds all intervals with overlapping ranges and splits them along the range boundaries. Completes in worst-case O(n^2*log n) time (many interval boundaries are inside many intervals), best-case O(n*log n) time (small number of overlaps << n per interval). Nr) rSrrRrzipr7rr;r%)r"boundsnew_ivslbounduboundr$s rsplit_overlapszIntervalTree.split_overlapsns  t"" #q ( ++,%!&"+vabz:NFF6l HVVRWW=>#; gr&c |syt|j}g dgd  fd}|D] r d} j|jks|sx j|jk(r_t |j j}d j d<ndd<t |j|d d<|||j y)a Finds all intervals with overlapping ranges and merges them into a single interval. If provided, uses data_reducer and data_initializer with similar semantics to Python's built-in reduce(reducer_func[, initializer]), as follows: If data_reducer is set to a function, combines the data fields of the Intervals with current_reduced_data = data_reducer(current_reduced_data, new_data) If data_reducer is None, the merged Interval's data field will be set to None, ignoring all the data fields of the merged Intervals. On encountering the first Interval to merge, if data_initializer is None (default), uses the first Interval's data field as the first value for current_reduced_data. If data_initializer is not None, current_reduced_data is set to a shallow copy of data_initializer created with copy.copy(data_initializer). If strict is True (default), intervals are only merged if their ranges actually overlap; adjacent, touching intervals will not be merged. If strict is False, intervals are merged even if they are only end-to-end adjacent. Completes in O(n*logn). Nc!jd<jytd<djd<jtjj dyNrr;appendr rr/r0current_reduceddata_initializer data_reducerhighermergedsr new_seriesz/IntervalTree.merge_overlaps..new_seriess'%+[[" f%%)*:%;"%1/!2Dfkk%R" hv||VZZQRASTUr&rr)rRrr/r0maxr;rr%) r"rrstrictsorted_intervalsrlower upper_boundrrrs `` @@@rmerge_overlapszIntervalTree.merge_overlapss8 !$"4"45& V V'Fr LL599,6<<599#<"%eii".new_seriesrr&rr) rRr range_matchesrr0r;rr/r%) r"rrrrrrrrrs `` @@@r merge_equalszIntervalTree.merge_equalss0 !$"4"45& V V'Fr ''."%eii".9$* 6TUN   !% (6T c3^K|]$}|jk\r|jkr|&ywr))r/r0)r*r$r/r0s rr+z'IntervalTree.envelop..?s. 2xx5 RVVs] s*-) rrrgr/r0rr bisect_leftr>search_overlapxrange r"r/r0rr$rz bound_begin bound_endrs `` @rrgzIntervalTree.envelop"s}}5L ;B<<"&&1 1 c\5L""5#%0,,$007 "..s3  d))* 6<[)6T*       r&c |j}|s tS|(|}|j|j|jS||k\r tS|j |t}|j j|}j|}|j|jfdt||D|S)a  Returns a set of all intervals overlapping the given range. Completes in O(m + k*log n) time, where: * n = size of the tree * m = number of matches * k = size of the search range :rtype: set of Interval c3DK|]}j|ywr)rrs rr+z'IntervalTree.overlap..[rr) rrrbr/r0rrrr>rrrs @rrbzIntervalTree.overlapEs}}5L ;B<<"&&1 1 c\5L""5#%0,,$007 "..s3  d))* 6<[)6T*    r&cV|jsy|jjdS)zm Returns the lower bound of the first interval in the tree. Completes in O(1) time. rrrr,s rr/zIntervalTree.beginas* """"'')!,,r&cV|jsy|jjdS)zl Returns the upper bound of the last interval in the tree. Completes in O(1) time. rrrr,s rr0zIntervalTree.endks* """"'')"--r&cRt|j|jS)z Returns a minimum-spanning Interval that encloses all the members of this IntervalTree. If the tree is empty, returns null Interval. :rtype: Interval )rr/r0r,s rrangezIntervalTree.rangeus dhhj11r&cJ|sy|j|jz S)z Returns the length of the minimum-spanning Interval that encloses all the members of this IntervalTree. If the tree is empty, return 0. r)r0r/r,s rspanzIntervalTree.span~s! xxzDJJL((r&cv|jr|jj|Sd}|s t|y|S)z ## FOR DEBUGGING ONLY ## Pretty-prints the structure of the tree. If tostring is true, prints nothing and returns a string. :rtype: None or str )tostringzN)rprint_structureprint)r"rrzs rrzIntervalTree.print_structures7 ====00(0C C+Ff  r&c|jr |jj|jk(sJ |D](}t|trJdj||D](}|jsJdj|i}|D]l}|j|vr||jxxd z cc<nd ||j<|j|vr||jxxd z cc<^d ||j<nt |jjt |jk(sJd |jj!D](\}}|||k(rJd j|||||jj#t y|jrJd |jJd y#t$r}t dt |jj}t d n#t $r ddlm}YnwxYw|||jz t d||j|z |d}~wwxYw)zk ## FOR DEBUGGING ONLY ## Checks the table to ensure that the invariants are held. z7Error: the tree and the membership set are out of sync!z(top_node.all_children() - all_intervals:r)pprintz(all_intervals - top_node.all_children():Nz9Error: Only Interval objects allowed in IntervalTree: {0}z=Error: Null Interval objects not allowed in IntervalTree: {0}rzDError: boundary_table is out of sync with the intervals in the tree!z5Error: boundary_table[{0}] should be {1}, but is {2}!z&Error: boundary table should be empty!zError: top_node isn't None!)rr all_childrenAssertionErrorrr NameErrorrr[rrrr/r0rrrverify)r"etivsrr$ bound_checkrQvals rrzIntervalTree.verifysl    }}113t7I7IIII"!"h/!6":/::<!6":'K88{*)Q.),-K)66[('1,'*+K't**//12c+:J:J:L6MM -- -M !//557S"3'3.4##)6[-s$44.8 MM  '** 98 9*==( .- .(y" M4==5578@A. .-.td0001@At))D01 s;)G I1#9I,H I, H2/I,1H22:I,,I1c t|dkryt||jjfd}|jj|d}t |j }||d<|r|S|S)z Returns a number between 0 and 1, indicating how suboptimal the tree is. The lower, the better. Roughly, this number represents the fraction of flawed Intervals in the tree. :rtype: float rgc4z }dz }|t|z S)z Returns a normalized score, indicating roughly how many times intervals share s_center with other intervals. Output is full-scale from 0 to 1. :rtype: float r)float)rawmaximummns rs_center_scorez*IntervalTree.score..s_center_scores&a%C!eGw' 'r&)depths_center _cumulative)rSr count_nodes depth_scorervalues)r" full_reportrreport cumulativerrs @@rscorezIntervalTree.scores t9> I MM % % ' (]]..q!4&( ) *} Mr&c |j|j}}||j}| t|S||j }|j ||S#t $r|j|cYSwxYw)a7 Returns a set of all intervals overlapping the given index or slice. Completes in O(k * log(n) + m) time, where: * n = size of the tree * m = number of matches * k = size of the search range (this is 1 for a point) :rtype: set of Interval )startstopr/rr0rbAttributeErrorra)r"rrrs r __getitem__zIntervalTree.__getitem__su "++uzz4E} <t9$|xxz<<t, , "775> ! "s6A#AA:9A:cR|j|j|j|y)a Adds a new interval to the tree. A shortcut for add(Interval(index.start, index.stop, value)). If an identical Interval object with equal range and data already exists, does nothing. Completes in O(log n) time. N)r<rr)r"rvalues r __setitem__zIntervalTree.__setitem__s %++uzz51r&c&|j|y)z5 Delete all items overlapping point. N)re)r"rqs r __delitem__zIntervalTree.__delitem__&s E"r&c||jvS)z Returns whether item exists as an Interval in the tree. This method only returns True for exact matches; for overlaps, see the overlaps() method. Completes in O(1) time. :rtype: bool )r)r"items r __contains__zIntervalTree.__contains__,st))))r&c t||||vS)zz Shortcut for (Interval(begin, end, data) in tree). Completes in O(1) time. :rtype: bool rr:s r containsizIntervalTree.containsi<ssD)T11r&c6|jjS)z Returns an iterator over all the intervals in the tree. Completes in O(1) time. :rtype: collections.Iterable[Interval] )r__iter__r,s rrzIntervalTree.__iter__Es!!**,,r&c,t|jS)zr Returns how many intervals are in the tree. Completes in O(1) time. :rtype: int )rSrr,s r__len__zIntervalTree.__len__Orr&cXt|txr|j|jk(S)z Whether two IntervalTrees are equal. Completes in O(n) time if sizes are equal; O(1) time otherwise. :rtype: bool )r[rrrOs r__eq__zIntervalTree.__eq__Xs, ul + 6   %"5"5 5 r&c@t|}|sydj|S)z :rtype: str zIntervalTree()zIntervalTree({0}))rRr)r"rs r__repr__zIntervalTree.__repr__ds$Tl#&--c2 2r&c:tt|jffS)z7 For pickle-ing. :rtype: tuple )rrRrr,s r __reduce__zIntervalTree.__reduce__ps fT%7%78:::r&r))NNT)NN)F)>__name__ __module__ __qualname____doc__ classmethodrr%r r r4r7rr<appendir>r@rBrDrFrJrLrNrVrYr]r_rerhrnrrrtrrrrrrrrrrargrbr/r0rrrrrrrrrrriterrrr__str__rr&rrr,sCEL!!%(6) * '*F4G * 7 *8 !4 ! !    2 ,,? 5 ,.?B:x' +!F8-.2) F.P F". 2# * 2- D'  3G;r&rN)r r2rnodernumbersrsortedcontainersrr warningsr collections.abcr ImportError collectionsrrrrrr&rrse*''* I;:I;'&'  Fs =A A  A AA