Beispiel #1
0
    def test_duplication_in_repeat(self):
        ref = 'ASFHGHGSFSFSLLLLLL' 'FLLLLSFSLMVPWSFKW'
        mut = 'ASFHGHGSFSFSLLLLLLL' 'FLLLLSFSLMVPWSFKW'

        call = IndelCall(ref, mut)
        print(call)

        self.assertEqual(18, call.nterm_aligned)
        self.assertEqual(len(ref) - 13 + 1, call.cterm_aligned)
        self.assertTrue(call.is_dup)

        self.assertEqual('p.L18dupL', call.hgvs_protein_notation())
Beispiel #2
0
    def test_duplication_in_repeat(self):
        ref = 'ASFHGHGSFSFSLLLLLL' 'FLLLLSFSLMVPWSFKW'
        mut = 'ASFHGHGSFSFSLLLLLLL' 'FLLLLSFSLMVPWSFKW'

        call = IndelCall(ref, mut)
        print(call)

        assert call.nterm_aligned == 18
        assert call.cterm_aligned == len(ref) - 13 + 1
        assert call.is_dup

        assert call.hgvs_protein_notation() == 'p.L18dupL'
Beispiel #3
0
    def test_cterminal_deletion(self):
        ref = 'MABCDEFGH'
        mut = 'MABCDE'

        call = IndelCall(ref, mut)
        print(call)
        self.assertEqual(6, call.nterm_aligned)
        self.assertFalse(call.cterm_aligned)
        self.assertFalse(call.is_dup)
        self.assertEqual('', call.ins_seq)
        self.assertEqual('FGH', call.del_seq)

        self.assertEqual('p.F7_H9delFGH', call.hgvs_protein_notation())
Beispiel #4
0
    def test_insertion_in_repeat(self):
        ref = 'MABCDEEEEFGH'
        mut = 'MABCDEEEEEEFGH'

        call = IndelCall(ref, mut)
        print(call)
        assert call.nterm_aligned == 9
        assert call.cterm_aligned == len(call.ref_seq) - 6 + 1
        assert call.is_dup
        assert call.ins_seq == 'EE'
        assert call.del_seq == ''

        assert call.hgvs_protein_notation() == 'p.E8_E9dupEE'
Beispiel #5
0
    def test_cterminal_no_orf_ext(self):
        ref = 'MABCDEFGH'
        mut = 'MABCDEFGHIJK*'

        call = IndelCall(ref, mut)
        print(call)
        assert call.nterm_aligned == 9
        assert not call.cterm_aligned
        assert not call.is_dup
        assert call.ins_seq == 'IJK*'
        assert call.del_seq == ''

        assert call.hgvs_protein_notation() == 'p.H9ext*4'
Beispiel #6
0
    def test_cterminal_no_orf_ext(self):
        ref = 'MABCDEFGH'
        mut = 'MABCDEFGHIJK*'

        call = IndelCall(ref, mut)
        print(call)
        self.assertEqual(9, call.nterm_aligned)
        self.assertFalse(call.cterm_aligned)
        self.assertFalse(call.is_dup)
        self.assertEqual('IJK*', call.ins_seq)
        self.assertEqual('', call.del_seq)

        self.assertEqual('p.H9ext*4', call.hgvs_protein_notation())
Beispiel #7
0
    def test_deletion(self):
        ref = 'MABCDEFGH'
        mut = 'MABCFGH'

        call = IndelCall(ref, mut)
        print(call)
        assert call.nterm_aligned == 4
        assert call.cterm_aligned == len(call.ref_seq) - 7 + 1
        assert not call.is_dup
        assert call.ins_seq == ''
        assert call.del_seq == 'DE'

        assert call.hgvs_protein_notation() == 'p.D5_E6delDE'
