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 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 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 setUp(self):
iv = IntervalNode(1, 2, Interval(1, 2))
self.max = 1000000
for i in range(0, self.max, 10):
f = Interval(i, i)
iv = iv.insert(f.start, f.end, f)
for i in range(600):
iv = iv.insert(0, 1, Interval(0, 1))
self.intervals = iv
def test_downstream(self):
iv = self.intervals
downstreams = iv.downstream_of_interval(Interval(59, 60),
num_intervals=200)
for d in downstreams:
self.assertTrue(d.start > 60)
downstreams = iv.downstream_of_interval(Interval(59, 60, strand=-1),
num_intervals=200)
for d in downstreams:
self.assertTrue(d.start < 59)
def test_upstream(self):
iv = self.intervals
upstreams = iv.upstream_of_interval(Interval(59, 60),
num_intervals=200)
for u in upstreams:
self.assertTrue(u.end < 59)
upstreams = iv.upstream_of_interval(Interval(60, 70, strand=-1),
num_intervals=200)
for u in upstreams:
self.assertTrue(u.start > 70)
upstreams = iv.upstream_of_interval(Interval(58, 58, strand=-1),
num_intervals=200)
for u in upstreams:
self.assertTrue(u.start > 59)
def _build_feature_tree(self, replicon):
interval_tree = Intersecter()
for feature in self._replicon_dict[replicon]["features"]:
interval_tree.add_interval(
Interval(feature["start"],
feature["end"],
value=feature,
strand=feature["strand"]))
return interval_tree
def test_right(self):
iv = self.intervals
self.assertEqual(str(iv.left(60, n=2)),
str([Interval(50, 59),
Interval(40, 49)]))
def get_right_start(b10):
r = iv.right(b10 + 1, n=1)
assert len(r) == 1
return r[0].start
for i in range(10, 100, 10):
self.assertEqual(get_right_start(i), i + 10)
for i in range(0, 100, 10):
r = iv.right(i - 1, max_dist=10, n=1)
print(r)
self.assertEqual(r[0].start, i)
def setUp(self):
iv = IntervalTree()
n = 0
for i in range(1, 1000, 80):
iv.insert(i, i + 10, dict(value=i * i))
# add is synonym for insert.
iv.add(i + 20, i + 30, dict(astr=str(i * i)))
# or insert/add an interval object with start, end attrs.
iv.insert_interval(
Interval(i + 40, i + 50, value=dict(astr=str(i * i))))
iv.add_interval(
Interval(i + 60, i + 70, value=dict(astr=str(i * i))))
n += 4
self.intervals = self.iv = iv
self.nintervals = n
def test_n(self):
iv = self.intervals
for i in range(0, 90, 10):
r = iv.after(i, max_dist=20, num_intervals=2)
self.assertEqual(r[0].start, i + 10)
self.assertEqual(r[1].start, i + 20)
r = iv.after_interval(Interval(i, i), max_dist=20, num_intervals=2)
self.assertEqual(r[0].start, i + 10)
self.assertEqual(r[1].start, i + 20)
def count_reads_for_peaks(self, replicon, peak_list):
self._interval_tree = Intersecter()
self._counts = np.array([0] * len(peak_list))
for ind, peak in enumerate(peak_list):
self._interval_tree.add_interval(
Interval(peak["peak_start"]-1,
peak["peak_end"],
value=ind,
strand=peak["peak_strand"]))
if self._paired_end:
self._cache_read2(replicon)
self._count_reads(replicon)
return self._counts
def count_reads_for_windows(self, replicon, strand, window_list):
self._interval_tree = Intersecter()
self._counts = np.array([0] * len(window_list))
for ind, window in enumerate(window_list):
self._interval_tree.add_interval(
Interval(window[0],
window[1],
value=ind,
strand=strand))
if self._paired_end:
self._cache_read2(replicon)
self._count_reads(replicon)
return self._counts