def test_short_and_long_peak(self):
intervals = [obg.Interval(0, 1, [1, 3]),
obg.Interval(2, 3, [6, -7, 9, 10])]
self.intervals = intervals
self.correct_intervals = [obg.Interval(0, 3, [1]),
intervals[1]]
self.do_asserts()
def test_subgraph_covered(self):
self.intervals = [
obg.Interval(1, 2, [3, 4, 8]),
obg.Interval(0, 3, [2, 5])
]
self.correct_intervals = self.intervals
self.do_asserts()
def test_peak_over_different_edges(self):
self.intervals = [
obg.Interval(0, 3, [-1, -11]),
obg.Interval(0, 2, [7]),
]
self.correct_intervals = self.intervals
self.do_asserts()
def test_from_intervals2(self):
graph = obg.GraphWithReversals(
{
1: obg.Block(10),
2: obg.Block(10),
3: obg.Block(10)
}, {
1: [2],
2: [3]
})
intervals = [
obg.Interval(1, 5, [1]),
obg.Interval(3, 7, [1]),
obg.Interval(5, 3, [1, 2]),
obg.Interval(5, 6, [2]),
obg.Interval(8, 8, [1, 2, 3])
]
pileup = SparsePileup.from_intervals(graph, intervals)
data = pileup.data
self.assertEqual(data[1].start_value, False)
self.assertEqual(data[2].start_value, 2)
self.assertEqual(data[3].start_value, 1)
self.assertTrue(np.all([1, 3, 5, 7, 8] == data[1].indexes))
#print("data 1 values")
#print(data[2].values)
self.assertTrue(np.all([1, 2, 2, 1, 2] == data[1].values))
self.assertTrue(np.all([3, 5, 6] == data[2].indexes))
self.assertTrue(np.all([1, 2, 1] == data[2].values))
self.assertTrue(np.all([8] == data[3].indexes))
self.assertTrue(np.all([0] == data[3].values))
def test_edge_holes(self):
self.intervals = [obg.Interval(0, 2, [i]) for i in [2, 4, 6]]
self.intervals.append(obg.Interval(1, 2, [5]))
self.correct_holes = [
obg.Interval(2, 1, [4, -5]),
obg.Interval(2, 1, [2, 5]),
]
self.do_asserts()
def test_multiple_rps(self):
intervals = [obg.Interval(4, 6, [1]), obg.Interval(6, 4, [1, 2])]
values = [1, 2]
self.pileup.set_sorted_interval_values(intervals, values)
correct = {}
correct[1] = ValuedIndexes([4, 6], [1, 2], 0, 10)
correct[2] = ValuedIndexes([4], [0], 2, 10)
self.assertEqual(self.pileup.data[1], correct[1])
self.assertEqual(self.pileup.data[2], correct[2])
def test_simple(self):
intervals = [obg.Interval(4, 6, [1]), obg.Interval(6, 8, [1])]
values = [1, 2]
self.pileup.set_sorted_interval_values(intervals, values)
correct = ValuedIndexes([4, 6, 8], [1, 2, 0], 0, 10)
print(correct)
print(self.pileup.data[1])
self.assertEqual(self.pileup.data[1], correct)
def test_cycle(self):
start_intervals = [
obg.Interval(0, 100, [1], graph=self.padded_graph),
obg.Interval(0, 100, [3], graph=self.padded_graph)]
pileup = SparsePileup.from_intervals(
self.padded_graph, start_intervals)
pileup.threshold(1)
cleaner = HolesCleaner(pileup, 40)
areas = cleaner.run()
true_areas = Areas(self.padded_graph, {})
self.assertEqual(areas, true_areas)
def test_loop_with_start_and_end_intervals(self):
start_intervals = [
obg.Interval(
90, 10, [1, 2],
graph=self.padded_graph),
obg.Interval(
90, 100, [2],
graph=self.padded_graph)]
pileup = SparsePileup.from_intervals(
self.padded_graph, start_intervals)
pileup.threshold(1)
cleaner = PeaksCleaner(pileup, 400)
areas = cleaner.run()
self.assertEqual(areas.areas, {})
def test_simple(self):
start_intervals = [
obg.Interval(10, 40, [2], graph=self.padded_graph),
obg.Interval(50, 90, [2], graph=self.padded_graph)]
pileup = SparsePileup.from_intervals(
self.padded_graph, start_intervals)
pileup.threshold(1)
cleaner = HolesCleaner(pileup, 40)
areas = cleaner.run()
self.assertEqual(areas, Areas(self.padded_graph,
{2: [0, 10, 40, 50, 90, 100]}))
pileup.fill_small_wholes(40)
true_pileup = SparsePileup.from_intervals(
self.padded_graph,
[obg.Interval(0, 100, [2], graph=self.padded_graph)])
true_pileup.threshold(1)
self.assertEqual(pileup, true_pileup)
def test_mid_interval(self):
start_intervals = [
obg.Interval(10, 90, [2], graph=self.padded_graph)]
pileup = SparsePileup.from_intervals(
self.lin_graph, start_intervals)
pileup.threshold(1)
cleaner = HolesCleaner(pileup, 20)
areas = cleaner.run()
self.assertEqual(areas, Areas(self.lin_graph))
def to_simple_intervals(self):
intervals = []
for node, area in self.areas.items():
for i in range(0, len(area) // 2):
start = int(area[i * 2])
end = int(area[i * 2 + 1])
interval = obg.Interval(start, end, [node], self.graph)
intervals.append(interval)
return intervals
def test_lin(self):
intervals = [
obg.Interval(80, 20, [1, 2]),
obg.Interval(41, 90, [2]),
obg.Interval(10, 50, [3]),
obg.Interval(70, 100, [3]),
obg.Interval(20, 50, [4])]
for i in intervals:
i.graph = self.lin_graph
pileup = SparsePileup.from_intervals(self.lin_graph, intervals)
pileup.threshold(1)
cleaner = HolesCleaner(pileup, 20)
areas = cleaner.run()
true_areas = Areas(self.lin_graph,
{2: [90, 100],
3: [0, 10, 50, 70],
4: [0, 20]})
self.assertEqual(areas, true_areas)
def test_loop_with_surrounding(self):
start_intervals = [obg.Interval(
90, 100, [1, 2],
graph=self.padded_graph)]
pileup = SparsePileup.from_intervals(
self.padded_graph, start_intervals)
pileup.threshold(1)
cleaner = PeaksCleaner(pileup, 400)
areas = cleaner.run()
self.assertIntervalsGiveSamePileup(areas, start_intervals)
def test_map_interval_collection(hierarchical_map):
interval_rps = [[100, 101], [100, 102], [101, 105], [102, 103], [102, 104],
[103, 105], [104, 105]]
intervals = [obg.Interval(5, 5, rps) for rps in interval_rps]
linear_intervals = hierarchical_map.map_interval_collection(intervals)
true_starts = [
5, 5, 10 + 5 * 26 / 11, 10 + 5, 10 + 5, 22 + 5 * 14 / 13, 22 + 5
]
true_ends = [
10 + 5 * 26 / 11, 10 + 5, 36 + 5, 22 + 5 * 14 / 13, 22 + 5, 36 + 5,
36 + 5
]
true_linear = LinearIntervalCollection(true_starts, true_ends)
assert linear_intervals == true_linear
def test_intervals_to_start_and_ends(self):
graph = obg.GraphWithReversals({
1: obg.Block(10),
2: obg.Block(10)
}, {1: [2]})
intervals = [
obg.Interval(1, 5, [1]),
obg.Interval(3, 7, [1]),
obg.Interval(5, 3, [1, 2]),
obg.Interval(5, 6, [2])
]
correct_starts = {1: [1, 3, 5], 2: [0, 5]}
correct_ends = {1: [5, 7, 10], 2: [3, 6]}
starts, ends = intervals_to_start_and_ends(graph, intervals)
#print("Starts")
#print(starts)
#print("Ends")
#print(ends)
for rp in graph.blocks:
self.assertTrue(np.all(correct_starts[rp] == starts[rp]))
self.assertTrue(np.all(correct_ends[rp] == ends[rp]))
def setUpRandomIntervals(self, with_hole=False):
# Create random interval
start_rp = randrange(1, self.n_blocks + 1)
start_offset = randrange(0, 3)
end_offset = max(randrange(0, 3), start_offset + 1)
rps = [start_rp]
prev_rp = start_rp
for i in range(0, self.n_blocks):
edges = self.graph.adj_list[prev_rp]
if len(edges) == 0:
break
rp = edges[randrange(0, len(edges))]
prev_rp = rp
if rp in rps:
break
rps.append(rp)
self.intervals = [obg.Interval(start_offset, end_offset, rps, self.graph)]
if with_hole:
# Split interval at random position
split_rp = randrange(0, len(rps))
if split_rp > 0:
split_pos = randrange(0, 2)
else:
split_pos = start_offset + 1
split_end = split_pos
first_interval_rps = rps[0:split_rp + 1]
if split_pos == 0:
first_interval_rps = first_interval_rps[0:split_rp]
split_end = 2
start_interval = obg.Interval(start_offset, split_end, first_interval_rps, self.graph)
end_interval = obg.Interval(split_pos, end_offset, rps[split_rp:], self.graph)
self.intervals = [start_interval, end_interval]
hole_rps = [first_interval_rps[-1]]
hole_end = split_pos
if rps[split_rp] != hole_rps[0]:
hole_rps.append(rps[split_rp])
if hole_end == 0:
hole_end = 3
hole_rps = hole_rps[:-1]
self.hole_interval = obg.Interval(split_end, hole_end, hole_rps, self.graph)
if start_interval.contains(self.hole_interval) or end_interval.contains(self.hole_interval) \
or start_interval.contains(self.hole_interval.get_reverse()) \
or end_interval.contains(self.hole_interval.get_reverse()):
self.hole_interval = obg.Interval(0, 0, [1], self.graph) # Use empty hole
self.intervals_without_holes = [obg.Interval(start_offset, end_offset, rps, self.graph)]
def extend_peak_to_reference(self, peak):
if peak.region_paths[0] < 0:
peak.graph = self.graph
peak = peak.get_reverse()
start_node = peak.region_paths[0]
end_node = peak.region_paths[-1]
start_offset = peak.start_position.offset
end_offset = peak.end_position.offset
rps = peak.region_paths
if start_node not in self.indexed_interval.nodes_in_interval():
start_node = min(
-node for node in self.graph.reverse_adj_list[-start_node]
if -node in self.indexed_interval.nodes_in_interval())
start_offset = self.graph.node_size(start_node) - 1
rps = [start_node] + rps
if end_node not in self.indexed_interval.nodes_in_interval():
end_node = max(
node for node in self.graph.adj_list[end_node]
if node in self.indexed_interval.nodes_in_interval())
end_offset = 1
rps = rps + [end_node]
return obg.Interval(start_offset, end_offset, rps)
def test_single_long_interval(self):
self.intervals = [obg.Interval(0, 3, [1, 3, 4, 6, -7, 9, 10])]
self.correct_intervals = [obg.Interval(0, 3, [1, 3, 4, 6, -7, 9, 10])]
self.do_asserts()
def diff_expr():
main_path = obg.Interval(3, 2, [1, 3, 4])
var_path = obg.Interval(3, 2, [1, 2, 4])
return DiffExpression("peak1", main_path, var_path, 14, 4)
def test_middle_hole(self):
self.intervals = [obg.Interval(0, 1, [2]),
obg.Interval(2, 3, [2]),
obg.Interval(0, 3, [5])]
self.correct_holes = [obg.Interval(1, 2, [2])]
self.do_asserts()
def test_single_hole(self):
self.intervals = [obg.Interval(0, 3, [2]),
obg.Interval(1, 3, [4])]
self.correct_holes = [obg.Interval(0, 1, [4])]
self.do_asserts()
def test_single_interval_on_reversed_nodes(self):
self.intervals = [obg.Interval(0, 3, [6, -7, -1, -11])]
self.correct_intervals = self.intervals
self.do_asserts()
def test_single_peak_positive_and_negative_node(self):
self.intervals = [obg.Interval(0, 3, [6, -7])]
self.correct_intervals = self.intervals
self.do_asserts()
edits = [Edit(4, 4, None), Edit(1, 1, "N")]
mapping_jsons = [{
"position": position_jsons[0],
"edit": edit_jsons
}, {
"position": position_jsons[1],
"edit": edit_jsons
}]
mappings = [Mapping(positions[0], edits), Mapping(positions[1], edits)]
path_jsons = [{"name": "path1", "mapping": mapping_jsons[:1]}]
paths = [Path("path1", mappings[:1])]
intervals = [offsetbasedgraph.Interval(10, 15, [0])]
nodes = [
Node("_", 0, 10),
Node("_", 1, 20),
Node("_", 2, 30),
Node("_", 3, 40)
]
edges = [Edge(0, 1), Edge(0, 2), Edge(1, 3), Edge(2, 3)]
vg_graphs = [Graph(nodes, edges, [])]
ob_graphs = [graph.get_offset_based_graph() for graph in vg_graphs]
pileup_intervals = [
offsetbasedgraph.Interval(5, 5, [0, 1]),
def test_whole_graph_covered(self):
self.intervals = [
obg.Interval(0, 3, [i]) for i in range(1, 12)
]
self.correct_intervals = self.intervals
self.do_asserts()
def get_sequence(sequence_graph, node_ids):
interval = obg.Interval(
0, sequence_graph._node_sizes[node_ids[-1]], node_ids)
return sequence_graph.get_interval_sequence(interval)
def test_splitted_long_interval(self):
intervals = [obg.Interval(0, 1, [1, 3, 4]),
obg.Interval(2, 3, [6, -7, 9, 10])]
self.intervals = intervals
self.correct_intervals = intervals
self.do_asserts()
def test_cleans_all(self):
self.intervals = [obg.Interval(0, 3, [1]), obg.Interval(3, 2, [4, 6])]
self.correct_intervals = []
self.do_asserts()