Beispiel #8
0
    def test_insertion(self):
        ref = 'MABCDEFGH'
        mut = 'MABCKADEFGH'

        call = IndelCall(ref, mut)
        print(call)
        assert call.nterm_aligned == 4
        assert call.cterm_aligned == len(call.ref_seq) - 5 + 1
        assert not call.is_dup
        assert call.ins_seq == 'KA'
        assert call.del_seq == ''

        assert call.hgvs_protein_notation() == 'p.C4_D5insKA'
Beispiel #9
0
    def test_cterminal_deletion(self):
        ref = 'MABCDEFGH'
        mut = 'MABCDE'

        call = IndelCall(ref, mut)
        print(call)
        assert call.nterm_aligned == 6
        assert not call.cterm_aligned
        assert not call.is_dup
        assert call.ins_seq == ''
        assert call.del_seq == 'FGH'

        assert call.hgvs_protein_notation() == 'p.F7_H9delFGH'
Beispiel #10
0
    def test_cterminal_stop_extension(self):
        ref = 'MABCDEFGH*'
        mut = 'MABCDEFGHIJK*'

        call = IndelCall(ref, mut)
        print(call)
        self.assertEqual(9, call.nterm_aligned)
        self.assertFalse(call.cterm_aligned)
        self.assertFalse(call.is_dup)
        self.assertEqual('IJK', call.ins_seq)
        self.assertEqual('', call.del_seq)

        self.assertEqual('p.*10ext*3', call.hgvs_protein_notation())
Beispiel #11
0
    def test_insertion_in_repeat(self):
        ref = 'MABCDEEEEFGH'
        mut = 'MABCDEEEEEEFGH'

        call = IndelCall(ref, mut)
        print(call)
        self.assertEqual(9, call.nterm_aligned)
        self.assertEqual(len(call.ref_seq) - 6 + 1, call.cterm_aligned)
        self.assertTrue(call.is_dup)
        self.assertEqual('EE', call.ins_seq)
        self.assertEqual('', call.del_seq)

        self.assertEqual('p.E8_E9dupEE', call.hgvs_protein_notation())
Beispiel #12
0
    def test_nterminal_deletion(self):
        ref = 'MABCDEFGH'
        mut = 'CDEFGH'

        call = IndelCall(ref, mut)
        print(call)
        assert not call.nterm_aligned
        assert call.cterm_aligned == len(call.ref_seq) - 4 + 1
        assert not call.is_dup
        assert call.ins_seq == ''
        assert call.del_seq == 'MAB'

        assert call.hgvs_protein_notation() == 'p.M1_B3delMAB'
Beispiel #13
0
    def test_insertion(self):
        ref = 'MABCDEFGH'
        mut = 'MABCKADEFGH'

        call = IndelCall(ref, mut)
        print(call)
        self.assertEqual(4, call.nterm_aligned)
        self.assertEqual(len(call.ref_seq) - 5 + 1, call.cterm_aligned)
        self.assertFalse(call.is_dup)
        self.assertEqual('KA', call.ins_seq)
        self.assertEqual('', call.del_seq)

        self.assertEqual('p.C4_D5insKA', call.hgvs_protein_notation())
Beispiel #14
0
    def test_deletion(self):
        ref = 'MABCDEFGH'
        mut = 'MABCFGH'

        call = IndelCall(ref, mut)
        print(call)
        self.assertEqual(4, call.nterm_aligned)
        self.assertEqual(len(call.ref_seq) - 7 + 1, call.cterm_aligned)
        self.assertFalse(call.is_dup)
        self.assertEqual('', call.ins_seq)
        self.assertEqual('DE', call.del_seq)

        self.assertEqual('p.D5_E6delDE', call.hgvs_protein_notation())
Beispiel #15
0
    def test_nterminal_deletion(self):
        ref = 'MABCDEFGH'
        mut = 'CDEFGH'

        call = IndelCall(ref, mut)
        print(call)
        self.assertFalse(call.nterm_aligned)
        self.assertEqual(len(call.ref_seq) - 4 + 1, call.cterm_aligned)
        self.assertFalse(call.is_dup)
        self.assertEqual('', call.ins_seq)
        self.assertEqual('MAB', call.del_seq)

        self.assertEqual('p.M1_B3delMAB', call.hgvs_protein_notation())
