def test_exon_switching_pos_noCDS(self):
"""Checking that an exon switching is treated correctly as a NON-retained intron even when the CDS is absent.
Positive strand case"""
t1 = Transcript()
t1.chrom, t1.strand, t1.id = 1, "+", "t1"
t1.add_exons([(101, 500), (801, 1000), (1201, 1300), (2501, 2800)])
t1.add_exons(
[
(201, 500), # 300
(801, 1000), # 200
(1201, 1300), # 100
(2501, 2530) # 30
],
features="CDS")
t1.finalize()
t2 = Transcript()
t2.chrom, t2.strand, t2.id = 1, "+", "t2"
t2.add_exons([(101, 500), (801, 1000), (1201, 1300), (1501, 1800)])
# t2.add_exons([(201, 500), # 300
# (801, 1000), # 200
# (1201, 1300), # 100
# (1501, 1530) # 30
# ], features="CDS")
t2.finalize()
sup = Superlocus(t1, json_conf=self.my_json)
sup.add_transcript_to_locus(t2)
sup.find_retained_introns(t2)
self.assertEqual(sup.transcripts["t2"].retained_intron_num, 0,
sup.transcripts["t2"].retained_introns)
def test_real_retained_pos_noCDS(self):
"""Here we verify that a real retained intron is called as such, even when the transcript lacks a CDS"""
t1 = Transcript()
t1.chrom, t1.strand, t1.id = 1, "+", "t1"
t1.add_exons([(101, 500), (801, 1000), (1201, 1300), (1501, 1800)])
t1.add_exons(
[
(201, 500), # 300
(801, 1000), # 200
(1201, 1300), # 100
(1501, 1530) # 30
],
features="CDS")
t1.finalize()
t2 = Transcript()
t2.chrom, t2.strand, t2.id = 1, "+", "t2"
t2.add_exons([(101, 500), (801, 1000), (1201, 1600)])
# t2.add_exons([(201, 500), # 300
# (801, 1000), # 200
# (1201, 1420), # 220
# ], features="CDS")
t2.finalize()
sup = Superlocus(t1, json_conf=self.my_json)
sup.add_transcript_to_locus(t2)
sup.find_retained_introns(t2)
self.assertEqual(sup.transcripts["t2"].retained_introns,
((1201, 1600), ))
def test_not_retained_neg(self):
"""Here we verify that a false retained intron is not called as such"""
t1 = Transcript()
t1.chrom, t1.strand, t1.id = 1, "-", "t1"
t1.add_exons([(101, 500), (801, 1000), (1201, 1300), (1501, 1800)])
t1.add_exons(
[
(201, 500), # 300
(801, 1000), # 200
(1201, 1300), # 100
(1501, 1530) # 30
],
features="CDS")
t1.finalize()
t2 = Transcript()
t2.chrom, t2.strand, t2.id = 1, "-", "t2"
t2.add_exons([(301, 1000), (1201, 1300), (1501, 1800)])
t2.add_exons(
[
(1501, 1530), # 30
(1201, 1300), # 100
(471, 1000) # 230
],
features="CDS")
t2.finalize()
sup = Superlocus(t1, json_conf=self.my_json)
sup.add_transcript_to_locus(t2)
sup.find_retained_introns(t2)
self.assertEqual(sup.transcripts["t2"].retained_intron_num, 0)
def test_mixed_strands(self):
"""Verify that no retained intron is called if the strands are mixed."""
t1 = Transcript()
t1.chrom, t1.strand, t1.id = 1, "+", "t1"
t1.add_exons([(101, 500), (801, 1000), (1201, 1300), (1501, 1800)])
t1.add_exons(
[
(201, 500), # 300
(801, 1000), # 200
(1201, 1300), # 100
(1501, 1530) # 30
],
features="CDS")
t1.finalize()
t2 = Transcript()
t2.chrom, t2.strand, t2.id = 1, "-", "t2"
t2.add_exons([(601, 1000), (1201, 1300), (1501, 1800)])
t2.add_exons(
[
(1501, 1530), # 30
(1201, 1300), # 100
(771, 1000) # 230
],
features="CDS")
t2.finalize()
sup = Superlocus(t1, json_conf=self.my_json, stranded=False)
sup.add_transcript_to_locus(t2)
sup.find_retained_introns(t2)
self.assertEqual(sup.transcripts["t2"].retained_intron_num, 0)
def test_add_two_partials(self):
logger = create_null_logger("test_add_two_partials")
logger.setLevel("INFO")
json_conf = load_and_validate_config(None)
json_conf.reference.genome = self.fai
json_conf.pick.alternative_splicing.only_confirmed_introns = False
json_conf.pick.run_options.only_reference_update = True
ref = Transcript(is_reference=True)
ref.chrom, ref.strand, ref.id = "Chr5", "-", "AT5G66670.2"
ref.add_exons([(26611258, 26612889)])
ref.add_exons([(26611474, 26612700)], features=["CDS"])
ref.finalize()
self.assertTrue(ref.is_coding)
# Chr5 TAIR10 mRNA 26611258 26612889 . - . ID=AT5G66670.2;Parent=AT5G66670;Name=AT5G66670.2;index=1
# Chr5 TAIR10 protein 26611474 26612700 . - . ID=AT5G66670.2-Protein;Parent=AT5G66670.2;Name=AT5G66670.2;derives_from=AT5G66670.2
# Chr5 TAIR10 three_prime_UTR 26611258 26611473 . - . Parent=AT5G66670.2
# Chr5 TAIR10 CDS 26611474 26612700 . - 0 Parent=AT5G66670.2
# Chr5 TAIR10 five_prime_UTR 26612701 26612889 . - . Parent=AT5G66670.2
# Chr5 TAIR10 exon 26611258 26612889 . - . Parent=AT5G66670.2
template1 = Transcript(is_reference=False)
template1.chrom, template1.strand, template1.id = ref.chrom, ref.strand, ref.id + "_frag1"
template1.add_exons(((26611116, 26611157), (26611258, 26612670)))
template1.add_exons(((26611474, 26612670), ), features=["CDS"])
template1.finalize()
self.assertTrue(template1.is_coding)
template2 = Transcript(is_reference=False)
template2.chrom, template2.strand, template2.id = ref.chrom, ref.strand, ref.id + "_frag2"
template2.add_exons(((26611574, 26612889), (26613007, 26613403)))
template2.add_exons(((26611574, 26612700), ), features=["CDS"])
template2.finalize()
self.assertTrue(template2.is_coding)
logger.setLevel("INFO")
json_conf.pick.alternative_splicing.pad = True
locus = Locus(ref, configuration=json_conf, logger=logger)
locus.add_transcript_to_locus(template1)
locus.add_transcript_to_locus(template2)
self.assertIn(template2.id, locus)
# self.assertIn(template1.id, locus)
# locus.logger.setLevel("DEBUG")
# for tid in locus:
# locus[tid].logger.setLevel("DEBUG")
locus.finalize_alternative_splicing(check_requirements=False)
self.assertTrue(locus._finalized)
self.assertNotIn(template1.id, locus, "\n" + str(locus))
self.assertNotIn(template2.id, locus, "\n" + str(locus))
self.assertEqual(
locus[ref.id].end, template2.end,
((locus[ref.id].end, ref.end, template2.end, template1.end),
(locus[ref.id].start, ref.start, template2.start,
template1.start)))
def test_non_coding_negative(self):
tr = Transcript()
tr.chrom = "Chr1"
tr.start = 101
tr.end = 2000
tr.strand = "-"
tr.add_exons([(101, 300),
(1701, 2000)])
tr.id = "test1"
tr.parent = "gene1"
tr.finalize()
gff = tr.format("gff", with_introns=True)
self.maxDiff = None
res = """Chr1\tMikado\ttranscript\t101\t2000\t.\t-\t.\tID=test1;Parent=gene1
Chr1\tMikado\texon\t101\t300\t.\t-\t.\tID=test1.exon1;Parent=test1
Chr1\tMikado\tintron\t301\t1700\t.\t-\t.\tID=test1.intron1;Parent=test1
Chr1\tMikado\texon\t1701\t2000\t.\t-\t.\tID=test1.exon2;Parent=test1"""
self.assertEqual(gff,
res,
"++++\n\n"+"\n+++\n".join([gff, res]))
gtf = tr.format("gtf", with_introns=True)
res = """Chr1\tMikado\ttranscript\t101\t2000\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\texon\t101\t300\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\tintron\t301\t1700\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\texon\t1701\t2000\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";"""
self.assertEqual(gtf, res,
"++++\n\n" + "\n+++\n".join([gtf, res]))
def test_coding_negative(self):
tr = Transcript()
tr.chrom = "Chr1"
tr.start = 101
tr.end = 2000
tr.strand = "-"
tr.add_exons([(101, 300), (1701, 2000)])
tr.add_exons([(101, 300), (1701, 2000)], features="CDS")
tr.id = "test1"
tr.parent = "gene1"
# Phase 0, 0 because the first CDS exon is 300bp
gff = tr.format("gff", with_introns=True)
self.maxDiff = None
res = """Chr1\tMikado\tmRNA\t101\t2000\t.\t-\t.\tID=test1;Parent=gene1;Name=test1
Chr1\tMikado\tCDS\t101\t300\t.\t-\t0\tID=test1.CDS1;Parent=test1
Chr1\tMikado\texon\t101\t300\t.\t-\t.\tID=test1.exon1;Parent=test1
Chr1\tMikado\tintron\t301\t1700\t.\t-\t.\tID=test1.intron1;Parent=test1
Chr1\tMikado\tCDS\t1701\t2000\t.\t-\t0\tID=test1.CDS2;Parent=test1
Chr1\tMikado\texon\t1701\t2000\t.\t-\t.\tID=test1.exon2;Parent=test1"""
self.assertEqual(
gff, res, "++++\n\n" + "\n+++\n".join(
[gff, res, ",\t".join([str(_) for _ in tr.internal_orfs])]))
gtf = tr.format("gtf", with_introns=True)
res = """Chr1\tMikado\tmRNA\t101\t2000\t.\t-\t.\tgene_id "gene1"; transcript_id "test1"; Name "test1";
Chr1\tMikado\tCDS\t101\t300\t.\t-\t0\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\texon\t101\t300\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\tintron\t301\t1700\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\tCDS\t1701\t2000\t.\t-\t0\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\texon\t1701\t2000\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";"""
self.assertEqual(gtf, res, "++++\n\n" + "\n+++\n".join([gtf, res]))
def test_noncoding(self):
transcript = Transcript()
transcript.chrom = "Chr1"
transcript.source = "test"
transcript.start = 10000
transcript.end = 20000
exons = [(10000, 11500), (12000, 13000), (15000, 18000),
(19000, 20000)]
transcript.add_exons(exons)
transcript.strand = "+"
transcript.finalize()
logger = Mikado.utilities.log_utils.create_null_logger("correct_cds2")
copied = transcript.deepcopy()
trimmed = trim_noncoding(copied, max_length=50)
self.assertEqual(trimmed.start, 11450)
self.assertEqual(trimmed.end, 19050)
copied = transcript.deepcopy()
trimmed = trim_noncoding(copied, max_length=200)
self.assertEqual(trimmed.start, 11300)
self.assertEqual(trimmed.end, 19200)
def test_intronMatch(self):
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 1
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 101
t2.end = 1600
t2.add_exons([(101, 500), (601, 700), (1001, 1320), (1451, 1460),
(1501, 1600)], "exon")
t2.add_exons([(401, 500), (601, 700), (1001, 1320), (1451, 1460),
(1501, 1510)], "CDS")
t2.finalize()
self.assertTrue(self.t1.is_coding)
self.assertTrue(t2.is_coding)
self.assertTrue(
MonosublocusHolder.is_intersecting(self.t1, t2,
logger=self.logger))
self.assertTrue(
MonosublocusHolder.is_intersecting(self.t1,
t2,
cds_only=True,
logger=self.logger))
def test_wrong_cds(self):
transcript = Transcript()
transcript.chrom = "15"
transcript.source = "protein_coding"
transcript.start = 47631264
transcript.end = 48051999
exons = [(47631264, 47631416), (47704590, 47704669),
(47762671, 47762742), (47893062, 47893093),
(47895572, 47895655), (48051942, 48051999)]
transcript.strand = "+"
transcript.add_exons(exons)
transcript.id = "ENST00000560636"
transcript.parent = "ENSG00000137872"
cds_line = "\t".join([
"15", "protein_coding", "CDS", "48051996", "48051996", ".", "+",
"0", "ID=ENST00000560636.cds1;Parent=ENST00000560636"
])
cds_line = GffLine(cds_line)
transcript.add_exon(cds_line)
logger = Mikado.utilities.log_utils.create_null_logger()
transcript.logger = logger
with self.assertLogs("null", level="WARNING"):
transcript.finalize()
trimmed = trim_coding(transcript, logger, max_length=50)
self.assertEqual(trimmed.start, 47631366)
self.assertEqual(trimmed.end, 48051992)
def test_coding_positive(self):
tr = Transcript()
tr.chrom = "Chr1"
tr.start = 101
tr.end = 2000
tr.strand = "+"
tr.add_exons([(101, 300),
(1701, 2000)])
tr.add_exons([(101, 300),
(1701, 2000)], features="CDS")
tr.id = "test1"
tr.parent = "gene1"
gff = tr.format("gff", with_introns=True)
self.maxDiff = None
res = """Chr1\tMikado\tmRNA\t101\t2000\t.\t+\t.\tID=test1;Parent=gene1;Name=test1
Chr1\tMikado\tCDS\t101\t300\t.\t+\t0\tID=test1.CDS1;Parent=test1
Chr1\tMikado\texon\t101\t300\t.\t+\t.\tID=test1.exon1;Parent=test1
Chr1\tMikado\tintron\t301\t1700\t.\t+\t.\tID=test1.intron1;Parent=test1
Chr1\tMikado\tCDS\t1701\t2000\t.\t+\t1\tID=test1.CDS2;Parent=test1
Chr1\tMikado\texon\t1701\t2000\t.\t+\t.\tID=test1.exon2;Parent=test1"""
self.assertEqual(gff,
res,
"++++\n\n" + "\n+++\n".join([gff, res]))
gtf = tr.format("gtf", with_introns=True)
res = """Chr1\tMikado\tmRNA\t101\t2000\t.\t+\t.\tgene_id "gene1"; transcript_id "test1"; Name "test1";
Chr1\tMikado\tCDS\t101\t300\t.\t+\t0\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\texon\t101\t300\t.\t+\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\tintron\t301\t1700\t.\t+\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\tCDS\t1701\t2000\t.\t+\t2\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\texon\t1701\t2000\t.\t+\t.\tgene_id "gene1"; transcript_id "test1";"""
self.assertEqual(gtf, res,
"++++\n\n" + "\n+++\n".join([gtf, res]))
def test_non_coding_negative(self):
tr = Transcript()
tr.chrom = "Chr1"
tr.start = 101
tr.end = 2000
tr.strand = "-"
tr.add_exons([(101, 300), (1701, 2000)])
tr.id = "test1"
tr.parent = "gene1"
tr.finalize()
gff = tr.format("gff", with_introns=True)
self.maxDiff = None
res = """Chr1\tMikado\ttranscript\t101\t2000\t.\t-\t.\tID=test1;Parent=gene1
Chr1\tMikado\texon\t101\t300\t.\t-\t.\tID=test1.exon1;Parent=test1
Chr1\tMikado\tintron\t301\t1700\t.\t-\t.\tID=test1.intron1;Parent=test1
Chr1\tMikado\texon\t1701\t2000\t.\t-\t.\tID=test1.exon2;Parent=test1"""
self.assertEqual(gff, res, "++++\n\n" + "\n+++\n".join([gff, res]))
gtf = tr.format("gtf", with_introns=True)
res = """Chr1\tMikado\ttranscript\t101\t2000\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\texon\t101\t300\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\tintron\t301\t1700\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";
Chr1\tMikado\texon\t1701\t2000\t.\t-\t.\tgene_id "gene1"; transcript_id "test1";"""
self.assertEqual(gtf, res, "++++\n\n" + "\n+++\n".join([gtf, res]))
def test_non_redundant_as(self):
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 20
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 101
t2.end = 1600
t2.add_exons([(101, 500), (601, 700), (1001, 1300), (1401, 1460),
(1501, 1600)], "exon")
t2.add_exons([(401, 500), (601, 700), (1001, 1300), (1401, 1440)],
"CDS")
t2.finalize()
self.locus.add_transcript_to_locus(t2)
self.assertEqual(len(self.locus.transcripts), 2,
self.locus.transcripts)
t3 = Transcript()
t3.chrom = "Chr1"
t3.strand = "+"
t3.score = 20
t3.id = "G3.1"
t3.parent = "G3"
t3.start = 201
t3.end = 1630
t3.add_exons([(201, 500), (601, 670), (1031, 1300), (1401, 1460),
(1501, 1630)], "exon")
t3.add_exons([(401, 500), (601, 670), (1031, 1300), (1401, 1440)],
"CDS")
t3.logger = self.logger
t3.finalize()
self.assertEqual(
self.locus.is_alternative_splicing(t3)[:2], (True, "j"))
self.locus.add_transcript_to_locus(t3)
self.assertEqual(len(self.locus.transcripts), 3,
self.locus.transcripts)
def test_no_overlap(self):
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 1
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 1600
t2.end = 2000
t2.add_exons([(1600, 1700), (1801, 2000)])
t2.add_exons([(1661, 1700), (1801, 1850)], "CDS")
t2.finalize()
self.assertFalse(MonosublocusHolder.is_intersecting(self.t1, t2))
def test_noIntronOverlap(self):
self.t1.strip_cds()
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 1
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 1250
t2.end = 2000
t2.add_exons([(1250, 1560), (1800, 2000)])
t2.finalize()
self.assertFalse(MonosublocusHolder.is_intersecting(self.t1, t2))
def test_intronOverlap(self):
self.t1.strip_cds()
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 1
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 101
t2.end = 1470
t2.add_exons([(101, 510), (601, 700), (960, 1350), (1420, 1470)])
t2.finalize()
self.assertTrue(MonosublocusHolder.is_intersecting(self.t1, t2))
def test_same_id(self):
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 1
t2.id = "G1.1"
t2.parent = "G1"
t2.start = 1250
t2.end = 2000
t2.add_exons([(1250, 1560), (1801, 2000)])
t2.add_exons([(1401, 1560), (1801, 1850)], "CDS")
t2.finalize()
# This fails because they have the same ID
self.assertFalse(MonosublocusHolder.is_intersecting(self.t1, t2))
def test_creation_from_transcript(self):
t = Transcript()
t.chrom = "Chr1"
t.start = 100
t.end = 200
t.strand = "+"
t.id = "test"
t.parent = "parent"
gene = Gene(t)
self.assertIn(t.id, gene, gene.keys())
self.assertIn(t, gene, gene.keys())
self.assertEqual(t.chrom, gene.chrom)
self.assertEqual(t.start, gene.start)
self.assertEqual(t.end, gene.end)
self.assertEqual(t.strand, gene.strand)
self.assertIs(t, gene[t.id])
def test_not_intersecting(self):
# This one is contained and should be rejected
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 20
t2.id = "G1.1"
t2.parent = "G1"
t2.start = 601
t2.end = 1420
t2.add_exons([(601, 700), (1001, 1300), (1401, 1420)], "exon")
t2.add_exons([(601, 700), (1001, 1300), (1401, 1420)], "CDS")
t2.finalize()
self.assertEqual(
self.locus.is_alternative_splicing(t2)[:2], (False, "c"))
def test_creation_from_transcript(self):
t = Transcript()
t.chrom = "Chr1"
t.start = 100
t.end = 200
t.strand = "+"
t.id = "test"
t.parent = "parent"
gene = Gene(t)
self.assertIn(t.id, gene, gene.keys())
self.assertIn(t, gene, gene.keys())
self.assertEqual(t.chrom, gene.chrom)
self.assertEqual(t.start, gene.start)
self.assertEqual(t.end, gene.end)
self.assertEqual(t.strand, gene.strand)
self.assertIs(t, gene[t.id])
def testCdsOverlap(self):
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 1
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 101
t2.end = 1600
t2.add_exons([(101, 500), (601, 700), (1001, 1300), (1401, 1460),
(1501, 1600)], "exon")
t2.add_exons([(401, 500), (601, 700), (1001, 1300), (1401, 1440)],
"CDS")
t2.finalize()
self.assertTrue(MonosublocusHolder.is_intersecting(self.t1, t2))
def test_lowscore(self):
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 1
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 101
t2.end = 1600
t2.add_exons([(101, 500), (601, 700), (1001, 1300), (1401, 1460),
(1501, 1600)], "exon")
t2.add_exons([(401, 500), (601, 700), (1001, 1300), (1401, 1440)],
"CDS")
t2.finalize()
self.locus.add_transcript_to_locus(t2)
self.assertEqual(len(self.locus.transcripts), 2,
self.locus.transcripts)
def test_only_CDS_overlap(self):
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 1
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 1250
t2.end = 2000
t2.add_exons([(1250, 1560), (1801, 2000)])
t2.add_exons([(1401, 1560), (1801, 1850)], "CDS")
t2.finalize()
self.assertFalse(MonosublocusHolder.is_intersecting(self.t1, t2))
t2.strip_cds()
t2.finalized = False
t2.add_exons([(1461, 1560), (1801, 1850)], "CDS")
# No CDS overlap this time
self.assertFalse(MonosublocusHolder.is_intersecting(self.t1, t2))
def test_caseNegative(self):
tr = Transcript()
tr.chrom, tr.start, tr.end, tr.strand = "Chr1", 101, 3000, "-"
tr.id = "test1"
tr.add_exons([(101, 300),
(401, 600),
(801, 1200),
(2501, 3000)
])
tr.add_exons([(421, 600), # 180
(801, 1200), # 400
(2501, 2700) # 200 = 780 % 3 == 0
], features="CDS")
with self.assertLogs("null", "DEBUG") as _:
tr.finalize()
self.assertTrue(tr.is_coding)
b12 = tr.as_bed12()
self.assertEqual(b12.thick_start, tr.combined_cds_end)
self.assertEqual(b12.thick_end, tr.combined_cds_start)
self.assertEqual(len(b12.block_sizes), tr.exon_num)
self.assertEqual(b12.block_sizes,
[200, 200, 400, 500],
b12.block_sizes)
self.assertEqual(b12.strand, "-")
self.assertEqual(b12.block_starts,
[0, 300, 700, 2400],
b12.block_starts)
self.assertEqual(tr.format("bed12"), str(b12))
self.assertEqual(str(b12),
"\t".join([str(_) for _ in
["Chr1", 100, 3000, tr.id, 0, tr.strand,
b12.thick_start - 1, b12.thick_end,
0, 4,
",".join([str(__) for __ in [200, 200, 400, 500]]),
",".join([str(___) for ___ in [0, 300, 700, 2400]])]]
))
def test_noCDSOverlap(self):
self.t1.strip_cds()
self.assertEqual(self.t1.combined_cds_introns, set())
self.t1.finalized = False
self.t1.add_exons([(401, 500), (601, 700), (1001, 1100)], "CDS")
self.t1.finalize()
t2 = Transcript()
t2.logger = self.logger
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 1
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 101
t2.end = 1470
t2.add_exons([(101, 510), (601, 700), (960, 1350), (1421, 1470)])
t2.add_exons([(1201, 1350), (1421, 1450)], "CDS")
t2.finalize()
self.assertTrue(self.t1.is_coding)
self.assertTrue(t2.is_coding)
self.assertGreaterEqual(
0,
overlap((self.t1.combined_cds_start, self.t1.combined_cds_end),
(t2.combined_cds_start, t2.combined_cds_end)),
[(self.t1.combined_cds_start, self.t1.combined_cds_end),
(t2.combined_cds_start, t2.combined_cds_end)])
self.assertTrue(
MonosublocusHolder.is_intersecting(self.t1, t2,
logger=self.logger))
self.assertFalse(
MonosublocusHolder.is_intersecting(self.t1,
t2,
cds_only=True,
logger=self.logger))
def test_valid_as(self):
t2 = Transcript()
t2.chrom = "Chr1"
t2.strand = "+"
t2.score = 20
t2.id = "G2.1"
t2.parent = "G2"
t2.start = 101
t2.end = 1600
t2.add_exons([(101, 500), (601, 700), (1001, 1300), (1401, 1460),
(1501, 1600)], "exon")
t2.add_exons([(401, 500), (601, 700), (1001, 1300), (1401, 1440)],
"CDS")
t2.finalize()
self.assertEqual(
self.locus.is_alternative_splicing(t2)[:2], (True, "J"))
self.locus.add_transcript_to_locus(t2)
self.assertEqual(len(self.locus.transcripts), 2,
self.locus.transcripts)
def test_correct_cds(self):
transcript = Transcript()
transcript.chrom = "Chr1"
transcript.source = "test"
transcript.start = 10000
transcript.end = 20000
exons = [(10000, 11500), (12000, 13000), (15000, 18000),
(19000, 20000)]
cds = [
(11400, 11500), # 101
(12000, 13000), # 1001 ==> 1102
(15000, 17998)
] # 2998 == > 3090 (y)
transcript.add_exons(exons)
transcript.add_exons(cds, features="CDS")
transcript.strand = "+"
transcript.finalize()
logger = Mikado.utilities.log_utils.create_null_logger("correct_cds")
copied = transcript.deepcopy()
trimmed = trim_coding(copied, logger, max_length=50)
self.assertEqual(trimmed.start, 11400)
self.assertEqual(trimmed.end, 19050)
copied = transcript.deepcopy()
self.assertEqual(copied.start, 10000)
trimmed = trim_coding(copied, logger, max_length=200)
self.assertEqual(trimmed.start, 11300)
self.assertEqual(trimmed.end, 19200)