def test_plot_probability_distribution(self):
with captured_output() as (_, _):
with tempfile.TemporaryDirectory() as tempdir:
temp_path = os.path.join(tempdir, "test.png")
self.perfect_binary.plot_probability_hist(
"A", save_fig_path=temp_path)
self.assertTrue(os.path.exists(temp_path))
def run_single_nucl_prob(self, fast5_glob, reference_location):
output_tmp_dir = os.path.join(
os.path.abspath(SingleNuclProbsTest.WORK_DIR), "output")
args = [
'-g', fast5_glob, '-r', reference_location, '-T', TEMPLATE_MODEL,
'-o', output_tmp_dir, '--step_size', '5'
]
with captured_output() as (err, out):
singleNuclProb.main(args)
in_file_count = len(glob.glob(fast5_glob))
output_files = glob.glob(os.path.join(output_tmp_dir, "*.tsv"))
out_file_count = len(output_files)
assert out_file_count == in_file_count, "Expected {} output files, got {}".format(
in_file_count, out_file_count)
# collect marginal files and compare with test files
marginal_output_files = glob.glob(
os.path.join(output_tmp_dir, 'tempFiles_errorCorrection', "*.tsv"))
for marginal in marginal_output_files:
marginal_name = os.path.basename(marginal)
expected = parse_marginals_full(
os.path.join(TEST_FILES, marginal_name))
obs = parse_marginals_full(marginal)
self.assertEqual(len(obs), len(expected))
self.assertTrue((obs == expected).all)
def test_get_n_samples(self):
with captured_output() as (_, _):
fns = self.cm_h.get_n_fns("A")
fps = self.cm_h.get_n_fps("A")
tps = self.cm_h.get_n_tps("A")
tns = self.cm_h.get_n_tns("A")
self.assertEqual(fns + tns + tps + fps, 50)
def test_initialize_pysam_wrapper(self):
with captured_output() as (_, _):
header = "@SQ SN:Chromosome LN:4641652 \n@PG ID:bwa PN:bwa VN:0.7.15-r1142-dirty CL:bwa mem " \
"-x ont2d /Users/andrewbailey/CLionProjects/nanopore-RNN/signalAlign/bin/test_output/tempFiles" \
"_alignment/temp_bwaIndex /Users/andrewbailey/CLionProjects/nanopore-RNN/signalAlign/bin/test" \
"_output/tempFiles_alignment/tempFiles_miten_PC_20160820_FNFAD20259_MN17223_mux_sca" \
"_AMS_158_R9_WGA_Ecoli_08_20_16_83098_ch138_read23_strand/temp_seq_5048dffc-a463-4d84-" \
"bd3b-90ca183f488a.fa\n"
test_sam = "5048dffc-a463-4d84-bd3b-90ca183f488a\t16\tChromosome\t623201\t57\t14S16M2I2M2I20M1I35M1D9M1" \
"D1M1D4M2I1M1I26M1D8M1I8M1D3M1D12M1D5M4D1M2D3M1D14M3D3M1I2M1I8M2D5M3D6M2D25M1I2M1I26M2I31M5D" \
"2M1D23M1D4M1D16M1D6M1I3M1I2M1I13M11S\t*\t0\t0\tAAACATAAACAGAACCACGGGTCCGTCTGGGCCCGACGACGCCG" \
"AGGTGGATTTTAGGGCGTGGCTTATCTGGCGCTGTTCGGCTGGTTGAGGCGGTCAGCCTTGCCGTCGTAACACATCACGCTGCAATCGCAA" \
"ACCCGGAAGTTGATGTTAGGCGATTAACGGCTTCAGACCTACAGACGGGCGACGCCGGCTACAGGCGCCGCGGTCGAAGCGCCGATGACAC" \
"CGGCTGTTTCCGCAAGCCGCCGAGCTTGCCTGGCCTGTTGATTATCTATGCAAGTTGTCATTGCTGGTGCCGGTGGAGTCATGACGCCAGAC" \
"GCCGCCGCAGGTACAGAACCGACAGTTAATGCTAAAACAAGCAACACGTAAACCGAACCGGGAAGTACGG\t*\tNM:i:102\tMD:Z:3" \
"T0T4T2T5T2T5T17T2G24^T9^T1^G6C2T3C0A1T7A6^C8C7^G3^G9T2^G0T0G3^GGCG1^AG0A2^G0T9T3^ATA3G6T2^T" \
"G3G1^TTT0G0G4^GA0T11T2C16G0G0T0T0T3T0T11G2G0T5T11T8^TGCGA2^T1T0T20^G4^C0G0T14^T9G2T3G2T1T2" \
"\tAS:i:159\tXS:i:0\n"
pysam_h = initialize_pysam_wrapper(header + test_sam)
self.assertIsInstance(pysam_h, pysam.AlignmentFile)
self.assertIsInstance(pysam_h, PysamWrapper)
with self.assertRaises(ValueError):
initialize_pysam_wrapper(header)
initialize_pysam_wrapper(test_sam)
initialize_pysam_wrapper("randomstring")
with self.assertRaises(OSError):
test_sam = "@SQ SN:ref LN:45\n@SQ SN:ref2 LN:40\nr001 163 ref 7 30 6M1 = 37 39 GATTACA * " \
"XX:B:S,12561,2,20,112"
initialize_pysam_wrapper(test_sam)
def test_create_and_delete_bucket(self):
with captured_output() as (_, _):
bucket_name = "py3helper-test"
self.handle.create_bucket(bucket_name)
self.assertTrue(self.handle.bucket_exists(bucket_name))
self.handle.delete_bucket(bucket_name)
self.assertFalse(self.handle.bucket_exists(bucket_name))
def test_is_iupac_base(self):
with captured_output() as (_, _):
for char in IUPAC_BASES:
self.assertTrue(is_iupac_base(char))
self.assertTrue(is_iupac_base(char.lower()))
self.assertFalse(is_iupac_base("F"))
def test_sam_string_to_aligned_segment(self):
with captured_output() as (_, _):
test_sam = "8898d755-e46d-4cbe-842c-545a97718b9d_Basecall_1D_template 0 rna_fake_reversed 674 11 " \
"20S12M2I21M1I4M3I10M2I4M5I37M3I4M1I3M2I5M2D5M6D5M2D15M5D3M3D4M2D5M2D9M2D6M2D2M2D1M2D5M2D1M2D1" \
"M2D12M2D1M2D15M2D7M2D1M2D3M2D3M2D4M2D5M2D1M2D8M2D3M2D1M2D3M2D3M2D1M2D2M2D1M2D5M2D4M2D2M2D1M2D" \
"3M2D4M2D3M2D3M2D4M2D3M2D4M2D3M2D14M2D3M2D3M2D7M2D4M2D3M2D3M2D4M2D7M2D3M2D4M2D1M2D4M2D3M2D3M2D" \
"13M1D8M57S * 0 0 AACCTAACGACACCACTATCCCTACACCCTATCCAACTACTATTACTCTATTCTACTTATCACCCTACT" \
"ACTACCTCATCCTCCTCCCTAAAATTTCGAGTAAGTAAAATCAATTTCGTGTCAAAATTCATTAAGGGCATCCTAATAGAGGTTGGTCGGCGA" \
"TTTTAATAAGTGTATGTTTCGGACGTTCATAAGTTTAAAGTGTTTGTGTTAACGTTTTCGTCTTTGATTTTGGAAGTATCAGTCACTCTAATT" \
"TTGTTACGAAGTAGTAAGAATTTCATGGACAATTATTTACGACGATTTATGATTCACGATTTTTTTTTTTCGATCACGACCGTCGACCGACGA" \
"CCACCGACCGTCGACCACCGAACCTACCATTATTTTTCCTTTTGAAAATATTACTGTTCGTGAGAATATAAGTAAAAAATAGAGTATTGACCT" \
"ATTGTGTCCCGTCCTAC * NM:i:179 MD:Z:3C1T6T1T2T4T0T2G3G6T0G2T2T3T3T1A1T1T0T5T2C1T2T0T2T1T" \
"4A1T1T11^TT5^TTATTT2T2^TT15^TTTTA3^TTT2T1^TT5^TT9^TT6^TT2^TT1^TT5^TT1^TT1^TT12^TT1^TT15^TT7^T" \
"T1^TT3^TT3^TT4^TT5^TT1^TT8^TT3^TT1^TT3^TT3^TT1^TT2^TT1^TT5^TT4^TT2^TT1^TT3^TT4^TT3^TT3^TT4^TT" \
"3^TT4^TT3^TT14^TT3^TT3^TT7^TT4^TT3^TT3^TT4^TT7^TT3^TT4^TT1^TT4^TT3^TT3^TT13^T0T1T5 AS:i:82 X" \
"S:i:0"
pysam_h = sam_string_to_aligned_segment(test_sam)
forward_seq = pysam_h.get_forward_sequence()
self.assertEqual(forward_seq,
"AACCTAACGACACCACTATCCCTACACCCTATCCAACTACTATTACTCTATTCTACTTATCACCCTACTACTACCTCATCCTCCTCC"
"CTAAAATTTCGAGTAAGTAAAATCAATTTCGTGTCAAAATTCATTAAGGGCATCCTAATAGAGGTTGGTCGGCGATTTTAATAAGTG"
"TATGTTTCGGACGTTCATAAGTTTAAAGTGTTTGTGTTAACGTTTTCGTCTTTGATTTTGGAAGTATCAGTCACTCTAATTTTGTTA"
"CGAAGTAGTAAGAATTTCATGGACAATTATTTACGACGATTTATGATTCACGATTTTTTTTTTTCGATCACGACCGTCGACCGACGA"
"CCACCGACCGTCGACCACCGAACCTACCATTATTTTTCCTTTTGAAAATATTACTGTTCGTGAGAATATAAGTAAAAAATAGAGTAT"
"TGACCTATTGTGTCCCGTCCTAC")
self.assertEqual(pysam_h.get_reference_sequence(),
"CCTcCtCCCTATtAtTAtTATTttTCgATTgTATTATtgTAtTAtTATtATTtCaTtAttTTTCGtGTcAtTAttATtAtTTTCaTtT"
"tATTATTGGGCATTTCCTATTATTTATtGATTGGTTGGTCGGCGATTTTTTATTATTTATtATTGTGTATTTGTTTCGGATTCGTTCA"
"TTTATTATTGTTTATTATTATTGTGTTTGTGTTATTATTCGTTTTCGTCTTTGATTTTTTGGATTATTGTATTTCATTGTCATTCTCT"
"ATTATTTTTTGTTATTCGATTATTGTATTGTATTATTGATTATTTTTCATTTGGATTCATTATTTTATTTTTATTCGATTCGATTTTT"
"ATTTGATTTTCATTCGATTTTTTTTTTTTTCGATTTCATTCGATTCCGTCGATTCCGATTCGATTCCATTCCGATTCCGTCGATTCCA"
"TTCCGATTATTCCTATTCCATTTTATTTTTTTCCTTTTGATtAtTATTA")
def test_accuracy_from_cigar(self):
with captured_output() as (_, _):
acc = self.base.accuracy_from_cigar()
self.assertEqual(acc, 2 / 5)
self.assertEqual(Cigar("10M").accuracy_from_cigar(), 1)
with self.assertRaises(AssertionError):
Cigar("234Y").accuracy_from_cigar()
def test_convert_seconds(self):
with captured_output() as (_, _):
n_seconds = 10.123412341234
d, h, m, s = convert_seconds(n_seconds)
self.assertEqual(0, d)
self.assertEqual(0, h)
self.assertEqual(0, m)
self.assertEqual(10, s)
n_seconds = 70.123412341234
d, h, m, s = convert_seconds(n_seconds)
self.assertEqual(0, d)
self.assertEqual(0, h)
self.assertEqual(1, m)
self.assertEqual(10, s)
n_seconds = 3610.123412341234
d, h, m, s = convert_seconds(n_seconds)
self.assertEqual(0, d)
self.assertEqual(1, h)
self.assertEqual(0, m)
self.assertEqual(10, s)
n_seconds = 86410.123412341234
d, h, m, s = convert_seconds(n_seconds)
self.assertEqual(1, d)
self.assertEqual(0, h)
self.assertEqual(0, m)
self.assertEqual(10, s)
def test_initialize(self):
with captured_output() as (_, _):
self.assertEqual(17, len(self.base.full_alignment_map))
self.assertEqual(15, len(self.base.alignment_map))
self.assertEqual(9, len(self.base.true_matches_map))
self.assertEqual(len(self.base.ref_map), 13)
self.assertEqual(len(self.base.query_map), 14)
def test_cigar_conversion(self):
with captured_output() as (_, _):
self.assertEqual(cigar_conversion("M"), 0)
self.assertEqual(cigar_conversion("I"), 1)
self.assertEqual(cigar_conversion("D"), 2)
self.assertEqual(cigar_conversion("N"), 3)
self.assertEqual(cigar_conversion("S"), 4)
self.assertEqual(cigar_conversion("H"), 5)
self.assertEqual(cigar_conversion("P"), 6)
self.assertEqual(cigar_conversion("="), 7)
self.assertEqual(cigar_conversion("X"), 8)
self.assertEqual(cigar_conversion(0), "M")
self.assertEqual(cigar_conversion(1), "I")
self.assertEqual(cigar_conversion(2), "D")
self.assertEqual(cigar_conversion(3), "N")
self.assertEqual(cigar_conversion(4), "S")
self.assertEqual(cigar_conversion(5), "H")
self.assertEqual(cigar_conversion(6), "P")
self.assertEqual(cigar_conversion(7), "=")
self.assertEqual(cigar_conversion(8), "X")
with self.assertRaises(AssertionError):
cigar_conversion("A")
cigar_conversion("ADSDFS")
cigar_conversion("MID")
cigar_conversion(9)
cigar_conversion(-1)
def test_pairwise_alignment_accuracy(self):
with captured_output() as (_, _):
self.assertEqual(pairwise_alignment_accuracy("AATA", "AATA"), 1)
self.assertEqual(pairwise_alignment_accuracy("AAAA", "AATA"), .75)
self.assertEqual(pairwise_alignment_accuracy("AAATTTAAAA", "AAAAAAA"), .70)
self.assertEqual(pairwise_alignment_accuracy("CCCCCAAATTTAAAA", "AAAAAAA", soft_clip=True), 7 / 15)
self.assertEqual(pairwise_alignment_accuracy(query="CCCCCAAATTTAAAA", ref="AAAAAAA", soft_clip=False), .70)
def test_get_random_string(self):
"""Test get_random_string"""
with captured_output() as (_, _):
test_string = get_random_string(5, "AAAA")
self.assertEqual(test_string, "AAAAA")
test_string = get_random_string(5, "ATGC")
self.assertEqual(len(test_string), 5)
self.assertTrue(set(test_string).issubset(set("ATGC")))
def test_get_pairwise_cigar(self):
with captured_output() as (_, _):
cigar = get_pairwise_cigar(ref="AATA", query="AATA")
self.assertEqual(cigar, "4M")
cigar = get_pairwise_cigar(query="ATTTTA", ref="TTTT", local=True)
self.assertEqual(cigar, "1S4M1S")
cigar = get_pairwise_cigar(query="ATTTTA", ref="TTFTT", local=True)
self.assertEqual(cigar, "1S2M1D2M1S")
def test_aggregate_methylbeds(self):
with captured_output() as (_, _):
merged_bed = aggregate_methylbeds([self.test_bed, self.test_bed])
self.assertSequenceEqual(merged_bed["Chromosome"]["+"]["2"],
[("255,0,0", 1, 100),
("255,0,0", 1, 100)])
self.assertSequenceEqual(merged_bed["Chromosome"]["-"]["1"],
[("0,255,0", 0, 0), ("0,255,0", 0, 0)])
def test_reverse(self):
with captured_output() as (_, _):
test = self.base.reverse("ATGC")
self.assertEqual(test, "CGTA")
with self.assertRaises(AttributeError):
self.base.reverse(1)
self.assertEqual(self.base.reverse("A1"), "1A")
self.assertEqual(self.base.reverse("a1"), "1A")
def test_reverse_cigar(self):
with captured_output() as (_, _):
rev_cigar = self.base.reverse_cigar()
self.assertEqual(rev_cigar, "1S1P2N1D1I2M1X")
cigar = "6M2I3M"
base = Cigar(cigar)
rev_cigar = base.reverse_cigar()
self.assertEqual(rev_cigar, "3M2I6M")
def test_DotDict(self):
with captured_output() as (_, _):
dict1 = {"a": 1, "b": 2, 3: "c", "d": {"e": 4}}
self.assertRaises(AssertionError, create_dot_dict, dict1)
dict1 = {"a": 1, "b": 2, "d": {"e": 4}}
dict2 = DotDict(dict1)
self.assertEqual(dict2.a, 1)
self.assertEqual(dict2.b, 2)
self.assertEqual(dict2.d, {"e": 4})
def test_reverse_complement(self):
with captured_output() as (_, _):
test = self.base.reverse_complement("ATGC")
self.assertEqual(test, "GCAT")
with self.assertRaises(AttributeError):
self.base.reverse_complement(1)
testbase = ReverseComplement(find="a1", replace="c2")
self.assertEqual(testbase.reverse_complement("A1"), "2C")
self.assertEqual(testbase.reverse_complement("a1"), "2C")
def test_list_dir_recursive(self):
with captured_output() as (_, _):
n_files = 0
for file_path in list_dir_recursive(os.path.join(
self.HOME, "tests"),
ext="py"):
n_files += 1
self.assertTrue(file_path.endswith("py"))
self.assertEqual(n_files, 7)
def test_is_non_canonical_iupac_base(self):
with captured_output() as (_, _):
self.assertFalse(is_non_canonical_iupac_base("A"))
self.assertFalse(is_non_canonical_iupac_base("T"))
self.assertFalse(is_non_canonical_iupac_base("G"))
self.assertFalse(is_non_canonical_iupac_base("C"))
for char in IUPAC_BASES:
if char not in "ATGC":
self.assertTrue(is_non_canonical_iupac_base(char))
def test_NestedDefaultDict(self):
with captured_output() as (_, _):
test_dict = NestedDefaultDict()
for x in list("a"):
self.assertEqual(test_dict[x], {})
self.assertEqual(test_dict[x][x], {})
self.assertEqual(test_dict[x][x], {})
self.assertEqual(test_dict[x][x][x][x], {})
self.assertEqual(test_dict[x][x][x][x][x], {})
def test_iupac_complement(self):
with captured_output() as (_, _):
handle = ReverseComplement()
for char in IUPAC_BASES:
bases = iupac_base_to_bases(char)
complement = iupac_complement(char)
complement_chars = iupac_base_to_bases(complement)
for x in bases:
self.assertTrue(handle.complement(x) in complement_chars)
def test_list_objects_generator(self):
with captured_output() as (_, _):
gen = self.handle.list_objects_generator("mybucket")
self.assertEqual(2, len([x for x in gen]))
gen = self.handle.list_objects_generator("mybucket/test/", "fa")
self.assertEqual(1, len([x for x in gen]))
with self.assertRaises(AssertionError):
self.handle.list_objects_generator("bailey-assembly-hubs/hubExamples/asdf").__next__()
self.handle.list_objects_generator("hubExamples").__next__()
def test_upload_and_delete_object(self):
with captured_output() as (_, _):
true_location = "mybucket/test.fa"
location = self.handle.upload_object(self.test_file, "mybucket/")
self.assertEqual(true_location, location)
self.assertTrue(self.handle.object_exists(location))
deleted = self.handle.delete_object(location)
self.assertTrue(deleted)
self.assertFalse(self.handle.object_exists(location))
def test_captured_output(self):
"""Test captured_output method"""
string1 = "Something"
string2 = "Else"
with captured_output() as (out, err):
print(string1, file=sys.stdout)
print(string2, file=sys.stderr)
self.assertEqual(out.getvalue(), "Something\n")
self.assertEqual(err.getvalue(), "Else\n")
def test_recall(self):
with captured_output() as (_, _):
recall = self.perfect_binary.recall(class_n="A", threshold=0.5)
tpr = self.perfect_binary.true_positive_rate(class_n="A",
threshold=0.5)
sens = self.perfect_binary.sensitivity(class_n="A", threshold=0.5)
self.assertEqual(sens, 1)
self.assertEqual(tpr, 1)
self.assertEqual(recall, 1)
def test_split_name(self):
with captured_output() as (_, _):
test_name = "/asdf/asdf/asdf/sdf.txt"
bucket, key = self.handle.split_name(test_name)
self.assertEqual(bucket, "asdf")
self.assertEqual(key, "asdf/asdf/sdf.txt")
test_name = "asdf/asdf/asdf/sdf.txt"
bucket, key = self.handle.split_name(test_name)
self.assertEqual(bucket, "asdf")
self.assertEqual(key, "asdf/asdf/sdf.txt")
def test_time_it(self):
"""Test time_it function"""
with captured_output() as (_, _):
def add(x, y):
return x + y
_, _ = time_it(add, 1, 2)
with self.assertRaises(AssertionError):
time_it(1, 1, 2)
def test_concatenate_files(self):
with captured_output() as (_, _):
with tempfile.TemporaryDirectory() as tempdir:
path = os.path.join(tempdir, "out.fa")
test_fa = os.path.join(
self.HOME, "tests/test_files/test_tar_dir/test.fa")
concatenate_files([path, test_fa], path)
self.assertEqual(
os.stat(path).st_size,
os.stat(test_fa).st_size)
