def get_clingen_clinvar_str_api(genome, transcript_uid, region=None):
if (region is None ):
response = jsonify([])
return response
transcript = Transcript(transcript_uid, genome)
res = []
if region in ["UTR", "INTRONIC", "GENIC", "CODING"]:
region_tuple = transcript.get_requested_region("GENIC")
else:
start = int(region.split(":")[1].split("-")[0])-1
end = int(region.split(":")[1].split("-")[1])
region_tuple = [(start, end)]
chrom = transcript.get_chr()
location = "overlapping"
# get full genic or custom region
if request.path.startswith("/get_str"):
res = get_strs(region_tuple[0][0]+1, region_tuple[0][1], chrom, genome, location) #add 1 to start to make 1 based for api call
elif request.path.startswith("/get_clinvar"):
res = get_clinvars(region_tuple[0][0]+1, region_tuple[0][1], chrom, genome, location) #add 1 to start to make 1 based for api call
else:
res = get_cnvs(region_tuple[0][0]+1, region_tuple[0][1], chrom, genome, location) #add 1 to start to make 1 based for api call
# cut if UTR, INTRONIC, or CODING
if region in ["UTR", "INTRONIC", "CODING"]:
subregions = transcript.get_requested_region(region)
res = extract_subregions(res, subregions, region)
response = jsonify(res)
return response
def test_get_codon_positive_medium(self):
XKR8_uid = get_all_transcripts("XKR8",
"grch38")[0]["qualifiers"]["uid"]
XKR8 = Transcript(XKR8_uid, "grch38")
codon = XKR8.get_codon_from_pos(27963497)
self.assertEqual(codon[0], "TGC")
self.assertEqual(codon[1], 0)
self.assertEqual(codon[2], 1)
def test_get_codon_negative_hard(self):
SOX18_uid = get_all_transcripts("SOX18",
"grch38")[0]["qualifiers"]["uid"]
SOX18 = Transcript(SOX18_uid, "grch38")
codon = SOX18.get_codon_from_pos(64048168)
self.assertEqual(codon[0], "GGC")
self.assertEqual(codon[1], 2)
self.assertEqual(codon[2], -1)
def test_get_sequence_stranded(self):
TOR1A_uid = get_all_transcripts("TOR1A",
"grch38")[0]["qualifiers"]["uid"]
TOR1A = Transcript(TOR1A_uid, "grch38")
sequence_positive = TOR1A.get_seq()
sequence_negative = TOR1A.get_seq(True)
self.assertEqual(
Seq(sequence_positive).reverse_complement(), sequence_negative)
def test_get_coding_negative_exons(self):
TOR1A_uid = get_all_transcripts("TOR1A",
"grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(TOR1A_uid, "grch38")
exons = transcript.get_coding()
exon_seq = transcript.get_seq_from_pos(exons)
self.assertEqual(
exon_seq,
"ATGAAGCTGGGCCGGGCCGTGCTGGGCCTGCTGCTGCTGGCGCCGTCCGTGGTGCAGGCGGTGGAGCCCATCAGCCTGGGACTGGCCCTGGCCGGCGTCCTCACCGGCTACATCTACCCGCGTCTCTACTGCCTCTTCGCCGAGTGCTGCGGGCAGAAGCGGAGCCTTAGCCGGGAGGCACTGCAGAAGGATCTGGACGACAACCTCTTTGGACAGCATCTTGCAAAGAAAATCATCTTAAATGCCGTGTTTGGTTTCATAAACAACCCAAAGCCCAAGAAACCTCTCACGCTCTCCCTGCACGGGTGGACAGGCACCGGCAAAAATTTCGTCAGCAAGATCATCGCAGAGAATATTTACGAGGGTGGTCTGAACAGTGACTATGTCCACCTGTTTGTGGCCACATTGCACTTTCCACATGCTTCAAACATCACCTTGTACAAGGATCAGTTACAGTTGTGGATTCGAGGCAACGTGAGTGCCTGTGCGAGGTCCATCTTCATATTTGATGAAATGGATAAGATGCATGCAGGCCTCATAGATGCCATCAAGCCTTTCCTCGACTATTATGACCTGGTGGATGGGGTCTCCTACCAGAAAGCCATGTTCATATTTCTCAGCAATGCTGGAGCAGAAAGGATCACAGATGTGGCTTTGGATTTCTGGAGGAGTGGAAAGCAGAGGGAAGACATCAAGCTCAAAGACATTGAACACGCGTTGTCTGTGTCGGTTTTCAATAACAAGAACAGTGGCTTCTGGCACAGCAGCTTAATTGACCGGAACCTCATTGATTATTTTGTTCCCTTCCTCCCCCTGGAATACAAACACCTAAAAATGTGTATCCGAGTGGAAATGCAGTCCCGAGGCTATGAAATTGATGAAGACATTGTAAGCAGAGTGGCTGAGGAGATGACATTTTTCCCCAAAGAGGAGAGAGTTTTCTCAGATAAAGGCTGCAAAACGGTGTTCACCAAGTTAGATTATTACTACGATGATTGA"
)
def test_noncoding_gene(self):
PRDM15_uid = get_all_transcripts("PRDM15",
"grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(PRDM15_uid, "grch38")
exons = transcript.get_coding()
exon_seq = transcript.get_seq_from_pos(exons)
self.assertEqual(
exon_seq,
"ATGGCTGAAGATGGGAGCGAAGAGATCATGTTCATCTGGTGTGAAGACTGCAGCCAGTACCACGACTCCGAATGTCCCGAGCTGGGCCCAGTGGTCATGGTCAAAGACTCCTTTGTGTTAAGCAGGGCAAGGTCATCCCTTCCTCCCAACTTGGAGATCAGACGACTGGAAGATGGAGCCGAGGGGGTGTTCGCCATCACTCAGCTCGTCAAGCGGACACAGTTCGGTCCCTTTGAGTCCAGGAGGGTCGCCAAATGGGAAAAGGAGTCTGCATTTCCCCTGAAGGTGTTCCAGAAGGACGGGCACCCCGTGTGCTTCGACACCTCCAACGAGGATGACTGCAACTGGATGATGCTGGTGCGGCCAGCGGCGGAGGCCGAGCACCAGAACCTGACGGCCTACCAGCACGGCAGCGACGTGTACTTCACCACCTCCAGAGACATCCCCCCGGGTACCGAGCTGCGCGTGTGGTATGCGGCCTTCTATGCCAAGAAGATGGACAAGCCCATGCTGAAGCAGGCCGGCTCTGGCGTCCACGCTGCAGGCACCCCAGAAAACAGCGCCCCCGTGGAGTCGGAGCCCAGCCAGTGGGCGTGTAAAGTGTGTTCTGCCACCTTCCTGGAGCTGCAGCTCCTCAATGAACATCTGTTGGGCCACTTAGAACAAGCCAAAAGCCTTCCTCCAGGCAGCCAAAGCGAGGCAGCAGCTCCCGAGAAGGAGCAGGACACACCCCGGGGGGAACCCCCTGCAGTGCCCGAGAGCGAGAATGTTGCCACCAAAGAACAGAAGAAAAAGCCTCGAAGGGGGAGAAAACCCAAAGTGTCCAAAGCTGAGCAGCCTCTAGTCATCGTGGAAGACAAGGAACCCACAGAGCAAGTGGCAGAGATCATTACCGAGGTCCCTCCGGATGAGCCTGTGAGTGCAACGCCAGATGAGCGGATCATGGAGCTGGTTCTGGGGAAGCTGGCCACCACCACCACTGACACCAGCTCGGTTCCAAAGTTCACCCATCATCAGAATAACACCATCACGCTCAAGAGGAGCTTAATTCTCTCAAGCAGACACGGCATCCGGCGCAAGCTCATCAAACAGCTCGGGGAGCACAAGCGGGTTTACCAGTGCAATATCTGCAGCAAGATCTTCCAGAACAGCAGCAACCTGAGCAGGCACGTGCGCTCGCATGGTGACAAGCTGTTTAAGTGCGAAGAGTGTGCAAAATTGTTCAGCCGCAAAGAGAGCCTAAAGCAGCACGTTTCCTACAAGCACAGCAGGAACGAGGTGGACGGCGAGTACAGGTACCGCTGCGGCACTTGTGAGAAGACCTTCCGCATCGAGAGCGCGCTGGAGTTCCACAACTGCAGGACAGATGACAAGACGTTCCAATGTGAGATGTGTTTCAGATTCTTCTCCACCAACAGCAACCTCTCCAAGCACAAGAAGAAGCACGGCGACAAGAAGTTTGCCTGTGAGGTCTGCAGCAAGATGTTCTACCGCAAGGACGTCATGCTGGACCACCAGCGCCGGCACCTGGAAGGAGTGCGGCGAGTGAAGCGAGAGGACCTGGAGGCCGGTGGGGAGAACCTGGTCCGTTACAAGAAGGAGCCTTCCGGGTGCCCGGTGTGTGGCAAGGTGTTCTCCTGCCGGAGCAATATGAACAAGCACCTGCTCACCCACGGCGACAAGAAGTACACCTGCGAGATCTGCGGGCGCAAGTTCTTCCGCGTGGATGTGCTCAGGGACCACATCCATGTCCACTTCAAGGACATCGCGTTGATGGATGACCACCAGAGGGAAGAGTTTATCGGCAAGATCGGGATCTCCTCGGAAGAAAACGATGACAATTCTGACGAGAGCGCAGACTCGGAGCCTCACAAGTACAGCTGCAAGCGGTGCCAGCTCACCTTCGGCCGGGGGAAGGAGTACCTGAAGCACATCATGGAGGTGCACAAGGAGAAGGGCTATGGCTGCAGCATCTGCAACCGGCGCTTTGCACTGAAGGCCACCTACCACGCCCACATGGTCATCCACCGTGAAAACCTGCCGGACCCCAACGTGCAGAAGTACATCCACCCCTGCGAGATCTGCGGGCGGATCTTCAACAGCATCGGGAACCTGGAGCGCCACAAGCTCATCCACACAGGTGTGAAGAGCCACGCCTGCGAGCAGTGTGGGAAGTCCTTTGCCAGGAAGGACATGCTGAAGGAGCACATGCGTGTGCACGACAATGTCCGCGAGTACCTGTGTGCCGAGTGTGGGAAAGGCATGAAGACCAAGCACGCGCTGCGCCACCACATGAAGCTGCACAAGGGCATCAAGGAGTACGAGTGCAAGGAGTGCCACCGCAGGTTCGCGCAGAAGGTCAACATGCTCAAGCACTGCAAGCGGCACACGGGGATTAAAGATTTCATGTGTGAATTGTGTGGGAAGACATTCAGCGAGAGGAACACCATGGAGACCCACAAGCTCATCCACACAGTGGGCAAGCAGTGGACGTGCTCCGTGTGCGACAAGAAGTACGTGACCGAGTACATGCTGCAGAAGCACGTTCAGCTCACACACGACAAGGTGGAGGCGCAGAGCTGCCAGCTGTGCGGGACCAAGGTGTCCACCAGGGCCTCCATGAGCCGACACATGCGGCGCAAGCACCCCGAGGTGCTCGCGGTGAGGATCGATGACCTGGACCACCTCCCGGAGACCACCACCATCGACGCCTCCTCCATTGGCATCGTCCAGCCTGAGCTGACTCTGGAGCAGGAGGATTTGGCCGAAGGGAAGCACGGGAAAGCTGCCAAGCGAAGTCACAAGAGAAAGCAGAAGCCAGAAGAGGAGGCGGGTGCTCCGGTGCCCGAGGACGCCACCTTCAGCGAATACTCAGAGAAAGAGACGGAGTTCACAGGCAGTGTAGGCGACGAGACCAATTCCGCAGTACAGAGCATTCAGCAGGTAGTGGTGACCCTGGGTGACCCAAATGTGACCACACCATCGAGCTCAGTCGGCTTAACCAACATCACCGTGACCCCCATCACCACTGCGGCCGCGACTCAGTTTACCAATCTCCAGCCGGTGGCCGTGGGGCACCTTACCACCCCTGAACGCCAGTTACAGCTGGACAACTCAATCCTGACCGTGACCTTTGATACCGTCAGCGGCTCTGCCATGTTGCACAACCGCCAAAATGACGTCCAGATCCACCCCCAGCCGGAAGCCTCGAACCCACAGTCTGTGGCCCATTTCATCAACCTGACGACCCTGGTCAACTCCATCACGCCCCTGGGGAGCCAGCTTAGTGACCAGCACCCGCTCACGTGGCGGGCAGTGCCCCAGACTGACGTCTTGCCACCCTCGCAGCCGCAGGCACCCCCACAGCAGGCGGCCCAGCCCCAGGTGCAGGCGGAGCAGCAGCAGCAGCAGATGTACAGCTACTGA"
)
def test_get_introns(self):
XKR8_uid = get_all_transcripts("XKR8",
"grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(XKR8_uid, "grch38")
introns = transcript.get_introns()
intron_seq = transcript.get_seq_from_pos(introns)
self.assertEqual(
intron_seq,
"GTGAGTGCTTCGCCCCGGGAGGGGAGGAGTGTCGGAGCCCAGCACCTCCGTCAGCTGGGTCACCTGTACAGGTGACACGCCATATGCCGGGAAGGGGACTGGGAGAGGGAACCAAGTCCTGTGGGCGCCTGGCCTACAGGTGAGCGTGCAGCCCTTTACGGAAAGGGAATCCCGGTAGACTGCCTTCATTCTAGCCCTAGCTTTCCTGGCACAGGCGAAGAAACTGAGGCCCAGGGAAGAAAGGGAGGCGCATGGGCTTTGAAGTCGGACCTCTCAGGGATCCACTTCTGGCTTTGCCCCCTCTCGCCTCACTTCTGCATTTCTCTGAGCCTCAGTTTCCTCCTGCGTAGAAAGGAGGTAGTCACCCTGAGACAGGTGTGACGGGCAGGCCTGTTGTGAAGAGTGAGCGAAAGAATGAGAAAGTGCCTCGCACAGTGCCTGGCCTGTAATGGCAGGGGCTGCGGACTCAGTTCAGCATCCCATGTTTCAGCATGGGCAGGGCCTTGGGAAGTCACTGACCTCTCAGTGGGGCTGTTTGGTTGCTGTTCCCATTGGGATGGGGATAGCGCCTGCCCGTTTGGTGAAGATGCAGTGAAATGACATCTGTCCACTGCCCTGGCTCAGAGTGAGCACTCAGCAACCTCAGCTGGCTTCTTGACCTGGGCCTCCCTGGGAGTTTCAGCAGCCCTGACCCCACCACAGCGCTTGCCCCTCACAAAGGCCGCCTCTCACCCTGTCTGCCTGGTTGTATTCTTCCCCCTGAAACTTGGCTTCCCACCCCAGACCCAGCAAGAGGGCAGAGATGGCCTCTGACTCATCCATGCCCATGGAGCCAGCCAGGGCTGGGCATAGGCTGGGTCCTGGAAAATGTGTGTGGATTCTGCTCCTTTTTGGACCTGGTGGAGCCTCGTAGAGATGGGAAAACAAACCCAAGGCTCAGAGGCATGCGACAAAGTCAGGGCAGAGGGTGGTGTGGGTTGGGATGGGGTGGCCAGGGCCAGGATCTGCTCTTGAATCCGTTTTTACAAACTCTTGAGATCTGGCCTTGACAAAGCCACACGGAGTCTCCAGGAGTGGAAGAGAGGAGCTTTGAATGTGGCAGTTTTGCCTGAGGGATTATAGAGACATCAGAAAACCCCGGGTGGGCATGAAGGGGTGCAGTTGTTAAGTCCTGGGCAGGCCTCCATGAGCCGTGAATCTGTAACTACCTTATGCATCTTTGTGGCCAATATTTCTGCTGAGCTTGAGTCAGACAGACTGTACTAGCTTTGGCTTTGGAAATGGGTCTCTGTTCCTGCCTGTGAATTGGCCGAGGCAGGGGTCCCTGCTAGGTCACTGGGGACCATAGGCAAAGGCTCCTGCTGAGGGAGAACCCCAGCCTGTCCTGCCTGCCTGCTCCTCAGTGTGTTCTTGTGTCCTTCCAGGGGAAGTGACAGTACATGTCTGGTGAATGAGCTTGTGATGAGTGAACGGGGTTCTCTCCCAATAGGCAACTGAGAGCAAAGTTCTGGGTGGAGGGTCCTTGGTGCATCCTCCACTTACTCTTCATGCCAGTGGGTACCCCAGACCTGTCTGTCCAAACTCTGGACTCTCTTAACTCCGCCCCAATCTCCATCCTTAACCACTCAGGGCCAGCCTCTTAAATGGGATCCCTCCTTCCAATCTAACCCTCCTCCAGCCCCTCCCCTGTGTGGCCGGGGCAAGGCAGAGTCTGATTCCATCTGGCCTGTGCCCAGAAGTGCCCAAGAGGCAAATGTCCTCTTGCCCACAGGACCCCAGGAGATCTTGGGCACACTAAAGTTTGAGAACTACTGCCTCAGGCAACTTTATAGCATGCCTTTCCAATTCAGGTTTGGATCCAAATCCTCATTCCAGTACTTATTAGCTGCTTATAATTTTTTGTTTGTTTTTTAAAAAGAGGTAGGGTCTGGTCAGGCTTGGTGGCTCATGCCTGTAATCCTAGCAGTCTGGGAGGCTGACGTGGGTGGATCACTTGAGGTCAGGAGTTTGAGACCAGCCTGCTGAACATGGCAAAAGCTCATCTCTACAAAAATTAGCCAGGTGTGGTGGCGCATGCCTGTAATCCCAGCATCCCAGCTACTCTGGAGGCCGAGGCAGGAGAATCGCTTGAACCTGGGAGGTGGAGGTTGCAGTGAGCCGAGTTTGTGCCACTGCACTCTAGCCTGGGCGACAAGCGACAGATGTAGACTCTGTCTCCAAAAAAAAAGAAAAAAAAAAAGAGAGAGAGAGGCAGGGTCTCTGTTGCCTGGGCTGGAGTGCAGTGGCACAATCAATCATGGCTCACAGTGGCCTTGAACTCCTGGGCTCAAGCTGTCCTCCTGCGTCAGCCTCCTGAGTAGCTTGGACTACAGGCTTGTACCACCACGTCCAACTAATTAAAAAAAATTCTTTGTAGAGATGGGGCTTGCTGTGTTGCCCAGGGTGGTCTCAAACTCCTGGCCTCCAGTGATCCTCTTGCCTTGGCCTGTCAAAATGTTGGGATTACAGGCGCGAGCCACTGCACCCAGACCTTATTAGCTTCTTGATCCTGTTTCCCCATCTGTAAAATGGGCTTTTGTGAGAAGTAAACAGGACAAGGTTTGTGATGAGCTTGGGACAGTGCTTAGCCAGCGGGAGTAGAAGGTGTATTGATCCCCATTTTTGCTTTTTTGTTTTTTTTGAGACGGAGTCTTGTTCTGTCGCCAGGCTGGAGTGCAGTGGCACGATCTCGGCTCACTGTAACCTCCGCCTTGCAGATTCAAGAGATTCTCCTGCCTCAGCCTCCTGAGTAGCTGGGACTACAGGCGCGCACCACCACACCCAGCTAATTTTTTGTATTAGTAGAGACGAGGCTTCACCATGTTAGCCAGGATGGTCTCAATCTCCTGAACTCGTGATCAGCCCGCCTCAGACTCCCAAAGTGCTGGGATTACAGGCATGAGCCACCACACCCGGCCTCGATCCTCATTTTACAGATGAAACAAGTTCAGTGAGGTTAGGACATTGCCGAAGGCCCCATAGCATGGATGTGAGGAGACAGGTTGGAGCCTGTGTCCACTCATTAGATGGGTGGGAGGCTGAGGAATTCACAGGACACTAACCTGGCCCTCTGGGCATTTGTGTGTGGTGCCTAGGTGAGTGAAGGCCTGTGGCTGGCCCCCCTGTCGTGGCTTGGTGGGGGGTCTCTCAAATGTTGGAACTGTTTTTAGTCTTTTATAAAGGCTGCTTAGAAAACAGGAGAACAGGCTTTAGTCAGGCAGATCTGGCTTGAAACCTAAAGTCACTCTACAGCTGTTTGAGTTTGGACAAATGCCTTGACCTCTCTGAGTATGTTTGTTCTCATCTGAAATATGGGCTTAAATCCTCCTGCCTCATAAGGTTGATGAAAGGATTAAATGAGGTGATGCAAAGAAAGCCCATTTCCTGGTACATAAGTTCCTGGTACAGAGTCTCACTCTGTCATCGCCCGTAGTGGAGTACAGCAGCCTGATCATGGCTCACTGTAGCCTCCACCTCCCAGGCTCAAGTGATCCTCCTGTCTCAGCCTCCTGAGTAGCTGGGACTACAAGTGTGTATCACCATGCTGGCTAATTTTTCTTTCTTTTTTTTTTTTTTTTTTTTGTAGAGACGAGGTCCCACTTTGTTACCCAGGCTGGTCTTGAACTCCTGAGCTCAAGTAACCTCCTACCTCAGCCTCCTAAGGTGCTGGGATTACAGGTGTCGCCCACTGTGCCTGGCCCACAAGTCTTAATTGTAATTTTTATAATTTTGAAGATAATGAAGTGTGTAAGGTGCCTGATACAGCATAGGTAACTTTTTAGTTAAGAAACAATTTCATACGTTGGGAGGCCAAGGTGCACAGGTCGCTTGAGGCCAGAGTTGGAGACCATCCTGGGTAACATAGTGAGACCTCATCTCTTCAAAATTTTAAAAGAGAAACAAGAAACAATATATTGAATGCCTTCATCCAGTCAGGTTTTCATTGTGCATCTCTTCTGTGCCTGTTACTGTGCTGGGGACACAGCAGTGAACAAGATGAACCCAGCCCCTGCCCTGCCAGGATGATAGACTAAAACAAGTAGCTACGGTTGAGTGACTGGAAAAGGGAGAGGCAGGGAGCAGAGGATCACAGGGCCCCCTAAGCATGGGTGAAGTTTACAGTGAGGAGCTTTGGGAGGGTTTTTGCATGAAAGGAAAGTGACTTGCCCATTTCCACAGACCTGGACAGTGGCCAAGCTAAAGAGGGCCCCCACTCACATCCGACTCAGGGTCCAAGCCTTCCCCTTTGCCTTCCTCCACCGCTGCCATAAATGCCACAGCCTCTCAAGAAACCAGTCCTCACTCTACCGTCACTCGCTGTGTGACCTGGAGAGCCTTCCTGTGGAAGATGGAGGTTGGACTCGATCTCCAAGGGCCCTTTCGTCTTGCTAGTCTGAGTCTATATATTGATTGAAAAAACAATAATAGCGGCTGTCACAATCGAGTGCCAGCTATTAGCCAGGCCCTGTGGGAAGCACTTACAGTCATCATTGCTCATGTTCACAGCAGCCCTGTAGGTTTGTGCTATATTGATCTTCATTTTTAAAGAGGTGCAGAAAGGTGAGTGACTTGCCCTGGGTTACTGGGCACTCACTGGGCACACGTCTTTGTCTGTTGAGGGTTGGGGGTGTCTAGAACCAGGGCCAAGTGCAGACAGTCTGCACTGTGAGTGTGGCAGGGGGTAAGGGGGCGAGACAGATTTTCCCTACTTTTTATTTAGCAAACATCTCTTTCGCTGCTGTTATGTGCCAGGTACTGGGCTGCTGGGGGATCCCAAGTGAGCAGAGTCTGTTTTCTACCCTCGAGGAGCCCAGAGATAAGGAAATAGATAATTACTGTGTGATGAGACTCCAGACAGAGGTGGGTGGCATGTTACAGGGATACCTGACACAGCTGAGTGGGTGGCATGGGGTCAGGGTGGGTGACTCCCGGGGCTCTTCAAGCTGGGGCCTGCGGGGTAATGGAGGAGTAGGCCGGGGAAGTGGGGCCTGTGCTTCTGGCGACCTAACATCCTGGGCAGAGCTTGTCAAGGTCACGGAAGGTGGCATGCTGGGCAAACTGGAAGAACATCAGCCCTGCTGAGACCTGGGCAAGGCTAATGAGCACAGATCTGTTTCCAGGCTAGGAGTGGGTTCTGGGCGCCTAATAGGTTCCCAGTAAACATCTGTCGAATGACTGCGGTGGACGGGGACAGGGGAGGAAGCAGTCGGGAGACGTGCCGGTGCCACTTCCATCCCTCCCTGGAGGCCCTTGTGCTTCTGCTCCAGGATTGGCAACCAGGAGGTGGGATAGGACCCCTGTTGTAAACTTCTGGATCTTGGAAAATCAAGGTTAGGGGTCAGTCCGATGGCCTCTGGTCTTGGAGGGGAGGGGAGGGGAGTGGGGAGACCTTCTGTCCACACAGCAGGGACATCTCTCCTGGCCCTGAGGGCAGCTTTAGCCAGAGCCTGTTGCCACCCCATGGGATTTTCTACTCCCTTTTTGAGACTAAGAAAGACGGAACTGAGACTGTTGATTTTTAGACACAAGGAAGGCTTGTGTTCTTCCCAGAAAGAAAGGGTTATGGGGCCCTGGAAGATGCCCAGGATGCAGCCAAGGCCCAGGGGTGCTGAGTGCTGGGTGGGCCACAGGTCACATCCTCTCATCTTTGACAAATACCACCCGGATAGCACCTACGCAGCAAAGCGCTGTGGTGAGGGGCAGGCTCTATATTAGGAGTCATAGCTTTGTTTTTGGTTGTGGGAACTCACTGGGTCTTCTCTAGCTGCAGATTTGCCTTCAACAAACGAGGGATTCTAATACCTACCCCAGGGTTGCTGGGAGGGCCCCCACGGTACCTGTGACCGCTGGGGAGTGCCAAGCAGGCTGGCCCCAGGACTCACTGTTCCCTCCTACTCTTTGCAG"
.upper())
def test_get_seq(
self
): ########################################################################3
XKR8_uid = get_all_transcripts("XKR8",
"grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(XKR8_uid, "grch38")
seq = transcript.get_seq()
self.assertEqual(
seq,
"GAGGGCTGCGCCCACCTCCTTCCTGCCTCGGCAACCCCGGGCCCTGAGGGCAGGCCCCAACCGCGGAGGAGCAGGAGAGGGCGGAGGCCGGCGGGCCATGCCCTGGTCGTCCCGCGGCGCCCTCCTTCGGGACCTGGTCCTGGGCGTGCTGGGCACCGCCGCCTTCCTGCTCGACCTGGGCACCGACCTGTGGGCCGCCGTCCAGTATGCGCTCGGCGGCCGCTACCTGTGGGCGGCGCTGGTGCTGGCGCTGCTGGGCCTGGCCTCCGTGGCGCTGCAGCTCTTCAGCTGGCTCTGGCTGCGCGCTGACCCTGCCGGCCTGCACGGGTCGCAGCCCCCGCGCCGCTGCCTGGCGCTGCTGCATCTCCTGCAGCTGGGTTACCTGTACAGGTGAGTGCTTCGCCCCGGGAGGGGAGGAGTGTCGGAGCCCAGCACCTCCGTCAGCTGGGTCACCTGTACAGGTGACACGCCATATGCCGGGAAGGGGACTGGGAGAGGGAACCAAGTCCTGTGGGCGCCTGGCCTACAGGTGAGCGTGCAGCCCTTTACGGAAAGGGAATCCCGGTAGACTGCCTTCATTCTAGCCCTAGCTTTCCTGGCACAGGCGAAGAAACTGAGGCCCAGGGAAGAAAGGGAGGCGCATGGGCTTTGAAGTCGGACCTCTCAGGGATCCACTTCTGGCTTTGCCCCCTCTCGCCTCACTTCTGCATTTCTCTGAGCCTCAGTTTCCTCCTGCGTAGAAAGGAGGTAGTCACCCTGAGACAGGTGTGACGGGCAGGCCTGTTGTGAAGAGTGAGCGAAAGAATGAGAAAGTGCCTCGCACAGTGCCTGGCCTGTAATGGCAGGGGCTGCGGACTCAGTTCAGCATCCCATGTTTCAGCATGGGCAGGGCCTTGGGAAGTCACTGACCTCTCAGTGGGGCTGTTTGGTTGCTGTTCCCATTGGGATGGGGATAGCGCCTGCCCGTTTGGTGAAGATGCAGTGAAATGACATCTGTCCACTGCCCTGGCTCAGAGTGAGCACTCAGCAACCTCAGCTGGCTTCTTGACCTGGGCCTCCCTGGGAGTTTCAGCAGCCCTGACCCCACCACAGCGCTTGCCCCTCACAAAGGCCGCCTCTCACCCTGTCTGCCTGGTTGTATTCTTCCCCCTGAAACTTGGCTTCCCACCCCAGACCCAGCAAGAGGGCAGAGATGGCCTCTGACTCATCCATGCCCATGGAGCCAGCCAGGGCTGGGCATAGGCTGGGTCCTGGAAAATGTGTGTGGATTCTGCTCCTTTTTGGACCTGGTGGAGCCTCGTAGAGATGGGAAAACAAACCCAAGGCTCAGAGGCATGCGACAAAGTCAGGGCAGAGGGTGGTGTGGGTTGGGATGGGGTGGCCAGGGCCAGGATCTGCTCTTGAATCCGTTTTTACAAACTCTTGAGATCTGGCCTTGACAAAGCCACACGGAGTCTCCAGGAGTGGAAGAGAGGAGCTTTGAATGTGGCAGTTTTGCCTGAGGGATTATAGAGACATCAGAAAACCCCGGGTGGGCATGAAGGGGTGCAGTTGTTAAGTCCTGGGCAGGCCTCCATGAGCCGTGAATCTGTAACTACCTTATGCATCTTTGTGGCCAATATTTCTGCTGAGCTTGAGTCAGACAGACTGTACTAGCTTTGGCTTTGGAAATGGGTCTCTGTTCCTGCCTGTGAATTGGCCGAGGCAGGGGTCCCTGCTAGGTCACTGGGGACCATAGGCAAAGGCTCCTGCTGAGGGAGAACCCCAGCCTGTCCTGCCTGCCTGCTCCTCAGTGTGTTCTTGTGTCCTTCCAGGGGAAGTGACAGTACATGTCTGGTGAATGAGCTTGTGATGAGTGAACGGGGTTCTCTCCCAATAGGCAACTGAGAGCAAAGTTCTGGGTGGAGGGTCCTTGGTGCATCCTCCACTTACTCTTCATGCCAGTGGGTACCCCAGACCTGTCTGTCCAAACTCTGGACTCTCTTAACTCCGCCCCAATCTCCATCCTTAACCACTCAGGGCCAGCCTCTTAAATGGGATCCCTCCTTCCAATCTAACCCTCCTCCAGCCCCTCCCCTGTGTGGCCGGGGCAAGGCAGAGTCTGATTCCATCTGGCCTGTGCCCAGAAGTGCCCAAGAGGCAAATGTCCTCTTGCCCACAGGACCCCAGGAGATCTTGGGCACACTAAAGTTTGAGAACTACTGCCTCAGGCAACTTTATAGCATGCCTTTCCAATTCAGGTTTGGATCCAAATCCTCATTCCAGTACTTATTAGCTGCTTATAATTTTTTGTTTGTTTTTTAAAAAGAGGTAGGGTCTGGTCAGGCTTGGTGGCTCATGCCTGTAATCCTAGCAGTCTGGGAGGCTGACGTGGGTGGATCACTTGAGGTCAGGAGTTTGAGACCAGCCTGCTGAACATGGCAAAAGCTCATCTCTACAAAAATTAGCCAGGTGTGGTGGCGCATGCCTGTAATCCCAGCATCCCAGCTACTCTGGAGGCCGAGGCAGGAGAATCGCTTGAACCTGGGAGGTGGAGGTTGCAGTGAGCCGAGTTTGTGCCACTGCACTCTAGCCTGGGCGACAAGCGACAGATGTAGACTCTGTCTCCAAAAAAAAAGAAAAAAAAAAAGAGAGAGAGAGGCAGGGTCTCTGTTGCCTGGGCTGGAGTGCAGTGGCACAATCAATCATGGCTCACAGTGGCCTTGAACTCCTGGGCTCAAGCTGTCCTCCTGCGTCAGCCTCCTGAGTAGCTTGGACTACAGGCTTGTACCACCACGTCCAACTAATTAAAAAAAATTCTTTGTAGAGATGGGGCTTGCTGTGTTGCCCAGGGTGGTCTCAAACTCCTGGCCTCCAGTGATCCTCTTGCCTTGGCCTGTCAAAATGTTGGGATTACAGGCGCGAGCCACTGCACCCAGACCTTATTAGCTTCTTGATCCTGTTTCCCCATCTGTAAAATGGGCTTTTGTGAGAAGTAAACAGGACAAGGTTTGTGATGAGCTTGGGACAGTGCTTAGCCAGCGGGAGTAGAAGGTGTATTGATCCCCATTTTTGCTTTTTTGTTTTTTTTGAGACGGAGTCTTGTTCTGTCGCCAGGCTGGAGTGCAGTGGCACGATCTCGGCTCACTGTAACCTCCGCCTTGCAGATTCAAGAGATTCTCCTGCCTCAGCCTCCTGAGTAGCTGGGACTACAGGCGCGCACCACCACACCCAGCTAATTTTTTGTATTAGTAGAGACGAGGCTTCACCATGTTAGCCAGGATGGTCTCAATCTCCTGAACTCGTGATCAGCCCGCCTCAGACTCCCAAAGTGCTGGGATTACAGGCATGAGCCACCACACCCGGCCTCGATCCTCATTTTACAGATGAAACAAGTTCAGTGAGGTTAGGACATTGCCGAAGGCCCCATAGCATGGATGTGAGGAGACAGGTTGGAGCCTGTGTCCACTCATTAGATGGGTGGGAGGCTGAGGAATTCACAGGACACTAACCTGGCCCTCTGGGCATTTGTGTGTGGTGCCTAGGTGCGTGCAGGAGCTGCGGCAGGGGCTGCTGGTGTGGCAGCAGGAGGAGCCCTCTGAGTTTGACTTGGCCTACGCCGACTTCCTCGCCCTGGACATCAGCATGCTGCGGCTCTTCGAGACCTTCTTGGAGACGGCACCACAGCTCACGCTGGTGCTGGCCATCATGCTGCAGAGTGGCCGGGCTGAGTACTACCAGTGTGAGTGAAGGCCTGTGGCTGGCCCCCCTGTCGTGGCTTGGTGGGGGGTCTCTCAAATGTTGGAACTGTTTTTAGTCTTTTATAAAGGCTGCTTAGAAAACAGGAGAACAGGCTTTAGTCAGGCAGATCTGGCTTGAAACCTAAAGTCACTCTACAGCTGTTTGAGTTTGGACAAATGCCTTGACCTCTCTGAGTATGTTTGTTCTCATCTGAAATATGGGCTTAAATCCTCCTGCCTCATAAGGTTGATGAAAGGATTAAATGAGGTGATGCAAAGAAAGCCCATTTCCTGGTACATAAGTTCCTGGTACAGAGTCTCACTCTGTCATCGCCCGTAGTGGAGTACAGCAGCCTGATCATGGCTCACTGTAGCCTCCACCTCCCAGGCTCAAGTGATCCTCCTGTCTCAGCCTCCTGAGTAGCTGGGACTACAAGTGTGTATCACCATGCTGGCTAATTTTTCTTTCTTTTTTTTTTTTTTTTTTTTGTAGAGACGAGGTCCCACTTTGTTACCCAGGCTGGTCTTGAACTCCTGAGCTCAAGTAACCTCCTACCTCAGCCTCCTAAGGTGCTGGGATTACAGGTGTCGCCCACTGTGCCTGGCCCACAAGTCTTAATTGTAATTTTTATAATTTTGAAGATAATGAAGTGTGTAAGGTGCCTGATACAGCATAGGTAACTTTTTAGTTAAGAAACAATTTCATACGTTGGGAGGCCAAGGTGCACAGGTCGCTTGAGGCCAGAGTTGGAGACCATCCTGGGTAACATAGTGAGACCTCATCTCTTCAAAATTTTAAAAGAGAAACAAGAAACAATATATTGAATGCCTTCATCCAGTCAGGTTTTCATTGTGCATCTCTTCTGTGCCTGTTACTGTGCTGGGGACACAGCAGTGAACAAGATGAACCCAGCCCCTGCCCTGCCAGGATGATAGACTAAAACAAGTAGCTACGGTTGAGTGACTGGAAAAGGGAGAGGCAGGGAGCAGAGGATCACAGGGCCCCCTAAGCATGGGTGAAGTTTACAGTGAGGAGCTTTGGGAGGGTTTTTGCATGAAAGGAAAGTGACTTGCCCATTTCCACAGACCTGGACAGTGGCCAAGCTAAAGAGGGCCCCCACTCACATCCGACTCAGGGTCCAAGCCTTCCCCTTTGCCTTCCTCCACCGCTGCCATAAATGCCACAGCCTCTCAAGAAACCAGTCCTCACTCTACCGTCACTCGCTGTGTGACCTGGAGAGCCTTCCTGTGGAAGATGGAGGTTGGACTCGATCTCCAAGGGCCCTTTCGTCTTGCTAGTCTGAGTCTATATATTGATTGAAAAAACAATAATAGCGGCTGTCACAATCGAGTGCCAGCTATTAGCCAGGCCCTGTGGGAAGCACTTACAGTCATCATTGCTCATGTTCACAGCAGCCCTGTAGGTTTGTGCTATATTGATCTTCATTTTTAAAGAGGTGCAGAAAGGTGAGTGACTTGCCCTGGGTTACTGGGCACTCACTGGGCACACGTCTTTGTCTGTTGAGGGTTGGGGGTGTCTAGAACCAGGGCCAAGTGCAGACAGTCTGCACTGTGAGTGTGGCAGGGGGTAAGGGGGCGAGACAGATTTTCCCTACTTTTTATTTAGCAAACATCTCTTTCGCTGCTGTTATGTGCCAGGTACTGGGCTGCTGGGGGATCCCAAGTGAGCAGAGTCTGTTTTCTACCCTCGAGGAGCCCAGAGATAAGGAAATAGATAATTACTGTGTGATGAGACTCCAGACAGAGGTGGGTGGCATGTTACAGGGATACCTGACACAGCTGAGTGGGTGGCATGGGGTCAGGGTGGGTGACTCCCGGGGCTCTTCAAGCTGGGGCCTGCGGGGTAATGGAGGAGTAGGCCGGGGAAGTGGGGCCTGTGCTTCTGGCGACCTAACATCCTGGGCAGAGCTTGTCAAGGTCACGGAAGGTGGCATGCTGGGCAAACTGGAAGAACATCAGCCCTGCTGAGACCTGGGCAAGGCTAATGAGCACAGATCTGTTTCCAGGCTAGGAGTGGGTTCTGGGCGCCTAATAGGTTCCCAGTAAACATCTGTCGAATGACTGCGGTGGACGGGGACAGGGGAGGAAGCAGTCGGGAGACGTGCCGGTGCCACTTCCATCCCTCCCTGGAGGCCCTTGTGCTTCTGCTCCAGGATTGGCAACCAGGAGGTGGGATAGGACCCCTGTTGTAAACTTCTGGATCTTGGAAAATCAAGGTTAGGGGTCAGTCCGATGGCCTCTGGTCTTGGAGGGGAGGGGAGGGGAGTGGGGAGACCTTCTGTCCACACAGCAGGGACATCTCTCCTGGCCCTGAGGGCAGCTTTAGCCAGAGCCTGTTGCCACCCCATGGGATTTTCTACTCCCTTTTTGAGACTAAGAAAGACGGAACTGAGACTGTTGATTTTTAGACACAAGGAAGGCTTGTGTTCTTCCCAGAAAGAAAGGGTTATGGGGCCCTGGAAGATGCCCAGGATGCAGCCAAGGCCCAGGGGTGCTGAGTGCTGGGTGGGCCACAGGTCACATCCTCTCATCTTTGACAAATACCACCCGGATAGCACCTACGCAGCAAAGCGCTGTGGTGAGGGGCAGGCTCTATATTAGGAGTCATAGCTTTGTTTTTGGTTGTGGGAACTCACTGGGTCTTCTCTAGCTGCAGATTTGCCTTCAACAAACGAGGGATTCTAATACCTACCCCAGGGTTGCTGGGAGGGCCCCCACGGTACCTGTGACCGCTGGGGAGTGCCAAGCAGGCTGGCCCCAGGACTCACTGTTCCCTCCTACTCTTTGCAGGGGTTGGCATCTGCACATCCTTCCTGGGCATCTCGTGGGCACTGCTCGACTACCACCGGGCCTTGCGCACCTGCCTCCCCTCCAAGCCGCTCCTGGGCCTGGGCTCCTCCGTGATCTACTTCCTGTGGAACCTGCTGCTGCTGTGGCCCCGAGTCCTGGCTGTGGCCCTGTTCTCAGCCCTCTTCCCCAGCTATGTGGCCCTGCACTTCCTGGGCCTGTGGCTGGTACTGCTGCTCTGGGTCTGGCTTCAGGGCACAGACTTCATGCCGGACCCCAGCTCCGAGTGGCTGTACCGGGTGACGGTGGCCACCATCCTCTATTTCTCCTGGTTCAACGTGGCTGAGGGCCGCACCCGAGGCCGGGCCATCATCCACTTCGCCTTCCTCCTGAGTGACAGCATTCTCCTGGTGGCCACCTGGGTGACTCATAGCTCCTGGCTGCCCAGCGGGATTCCACTGCAGCTGTGGCTGCCTGTGGGATGCGGCTGCTTCTTTCTGGGCCTGGCTCTGCGGCTTGTGTACTACCACTGGCTGCACCCTAGCTGCTGCTGGAAGCCCGACCCTGACCAGGTAGACGGGGCCCGGAGTCTGCTTTCTCCAGAGGGGTATCAGCTGCCTCAGAACAGGCGCATGACCCATTTAGCACAGAAGTTTTTCCCCAAGGCTAAGGATGAGGCTGCTTCGCCAGTGAAGGGATAGGTGAACGGCGTCCTTTGAAGCAGGATCAGACCCAGCCAGCAGAGATGGAGAGTGACTCTGTTGGCAGAAGGCAGGCGAGGATAAGCTAACGATGCTGCTGTGGCCTCTATGCACTCAGCAAGAGCGGGACGCCTGTGCTGGGCCGGGCACCAGGGATGGTGCTGAGTCGGGCAGAGGCCTCCTTTCAAGGAGTTCACAGTGAACAAGATGAGAAGGGCTGGGCCCTGGAGGGTCAAGAGCCCCAATTATGTACAAGACACTTTGGGAGGAAAGAAGACTACCTTTTCCCCCTGCCATTGGTATAGCTGGTGCCCCAAAACTTCCACCTCCCTCCCTGGCTACCTCTAAAATGACTGGTATAGGTGCTGCCCCACCCCTTAGCTCCCCTATCCTGGGCTAGGAGGCCACAGGGGCTGTCCTCTAGAATTCTTCCTTCCCTCCCCCACACCATTCATTCAATTCATGAAACAAATCTTTGCCAAGAGCAGTTTATGTGCCAGGAACATCATTCTGTCCTTGCAACCTGGAACAAGACCAGCTACCAGCCTAGCTTCATCCGCTACTTGCACCAACCAGTCCCGGGTTAGATCCCAAATGCTAGAAGCCAGGGATGCCCAACTCTGGGTGGCCCCAGTCAGAACCTCTGGGATCTCAGTGAAGCTGGCCTGGCCTCTGCTCCTGCTCTCAAGGGGCTGCTTTTCAACCAAGAGCCTTGTGAGCCTGGTCTGAGCCTTGCACAGCCACTGAGTATTTTTTTTGCCTTAGCCAGTGTACCTCCTACCTCAGTCTATGTGAGAGGAAGAGAATGTGTGTGCCTGTGGGTCTCTACAAGTGACAGATGTGTTGTTTTCAACAGTATTATTAGGTTATGAATAAAGCCTCATGAAATCCTC"
.upper())
class InsersionMethodTesting(unittest.TestCase):
time.sleep(2)
indel_any = {
'TYPE': 'INDEL',
'REGION': 'INTRONIC',
'IMPACT': {
"INDEL_AMOUNT": 5,
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
indel_spec = {
'TYPE': 'INDEL',
'REGION': 'CODING',
'IMPACT': {
"INDEL_AMOUNT": 8,
"START": 129814200
},
"ZYGOSITY": "HETEROZYGOUS"
}
SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"]
positive_transcript = Transcript(SOX9_uid, "grch38")
TOR1A_uid = get_all_transcripts("TOR1A", "grch38")[0]["qualifiers"]["uid"]
negative_transcript = Transcript(TOR1A_uid, "grch38")
indel_any = Indel(indel_any, positive_transcript)
indel_spec = Indel(indel_spec, negative_transcript)
# test 7
def test_check_insertion_generation(self):
self.assertEqual(len(self.indel_any.get_insertion_str(50)), 50)
# test 8
def test_get_insertion_any(self):
insertion = self.indel_any.get_insertion()
self.assertEqual(len(insertion["alt"]), 6)
# test 9
def test_get_insertion_spec(self):
insertion = self.indel_spec.get_insertion()
self.assertEqual(insertion["pos"], 129814199)
self.assertEqual(len(insertion["alt"]), 9)
# test 10
def test_get_insertion_row(self):
insertion = self.indel_spec.get_vcf_row()
self.assertEqual(insertion['chrom'], "9")
self.assertEqual(insertion['pos'], '129814200')
self.assertEqual(len(insertion['alt']), 9)
print(insertion)
class SNVCreationTests(unittest.TestCase):
time.sleep(1)
XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(XKR8_uid, "grch38")
# test 1
def test_wrong_type(self):
snv = {
"TYPE": "SNP",
"REGION": "INTRONIC",
"IMPACT": {
"SNV_TYPE": "A",
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
SNV(snv, self.transcript)
# test 2
def test_wrong_type_impact(self):
snv = {
"TYPE": "SNV",
"REGION": "INTRONIC",
"IMPACT": {
"SNV_TYPE": "WRONG",
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
SNV(snv, self.transcript)
class clinvarTests(unittest.TestCase):
SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(SOX9_uid, "grch38")
# test 1
def test_clinvar(self):
clinvar = {
"TYPE": "CLINVAR",
"REGION": "GENIC",
"IMPACT": {
"CLINVAR_ID": 507525
},
"ZYGOSITY": "HETEROZYGOUS"
}
clinvar = ClinVar(clinvar, self.transcript)
row = clinvar.get_vcf_row()
self.assertEqual(row["chrom"], "17")
self.assertEqual(row["pos"], "72121409")
self.assertEqual(row["ref"], "C")
self.assertEqual(row["alt"], "T")
# test 2
def test_clinvar_wrong(self):
clinvar = {
"TYPE": "CLINVAR",
"REGION": "GENIC",
"IMPACT": {
"CLINVAR_ID": 2000000000
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
ClinVar(clinvar, self.transcript)
class InsersionMethodTesting(unittest.TestCase):
time.sleep(2)
mei_any = {
'TYPE': 'MEI',
'REGION': 'INTRONIC',
'IMPACT': {
"ELEMENT": "ALU",
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
mei_spec = {
'TYPE': 'MEI',
'REGION': 'CODING',
'IMPACT': {
"ELEMENT": "ALU",
"START": 129814000
},
"ZYGOSITY": "HETEROZYGOUS"
}
SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"]
positive_transcript = Transcript(SOX9_uid, "grch38")
TOR1A_uid = get_all_transcripts("TOR1A", "grch38")[0]["qualifiers"]["uid"]
negative_transcript = Transcript(TOR1A_uid, "grch38")
# test 4
def test_get_insertion_any(self):
mei = MEI(self.mei_any, self.positive_transcript)
vcf_row = mei.get_vcf_row()
self.assertEqual(vcf_row["alt"], '<INS:MEI:ALU>')
self.assertRegex(vcf_row["info"], re.compile('.*SVLEN=282.*'))
# test 5
def test_get_insertion_spec(self):
mei = MEI(self.mei_spec, self.negative_transcript)
vcf_row = mei.get_vcf_row()
self.assertEqual(vcf_row["pos"], '129814000')
self.assertEqual(vcf_row["alt"], '<INS:MEI:ALU>')
self.assertEqual(vcf_row["info"],
'SVTYPE=INS;END=129814282;SVLEN=282;')
self.assertEqual(vcf_row['chrom'], "9")
def __init__(self, variants_file):
"""
creates variants object which has gene, inheritance, var1, var2
"""
if type(variants_file) != dict:
f = open(variants_file)
variants_json = json.load(f)
f.close()
else:
variants_json = variants_file
try:
self.transcript = Transcript(variants_json["GENE_UID"],
variants_json["GENOME"])
self.var1 = self.make_variant(variants_json["VAR1"],
self.transcript)
self.var2 = self.make_variant(variants_json["VAR2"],
self.transcript)
self.sex = variants_json["SEX"]
self.check_sex_zygosity()
except Exception as e:
raise Exception(e)
class MutationMethods(unittest.TestCase):
time.sleep(1)
XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(XKR8_uid, "grch38")
snv = {
"TYPE": "SNV",
"REGION": "INTRONIC",
"IMPACT": {
"SNV_TYPE": "A",
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, transcript)
# test 3
def test_nonsense_exists(self):
self.assertEqual(self.snv.nonsense_mutation("TAT", 2), "A")
# test 4
def test_nonsense_not_exists(self):
self.assertFalse(self.snv.nonsense_mutation("TAT", 1))
# test 5
def test_misssense_false(self):
self.assertFalse(self.snv.missense_mutation("TAT", 2))
# test 6
def test_misssense_exists(self):
self.assertIn(self.snv.missense_mutation("CAC", 2), ["G", "A"])
# test 7
def test_synonymous_exists(self):
self.assertFalse(self.snv.synonymous_mutation("TGG", 2))
# test 8
def test_synonymous_false(self):
self.assertEqual(self.snv.synonymous_mutation("CAA", 2), "G")
# test 9
def test_any_mutation(self):
self.assertIn(self.snv.any_mutation("CAA", 2), ["G", "C", "T"])
# test 10
def test_stoploss(self):
self.assertIn(self.snv.stoploss_mutation("TAG", 2), ["C", "T"])
# test 11
def test_stoploss_not_valid(self):
self.assertFalse(self.snv.stoploss_mutation("GGA", 2))
class NonCodingSNV(unittest.TestCase):
time.sleep(1)
SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"]
positive_transcript = Transcript(SOX9_uid, "grch38")
# test 12
def test_basic_non_coding(self):
snv = {
"TYPE": "SNV",
"REGION": "INTRONIC",
"IMPACT": {
"SNV_TYPE": "A",
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.positive_transcript)
row = snv.get_vcf_row()
self.assertEqual(row["alt"], "A")
# test 13
def test_basic_non_coding_exact(self):
snv = {
"TYPE": "SNV",
"REGION": "INTRONIC",
"IMPACT": {
"SNV_TYPE": "A",
"START": 72122000
},
"ZYGOSITY": "HETEROZYGOUS"
}
row = SNV(snv, self.positive_transcript).get_vcf_row()
self.assertEqual(row["pos"], "72122000")
self.assertEqual(row["ref"], "C")
self.assertEqual(row["alt"], "A")
# test 14
def test_non_coding_incorrect_impact(self):
snv = {
"TYPE": "SNV",
"REGION": "INTRONIC",
"IMPACT": {
"SNV_TYPE": "MISSENSE",
"START": 72121999
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
snv = SNV(snv, self.positive_transcript)
def test_raises_length_greater_than_location(self):
SOX18_uid = get_all_transcripts("SOX18",
"grch38")[0]["qualifiers"]["uid"]
SOX18 = Transcript(SOX18_uid, "grch38")
indel = {
'TYPE': 'INDEL',
'REGION': 'INTRONIC',
'IMPACT': {
"INDEL_AMOUNT": -150,
"START": 64049150
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
indel = Indel(indel, SOX18)
def test_type_value_MEI(self):
time.sleep(2)
XKR8_uid = get_all_transcripts("XKR8",
"grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(XKR8_uid, "grch38")
mei = {
"TYPE": "SNV",
"REGION": "INTRONIC",
"IMPACT": {
"ELEMENT": "ALU",
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
MEI(mei, transcript)
def test_location_0(self):
time.sleep(2)
SOX18_uid = get_all_transcripts("SOX18",
"grch38")[0]["qualifiers"]["uid"]
SOX18 = Transcript(SOX18_uid, "grch38")
mei = {
"TYPE": "MEI",
"REGION": "INTRONIC",
"IMPACT": {
"ELEMENT": "ALU",
"START": 0
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
MEI(mei, SOX18).get_vcf_row()
def test_get_utrs_negative_strand(self):
TOR1A_uid = get_all_transcripts("TOR1A",
"grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(TOR1A_uid, "grch38")
both_utr = transcript.get_utr("both")
both_utr = transcript.get_seq_from_pos(both_utr)
self.assertEqual(
both_utr,
"GCACCGGTTCGCGGTCGGCGCGAGAACAAGCAGGGTGGCGCGGGTCCGGGCCAGTCATGATTGGCAGCCGGAGTCACTGCCTGGAGTTGGAAAAGAAACAACACTCAGTCCTTCCACACTTCCACCCCCAGCTCCTTTCCCTGGAAGAGGAATCCAGTGAATGTTCCTGTTTGATGTGACAGGAATTCTCCCTGGCATTGTTTCCACCCCCTGGTGCCTGCAGGCCACCCAGGGACCACGGGCGAGGACGTGAAGCCTCCCGAACACGCACAGAAGGAAGGAGCCAGCTCCCAGCCCACTCATCGCAGGGCTCATGATTTTTTACAAATTATGTTTTAATTCCAAGTGTTTCTGTTTCAAGGAAGGATGAATAAGTTTTATTGAAAATGTGGTAACTTTATTTAAAATGATTTTTAACATTATGAGAGACTGCTCAGATTCTAAGTTGTTGGCCTTGTGTGTGTGTTTTTTTTTAAGTTCTCATCATTATTACATAGACTGTGATGTATCTTTACTGGAAATGAGCCCAAGCACACATGCATGGCATTTGTTCCACAGGAGGGCATCCCTGGGGATGTGGCTGGAGCATGAGCCAGCTCTGTCCCAGGATGGTCCCAGCGGATGCTGCCAGGGGCAGTGAAGTGTTTAGGTGAAGGACAAGTAGGTAAGAGGACGCCTTCAGGCACCACAGATAAGCCTGAAACAGCCTCTCCAAGGGTTTTCACCTTAGCAACAATGGGAGCTGTGGGAGTGATTTTGGCCACACTGTCAACATTTGTTAGAACCAGTCTTTTGAAAGAAAAGTATTTCCAACTTGTCACTTGCCAGTCACTCCGTTTTGCAAAAGGTGGCCCTTCACTGTCCATTCCAAATAGCCCACACGTGCTCTCTGCTGGATTCTAAATTATGTGAATTTTGCCATATTAAATCTTCCTCATTTATACTATTATTTGTTACGTTCAATCAGAATCCCCGAAACCTCCTATAAAGCTTAGCTGCCCCTTCTGAGGATGCTGAGAACGGTGTCTTTCTTTATAAATGCAAATGGCTACCGTTTTACAATAAAATTTTGCATGTGCCA"
)
prime_5 = transcript.get_utr("5_prime")
prime_5 = transcript.get_seq_from_pos(prime_5)
self.assertEqual(
prime_5, "GCACCGGTTCGCGGTCGGCGCGAGAACAAGCAGGGTGGCGCGGGTCCGGGC")
prime_3 = transcript.get_utr("3_prime")
prime_3 = transcript.get_seq_from_pos(prime_3)
self.assertEqual(
prime_3,
"CAGTCATGATTGGCAGCCGGAGTCACTGCCTGGAGTTGGAAAAGAAACAACACTCAGTCCTTCCACACTTCCACCCCCAGCTCCTTTCCCTGGAAGAGGAATCCAGTGAATGTTCCTGTTTGATGTGACAGGAATTCTCCCTGGCATTGTTTCCACCCCCTGGTGCCTGCAGGCCACCCAGGGACCACGGGCGAGGACGTGAAGCCTCCCGAACACGCACAGAAGGAAGGAGCCAGCTCCCAGCCCACTCATCGCAGGGCTCATGATTTTTTACAAATTATGTTTTAATTCCAAGTGTTTCTGTTTCAAGGAAGGATGAATAAGTTTTATTGAAAATGTGGTAACTTTATTTAAAATGATTTTTAACATTATGAGAGACTGCTCAGATTCTAAGTTGTTGGCCTTGTGTGTGTGTTTTTTTTTAAGTTCTCATCATTATTACATAGACTGTGATGTATCTTTACTGGAAATGAGCCCAAGCACACATGCATGGCATTTGTTCCACAGGAGGGCATCCCTGGGGATGTGGCTGGAGCATGAGCCAGCTCTGTCCCAGGATGGTCCCAGCGGATGCTGCCAGGGGCAGTGAAGTGTTTAGGTGAAGGACAAGTAGGTAAGAGGACGCCTTCAGGCACCACAGATAAGCCTGAAACAGCCTCTCCAAGGGTTTTCACCTTAGCAACAATGGGAGCTGTGGGAGTGATTTTGGCCACACTGTCAACATTTGTTAGAACCAGTCTTTTGAAAGAAAAGTATTTCCAACTTGTCACTTGCCAGTCACTCCGTTTTGCAAAAGGTGGCCCTTCACTGTCCATTCCAAATAGCCCACACGTGCTCTCTGCTGGATTCTAAATTATGTGAATTTTGCCATATTAAATCTTCCTCATTTATACTATTATTTGTTACGTTCAATCAGAATCCCCGAAACCTCCTATAAAGCTTAGCTGCCCCTTCTGAGGATGCTGAGAACGGTGTCTTTCTTTATAAATGCAAATGGCTACCGTTTTACAATAAAATTTTGCATGTGCCA"
)
class VariantMethodTests(unittest.TestCase):
XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(XKR8_uid, "grch38")
good_var = {
"TYPE": "INDEL",
"REGION": "INTRONIC",
"IMPACT": {
"INDEL_AMOUNT": -100,
"LOCATION": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
good_var = Variant(good_var, transcript)
def test_get_type(self):
self.assertEqual(self.good_var.get_type(), "INDEL")
def test_get_region(self):
self.assertEqual(self.good_var.get_region(), "INTRONIC")
class Variants:
def __init__(self, variants_file):
"""
creates variants object which has gene, inheritance, var1, var2
"""
if type(variants_file) != dict:
f = open(variants_file)
variants_json = json.load(f)
f.close()
else:
variants_json = variants_file
try:
self.transcript = Transcript(variants_json["GENE_UID"],
variants_json["GENOME"])
self.var1 = self.make_variant(variants_json["VAR1"],
self.transcript)
self.var2 = self.make_variant(variants_json["VAR2"],
self.transcript)
self.sex = variants_json["SEX"]
self.check_sex_zygosity()
except Exception as e:
raise Exception(e)
def make_variant(self, var, transcript):
if var == "None":
return None
var_type = var["TYPE"]
if var_type == "SNV":
variant = SNV(var, transcript)
elif var_type == "INDEL":
variant = Indel(var, transcript)
elif var_type == "STR":
variant = ShortTandemRepeat(var, transcript)
elif var_type == "MEI":
variant = MEI(var, transcript)
elif var_type == "CLINVAR":
variant = ClinVar(var, transcript)
elif var_type == "CNV":
variant = CopyNumberVariant(var, transcript)
elif var_type == "CLINGEN":
variant = CopyNumberVariant(var, transcript)
else:
variant = Variant(var, transcript)
return variant
def check_sex_zygosity(self):
if self.sex not in ['XX', 'XY']:
raise ValueError('SEX must be one of: XX, XY')
if self.transcript.chrom == 'chrY' and self.sex != 'XY':
raise ValueError('SEX of proband must be XY when selecting Y gene')
if self.var1.zygosity in ['HOMOZYGOUS', 'HEMIZYGOUS'
] and self.var2 != None:
raise ValueError(
'Cannot have a second variant if the first is HOMOZYGOUS or HEMIZYGOUS'
)
if self.var1.zygosity != 'HEMIZYGOUS' and self.sex == 'XY' and self.transcript.get_chr(
) in ["chrX", "chrY"]:
raise ValueError('With XY sex zygosity must be HEMIZYGOUS')
def variants_2_VCF(self):
""" turns variant template into variant, string representing vcf """
# print(self.var2)
r2 = ""
if self.var2 != None:
r2 = self.var2.get_vcf_row()
r1 = self.var1.get_vcf_row()
return (r1, r2)
def get_variant_rows(self):
vcf = self.variants_2_VCF()
return {"var1": vcf[0], "var2": vcf[1]}
def test_normal_gene(self):
transcript = Transcript(5, 'grch38')
print(transcript)
class DirectedSNVCodingRegionTestsPositive(unittest.TestCase):
time.sleep(1)
SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"]
positive_transcript = Transcript(SOX9_uid, "grch38")
# test 15
def test_directed_SNV_exists_single_replacement(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "G",
"START": 72121500
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.positive_transcript).get_vcf_row()
self.assertEqual(snv['ref'], "T")
self.assertEqual(snv['alt'], "G")
# test 16
def test_directed_SNV_exists_nonsense(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "NONSENSE",
"START": 72121513
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.positive_transcript).get_vcf_row()
self.assertEqual(snv['ref'], "C")
self.assertEqual(snv['alt'], "A")
# test 17
def test_directed_SNV_exists_missense(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "MISSENSE",
"START": 72121517
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.positive_transcript)
# test 18
def test_directed_SNV_exists_SYNONYMOUS(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "SYNONYMOUS",
"START": 72121517
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.positive_transcript).get_vcf_row()
self.assertEqual(snv['ref'], "C")
self.assertEqual(snv['alt'], "T")
# test 19
def test_directed_SNV_false(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "NONSENSE",
"START": 72121517
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(Exception):
snv = SNV(snv, self.positive_transcript)
# test 20
def test_directed_SNV_stoploss_false(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "STOPLOSS",
"START": 72124380
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(Exception):
snv = SNV(snv, self.positive_transcript)
# test 21
def test_directed_SNV_stoploss_exists(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "STOPLOSS",
"START": 72124385
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.positive_transcript).get_vcf_row()
self.assertEqual(snv['ref'], "T")
self.assertIn(snv['alt'], ["A", "G", "C"])
self.assertEqual(snv['pos'], "72124385")
# test 22
def test_undirected_SNV_stoploss_exists(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "STOPLOSS",
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.positive_transcript).get_vcf_row()
self.assertIn(snv['pos'], ["72124385", "72124386", "72124387"])
class DirectedSNVCodingRegionTestsNegative(unittest.TestCase):
time.sleep(1)
SOX18_uid = get_all_transcripts("SOX18", "grch38")[0]["qualifiers"]["uid"]
negative_transcript = Transcript(SOX18_uid, "grch38")
# test 23
def test_directed_SNV_exists_single_replacement(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "G",
"START": 64048520
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.negative_transcript).get_vcf_row()
self.assertEqual(snv['ref'], "C")
self.assertEqual(snv['alt'], "G")
# test 24
def test_directed_SNV_exists_nonsense(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "NONSENSE",
"START": 64048519
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.negative_transcript).get_vcf_row()
self.assertEqual(snv['ref'], "C")
self.assertEqual(snv['alt'], "A")
# test 25
def test_directed_SNV_not_exists_missense(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "MISSENSE",
"START": 64048502
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(Exception):
snv = SNV(snv, self.negative_transcript)
# test 26
def test_directed_SNV_exists_SYNONYMOUS(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "SYNONYMOUS",
"START": 64048502
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.negative_transcript).get_vcf_row()
self.assertEqual(snv['ref'], "C")
self.assertIn(snv['alt'], ["A", "G", "T"])
# test 27
def test_directed_SNV_stoploss_false(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "STOPLOSS",
"START": 64048164
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(Exception):
snv = SNV(snv, self.negative_transcript)
# test 28
def test_directed_SNV_stoploss_exists(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "STOPLOSS",
"START": 64048166
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.negative_transcript).get_vcf_row()
self.assertEqual(snv['ref'], "C")
self.assertIn(snv['alt'], ["A", "G"])
self.assertEqual(snv['pos'], "64048166")
# test 29
def test_undirected_SNV_stoploss_exists(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "STOPLOSS",
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.negative_transcript).get_vcf_row()
self.assertIn(snv['pos'], ["64048166", "64048167", "64048168"])
# test 29
def test_undirected_SNV(self):
snv = {
"TYPE": "SNV",
"REGION": "CODING",
"IMPACT": {
"SNV_TYPE": "ANY",
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
snv = SNV(snv, self.negative_transcript).get_vcf_row()
class DeletionMethodTestCase(unittest.TestCase):
time.sleep(2)
# positive_transcript = Transcript(64805) # SOX9
SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"]
positive_transcript = Transcript(SOX9_uid, "grch38")
# test 11
def test_basic_deletion(self):
indel = {
'TYPE': 'INDEL',
'REGION': 'CODING',
'IMPACT': {
"INDEL_AMOUNT": -5,
"START": 72121500
},
"ZYGOSITY": "HETEROZYGOUS"
}
indel = Indel(indel, self.positive_transcript)
deletion = indel.get_deletion()
self.assertEqual(deletion["ref"], "TCGGGC")
self.assertEqual(deletion["alt"], "T")
self.assertEqual(deletion["pos"], 72121499)
# test 12
def test_any_location_deletion(self):
indel = {
'TYPE': 'INDEL',
'REGION': 'CODING',
'IMPACT': {
"INDEL_AMOUNT": -5,
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
indel = Indel(indel, self.positive_transcript)
deletion = indel.get_deletion()
self.assertEqual(len(deletion["ref"]), 6)
self.assertEqual(len(deletion["alt"]), 1)
# test 13
def test_raises_length_over_200(self):
indel = {
'TYPE': 'INDEL',
'REGION': 'CODING',
'IMPACT': {
"INDEL_AMOUNT": 570,
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Indel(indel, self.positive_transcript).get_deletion()
# test 14
def test_raises_length_greater_than_region(self):
SOX18_uid = get_all_transcripts("SOX18",
"grch38")[0]["qualifiers"]["uid"]
SOX18 = Transcript(SOX18_uid, "grch38")
indel = {
'TYPE': 'INDEL',
'REGION': 'INTRONIC',
'IMPACT': {
"INDEL_AMOUNT": -199,
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Indel(indel, SOX18)
# test 15
def test_raises_length_greater_than_location(self):
SOX18_uid = get_all_transcripts("SOX18",
"grch38")[0]["qualifiers"]["uid"]
SOX18 = Transcript(SOX18_uid, "grch38")
indel = {
'TYPE': 'INDEL',
'REGION': 'INTRONIC',
'IMPACT': {
"INDEL_AMOUNT": -150,
"START": 64049150
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
indel = Indel(indel, SOX18)
def test_assert_raises(self):
with self.assertRaises(Exception) as cm:
Transcript(9000000, 'grch38')
err = cm.exception
self.assertEqual(str(err), 'cannot make transcript')
class IndelCreationTests(unittest.TestCase):
time.sleep(2)
XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(XKR8_uid, "grch38")
SOX18_uid = get_all_transcripts("SOX18", "grch38")[0]["qualifiers"]["uid"]
SOX18 = Transcript(SOX18_uid, "grch38")
# test 1
def test_wrong_keys(self):
indel = {
"TYPE": "INDEL",
"REGION": "INTRONIC",
"check": 5,
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(KeyError):
Indel(indel, self.transcript)
# test 2
def test_region_value(self):
indel = {
"TYPE": "INDEL",
"REGION": "TEST",
"IMPACT": {
"INDEL_AMOUNT": 5,
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Indel(indel, self.transcript)
# test 3
def test_type_value(self):
indel = {
"TYPE": "TEST",
"REGION": "INTRONIC",
"IMPACT": {
"INDEL_AMOUNT": 5,
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Indel(indel, self.transcript)
# test 4
def test_type_value_indel(self):
indel = {
"TYPE": "SNV",
"REGION": "INTRONIC",
"IMPACT": {
"INDEL_AMOUNT": 8332,
"START": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Indel(indel, self.transcript)
# test 5
def test_location_0(self):
indel = {
"TYPE": "INDEL",
"REGION": "INTRONIC",
"IMPACT": {
"INDEL_AMOUNT": 5,
"START": 0
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Indel(indel, self.SOX18).get_vcf_row()
# test 6
def test_location_str(self):
indel = {
"TYPE": "INDEL",
"REGION": "INTRONIC",
"IMPACT": {
"INDEL_AMOUNT": 5,
"START": "four"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Indel(indel, self.SOX18).get_vcf_row()
class STRBasicTests(unittest.TestCase):
WASH7P_uid = get_all_transcripts("WASH7P",
"grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(WASH7P_uid, "grch38")
STR_uid = get_strs(16620, 16631, "1", "grch38",
"exact")[0]["qualifiers"]["uid"]
# test 1
def test_correct_motif(self):
STR = {
"IMPACT": {
"STR_ID": self.STR_uid,
"LENGTH": 2,
},
"REGION": "UTR",
"TYPE": "STR",
"ZYGOSITY": "HETEROZYGOUS"
}
STR = ShortTandemRepeat(STR, self.transcript)
self.assertEqual(STR.motif, "GCT")
def test_retraction_too_large(self):
STR = {
"IMPACT": {
"STR_ID": self.STR_uid,
"LENGTH": -50,
},
"REGION": "GENIC",
"TYPE": "STR",
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(TypeError):
ShortTandemRepeat(STR, self.transcript)
def test_retraction_works(self):
STR = {
"IMPACT": {
"STR_ID": self.STR_uid,
"LENGTH": -2,
},
"REGION": "UTR",
"TYPE": "STR",
"ZYGOSITY": "HETEROZYGOUS"
}
STR = ShortTandemRepeat(STR, self.transcript)
vcf_row = STR.get_vcf_row()
self.assertEqual(vcf_row['pos'], "16619")
self.assertEqual(vcf_row['ref'], "CGCTGCT")
self.assertEqual(vcf_row['alt'], "C")
def test_insertion_too_large(self):
STR = {
"IMPACT": {
"STR_ID": self.STR_uid,
"LENGTH": 10000,
},
"REGION": "UTR",
"TYPE": "STR",
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(Exception) as cm:
STR = ShortTandemRepeat(STR, self.transcript)
err = cm.exception
self.assertEqual(str(err), 'expansion length is too large')
def test_insertion_works(self):
STR = {
"IMPACT": {
"STR_ID": self.STR_uid,
"LENGTH": 5,
},
"REGION": "UTR",
"TYPE": "STR",
"ZYGOSITY": "HETEROZYGOUS"
}
STR = ShortTandemRepeat(STR, self.transcript)
vcf_row = STR.get_vcf_row()
self.assertEqual(vcf_row['pos'], "16620")
self.assertEqual(vcf_row['ref'], "GCT")
self.assertEqual(vcf_row['alt'], "GCTGCTGCTGCTGCTGCT")
class VariantCreationTests(unittest.TestCase):
XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"]
transcript = Transcript(XKR8_uid, "grch38")
def test_bad_formatting(self):
variant = {
"TYPE": "INDEL",
"REGION": "INTRONIC",
"CHECK": -8332,
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(KeyError):
Variant(variant, self.transcript)
def test_region_fail(self):
variant = {
"TYPE": "INDEL",
"REGION": "TEST",
"IMPACT": {
"INDEL_AMOUNT": -400,
"LOCATION": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Variant(variant, self.transcript)
def test_region_fail2(self):
variant = {
"TYPE": "INDEL",
"REGION": "2:126-245a",
"IMPACT": {
"INDEL_AMOUNT": -400,
"LOCATION": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Variant(variant, self.transcript)
def test_region_pass(self):
variant = {
"TYPE": "INDEL",
"REGION": "2:126-245",
"IMPACT": {
"INDEL_AMOUNT": -400,
"LOCATION": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
good_var = Variant(variant, self.transcript)
def test_type_fail(self):
variant = {
"TYPE": "TEST",
"REGION": "INTRONIC",
"IMPACT": {
"INDEL_AMOUNT": -400,
"LOCATION": "ANY"
},
"ZYGOSITY": "HETEROZYGOUS"
}
with self.assertRaises(ValueError):
Variant(variant, self.transcript)
