def test_merge_overlaps_reducer_wo_initializer():
def reducer(old, new):
return "%s, %s" % (old, new)
# empty tree
e = IntervalTree()
e.merge_overlaps(data_reducer=reducer)
e.verify()
assert not e
# One Interval in tree
o = IntervalTree.from_tuples([(1, 2, 'hello')])
o.merge_overlaps(data_reducer=reducer)
o.verify()
assert len(o) == 1
assert sorted(o) == [Interval(1, 2, 'hello')]
# many Intervals in tree, with gap
t = trees['ivs1']()
t.merge_overlaps(data_reducer=reducer)
t.verify()
assert len(t) == 2
assert sorted(t) == [
Interval(1, 2,'[1,2)'),
Interval(4, 15, '[4,7), [5,9), [6,10), [8,10), [8,15), [10,12), [12,14), [14,15)')
]
def test_merge_overlaps_reducer_with_initializer():
def reducer(old, new):
return old + [new]
# empty tree
e = IntervalTree()
e.merge_overlaps(data_reducer=reducer, data_initializer=[])
e.verify()
assert not e
# One Interval in tree
o = IntervalTree.from_tuples([(1, 2, 'hello')])
o.merge_overlaps(data_reducer=reducer, data_initializer=[])
o.verify()
assert len(o) == 1
assert sorted(o) == [Interval(1, 2, ['hello'])]
# many Intervals in tree, with gap
t = trees['ivs1']()
t.merge_overlaps(data_reducer=reducer, data_initializer=[])
t.verify()
assert len(t) == 2
assert sorted(t) == [
Interval(1, 2, ['[1,2)']),
Interval(4, 15, [
'[4,7)',
'[5,9)',
'[6,10)',
'[8,10)',
'[8,15)',
'[10,12)',
'[12,14)',
'[14,15)',
])
]
def setUp(self):
iv = IntervalNode(50, 59, Interval(50, 59))
for i in range(0, 110, 10):
if i == 50: continue
f = Interval(i, i + 9)
iv = iv.insert(f.start, f.end, f)
self.intervals = iv
def test_merge_neighbors_with_gap_nonstrict():
def reducer(old, new):
return "%s, %s" % (old, new)
# default distance=1
t = IntervalTree.from_tuples(data.ivs1.data)
t.merge_neighbors(data_reducer=reducer, distance=1, strict=False)
t.verify()
assert len(t) == 2
assert sorted(t) == [
Interval(1, 2, '[1,2)'),
Interval(
4, 15,
'[4,7), [5,9), [6,10), [8,10), [8,15), [10,12), [12,14), [14,15)'),
]
# distance=2
t = IntervalTree.from_tuples(data.ivs1.data)
t.merge_neighbors(data_reducer=reducer, distance=2, strict=False)
t.verify()
assert len(t) == 1
assert sorted(t) == [
Interval(
1, 15,
'[1,2), [4,7), [5,9), [6,10), [8,10), [8,15), [10,12), [12,14), [14,15)'
)
]
def trim_contigs(
itrees: Mapping[str, IntervalTree],
scaffolds: Mapping[str, SeqRecord],
) -> None:
for scaffold, seq in scaffolds.items():
new_contigs = list()
contigs = sorted(itrees[scaffold], key=lambda x: x.begin)
last_end = 0
for i in range(len(contigs)):
contig = contigs[i]
assert contig.begin >= last_end
last_end = contig.end
j = contig.begin
while (j < len(seq)) and (seq.seq[j] == "N"):
j += 1
if j != contig.begin:
contig = Interval(j, contig.end, contig.data)
k = contig.end - 1
while (k >= 0) and (seq.seq[k] == "N"):
k -= 1
if k != contig.end - 1:
contig = Interval(contig.begin, k + 1, contig.data)
if len(contig) > 1:
new_contigs.append(contig)
itrees[scaffold] = IntervalTree(new_contigs)
return
def test_merge_overlaps_with_gap():
t = IntervalTree.from_tuples(data.ivs1.data)
t.merge_overlaps()
t.verify()
assert len(t) == 2
assert t == IntervalTree([Interval(1, 2, '[1,2)'), Interval(4, 15)])
def EXONS(d):
exStarts = d['exonStarts'].split(b',')
exEnds = d['exonEnds'].split(b',')
intron_count=int(d['exonCount'])-1
exon_count=int(d['exonCount'])
strand = d['strand']
for i in range(exon_count):
exon_d = d.copy()
if strand == '+':
exon_d['exonNum']=str(i+1)
elif strand == '-':
exon_d['exonNum']=str(exon_count-i)
#Since interval trees are not inclusive of upper limit, add one to the exon end boundary
yield Interval(int(exStarts[i]), int(exEnds[i])+1, exon_d)
#Setup the intron info
if i < intron_count:
#Since interval trees are not inclsive of upper limit, add one to the intron start boundary and not to the end boundary
intron_start=int(exEnds[i])+1
intron_end=int(exStarts[i+1])
new_d=d.copy()
if new_d['strand']=='-':
new_d['intronNum']=str(intron_count - i)
elif new_d['strand']=='+':
new_d['intronNum']=str(i+1)
yield Interval(intron_start, intron_end, new_d)
def layout_cost(params):
geometry = params_to_geometry(params)
pdf = DOC.compile(geometry)
pdf_document = fitz.open(pdf)
if pdf_document.pageCount > 1:
return 10
page1 = pdf_document[-1]
full_tree_y = IntervalTree()
tree_y = IntervalTree()
blks = page1.getTextBlocks() # Read text blocks of input page
# Calculate CropBox & displacement
disp = fitz.Rect(page1.CropBoxPosition, page1.CropBoxPosition)
croprect = page1.rect + disp
full_tree_y.add(Interval(croprect[1], croprect[3]))
for b in blks: # loop through the blocks
r = fitz.Rect(b[:4]) # block rectangle
# add dislacement of original /CropBox
r += disp
_, y0, _, y1 = r
tree_y.add(Interval(y0, y1))
tree_y.merge_overlaps()
for i in tree_y:
full_tree_y.add(i)
full_tree_y.split_overlaps()
# For top and bottom margins, we only know they are the first and last elements in the list
full_tree_y_list = list(sorted(full_tree_y))
_, bottom_margin = \
map(get_interval_width, full_tree_y_list[::len(full_tree_y_list) - 1])
return bottom_margin
def __get_iedge_in_tree(self, u, v, begin, end):
"""Return interval edge if found in the interval graph with the exact interval,
otherwise return None.
Parameters
----------
u, v : nodes
Nodes can be, for example, strings or numbers.
Nodes must be hashable (and not None) Python objects.
begin : integer
Inclusive beginning time of the edge appearing in the interval graph.
end : integer
Non-inclusive ending time of the edge appearing in the interval graph.
Must be bigger than begin.
Examples
--------
>>> G = dnx.IntervalGraph()
>>> G.add_edge(1, 2, 3, 10)
>>> G.__get_iedge_in_tree(2, 1, 3, 10)
Interval(3, 10, (1, 2))
>>> G.__get_iedge_in_tree(2, 1, 4, 10)
None
"""
temp_iedge = Interval(begin, end, (u, v))
if temp_iedge in self.tree:
return temp_iedge
temp_iedge = Interval(begin, end, (v, u))
if temp_iedge in self.tree:
return temp_iedge
return None
def test_update():
t = IntervalTree()
interval = Interval(0, 1)
s = set([interval])
t.update(s)
assert isinstance(t, IntervalTree)
assert len(t) == 1
assert set(t).pop() == interval
t.clear()
assert not t
t.extend(s)
t.extend(s)
assert isinstance(t, IntervalTree)
assert len(t) == 1
assert set(t).pop() == interval
interval = Interval(2, 3)
t.update([interval])
assert isinstance(t, IntervalTree)
assert len(t) == 2
assert sorted(t)[1] == interval
t = IntervalTree(s)
t.extend([interval])
assert isinstance(t, IntervalTree)
assert len(t) == 2
assert sorted(t)[1] == interval
def find_n_stretches(
scaffolds: Mapping[str, SeqRecord],
n_stretch: int,
) -> Dict[str, IntervalTree]:
itrees = dict()
for scaffold, seq in scaffolds.items():
itrees[scaffold] = IntervalTree()
n_count = 0
for i, base in enumerate(seq):
if base.upper() == "N":
n_count += 1
elif n_count >= n_stretch:
interval = Interval(i - n_count, i)
itrees[scaffold].add(interval)
n_count = 0
else:
n_count = 0
if n_count >= n_stretch:
interval = Interval(i - n_count, i)
itrees[scaffold].add(interval)
return itrees
def test_ensure_there_are_no_overlapping_records___one_overlap(self):
interval_tree = IntervalTree(
[Interval(1, 3), Interval(5, 10),
Interval(9, 15)])
self.assertRaises(InconsistentVCFException,
ensure_there_are_no_overlapping_records,
interval_tree)
def add_tx(self, tx: BaseTransaction) -> None:
""" Add a new transaction to the index
:param tx: Transaction to be added
"""
assert tx.hash is not None
assert tx.storage is not None
if tx.hash in self.tx_last_interval:
return
# Fix the end of the interval of its parents.
for parent_hash in tx.parents:
pi = self.tx_last_interval.get(parent_hash, None)
if not pi:
continue
if tx.timestamp < pi.end:
self.tree.remove(pi)
new_interval = Interval(pi.begin, tx.timestamp, pi.data)
self.tree.add(new_interval)
self.tx_last_interval[parent_hash] = new_interval
# Check whether any children has already been added.
# It so, the end of the interval is equal to the smallest timestamp of the children.
min_timestamp = inf
meta = tx.get_metadata()
for child_hash in meta.children:
if child_hash in self.tx_last_interval:
child = tx.storage.get_transaction(child_hash)
min_timestamp = min(min_timestamp, child.timestamp)
# Add the interval to the tree.
interval = Interval(tx.timestamp, min_timestamp, tx.hash)
self.tree.add(interval)
self.tx_last_interval[tx.hash] = interval
def _get_ranges(self, addr, count):
"""! @brief Splits a memory address range into cached and uncached subranges.
@return Returns a 2-tuple with the first element being a set of Interval objects for each
of the cached subranges. The second element is a set of Interval objects for each of the
non-cached subranges.
"""
cached = self._cache.overlap(addr, addr + count)
uncached = {Interval(addr, addr + count)}
for cachedIv in cached:
newUncachedSet = set()
for uncachedIv in uncached:
# No overlap.
if cachedIv.end < uncachedIv.begin or cachedIv.begin > uncachedIv.end:
newUncachedSet.add(uncachedIv)
continue
# Begin segment.
if cachedIv.begin - uncachedIv.begin > 0:
newUncachedSet.add(Interval(uncachedIv.begin, cachedIv.begin))
# End segment.
if uncachedIv.end - cachedIv.end > 0:
newUncachedSet.add(Interval(cachedIv.end, uncachedIv.end))
uncached = newUncachedSet
return cached, uncached
def test_ensure_there_are_no_overlapping_records___no_overlapping_records___close(
self):
interval_tree = IntervalTree(
[Interval(1, 5), Interval(5, 10),
Interval(10, 15)])
ensure_there_are_no_overlapping_records(interval_tree)
self.assertTrue(True)
def chop_tree(tree, onset, offset):
"""Trim Intervals so that none overlap [``onset``, ``offset``].
Intervals contained entirely within the chopped region are removed and
those overlapping, but not contained are trimmed back. Differs from
``IntervalTree.chop`` in that it keeps track of which intervals in the
tree were affected.
This is an inplace operation.
Parameters
----------
tree : IntervalTree
Interval tree.
onset : float
Onset of chopped region.
offset : float
Offset of chopped region.
Returns
-------
affected_intervals : set of Interval
Intervals from ``tree`` that overlap chopped region.
"""
overlapped_intervals = set() # Intervals overlapping chopped region.
insertions = set() # Intervals to add.
# Identify intervals contained entirely within [onset, offset].
overlapped_intervals.update(tree.envelop(onset, offset))
# Identify all other intervals overlapping [onset, offset]. These belong
# to two classes:
# - right overlap -- interval.begin < onset
# - left overlap -- offset < interval.end
for intrvl in tree.at(onset):
if intrvl.begin >= onset:
continue
overlap_dur = intrvl.end - onset
if not overlap_dur:
continue
overlapped_intervals.add(intrvl)
insertions.add(Interval(intrvl.begin, onset, intrvl.data))
for intrvl in tree.at(offset):
if intrvl.end <= offset:
continue
overlap_dur = offset - intrvl.begin
if not overlap_dur:
continue
overlapped_intervals.add(intrvl)
insertions.add(Interval(offset, intrvl.end, intrvl.data))
# Update tree.
for intrvl in overlapped_intervals:
tree.discard(intrvl)
tree.update(insertions)
return overlapped_intervals
def test_interval_cmp_int():
iv = Interval(0, 10)
assert iv.__cmp__(-5) == 1
assert iv.__cmp__(0) == 1
assert iv.__cmp__(5) == -1
assert iv.__cmp__(10) == -1
assert iv.__cmp__(15) == -1
def test_interval_overlaps_point():
iv = Interval(0, 10)
assert not iv.overlaps(-5)
assert iv.overlaps(0)
assert iv.overlaps(5)
assert not iv.overlaps(10)
assert not iv.overlaps(15)
def test_twoIntervalsAboveMinLen_returnSame(self):
tree = IntervalTree([Interval(1, 3), Interval(3, 7)])
min_len = 1
actual = merge_short_intervals(tree, min_len=min_len)
expected = tree
assert actual == expected
def test_list_init():
tree = IntervalTree([Interval(-10, 10), Interval(-20.0, -10.0)])
tree.verify()
assert tree
assert len(tree) == 2
assert tree.items() == set([Interval(-10, 10), Interval(-20.0, -10.0)])
assert tree.begin() == -20
assert tree.end() == 10
def test_interval_cmp_int():
iv = Interval(0, 10)
assert iv.__cmp__(-5) == 1
assert iv.__cmp__(0) == 1
assert iv.__cmp__(5) == -1
assert iv.__cmp__(10) == -1
assert iv.__cmp__(15) == -1
def test_interval_overlaps_point():
iv = Interval(0, 10)
assert not iv.overlaps(-5)
assert iv.overlaps(0)
assert iv.overlaps(5)
assert not iv.overlaps(10)
assert not iv.overlaps(15)
def test_oneIntervalBelowMinLen_returnIntervalEndPlusOne(self):
tree = IntervalTree([Interval(1, 3)])
min_len = 9
actual = merge_short_intervals(tree, min_len=min_len)
expected = IntervalTree([Interval(1, 4)])
assert actual == expected
def test_twoIntervalsOneBelowMinLen_returnOneInterval(self):
tree = IntervalTree([Interval(1, 3, "foo"), Interval(3, 7, "bar")])
min_len = 3
actual = merge_short_intervals(tree, min_len=min_len)
expected = IntervalTree([Interval(1, 7, data="foo+bar")])
assert actual == expected
def test_invalid_update():
t = IntervalTree()
with pytest.raises(ValueError):
t.update([Interval(1, 0)])
with pytest.raises(ValueError):
t.update([Interval(1, 1)])
def test_ensure_there_are_no_overlapping_records___no_overlapping_records___far_away(
self):
interval_tree = IntervalTree(
[Interval(1, 5),
Interval(10, 15),
Interval(20, 25)])
ensure_there_are_no_overlapping_records(interval_tree)
self.assertTrue(True)
def setUp(self):
iv = IntervalTree()
iv.add_interval(Interval(50, 59))
for i in range(0, 110, 10):
if i == 50: continue
f = Interval(i, i + 9)
iv.add_interval(f)
self.intervals = iv
def make_distinct(*bounded: Bounded):
"""Ensures that all of the provided bounded arguments are tightened until they are finite and
either definitive or non-overlapping with any of the other arguments."""
tree: IntervalTree = IntervalTree()
for b in bounded:
if not b.bounds().finite:
b.tighten_bounds()
if not b.bounds().finite:
raise ValueError(f"Could not tighten {b!r} to a finite bound")
tree.add(Interval(b.bounds().lower_bound, b.bounds().upper_bound + 1, b))
while len(tree) > 1:
# find the biggest interval in the tree
biggest: Optional[Interval] = None
for m in tree:
m_size = m.end - m.begin
if biggest is None or m_size > biggest.end - biggest.begin:
biggest = m
assert biggest is not None
if biggest.data.bounds().definitive():
# This means that all intervals are points, so we are done!
break
tree.remove(biggest)
matching = tree[biggest.begin:biggest.end]
if len(matching) < 1:
# This interval does not intersect any others, so it is distinct
continue
# now find the biggest other interval that intersects with biggest:
second_biggest: Optional[Interval] = None
for m in matching:
m_size = m.end - m.begin
if second_biggest is None or m_size > second_biggest.end - second_biggest.begin:
second_biggest = m
assert second_biggest is not None
tree.remove(second_biggest)
# Shrink the two biggest intervals until they are distinct
while True:
biggest_bound: Range = biggest.data.bounds()
second_biggest_bound: Range = second_biggest.data.bounds()
if (biggest_bound.definitive() and second_biggest_bound.definitive()) or \
biggest_bound.upper_bound < second_biggest_bound.lower_bound or \
second_biggest_bound.upper_bound < biggest_bound.lower_bound:
break
biggest.data.tighten_bounds()
second_biggest.data.tighten_bounds()
new_interval = Interval(
begin=biggest.data.bounds().lower_bound,
end=biggest.data.bounds().upper_bound + 1,
data=biggest.data
)
if tree.overlaps(new_interval.begin, new_interval.end):
tree.add(new_interval)
new_interval = Interval(
begin=second_biggest.data.bounds().lower_bound,
end=second_biggest.data.bounds().upper_bound + 1,
data=second_biggest.data
)
if tree.overlaps(new_interval.begin, new_interval.end):
tree.add(new_interval)
def test_fromBed_twoLinesBedReturnsMaskerWithTwoIntervals(self):
bed = StringIO("chrom\t3\t7\nchrom\t8\t10")
actual = Masker.from_bed(bed)
expected = Masker(
IntervalTree([Interval(3, 7, "chrom"), Interval(8, 10, "chrom")])
)
assert actual == expected
def test_len():
iv = Interval(0, 0)
assert len(iv) == 3
iv = Interval(0, 1, 2)
assert len(iv) == 3
iv = Interval(1.3, 2.2)
assert len(iv) == 3
def setUp(self):
self.tree_a = IntervalTree()
self.tree_a.insert_interval(Interval(0, 10, 0))
self.tree_a.insert_interval(Interval(5, 15, 1))
self.tree_a.insert_interval(Interval(20, 25, 2))
self.tree_b = IntervalTree()
self.tree_b.insert_interval(Interval(0, 10, 0))
self.tree_b.insert_interval(Interval(25, 30, 1))
def test_left(self):
iv = self.intervals
self.assertEqual(str(iv.left(60, n=2)),
str([Interval(50, 59),
Interval(40, 49)]))
for i in range(10, 100, 10):
r = iv.left(i, max_dist=10, n=1)
self.assertEqual(r[0].end, i - 1)
def test_interval_int_cmp():
"""
Test comparisons with ints using __cmp__()
"""
iv = Interval(0, 10)
assert iv.__cmp__(-5) == 1
assert iv.__cmp__(0) == 1
assert iv.__cmp__(5) == -1
assert iv.__cmp__(10) == -1
assert iv.__cmp__(15) == -1
def __getitem__(self, index):
if type(index) is slice:
if index.step is not None:
raise ValueError("Slice indexing is used for intervals, which do not have a step.")
iv = Interval(index.start, index.stop)
result = {x.data for x in self.history[iv]}
result.update(x[0] for x in self.current.items() if iv.overlaps(Interval(begin=x[1], end=None)))
else:
result = {x.data for x in self.history[index]}
result.update(item_ for item_, time_ in self.current.items() if time_ <= index)
return result
def test_copy():
iv0 = Interval(1, 2, 3)
iv1 = iv0.copy()
assert iv1.begin == iv0.begin
assert iv1.end == iv0.end
assert iv1.data == iv0.data
assert iv1 == iv0
iv2 = pickle.loads(pickle.dumps(iv0))
assert iv2.begin == iv0.begin
assert iv2.end == iv0.end
assert iv2.data == iv0.data
assert iv2 == iv0
def reload_line(self,line,defaults):
value,data=self.create_default_datarecord(line, defaults)
#TODO: how do we initialize default TTL from command line
lower,upper=ip4range(value)
lowerlong=ip2long(lower)
upperlong=ip2long(upper)
if defaults.maxrange4!=None and upperlong-lowerlong>defaults.maxrange4:
logging.warn("MAXRANGE4 prohobits adding %s in %s"%(value,self.filename))
return
interval=Interval(lowerlong,upperlong)
interval.data=data
self.tmpintervals.append(interval)
self.tmpcount+=1
def test_length():
iv = Interval(0, 0)
assert iv.length() == 0
iv = Interval(0, 3)
assert iv.length() == 3
iv = Interval(-1, 1, 'data')
assert iv.length() == 2
iv = Interval(0.1, 3)
assert iv.length() == 2.9
def test_interval_interval_cmp():
"""
Test comparisons with other Intervals using __cmp__()
"""
iv0 = Interval(0, 10)
iv1 = Interval(-10, -5)
iv2 = Interval(-10, 0)
iv3 = Interval(-10, 5)
iv4 = Interval(-10, 10)
iv5 = Interval(-10, 20)
iv6 = Interval(0, 20)
iv7 = Interval(5, 20)
iv8 = Interval(10, 20)
iv9 = Interval(15, 20)
assert iv0.__cmp__(iv0) == 0
assert iv0.__cmp__(iv1) == 1
assert iv0.__cmp__(iv2) == 1
assert iv0.__cmp__(iv3) == 1
assert iv0.__cmp__(iv4) == 1
assert iv0.__cmp__(iv5) == 1
assert iv0.__cmp__(iv6) == -1
assert iv0.__cmp__(iv7) == -1
assert iv0.__cmp__(iv8) == -1
assert iv0.__cmp__(iv9) == -1
def test_interval_overlaps_interval():
iv0 = Interval(0, 10)
iv1 = Interval(-10, -5)
iv2 = Interval(-10, 0)
iv3 = Interval(-10, 5)
iv4 = Interval(-10, 10)
iv5 = Interval(-10, 20)
iv6 = Interval(0, 20)
iv7 = Interval(5, 20)
iv8 = Interval(10, 20)
iv9 = Interval(15, 20)
assert iv0.overlaps(iv0)
assert not iv0.overlaps(iv1)
assert not iv0.overlaps(iv2)
assert iv0.overlaps(iv3)
assert iv0.overlaps(iv4)
assert iv0.overlaps(iv5)
assert iv0.overlaps(iv6)
assert iv0.overlaps(iv7)
assert not iv0.overlaps(iv8)
assert not iv0.overlaps(iv9)
def test_interval_overlaps_range():
iv0 = Interval(0, 10)
iv1 = (-10, -5)
iv2 = (-10, 0)
iv3 = (-10, 5)
iv4 = (-10, 10)
iv5 = (-10, 20)
iv6 = (0, 20)
iv7 = (5, 20)
iv8 = (10, 20)
iv9 = (15, 20)
assert iv0.overlaps(iv0)
assert not iv0.overlaps(*iv1)
assert not iv0.overlaps(*iv2)
assert iv0.overlaps(*iv3)
assert iv0.overlaps(*iv4)
assert iv0.overlaps(*iv5)
assert iv0.overlaps(*iv6)
assert iv0.overlaps(*iv7)
assert not iv0.overlaps(*iv8)
assert not iv0.overlaps(*iv9)
def test_interval_cmp_interval():
iv0 = Interval(0, 10)
iv1 = Interval(-10, -5)
iv2 = Interval(-10, 0)
iv3 = Interval(-10, 5)
iv4 = Interval(-10, 10)
iv5 = Interval(-10, 20)
iv6 = Interval(0, 20)
iv7 = Interval(5, 20)
iv8 = Interval(10, 20)
iv9 = Interval(15, 20)
assert iv0.__cmp__(iv0) == 0
assert iv0.__cmp__(iv1) == 1
assert iv0.__cmp__(iv2) == 1
assert iv0.__cmp__(iv3) == 1
assert iv0.__cmp__(iv4) == 1
assert iv0.__cmp__(iv5) == 1
assert iv0.__cmp__(iv6) == -1
assert iv0.__cmp__(iv7) == -1
assert iv0.__cmp__(iv8) == -1
assert iv0.__cmp__(iv9) == -1
def test_get_fields():
ivn = Interval(0, 1)
ivo = Interval(0, 1, 'hello')
assert ivn._get_fields() == (0, 1)
assert ivo._get_fields() == (0, 1, 'hello')
def test_interval_int_comparison_methods():
"""
Test comparisons with integers using gt(), ge(), lt() and le()
"""
iv = Interval(0, 10)
assert iv.gt(-5)
assert iv.ge(-5)
assert not iv.lt(-5)
assert not iv.le(-5)
assert not iv.gt(0)
assert iv.ge(0)
assert not iv.lt(0)
assert not iv.le(0)
assert not iv.gt(5)
assert not iv.ge(5)
assert not iv.lt(5)
assert not iv.le(5)
assert not iv.gt(10)
assert not iv.ge(10)
assert iv.lt(10)
assert iv.le(10)
assert not iv.gt(15)
assert not iv.ge(15)
assert iv.lt(15)
assert iv.le(15)
def test_interval_interval_comparison_methods():
"""
Test comparisons with other Intervals using gt(), ge(), lt() and
le()
"""
iv0 = Interval(0, 10)
iv1 = Interval(-10, -5)
iv2 = Interval(-10, 0)
iv3 = Interval(-10, 5)
iv4 = Interval(-10, 10)
iv5 = Interval(-10, 20)
iv6 = Interval(0, 20)
iv7 = Interval(5, 20)
iv8 = Interval(10, 20)
iv9 = Interval(15, 20)
assert not iv0.gt(iv0)
assert iv0.gt(iv1)
assert iv0.gt(iv2)
assert not iv0.gt(iv3)
assert not iv0.gt(iv4)
assert not iv0.gt(iv5)
assert not iv0.gt(iv6)
assert not iv0.gt(iv7)
assert not iv0.gt(iv8)
assert not iv0.gt(iv9)
assert iv0.ge(iv0)
assert iv0.ge(iv1)
assert iv0.ge(iv2)
assert iv0.ge(iv3)
assert iv0.ge(iv4)
assert iv0.ge(iv5)
assert iv0.ge(iv6)
assert not iv0.ge(iv7)
assert not iv0.ge(iv8)
assert not iv0.ge(iv9)
assert not iv0.lt(iv0)
assert not iv0.lt(iv1)
assert not iv0.lt(iv2)
assert not iv0.lt(iv3)
assert not iv0.lt(iv4)
assert not iv0.lt(iv5)
assert not iv0.lt(iv6)
assert not iv0.lt(iv7)
assert iv0.lt(iv8)
assert iv0.lt(iv9)
assert iv0.le(iv0)
assert not iv0.le(iv1)
assert not iv0.le(iv2)
assert not iv0.le(iv3)
assert iv0.le(iv4)
assert iv0.le(iv5)
assert iv0.le(iv6)
assert iv0.le(iv7)
assert iv0.le(iv8)
assert iv0.le(iv9)
def test_isnull():
iv = Interval(0, 0)
assert iv.is_null()
iv = Interval(1, 0)
assert iv.is_null()
def test_interval_null_interval_comparison_methods():
"""
Test comparisons with other Intervals using gt(), ge(), lt() and
le()
"""
iv0 = Interval(0, 10)
ivn = Interval(0, 0)
with pytest.raises(ValueError):
iv0.gt(ivn)
with pytest.raises(ValueError):
ivn.gt(iv0)
with pytest.raises(ValueError):
iv0.ge(ivn)
with pytest.raises(ValueError):
ivn.ge(iv0)
with pytest.raises(ValueError):
iv0.lt(ivn)
with pytest.raises(ValueError):
ivn.lt(iv0)
with pytest.raises(ValueError):
iv0.le(ivn)
with pytest.raises(ValueError):
ivn.le(iv0)
def test_interval_int_comparison_methods():
iv = Interval(0, 10)
assert iv.gt(-5)
assert iv.ge(-5)
assert not iv.lt(-5)
assert not iv.le(-5)
assert not iv.gt(0)
assert iv.ge(0)
assert not iv.lt(0)
assert not iv.le(0)
assert not iv.gt(5)
assert not iv.ge(5)
assert not iv.lt(5)
assert not iv.le(5)
assert not iv.gt(10)
assert not iv.ge(10)
assert iv.lt(10)
assert iv.le(10)
assert not iv.gt(15)
assert not iv.ge(15)
assert iv.lt(15)
assert iv.le(15)
