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 graph():
return obg.Graph({i + 1: obg.Block(10)
for i in range(4)}, {
1: [2, 3],
2: [4],
3: [4]
})
def setUp(self):
from collections import defaultdict
self.n_blocks = 100
self.n_edges = self.n_blocks + 50
blocks = {}
blocks_list = []
for i in range(1, self.n_blocks + 1):
blocks[i] = obg.Block(3)
blocks_list.append(i)
# Random edges
edge_dict = defaultdict(list)
for i in range(0, self.n_edges):
start = blocks_list[randrange(0, len(blocks_list))]
end = blocks_list[randrange(0, len(blocks_list))]
if randrange(0, 2) == 1:
start = -start
if randrange(0, 2) == 1:
end = -end
if end == start or end == -start:
continue
if end not in edge_dict[start]:
edge_dict[start].append(end)
self.graph = obg.GraphWithReversals(blocks, edge_dict)
def setUp(self):
super().setUp()
nodes = {i: obg.Block(100) for i in range(1, 11)}
edges = {i: [i+1] for i in range(1, 10)}
self.lin_graph = obg.GraphWithReversals(nodes, edges)
edges = {i: [i+1, (i+5) % 5 + 1] for i in range(1, 5)}
self.double_graph = obg.GraphWithReversals(nodes, edges)
def test_add_pos_and_negbinary_areas(self):
touched_nodes = set()
graph = obg.Graph({1: obg.Block(100)}, {})
pos_starts = np.array([0] + [i * 10 for i in range(9)])
pos_ends = np.array([100] + [(i + 2) * 10 for i in range(9)])
neg_starts = np.array([0] + [i * 10 + 5 for i in range(9)])
neg_ends = np.array([100] + [(i + 1) * 10 + 5 for i in range(9)])
bin_areas = []
for start, end in zip(pos_starts, pos_ends):
binary_connected_areas = BinaryContinousAreas(graph)
binary_connected_areas.add(1, start, end)
binary_connected_areas.sanitize()
bin_areas.append(binary_connected_areas)
for start, end in zip(neg_starts, neg_ends):
binary_connected_areas = BinaryContinousAreas(graph)
binary_connected_areas.add(-1, start, end)
binary_connected_areas.sanitize()
bin_areas.append(binary_connected_areas)
valued_areas = ValuedAreas(graph)
for bin_area in bin_areas:
valued_areas.add_binary_areas(bin_area,
touched_nodes=touched_nodes)
true_starts = np.sort(np.concatenate([pos_starts, 100 - neg_ends]))
true_ends = np.sort(np.concatenate([pos_ends, 100 - neg_starts]))
self.assertTrue(
np.all(np.sort(valued_areas.get_starts_array(1)) == true_starts))
self.assertTrue(
np.all(np.sort(valued_areas.get_ends_array(1)) == true_ends))
def test_long_hole():
pileup = SparseValues([0, 5, 95], [True, False, True])
graph = obg.GraphWithReversals({i: obg.Block(1)
for i in range(1, 101)},
{i: [i + 1]
for i in range(1, 100)})
holes = HolesCleaner(graph, pileup, 56).run()
assert holes == pileup
def test_internals():
graph = obg.GraphWithReversals({101: obg.Block(100)}, {101: []})
pileup = SparseValues([0, 10, 19, 30, 41, 50], [1, 0, 1, 0, 1, 0])
cleaned = HolesCleaner(graph, pileup, 10).run()
true = SparseValues([0, 30, 41, 50], [1, 0, 1, 0])
assert cleaned == true
def setUp(self):
self.graph = obg.GraphWithReversals(
{i: obg.Block(10)
for i in range(1, 5)}, {
1: [2],
2: [3],
3: [4]
})
self.pileup = SparsePileup(self.graph)
def hierarchical_graph():
nodes = {i: obg.Block(i - 90) for i in range(100, 106)}
edges = {
100: [101, 102],
101: [105],
102: [103, 104],
103: [105],
104: [105]
}
return obg.Graph(nodes, edges)
def snp_graph():
nodes = {i: obg.Block((i % 2) + 1) for i in range(100, 106)}
edges = {
100: [101, 102],
101: [105],
102: [103, 104],
103: [105],
104: [105]
}
return obg.Graph(nodes, edges)
def graph():
nodes = {i: obg.Block(10) for i in range(10, 18)}
edges = {
10: [11],
11: [12, 13],
12: [14],
13: [14],
14: [15, 16, 17],
15: [16],
16: [17]
}
return obg.Graph(nodes, edges)
def test_holes_cleaner():
indices = np.array(
[80, 100, 180, 220, 240, 250, 300, 400, 500, 520, 610, 810])
values = np.array([(i % 2) for i, _ in enumerate(indices)])
pileup = SparseValues(indices, values)
graph = obg.GraphWithReversals({i + 1: obg.Block(100)
for i in range(10)},
{i: [i + 1]
for i in range(1, 10)})
# graph.node_indexes = np.arange(0, 1001, 100)
holes = HolesCleaner(graph, pileup, 10).run()
print(holes)
def setUp(self):
self.graph = obg.GraphWithReversals({i: obg.Block(3) for i in range(1, 12)},
{
-1: [-11],
1: [2, 3, 7],
2: [4, 5],
3: [4, 5],
4: [-5, 6, 8],
5: [7],
6: [-7, 9],
7: [9],
9: [10]
})
def complicated_offset():
nodes = {i: obg.Block(2) for i in range(101, 111)}
edges = {
101: [102, 103],
102: [104],
103: [104],
104: [105, 106],
105: [107],
106: [107],
107: [108, 109],
109: [110]
}
return obg.GraphWithReversals(nodes, edges)
def complicated_graph():
nodes = {i: obg.Block(2) for i in range(1, 11)}
edges = {
1: [2, 3],
2: [4],
3: [4],
4: [5, 6],
5: [7],
6: [7],
7: [8, 9],
9: [10]
}
return obg.GraphWithReversals(nodes, edges)
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 test_add_binary_areas(self):
touched_nodes = set()
graph = obg.Graph({1: obg.Block(100)}, {})
starts = np.array([0] + [i * 10 for i in range(9)])
ends = np.array([100] + [(i + 2) * 10 for i in range(9)])
bin_areas = []
for start, end in zip(starts, ends):
binary_connected_areas = BinaryContinousAreas(graph)
binary_connected_areas.add(1, start, end)
binary_connected_areas.sanitize()
bin_areas.append(binary_connected_areas)
valued_areas = ValuedAreas(graph)
for bin_area in bin_areas:
valued_areas.add_binary_areas(bin_area,
touched_nodes=touched_nodes)
self.assertTrue(
np.all(valued_areas.get_starts_array(1) == np.sort(starts)))
self.assertTrue(
np.all(valued_areas.get_ends_array(1) == np.sort(ends)))
def test_end_hole():
pileup = SparseValues([0, 5, 10], [False, True, False])
graph = obg.GraphWithReversals({1: obg.Block(12)}, {1: []})
holes = HolesCleaner(graph, pileup, 4).run()
assert holes == pileup
import offsetbasedgraph as obg
from graph_peak_caller.postprocess.maxpaths import SparseMaxPaths
from graph_peak_caller.sparsediffs import SparseValues
from graph_peak_caller.peakcollection import Peak
import numpy as np
nodes = {i + 1: obg.Block(10) for i in range(10)}
edges = {i: [i + 1] for i in range(1, 10)}
edges[1] = [2, 3]
edges[2] = [4]
edges[3] = [4]
graph = obg.GraphWithReversals(nodes, edges)
def complicated_offset():
nodes = {i: obg.Block(2) for i in range(101, 111)}
edges = {
101: [102, 103],
102: [104],
103: [104],
104: [105, 106],
105: [107],
106: [107],
107: [108, 109],
109: [110]
}
return obg.GraphWithReversals(nodes, edges)
def offsetgraph():
def to_obg(self):
return offsetbasedgraph.Block(self.n_basepairs)
import unittest
from graph_peak_caller.areas import BinaryContinousAreas, BCACollection
import offsetbasedgraph as obg
nodes = {i: obg.Block(10) for i in range(1, 10)}
graph = obg.GraphWithReversals(nodes, {i: [i+1] for i in range(1, 9)})
class TestBinaryContinousAreas(unittest.TestCase):
def setUp(self):
self.areas = BinaryContinousAreas(graph)
self.areas.full_areas = {1: 1, 2: 1}
self.areas.starts = {3: 2, 4: 5}
self.areas.internal_intervals = {5: [2, 7]}
def test_file_in_out(self):
line = self.areas.to_file_line()
print(line)
new_areas = BinaryContinousAreas.from_file_line(line, graph)
self.assertEqual(new_areas, self.areas)
c = BCACollection([self.areas, self.areas])
c.to_file("tmp.subgraphs")
BCACollection.from_file("tmp.subgraphs", graph)
def test_filled_interval(self):
interval = obg.DirectedInterval(4, 4, [2, 3, 4])
areas = BinaryContinousAreas(graph)
areas.filled_interval(interval)
areas.sanitize()
def graph():
nodes = [9, 10, 11, 12, 13, 14]
nodes = {i: obg.Block(10) for i in nodes}
edges = {9: [10], 10: [11, 12], 11: [13], 12: [13], 13: [14]}
return obg.Graph(nodes, edges)
def setUp(self):
nodes = {i: obg.Block(10) for i in range(1, 11)}
edges = {i: [i+1, i+6] for i in range(1, 6)}
self.graph = obg.GraphWithReversals(nodes, edges)
def setUp(self):
nodes = {i + 1: obg.Block(10) for i in range(5)}
edges = {1: [2, 3], 2: [4], 3: [-4], 4: [5], -4: [5]}
self.graph = obg.GraphWithReversals(nodes, edges)
data = {
node_id: ValuedIndexes(
np.array([2 * i for i in range(1, 5)]),
np.array([2 * i + 10 * node_id for i in range(1, 5)]),
node_id * 10, 10)
for node_id in nodes
}
self.pileup = SparsePileup(self.graph)
self.pileup.data = data
self.pileup = DensePileup.create_from_old_sparsepileup(self.pileup)
flat_data = {
node_id: ValuedIndexes(np.array([], dtype="int"), np.array([]),
node_id * 10, 10)
for node_id in nodes
}
self.flat_pileup = SparsePileup(self.graph)
self.flat_pileup.data = flat_data
self.flat_pileup = DensePileup.create_from_old_sparsepileup(
self.flat_pileup)
self.peak = BinaryContinousAreas(self.graph)
self.peak.add_full(2)
self.peak.add_full(4)
self.peak.add_full(3)
self.peak.add_start(5, 5)
self.peak.add_start(-1, 5)
indexes = np.array([2, 4, 6, 8])
values = np.array([2, 4, 6, 8])
self.scores = {
2: ValuedIndexes(indexes, values + 20, 20, 10),
-2: ValuedIndexes(indexes, values + 20, 20, 10),
3: ValuedIndexes(indexes, values + 30, 30, 10),
-3: ValuedIndexes(indexes, values + 30, 30, 10),
4: ValuedIndexes(indexes, values + 40, 40, 10),
-4: ValuedIndexes(indexes, values + 40, 40, 10),
5: ValuedIndexes(np.array([2, 4]), np.array([52, 54]), 50, 5),
-1: ValuedIndexes(np.array([1, 3]), np.array([16, 18]), 14, 5)
}
self.flat_scores = {
2: ValuedIndexes(np.array([], dtype="int"), np.array([]), 20, 10),
3: ValuedIndexes(np.array([], dtype="int"), np.array([]), 30, 10),
4: ValuedIndexes(np.array([], dtype="int"), np.array([]), 40, 10),
-2: ValuedIndexes(np.array([], dtype="int"), np.array([]), 20, 10),
-3: ValuedIndexes(np.array([], dtype="int"), np.array([]), 30, 10),
-4: ValuedIndexes(np.array([], dtype="int"), np.array([]), 40, 10),
5: ValuedIndexes(np.array([], dtype="int"), np.array([]), 50, 5),
-1: ValuedIndexes(np.array([], dtype="int"), np.array([]), 10, 5)
}
self.peak2 = BinaryContinousAreas(self.graph)
self.peak2.add_full(2)
self.peak2.add_start(-3, 7)
self.peak2.add_full(4)
self.peak2.add_start(5, 5)
self.scores2 = {
2: ValuedIndexes(indexes, values + 20, 20, 10),
-3: ValuedIndexes(np.array([1, 3, 5]), np.array([34, 36, 38]), 32,
7),
4: ValuedIndexes(indexes, values + 40, 40, 10),
5: ValuedIndexes(np.array([2, 4]), np.array([52, 54]), 50, 5),
}
self.scored_peak = ScoredPeak(self.peak, self.scores)
self.flat_scored_peak = ScoredPeak(self.peak, self.flat_scores)
self.scored_peak2 = ScoredPeak(self.peak2, self.scores2)
self.max_path = obg.DirectedInterval(5,
5, [1, 3, -4, 5],
graph=self.graph)
self.max_path2 = obg.DirectedInterval(3,
5, [3, -4, 5],
graph=self.graph)
def get_padded_cyclic_graph():
nodes = {1: obg.Block(100), 2: obg.Block(100),
3: obg.Block(100), 4: obg.Block(100)}
adj_list = {1: [2], 2: [3, 4, 2]}
return Graph(nodes, adj_list)
def sorted_wierd_graph(a, b):
nodes = {i + 1: obg.Block(100) for i in range(4)}
edges = {1: [2, 3], 2: [4], 3: [4]}
return obg.GraphWithReversals(nodes, edges)
import pytest
if pytest.__version__ < "3.0.0":
pytest.skip()
import numpy as np
import unittest
import offsetbasedgraph as obg
# from test_snarls import snarl_graph2
# from graph_peak_caller.control.linearsnarls import \
# UnmappedIndices, LinearPileup
# from graph_peak_caller.control.snarlmaps import LinearSnarlMap
graph = obg.GraphWithReversals(
{3: obg.Block(20), 5: obg.Block(10),
12: obg.Block(20), 13: obg.Block(21),
}, {})
@pytest.mark.skip()
class TestSnarlMap(unittest.TestCase):
def setUp(self):
self.snarl_map = LinearSnarlMap.from_snarl_graph(snarl_graph2, graph)
self.graph_positions = [obg.Position(5, 4),
obg.Position(3, 4),
obg.Position(12, 4),
obg.Position(13, 4)]
self.linear_positions = [4, 31/20*4, 10+21/20*4, 14]
self.linear_positions = [p for p in self.linear_positions]
self.graph_interval = obg.DirectedInterval(self.graph_positions[0],
self.graph_positions[2])
def get_large_cyclic_graph():
nodes = {1: obg.Block(100), 2: obg.Block(20)}
adj_list = {1: [2], 2: [1]}
return Graph(nodes, adj_list)
def small_graph():
nodes = {i: obg.Block(10) for i in range(101, 107)}
edges = {101: [102], 102: [103, 104], 103: [105], 104: [105], 105: [106]}
return obg.GraphWithReversals(nodes, edges)
def get_small_cyclic_graph():
nodes = {1: obg.Block(100)}
adj_list = {1: [1]}
return Graph(nodes, adj_list)