Beispiel #16
0
    def test_cterminal_stop_extension(self):
        ref = 'MABCDEFGH*'
        mut = 'MABCDEFGHIJK*'

        call = IndelCall(ref, mut)
        print(call)
        assert call.nterm_aligned == 9
        assert not call.cterm_aligned
        assert not call.is_dup
        assert call.ins_seq == 'IJK'
        assert call.del_seq == ''

        assert call.hgvs_protein_notation() == 'p.*10ext*3'
Beispiel #17
0
    def test_small_duplication(self):
        bpp = BreakpointPair(
            Breakpoint('6', 157100005, strand='+', orient='R'),
            Breakpoint('6', 157100007, strand='+', orient='L'),
            event_type=SVTYPE.DUP,
            untemplated_seq='',
            protocol=PROTOCOL.GENOME,
        )
        # annotate the breakpoint with the gene
        annotations = annotate_events([bpp],
                                      reference_genome=self.reference_genome,
                                      annotations=self.reference_annotations)
        self.assertEqual(1, len(annotations))

        ann = Annotation(bpp, transcript1=self.best, transcript2=self.best)
        ft = FusionTranscript.build(
            ann,
            self.reference_genome,
            min_orf_size=300,
            max_orf_cap=10,
            min_domain_mapping_match=0.9,
        )
        ref_tx = self.best.translations[0]
        fusion_tx = ft.translations[0]

        # compare the fusion translation to the refernece translation to create the protein notation
        ref_aa_seq = ref_tx.get_aa_seq(self.reference_genome)
        call = IndelCall(ref_aa_seq, fusion_tx.get_aa_seq())
        self.assertTrue(call.is_dup)

        notation = call_protein_indel(ref_tx, fusion_tx, self.reference_genome)
        print(notation)
        self.assertEqual('ENST00000346085:p.G319dupG', notation)
Beispiel #18
0
 def test_deletion(self):
     refseq = 'asdfghjkl'
     mutseq = 'asdfkl'
     indel = IndelCall(refseq, mutseq)
     assert indel.nterm_aligned == 4
     assert indel.cterm_aligned == len(indel.ref_seq) - 8 + 1
     assert indel.del_seq == 'ghj'
     assert indel.ins_seq == ''
     assert not indel.is_dup
Beispiel #19
0
 def test_delete_end(self):
     refseq = 'asdfghjkl'
     mutseq = 'asdfgh'
     indel = IndelCall(refseq, mutseq)
     self.assertEqual(6, indel.last_aligned)
     self.assertEqual(-1, indel.next_aligned)
     self.assertEqual('jkl', indel.del_seq)
     self.assertEqual('', indel.ins_seq)
     self.assertFalse(indel.is_dup)
Beispiel #20
0
 def test_deletion(self):
     refseq = 'asdfghjkl'
     mutseq = 'asdfkl'
     indel = IndelCall(refseq, mutseq)
     self.assertEqual(4, indel.last_aligned)
     self.assertEqual(8, indel.next_aligned)
     self.assertEqual('ghj', indel.del_seq)
     self.assertEqual('', indel.ins_seq)
     self.assertFalse(indel.is_dup)
Beispiel #21
0
 def test_ins_end(self):
     refseq = 'asdfghjkl'
     mutseq = 'asdfghjklmmm'
     indel = IndelCall(refseq, mutseq)
     assert indel.nterm_aligned == 9
     assert indel.cterm_aligned == 0
     assert indel.del_seq == ''
     assert indel.ins_seq == 'mmm'
     assert not indel.is_dup
