def test_add_asm_graph():
# Load the assembly graph.
sg_edges_list = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'sg_edges_list')
utg_data = os.path.join(helpers.get_test_data_dir(), 'gfa-1', 'utg_data')
ctg_paths = os.path.join(helpers.get_test_data_dir(), 'gfa-1', 'ctg_paths')
asm_graph = AsmGraph(sg_edges_list, utg_data, ctg_paths)
# Add the graph to GFA.
gfa_graph = mod.GFAGraph()
gfa_graph.add_asm_graph(asm_graph)
assert(len(gfa_graph.paths.keys()) == 0)
expected = {
('000000016:B', '000000027:B'): ['000000016:B', '000000027:B', '*', 1540, 99.94, 449, 0, None, None, None, None],
('000000005:B', '000000016:B'): ['000000005:B', '000000016:B', '*', 1487, 99.93, 502, 0, None, None, None, None],
('000000016:B', '000000025:B'): ['000000016:B', '000000025:B', '*', 1540, 99.94, 449, 0, None, None, None, None],
('000000007:B', '000000005:B'): ['000000007:B', '000000005:B', '*', 1980, 99.95, 9, 0, None, None, None, None],
('000000018:B', '000000004:B'): ['000000018:B', '000000004:B', '*', 1963, 99.95, 26, 0, None, None, None, None],
('000000025:B', '000000018:B'): ['000000025:B', '000000018:B', '*', 1978, 99.95, 11, 0, None, None, None, None]
}
assert(len(gfa_graph.edges.keys()) == len(expected.keys()))
for key, edge in gfa_graph.edges.iteritems():
assert(key in expected)
assert(expected[key] == edge)
def test_add_nx_string_graph():
# Load the assembly graph.
sg_edges_list = os.path.join(helpers.get_test_data_dir(), 'gfa-1',
'sg_edges_list')
utg_data = os.path.join(helpers.get_test_data_dir(), 'gfa-1', 'utg_data')
ctg_paths = os.path.join(helpers.get_test_data_dir(), 'gfa-1', 'ctg_paths')
asm_graph = AsmGraph(sg_edges_list, utg_data, ctg_paths)
# The following block is taken from Unzip, graphs_to_h_tigs.py.
nx_sg = nx.DiGraph()
arid_to_phase = {}
for ctg_id in asm_graph.ctg_data.keys():
ctg_G = asm_graph.get_sg_for_ctg(ctg_id)
ctg_nodes = set(ctg_G.nodes())
for v, w in ctg_G.edges():
vrid = v[:9]
wrid = w[:9]
edge_data = asm_graph.sg_edges[(v, w)]
if edge_data[-1] != "G":
continue
vphase = arid_to_phase.get(vrid, (-1, 0))
wphase = arid_to_phase.get(wrid, (-1, 0))
if vphase[0] == wphase[0] and vphase[1] != wphase[1]:
cross_phase = "Y"
else:
cross_phase = "N"
nx_sg.add_node(v,
label="%d_%d" % vphase,
phase="%d_%d" % vphase,
src="P")
nx_sg.add_node(w,
label="%d_%d" % wphase,
phase="%d_%d" % wphase,
src="P")
nx_sg.add_edge(v, w, src="OP", cross_phase=cross_phase)
# we need to add the complimentary edges as the ctg_graph does not contain the dual edges
rv = reverse_end(v)
rw = reverse_end(w)
nx_sg.add_node(rv,
label="%d_%d" % vphase,
phase="%d_%d" % vphase,
src="P")
nx_sg.add_node(rw,
label="%d_%d" % wphase,
phase="%d_%d" % wphase,
src="P")
nx_sg.add_edge(rw, rv, src="OP", cross_phase=cross_phase)
# Add the string graph to the GFA.
gfa_graph = mod.GFAGraph()
gexf_file = os.path.join(helpers.get_test_data_dir(), 'gfa-1', 'sg.gexf')
nx_sg = nx.read_gexf(gexf_file)
gfa_graph.add_nx_string_graph(nx_sg)
def test_calc_cutoff_err():
partial_capture_fn = os.path.join(
helpers.get_test_data_dir(), 'calc_cutoff/partial_capture.txt')
assert os.path.exists(partial_capture_fn)
with pytest.raises(Exception) as excinfo:
mod.main('prog --coverage 23 1 {}'.format(partial_capture_fn).split())
assert expected_err in str(excinfo.value)
def test_calc_cutoff(capsys):
partial_capture_fn = os.path.join(helpers.get_test_data_dir(), 'calc_cutoff/partial_capture.txt')
assert os.path.exists(partial_capture_fn)
mod.main('prog --coverage 14 1 {}'.format(partial_capture_fn).split())
out, err = capsys.readouterr()
assert out == '2'
assert not err
def test_calc_cutoff_err():
partial_capture_fn = os.path.join(helpers.get_test_data_dir(),
'calc_cutoff/partial_capture.txt')
assert os.path.exists(partial_capture_fn)
with pytest.raises(Exception) as excinfo:
mod.main('prog --coverage 23 1 {}'.format(partial_capture_fn).split())
assert expected_err in str(excinfo.value)
def test_filter_tiling_paths_by_len():
p_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'p_ctg_tiling_path_1')
p_path, p_edge_to_ctg = mod.load_tiling_paths(p_ctg_tiling_path_file, 'P')
_, p_ctg_len = mod.calc_tiling_paths_len(p_path)
p_path_filtered = mod.filter_tiling_paths_by_len(p_path, p_ctg_len, 0)
assert(sorted(p_path_filtered.keys()) == sorted(
['000000F', '000001F', '000002F', '000003F', '000004F']))
p_path_filtered = mod.filter_tiling_paths_by_len(p_path, p_ctg_len, 10000)
assert(sorted(p_path_filtered.keys()) == sorted(
['000000F', '000001F', '000002F', '000003F']))
p_path_filtered = mod.filter_tiling_paths_by_len(p_path, p_ctg_len, 35000)
assert(sorted(p_path_filtered.keys()) == sorted(['000000F', '000001F']))
p_path_filtered = mod.filter_tiling_paths_by_len(p_path, p_ctg_len, 100000)
assert(sorted(p_path_filtered.keys()) == sorted([]))
# Test a degenerate case where there is no length for a particular contig.
keys = p_ctg_len.keys()
p_ctg_len_degenerate = {}
for i in xrange(1, len(keys)):
p_ctg_len_degenerate[keys[i]] = p_ctg_len[keys[i]]
with pytest.raises(Exception) as e_info:
p_path_filtered = mod.filter_tiling_paths_by_len(
p_path, p_ctg_len_degenerate, 0)
def test_calc_cutoff(capsys):
partial_capture_fn = os.path.join(
helpers.get_test_data_dir(), 'calc_cutoff/partial_capture.txt')
assert os.path.exists(partial_capture_fn)
mod.main('prog --coverage 14 1 {}'.format(partial_capture_fn).split())
out, err = capsys.readouterr()
assert out == '2'
assert not err
def test_calc_cutoff_errfile(monkeypatch, tmpdir):
fn = str(tmpdir.mkdir('tmp').join('errfile'))
monkeypatch.setenv('PBFALCON_ERRFILE', fn)
partial_capture_fn = os.path.join(helpers.get_test_data_dir(), 'calc_cutoff/partial_capture.txt')
assert os.path.exists(partial_capture_fn)
with pytest.raises(Exception) as excinfo:
mod.main('prog --coverage 23 1 {}'.format(partial_capture_fn).split())
assert expected_err in str(excinfo.value)
assert expected_err in open(fn).read()
def wrap_write_gfa_v1_test(use_sg, use_nx, use_tp, write_reads, write_contigs,
min_p_len, min_a_len, expected_path):
# Create a GFA graph.
gfa_graph = mod.GFAGraph()
# Init paths to other input files.
preads_file = os.path.join(helpers.get_test_data_dir(), 'gfa-1',
'preads4falcon.fasta')
p_ctg_fasta = os.path.join(helpers.get_test_data_dir(), 'gfa-1',
'p_ctg.fa')
a_ctg_fasta = os.path.join(helpers.get_test_data_dir(), 'gfa-1',
'a_ctg.fa')
if use_sg:
# Load the assembly graph.
sg_edges_list = os.path.join(helpers.get_test_data_dir(), 'gfa-1',
'sg_edges_list')
utg_data = os.path.join(helpers.get_test_data_dir(), 'gfa-1',
'utg_data')
ctg_paths = os.path.join(helpers.get_test_data_dir(), 'gfa-1',
'ctg_paths')
asm_graph = AsmGraph(sg_edges_list, utg_data, ctg_paths)
# Add the string graph to the GFA.
gfa_graph.add_asm_graph(asm_graph)
if use_tp:
p_ctg_tiling_path_file = os.path.join(helpers.get_test_data_dir(),
'gfa-1', 'p_ctg_tiling_path')
a_ctg_tiling_path_file = os.path.join(helpers.get_test_data_dir(),
'gfa-1', 'a_ctg_tiling_path')
gen_gfa_v1.add_tiling_paths_to_gfa(p_ctg_fasta, a_ctg_fasta,
p_ctg_tiling_path_file,
a_ctg_tiling_path_file, min_p_len,
min_a_len, gfa_graph)
if use_nx:
gexf_file = os.path.join(helpers.get_test_data_dir(), 'gfa-1',
'sg.gexf')
nx_sg = nx.read_gexf(gexf_file)
gfa_graph.add_nx_string_graph(nx_sg)
fp_out = StringIO()
# Run the unit under test.
gfa_graph.write_gfa_v1(fp_out, preads_file, [p_ctg_fasta, a_ctg_fasta],
write_reads, write_contigs)
# Compare results.
value = fp_out.getvalue()
helpers.assert_filecmp(value, expected_path)
def test_calc_cutoff_errfile(monkeypatch, tmpdir):
fn = str(tmpdir.mkdir('tmp').join('errfile'))
monkeypatch.setenv('PBFALCON_ERRFILE', fn)
partial_capture_fn = os.path.join(
helpers.get_test_data_dir(), 'calc_cutoff/partial_capture.txt')
assert os.path.exists(partial_capture_fn)
with pytest.raises(Exception) as excinfo:
mod.main('prog --coverage 23 1 {}'.format(partial_capture_fn).split())
assert expected_err in str(excinfo.value)
assert expected_err in open(fn).read()
def test_format_gfa_v1_path_line():
gfa_graph = mod.GFAGraph()
# Load tiling paths from file.
p_ctg_tiling_path_file = os.path.join(helpers.get_test_data_dir(),
'p_ctg_tiling_path_1')
p_paths, p_edge_to_ctg = gen_gfa_v1.load_tiling_paths(
p_ctg_tiling_path_file, 'P')
# If seq_len_map is None, all CIGAR operations should be '*'.
expected = {
'000000F':
'P\t000000F\t000092122-,000081654-,000034462-,000061403-,000021348-,000062240-,000083779-,000019819+,000063672+,000026565+,000050047-\t*,*,*,*,*,*,*,*,*,*,*',
'000001F':
'P\t000001F\t000070651+,000018109+,000068978+,000100559+,000010548-,000006846-,000065052-,000071922+,000076878+,000000861+,000001755-\t*,*,*,*,*,*,*,*,*,*,*',
'000002F':
'P\t000002F\t000088930+,000008918+,000100248-,000085315-,000071965+,000082497+\t*,*,*,*,*,*',
'000003F': 'P\t000003F\t000084518+,000011674+,000057445-\t*,*,*',
'000004F': 'P\t000004F\t000014727+,000024020+,000060868+\t*,*,*',
}
seq_len_map = None
for ctg_id, path in p_paths.iteritems():
path_line = gfa_graph.format_gfa_v1_path_line(ctg_id, path,
seq_len_map)
assert (path_line == expected[ctg_id])
# The seq_len_map dict is only used for the first read in the path,
# because it needs to be included completely. The other CIGAR operations
# are determined directly from the edges.
expected = {
'000000F':
'P\t000000F\t000092122-,000081654-,000034462-,000061403-,000021348-,000062240-,000083779-,000019819+,000063672+,000026565+,000050047-\t10000M,33726M,10123M,1352M,9924M,5834M,862M,5562M,1384M,473M,2171M',
'000001F':
'P\t000001F\t000070651+,000018109+,000068978+,000100559+,000010548-,000006846-,000065052-,000071922+,000076878+,000000861+,000001755-\t10000M,10077M,3766M,2648M,2421M,2089M,18168M,2723M,2451M,666M,15088M',
'000002F':
'P\t000002F\t000088930+,000008918+,000100248-,000085315-,000071965+,000082497+\t10000M,15215M,3113M,4851M,1857M,6035M',
'000003F':
'P\t000003F\t000084518+,000011674+,000057445-\t10000M,9432M,23096M',
'000004F':
'P\t000004F\t000014727+,000024020+,000060868+\t10000M,5238M,3235M',
}
for ctg_id, path in p_paths.iteritems():
# Initialize all reads to a fixed value, just to be safe.
seq_len_map = {}
for edge in path:
v, w = edge[0], edge[1]
seq_len_map[v.split(':')[0]] = 10000
seq_len_map[w.split(':')[0]] = 10000
path_line = gfa_graph.format_gfa_v1_path_line(ctg_id, path,
seq_len_map)
assert (path_line == expected[ctg_id])
# Test a degenerate case where path is None.
path_line = gfa_graph.format_gfa_v1_path_line('', None, None)
assert (path_line == '')
def test_calc_tiling_paths_len():
p_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'p_ctg_tiling_path_1')
p_path, p_edge_to_ctg = mod.load_tiling_paths(p_ctg_tiling_path_file, 'P')
p_coords, p_ctg_len = mod.calc_tiling_paths_len(p_path)
for ctg_id in p_coords.keys():
shared_items = set(expected_coord_map[ctg_id].items()) & set(
p_coords[ctg_id].items())
assert(len(shared_items) == len(p_coords[ctg_id]))
assert(expected_contig_len[ctg_id] == p_ctg_len[ctg_id])
def test_calc_node_coords():
# The p_ctg_tiling_path_1 is a normal tiling path file.
p_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'p_ctg_tiling_path_1')
p_paths, p_edge_to_ctg = mod.load_tiling_paths(p_ctg_tiling_path_file, 'P')
ctg_id = '000000F'
coord_map, contig_len = mod.calc_node_coords(p_paths[ctg_id])
shared_items = set(expected_coord_map[ctg_id].items()) & set(
coord_map.items())
assert(len(shared_items) == len(coord_map))
assert(expected_contig_len[ctg_id] == contig_len)
# The p_ctg_tiling_path_2 has two degenerative cases:
# - 000000F which has an inner cycle
# - 000001F which has an out-of-order edge
# - 000002F which is circular (this is a valid case)
p_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'p_ctg_tiling_path_2')
p_paths, p_edge_to_ctg = mod.load_tiling_paths(p_ctg_tiling_path_file, 'P')
# Allow cycles, but the node's coord gets overwritten.
ctg_id = '000000F'
coord_map, contig_len = mod.calc_node_coords(p_paths[ctg_id])
assert(coord_map['000081654:B'] == 55125)
# Do not allow unsorted graphs.
ctg_id = '000001F'
with pytest.raises(Exception) as e_info:
coord_map, contig_len = mod.calc_node_coords(p_paths[ctg_id])
# Allow circular graphs.
ctg_id = '000002F'
coord_map, contig_len = mod.calc_node_coords(p_paths[ctg_id])
assert(contig_len == 18473)
# Test for an empty tiling path.
coord_map, contig_len = mod.calc_node_coords([])
assert(not coord_map)
assert(contig_len == 0)
def test_load_tiling_paths():
p_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'p_ctg_tiling_path_1')
p_path, p_edge_to_ctg = mod.load_tiling_paths(p_ctg_tiling_path_file, 'P')
assert(sorted(p_path.keys()) == sorted(
['000000F', '000001F', '000002F', '000003F', '000004F']))
for ctg_id, path in p_path.iteritems():
for edge in path:
v, w, b, e, l, idt, etype = edge
assert((v, w) in p_edge_to_ctg)
assert(p_edge_to_ctg[(v, w)] == (ctg_id, etype))
def test_load_tiling_paths_from_stream():
# This tests a normal case.
p_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'p_ctg_tiling_path_1')
p_paths = {}
edge_to_ctg = {}
with open(p_ctg_tiling_path_file) as f:
p_paths, edge_to_ctg = mod.load_tiling_paths_from_stream(f, 'P')
assert(sorted(p_paths.keys()) == sorted(
['000000F', '000001F', '000002F', '000003F', '000004F']))
for ctg_id, path in p_paths.iteritems():
for edge in path:
v, w, b, e, l, idt, etype = edge
assert((v, w) in edge_to_ctg)
assert(edge_to_ctg[(v, w)] == (ctg_id, etype))
def test_write_gfa_v1_2():
# Tests a case where a node is added to the graph, but
# there is no corresponding pread in preads4falcon.fasta file.
# Create a GFA graph.
gfa_graph = mod.GFAGraph()
# Load the p_ctg tiling paths.
p_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'p_ctg_tiling_path')
p_paths, p_edge_to_ctg = gen_gfa_v1.load_tiling_paths(
p_ctg_tiling_path_file, 'P')
# Add the tiling paths to the GFA.
for ctg_id, path in p_paths.iteritems():
gfa_graph.add_tiling_path(path, ctg_id)
# Init paths to other input files.
preads_file = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'preads4falcon.fasta')
p_ctg_fasta = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'p_ctg.fa')
a_ctg_fasta = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'a_ctg.fa')
write_reads = False
write_contigs = False
fp_out = StringIO()
# Add a node which does not exist in the preads4falcon.fasta file.
gfa_graph.add_read_from_node('12345:B')
# Run the unit under test.
with pytest.raises(Exception) as e_info:
gfa_graph.write_gfa_v1(fp_out, preads_file, [
p_ctg_fasta, a_ctg_fasta], write_reads, write_contigs)
def test_add_tiling_path():
# Load the tiling path. These methods are tested in test_gen_gfa_v1.py.
p_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'p_ctg_tiling_path_1')
p_paths, p_edge_to_ctg = gen_gfa_v1.load_tiling_paths(
p_ctg_tiling_path_file, 'P')
# Create a new GFA graph.
gfa_graph = mod.GFAGraph()
# Add the tiling paths.
for ctg_id, path in p_paths.iteritems():
gfa_graph.add_tiling_path(path, ctg_id)
# Check if we have the correct number of tiling paths.
assert(len(gfa_graph.paths.keys()) == len(p_paths.keys()))
# They should be same as loaded.
for ctg_id, path in p_paths.iteritems():
assert(ctg_id in gfa_graph.paths)
assert(gfa_graph.paths[ctg_id] == path)
def test_write_gfa_v1_1():
test_dir = os.path.join(helpers.get_test_data_dir(), 'gfa-1')
# Test various combinations of options.
wrap_write_gfa_v1_test(True, False, True, True, True,
0, 0, os.path.join(test_dir, 'expected-1-sg-r-c.gfa'))
wrap_write_gfa_v1_test(False, False, True, True, True, 0, 0, os.path.join(
test_dir, 'expected-2-tiling-r-c.gfa'))
wrap_write_gfa_v1_test(False, False, True, False, True, 0, 0, os.path.join(
test_dir, 'expected-3-tiling-no_r-c.gfa'))
wrap_write_gfa_v1_test(False, False, True, False, False, 0, 0, os.path.join(
test_dir, 'expected-4-tiling-no_r-no_c.gfa'))
wrap_write_gfa_v1_test(True, False, True, False, False, 0, 0, os.path.join(
test_dir, 'expected-5-sg-no_r-no_c.gfa'))
wrap_write_gfa_v1_test(False, False, True, False, False, 10000, 10000, os.path.join(
test_dir, 'expected-6-tiling-no_r-no_c-minlen.gfa'))
wrap_write_gfa_v1_test(False, True, False, False, False, 0, 0, os.path.join(
test_dir, 'expected-7-nx-no_r-no_c.gfa'))
wrap_write_gfa_v1_test(False, True, True, False, False, 0, 0, os.path.join(
test_dir, 'expected-8-nx-tiling-no_r-no_c.gfa'))
wrap_write_gfa_v1_test(False, True, True, True, True, 0, 0, os.path.join(
test_dir, 'expected-9-nx-tiling-r-c.gfa'))
def test_main_6(capsys):
test_dir = os.path.join(helpers.get_test_data_dir(), 'gfa-1')
argv = [
'prog',
'--p-ctg-tiling-path',
os.path.join(test_dir, 'p_ctg_tiling_path'),
'--a-ctg-tiling-path',
os.path.join(test_dir, 'a_ctg_tiling_path'),
'--preads-fasta',
os.path.join(test_dir, 'preads4falcon.fasta'),
'--p-ctg-fasta',
os.path.join(test_dir, 'p_ctg.fa'),
'--a-ctg-fasta',
os.path.join(test_dir, 'a_ctg.fa'),
'--sg-edges-list',
os.path.join(test_dir, 'sg_edges_list'),
'--utg-data',
os.path.join(test_dir, 'utg_data'),
'--ctg-paths',
os.path.join(test_dir, 'ctg_paths'),
'--tiling',
# '--write-reads',
# '--write-contigs',
'--min-p-len',
'10000',
'--min-a-len',
'10000',
]
mod.main(argv)
out, err = capsys.readouterr()
result = out.strip().splitlines()
expected = [
line.strip() for line in
open(os.path.join(
test_dir, 'expected-6-tiling-no_r-no_c-minlen.gfa')).readlines()
]
assert (result == expected)
def test_main_2(capsys):
test_dir = os.path.join(helpers.get_test_data_dir(), 'gfa-1')
argv = ['prog',
'--p-ctg-tiling-path', os.path.join(test_dir, 'p_ctg_tiling_path'),
'--a-ctg-tiling-path', os.path.join(test_dir, 'a_ctg_tiling_path'),
'--preads-fasta', os.path.join(test_dir, 'preads4falcon.fasta'),
'--p-ctg-fasta', os.path.join(test_dir, 'p_ctg.fa'),
'--a-ctg-fasta', os.path.join(test_dir, 'a_ctg.fa'),
'--sg-edges-list', os.path.join(test_dir, 'sg_edges_list'),
'--utg-data', os.path.join(test_dir, 'utg_data'),
'--ctg-paths', os.path.join(test_dir, 'ctg_paths'),
# '--add-string-graph',
'--write-reads',
'--write-contigs',
'--min-p-len', '0',
'--min-a-len', '0',
]
mod.main(argv)
out, err = capsys.readouterr()
expected_path = os.path.join(test_dir,
'expected-2-tiling-r-c.gfa')
helpers.assert_filecmp(out, expected_path)
def test_calc_cutoff_errfile(monkeypatch, tmpdir):
fn = str(tmpdir.mkdir('tmp').join('errfile'))
monkeypatch.setenv('PBFALCON_ERRFILE', fn)
partial_capture_fn = os.path.join(helpers.get_test_data_dir(),
'calc_cutoff/partial_capture.txt')
assert os.path.exists(partial_capture_fn)
with pytest.raises(Exception) as excinfo:
mod.main('prog --coverage 23 1 {}'.format(partial_capture_fn).split())
#assert expected_err0 in str(excinfo.value)
assert expected_err1 in str(excinfo.value)
with open(fn) as sin:
errfile_content = sin.read()
assert expected_err0 in errfile_content
assert expected_err1 in errfile_content
# Also check new 'alarms.json'
encoded0 = json.dumps(expected_err0)[
1:-1] # actually just escapes the newlines
encoded1 = json.dumps(expected_err1)[1:-1]
with open('alarms.json') as sin:
alarm_content = sin.read()
assert encoded0 in alarm_content
assert encoded1 in alarm_content
def test_write_gfa_v1_1(args, expected_path):
test_dir = os.path.join(helpers.get_test_data_dir(), 'gfa-1')
with system.cd(test_dir):
wrap_write_gfa_v1_test(*args, expected_path=expected_path)
def wrap_write_gfa_v1_test(use_sg, use_nx, use_tp, write_reads, write_contigs, min_p_len, min_a_len, expected_path):
# Create a GFA graph.
gfa_graph = mod.GFAGraph()
if use_sg:
# Load the assembly graph.
sg_edges_list = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'sg_edges_list')
utg_data = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'utg_data')
ctg_paths = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'ctg_paths')
asm_graph = AsmGraph(sg_edges_list, utg_data, ctg_paths)
# Add the string graph to the GFA.
gfa_graph.add_asm_graph(asm_graph)
if use_tp:
# Load the p_ctg tiling paths.
p_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'p_ctg_tiling_path')
p_paths, p_edge_to_ctg = gen_gfa_v1.load_tiling_paths(
p_ctg_tiling_path_file, 'P')
# Add the tiling paths to the GFA.
for ctg_id, path in p_paths.iteritems():
_, contig_len = gen_gfa_v1.calc_node_coords(path)
if contig_len >= min_p_len:
gfa_graph.add_tiling_path(path, ctg_id)
a_ctg_tiling_path_file = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'a_ctg_tiling_path')
a_paths, a_edge_to_ctg = gen_gfa_v1.load_tiling_paths(
a_ctg_tiling_path_file, 'P')
# Add the tiling paths to the GFA.
for ctg_id, path in a_paths.iteritems():
_, contig_len = gen_gfa_v1.calc_node_coords(path)
if contig_len >= min_a_len:
gfa_graph.add_tiling_path(path, ctg_id)
if use_nx:
gexf_file = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'sg.gexf')
nx_sg = nx.read_gexf(gexf_file)
gfa_graph.add_nx_string_graph(nx_sg)
# Init paths to other input files.
preads_file = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'preads4falcon.fasta')
p_ctg_fasta = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'p_ctg.fa')
a_ctg_fasta = os.path.join(
helpers.get_test_data_dir(), 'gfa-1', 'a_ctg.fa')
fp_out = StringIO()
# Run the unit under test.
gfa_graph.write_gfa_v1(fp_out, preads_file, [
p_ctg_fasta, a_ctg_fasta], write_reads, write_contigs)
# Compare results.
result = fp_out.getvalue()
result = result.splitlines()
expected = [line.strip() for line in open(expected_path).readlines()]
assert(result == expected)