Beispiel #22
0
 def test_delins_start(self):
     refseq = 'asdfghjkl'
     mutseq = 'mmfghjkl'
     indel = IndelCall(refseq, mutseq)
     self.assertEqual(0, indel.nterm_aligned)
     self.assertEqual(6, indel.cterm_aligned)
     self.assertEqual('asd', indel.del_seq)
     self.assertEqual('mm', indel.ins_seq)
     self.assertFalse(indel.is_dup)
Beispiel #23
0
 def test_ins_end(self):
     refseq = 'asdfghjkl'
     mutseq = 'asdfghjklmmm'
     indel = IndelCall(refseq, mutseq)
     self.assertEqual(9, indel.nterm_aligned)
     self.assertEqual(0, indel.cterm_aligned)
     self.assertEqual('', indel.del_seq)
     self.assertEqual('mmm', indel.ins_seq)
     self.assertFalse(indel.is_dup)
Beispiel #24
0
 def test_deletion(self):
     refseq = 'asdfghjkl'
     mutseq = 'asdfkl'
     indel = IndelCall(refseq, mutseq)
     self.assertEqual(4, indel.nterm_aligned)
     self.assertEqual(len(indel.ref_seq) - 8 + 1, indel.cterm_aligned)
     self.assertEqual('ghj', indel.del_seq)
     self.assertEqual('', indel.ins_seq)
     self.assertFalse(indel.is_dup)
Beispiel #25
0
 def test_delete_start_repetition(self):
     refseq = 'asdafghjkl'
     mutseq = 'afghjkl'
     indel = IndelCall(refseq, mutseq)
     self.assertEqual(0, indel.nterm_aligned)
     self.assertEqual(7, indel.cterm_aligned)
     self.assertEqual('asd', indel.del_seq)
     self.assertEqual('', indel.ins_seq)
     self.assertFalse(indel.is_dup)
Beispiel #26
0
 def test_delete_end(self):
     refseq = 'asdfghjkl'
     mutseq = 'asdfgh'
     indel = IndelCall(refseq, mutseq)
     assert indel.nterm_aligned == 6
     assert indel.cterm_aligned == 0
     assert indel.del_seq == 'jkl'
     assert indel.ins_seq == ''
     assert not indel.is_dup
Beispiel #27
0
 def test_ins_start(self):
     refseq = 'asdfghjkl'
     mutseq = 'mmasdfghjkl'
     indel = IndelCall(refseq, mutseq)
     self.assertEqual(-1, indel.last_aligned)
     self.assertEqual(1, indel.next_aligned)
     self.assertEqual('', indel.del_seq)
     self.assertEqual('mm', indel.ins_seq)
     self.assertFalse(indel.is_dup)
Beispiel #28
0
 def test_delete_start_repetition(self):
     refseq = 'asdafghjkl'
     mutseq = 'afghjkl'
     indel = IndelCall(refseq, mutseq)
     assert indel.nterm_aligned == 0
     assert indel.cterm_aligned == 7
     assert indel.del_seq == 'asd'
     assert indel.ins_seq == ''
     assert not indel.is_dup
Beispiel #29
0
 def test_delins_start(self):
     refseq = 'asdfghjkl'
     mutseq = 'mmfghjkl'
     indel = IndelCall(refseq, mutseq)
     assert indel.nterm_aligned == 0
     assert indel.cterm_aligned == 6
     assert indel.del_seq == 'asd'
     assert indel.ins_seq == 'mm'
     assert not indel.is_dup
Beispiel #30
0
 def test_dup(self):
     refseq = 'asdfghjkl'
     mutseq = 'asdfsdfghjkl'
     indel = IndelCall(refseq, mutseq)
     print(indel)
     self.assertEqual(4, indel.nterm_aligned)
     self.assertEqual(len(indel.ref_seq) - 2 + 1, indel.cterm_aligned)
     self.assertEqual('', indel.del_seq)
     self.assertEqual('sdf', indel.ins_seq)
     self.assertTrue(indel.is_dup)