def test_spliced_antisense(self): """ Example where the transcript matches known vertices but is antisense """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr2" strand = "-" positions = [1000, 900, 600, 500, 100, 1] annotation = talon.identify_transcript(chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) anti_gene_ID = fetch_correct_ID("TG2", "gene", cursor) gene_novelty_types = [x[-2] for x in annotation['gene_novelty']] t_novelty_types = [x[-2] for x in annotation['transcript_novelty']] assert annotation['gene_novelty'][0][-1] == "TRUE" assert "antisense_gene" in gene_novelty_types assert "antisense_transcript" in t_novelty_types assert annotation['start_delta'] == annotation['end_delta'] == 0 conn.close()
def test_NNC(self): """ Example where the transcript skips an exon and has a novel splice donor """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" strand = "+" positions = [1, 50, 900, 1000] annotation = talon.identify_transcript(chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) correct_gene_ID = fetch_correct_ID("TG1", "gene", cursor) novelty_types = [x[-2] for x in annotation['transcript_novelty']] assert annotation['gene_ID'] == correct_gene_ID assert "NNC_transcript" in novelty_types assert annotation['start_delta'] == annotation['end_delta'] == 0 conn.close()
def test_genomic_unspliced(self): """ Monoexonic fragment that overlaps gene 1 """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) talon.make_temp_monoexonic_transcript_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" strand = "+" positions = (1, 990) annotation = talon.identify_monoexon_transcript( chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) correct_gene_ID = fetch_correct_ID("TG1", "gene", cursor) novelty_types = [x[-2] for x in annotation['transcript_novelty']] assert annotation['gene_ID'] == correct_gene_ID assert "genomic_transcript" in novelty_types assert annotation['end_delta'] == -10 conn.close()
def test_ISM_internal(self): """ Example where the transcript matches an internal exon """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) talon.make_temp_monoexonic_transcript_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" strand = "+" positions = (500, 600) annotation = talon.identify_monoexon_transcript( chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) correct_gene_ID = fetch_correct_ID("TG1", "gene", cursor) novelty_types = [x[-2] for x in annotation['transcript_novelty']] assert annotation['gene_ID'] == correct_gene_ID assert "ISM_transcript" in novelty_types assert annotation['start_delta'] == annotation['end_delta'] == 0 conn.close()
def test_NNC_match(self): """ Example where the transcript is an NNC match to an existing one by virtue of a new splice donor. """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" positions = [1, 110, 900, 1000] edge_IDs = [run_info.edge + 1] vertex_IDs = [run_info.vertex + 1, 5] strand = "+" v_novelty = [0, 0] gene_ID, transcript_ID, transcript_novelty, start_end_info = talon.process_NNC( chrom, positions, strand, edge_IDs, vertex_IDs, transcript_dict, gene_starts, gene_ends, edge_dict, location_dict, vertex_2_gene, run_info) correct_gene_ID = fetch_correct_ID("TG1", "gene", cursor) assert gene_ID == correct_gene_ID assert start_end_info["vertex_IDs"] == [1] + vertex_IDs + [6] assert transcript_dict[frozenset(start_end_info["edge_IDs"])] != None conn.close()
def test_find_match(self): """ Example where the toy transcript edge dict does not contain the edge being queried. """ conn, cursor = get_db_cursor() # Create a location dict and then fetch vertices for two psotions build = "toy_build" location_dict = talon.make_location_dict(build, cursor) edge_dict = talon.make_edge_dict(cursor) conn.close() chrom = "chr1" pos1 = 600 pos2 = 500 v1 = talon.search_for_vertex_at_pos(chrom, pos1, location_dict)["location_ID"] v2 = talon.search_for_vertex_at_pos(chrom, pos2, location_dict)["location_ID"] assert v1 != None assert v2 != None # Now look for the edge between them edge_match = talon.search_for_edge(v1, v2, "exon", edge_dict) assert edge_match == None # Try them in the opposite order edge_match = talon.search_for_edge(v2, v1, "exon", edge_dict) assert edge_match["edge_ID"] == 3
def test_partial_match_3prime(self): """ Example where the transcript is short, so it overlaps the annotated transcript but is not an accepted match. the end should get assigned to the annotated end, but the end is novel """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) talon.make_temp_monoexonic_transcript_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr4" strand = "-" positions = (2000, 1100) annotation = talon.identify_monoexon_transcript( chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) correct_gene_ID = fetch_correct_ID("TG6", "gene", cursor) assert annotation['gene_ID'] == correct_gene_ID assert annotation['start_delta'] == None assert annotation['end_delta'] == -100 conn.close()
def test_antisense(self): """ Example where the transcript is antisense """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) talon.make_temp_monoexonic_transcript_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr4" strand = "+" positions = (1300, 3900) annotation = talon.identify_monoexon_transcript( chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) anti_gene_ID = fetch_correct_ID("TG6", "gene", cursor) gene_novelty_types = [x[-2] for x in annotation['gene_novelty']] t_novelty_types = [x[-2] for x in annotation['transcript_novelty']] assert annotation['gene_novelty'][0][-1] == "TRUE" assert "antisense_gene" in gene_novelty_types assert "antisense_transcript" in t_novelty_types conn.close()
def test_FSM_perfect(self): """ Example where the transcript is a perfect full splice match. """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" positions = [1, 100, 500, 600, 900, 1010] strand = "+" edge_IDs = [2, 3, 4] vertex_IDs = [2, 3, 4, 5] v_novelty = [0, 0, 0, 0] all_matches = talon.search_for_ISM(edge_IDs, transcript_dict) gene_ID, transcript_ID, novelty, start_end_info = talon.process_FSM( chrom, positions, strand, edge_IDs, vertex_IDs, all_matches, gene_starts, gene_ends, edge_dict, location_dict, run_info) correct_gene_ID = fetch_correct_ID("TG1", "gene", cursor) correct_transcript_ID = fetch_correct_ID("TG1-001", "transcript", cursor) assert gene_ID == correct_gene_ID assert transcript_ID == correct_transcript_ID assert novelty == [] assert start_end_info["start_vertex"] == 1 assert start_end_info["end_vertex"] == 6 assert start_end_info["diff_3p"] == 10 conn.close()
def test_FSM_end_diff(self): """ Example where the transcript is an FSM but has a difference on the ends large enough to be novel. """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr2" strand = "+" positions = [1, 100, 500, 600, 900, 1500] annotation = talon.identify_transcript(chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) correct_gene_ID = fetch_correct_ID("TG2", "gene", cursor) novelty_types = [x[-2] for x in annotation['transcript_novelty']] assert annotation['gene_ID'] == correct_gene_ID assert annotation['end_delta'] == None conn.close()
def test_no_match(self): """ Example with no FSM match """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" positions = [1, 100, 500, 600] strand = "+" edge_IDs = [2] vertex_IDs = [2, 3, 4, 5] v_novelty = [0, 0, 0, 0] all_matches = talon.search_for_ISM(edge_IDs, transcript_dict) gene_ID, transcript_ID, novelty, start_end_info = talon.process_FSM( chrom, positions, strand, edge_IDs, vertex_IDs, all_matches, gene_starts, gene_ends, edge_dict, location_dict, run_info) assert gene_ID == transcript_ID == None conn.close()
def test_ISM_suffix(self): """ Example where the transcript is an ISM with suffix """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" strand = "+" positions = [500, 600, 900, 1000] edge_IDs = [4] vertex_IDs = [4, 5] v_novelty = [0, 0] all_matches = talon.search_for_ISM(edge_IDs, transcript_dict) gene_ID, transcript_ID, novelty, start_end_info = talon.process_ISM( chrom, positions, strand, edge_IDs, vertex_IDs, all_matches, transcript_dict, gene_starts, gene_ends, edge_dict, location_dict, run_info) correct_gene_ID = fetch_correct_ID("TG1", "gene", cursor) assert gene_ID == correct_gene_ID assert start_end_info["vertex_IDs"] == [3, 4, 5, 6] assert start_end_info["edge_IDs"] == [3, 4, 5] assert start_end_info["start_novelty"] == 0 # because the exon is known assert start_end_info["end_novelty"] == 0 assert transcript_dict[frozenset(start_end_info["edge_IDs"])] != None conn.close()
def test_FSM_start_diff(self): """ Example where the transcript is an FSM but has a difference on the start large enough to be novel. """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) orig_vertices = run_info['vertex'] gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" positions = [2501, 1500, 1000, 900] #First postion is > 500bp away strand = "-" edge_IDs = [7] vertex_IDs = [7, 6] v_novelty = [0, 0] all_matches = talon.search_for_ISM(edge_IDs, transcript_dict) gene_ID, transcript_ID, novelty, start_end_info = talon.process_FSM( chrom, positions, strand, edge_IDs, vertex_IDs, all_matches, gene_starts, gene_ends, edge_dict, location_dict, run_info) correct_gene_ID = fetch_correct_ID("TG3", "gene", cursor) correct_transcript_ID = fetch_correct_ID("TG3-001", "transcript", cursor) assert gene_ID == correct_gene_ID assert transcript_ID == correct_transcript_ID assert start_end_info["start_vertex"] == orig_vertices + 1 assert start_end_info["end_vertex"] == 5 conn.close()
def test_antisense(self): """ Example where all of the vertices are in the database, but the edges are not, because they are antisense to the original transcript """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) run_info = talon.init_run_info(cursor, build) orig_n_edges = len(edge_dict) conn.close() chrom = "chr2" vertex_IDs = [14, 13, 12, 11, 10, 9] strand = "-" edge_IDs, novelty = talon.match_all_transcript_edges( vertex_IDs, strand, edge_dict, run_info) expected_edges = [] for i in range(1, 6): num = orig_n_edges + i edge_id = num expected_edges.append(edge_id) assert edge_IDs == tuple(expected_edges) assert novelty == (1, 1, 1, 1, 1)
def test_ISM_prefix(self): """ Example where the transcript is a prefix ISM with a novel start """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) orig_exons = run_info["edge"] chrom = "chr1" strand = "+" positions = [1, 100, 500, 600] edge_IDs = [2] vertex_IDs = [2, 3] v_novelty = [0, 0] all_matches = talon.search_for_ISM(edge_IDs, transcript_dict) gene_ID, transcript_ID, novelty, start_end_info = talon.process_ISM( chrom, positions, strand, edge_IDs, vertex_IDs, all_matches, transcript_dict, gene_starts, gene_ends, edge_dict, location_dict, run_info) correct_gene_ID = fetch_correct_ID("TG1", "gene", cursor) assert gene_ID == correct_gene_ID assert start_end_info["vertex_IDs"] == [1, 2, 3, 4] assert start_end_info["edge_IDs"] == [1, 2, 3] conn.close()
def test_FSM_perfect(self): """ Example where the transcript is a perfect full splice match. """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" strand = "+" positions = [1, 100, 500, 600, 900, 1000] annotation = talon.identify_transcript(chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) correct_gene_ID = fetch_correct_ID("TG1", "gene", cursor) correct_transcript_ID = fetch_correct_ID("TG1-001", "transcript", cursor) assert annotation['gene_ID'] == correct_gene_ID assert annotation['transcript_ID'] == correct_transcript_ID assert annotation['transcript_novelty'] == [] conn.close()
def test_NIC_instead_of_ISM(self): """ Test case where the transcript looks like an ISM, but is NIC on account of having known starts and ends """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr3" strand = "+" positions = (800, 1000, 1200, 1400, 1600, 1800, 2000, 2200) annotation = talon.identify_transcript(chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) correct_gene_ID = fetch_correct_ID("TG5", "gene", cursor) novelty_types = [x[-2] for x in annotation['transcript_novelty']] assert annotation['gene_ID'] == correct_gene_ID assert "NIC_transcript" in novelty_types conn.close()
def test_match(self): """ Example where the transcript is a moniexonic match. """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) talon.make_temp_monoexonic_transcript_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr4" strand = "-" positions = (3900, 1100) annotation = talon.identify_monoexon_transcript( chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) correct_gene_ID = fetch_correct_ID("TG6", "gene", cursor) correct_transcript_ID = fetch_correct_ID("TG6-001", "transcript", cursor) assert annotation['gene_ID'] == correct_gene_ID assert annotation['start_delta'] == 100 assert annotation['end_delta'] == -100 conn.close()
def test_datasets(self): """ Try to add dataset metadata to database """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) run_info = talon.init_run_info(cursor, build) datasets = [(1, "toy", "toy", "toy")] talon.add_datasets(cursor, datasets) # Test if items are there query = "SELECT * FROM dataset" cursor.execute(query) assert len(cursor.fetchall()) == 1 conn.close()
def test_antisense(self): """ Example where the vertices are known but there is no same-strand match """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) locations = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) # Construct temp novel gene db talon.make_temp_novel_gene_table(cursor, "toy_build") chrom = "chr1" start = 1000 end = 1 edge_IDs = [run_info.edge + 1] positions = [1000, 900, 100, 1] vertex_IDs = [5, 2] strand = "-" anti_strand = "+" v_novelty = (0, 0, 0, 0) # Find antisense match gene_ID, transcript_ID, gene_novelty, transcript_novelty, start_end_info = \ talon.process_spliced_antisense(chrom, positions, strand, edge_IDs, vertex_IDs, transcript_dict, gene_starts, gene_ends, edge_dict, locations, vertex_2_gene, run_info, cursor) #anti_gene_ID = talon.find_gene_match_on_vertex_basis(vertex_IDs, # anti_strand, # vertex_2_gene) correct_gene_ID = fetch_correct_ID("TG1", "gene", cursor) anti_gene_ID = gene_novelty[-1][-1] assert anti_gene_ID == correct_gene_ID assert start_end_info["vertex_IDs"] == [6, 5, 2, 1] conn.close()
def test_abundance(self): """ Try to add abundance entries to database in batches """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) run_info = talon.init_run_info(cursor, build) abundance = [(1, "test", 5), (2, "test", 1), (3, "test", 2)] batch_size = 2 talon.batch_add_abundance(cursor, abundance, batch_size) # Test if items are there query = "SELECT * FROM abundance" cursor.execute(query) assert len(cursor.fetchall()) == 3 conn.close()
def test_exon_annot(self): """ Try to add exon annotation entries to database in batches """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) run_info = talon.init_run_info(cursor, build) annot = [(1, "toy", "TALON", "status", "NOVEL"), (2, "toy", "TALON", "status", "NOVEL")] batch_size = 3 talon.batch_add_annotations(cursor, annot, "exon", batch_size) # Test if items are there query = "SELECT * FROM exon_annotations WHERE value = 'NOVEL'" cursor.execute(query) assert len(cursor.fetchall()) == 2 conn.close()
def test_all_known_edges(self): """ Example where the toy transcript database contains matches for all vertices. """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) run_info = talon.init_run_info(cursor, build) conn.close() chrom = "chr1" vertex_IDs = [1, 2, 3, 4, 5, 6] strand = "+" edge_IDs, novelty = talon.match_all_transcript_edges( vertex_IDs, strand, edge_dict, run_info) assert edge_IDs == (1, 2, 3, 4, 5) assert novelty == (0, 0, 0, 0, 0)
def test_gene_update(self): """ Try to add novel gene entries to database while ignoring duplicates """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) run_info = talon.init_run_info(cursor, build) talon.make_temp_novel_gene_table(cursor, build) talon.create_gene("chr4", 1, 1000, "+", cursor, run_info) talon.add_genes(cursor) # Test if gene with ID 6 is there, but make sure we didn't add # duplicates of the other genes query = "SELECT * FROM genes" gene_IDs = [x['gene_ID'] for x in cursor.execute(query)] assert 7 in gene_IDs assert len(gene_IDs) == 7 conn.close()
def test_observed(self): """ Try to add observed entries to database in batches """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) run_info = talon.init_run_info(cursor, build) observed = [(1, 1, 1, "read1", "test", 1, 2, 1, 1, 0, 0, 100), (2, 1, 1, "read2", "test", 1, 2, 1, 1, 0, 0, 100), (3, 1, 1, "read3", "test", 1, 2, 1, 1, 0, 0, 100)] batch_size = 1 talon.batch_add_observed(cursor, observed, batch_size) # Test if items are there query = "SELECT * FROM observed" cursor.execute(query) assert len(cursor.fetchall()) == 3 conn.close()
def test_edge_update(self): """ Try to add novel exons and introns. """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) run_info = talon.init_run_info(cursor, build) orig_n_edges = run_info.edge talon.create_edge(2, 1, "exon", "-", edge_dict, run_info) batch_size = 10 talon.batch_add_edges(cursor, edge_dict, batch_size) # Test if the edge table has the correct number of edges now query = "SELECT * FROM edge" cursor.execute(query) edge_IDs = [x['edge_ID'] for x in cursor.fetchall()] assert orig_n_edges + 1 in edge_IDs assert len(edge_IDs) == orig_n_edges + 1 conn.close()
def test_overlap_but_no_vertex_match(self): """ Example where the transcript is short, so it overlaps the annotated transcript but is not an accepted match. the start should get assigned to the annotated end, but the end is novel """ conn, cursor = get_db_cursor() build = "toy_build" talon.make_temp_novel_gene_table(cursor, build) talon.make_temp_monoexonic_transcript_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) tot_vertices = len(vertex_2_gene) query = """ SELECT COUNT(*) FROM temp_monoexon """ tot_monoexonic = cursor.execute(query).fetchone()[0] chrom = "chr4" strand = "-" positions = (2500, 2000) annotation = talon.identify_monoexon_transcript( chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) correct_gene_ID = fetch_correct_ID("TG6", "gene", cursor) print(annotation['start_vertex']) print(annotation['end_vertex']) assert annotation['gene_ID'] == correct_gene_ID assert annotation['start_delta'] == None assert annotation['end_delta'] == None # Now check if the transcript got added to the right data structures assert len(vertex_2_gene) == tot_vertices + 2 assert cursor.execute(query).fetchone()[0] == tot_monoexonic + 1 conn.close()
def test_no_match(self): """ Example with no ISM match """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr1" strand = "+" positions = [1, 100, 900, 1000] edge_IDs = [200] vertex_IDs = [2, 5] v_novelty = [0, 0] all_matches = talon.search_for_ISM(edge_IDs, transcript_dict) assert all_matches == None conn.close()
def test_NIC_with_all_known_edges(self): """ Test case derived from a real mouse Map2k4 read. All of edges are known (except 3'), yet the read is NIC not FSM/ISM """ conn = sqlite3.connect("scratch/Map2k4.db") conn.row_factory = sqlite3.Row cursor = conn.cursor() build = "mm10" talon.make_temp_novel_gene_table(cursor, build) edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) chrom = "chr11" strand = "-" positions = [ 65788254, 65788136, 65775765, 65775733, 65756371, 65756269, 65735366, 65735192, 65719603, 65719484, 65712297, 65712178, 65709983, 65709932, 65707111, 65706984, 65696365, 65696288, 65693570, 65693422, 65691773, 65691728, 65690804, 65689322 ] annotation = talon.identify_transcript(chrom, positions, strand, cursor, location_dict, edge_dict, transcript_dict, vertex_2_gene, gene_starts, gene_ends, run_info) assert annotation['gene_ID'] == 1 assert annotation['transcript_ID'] == 8 novelty_types = [x[-2] for x in annotation['transcript_novelty']] assert "NIC_transcript" in novelty_types conn.close()
def test_genomic(self): """ Example where the transcript overlaps a gene but contains no known splice vertices """ conn, cursor = get_db_cursor() build = "toy_build" edge_dict = talon.make_edge_dict(cursor) location_dict = talon.make_location_dict(build, cursor) run_info = talon.init_run_info(cursor, build) transcript_dict = talon.make_transcript_dict(cursor, build) vertex_2_gene = talon.make_vertex_2_gene_dict(cursor) gene_starts, gene_ends = talon.make_gene_start_and_end_dict( cursor, build) # Construct temp novel gene db talon.make_temp_novel_gene_table(cursor, "toy_build") chrom = "chr1" positions = [1000, 950, 700, 600] edge_IDs = [run_info.edge + 1, run_info.edge + 2] vertex_IDs = [run_info.vertex + 1, run_info.vertex + 2] strand = "-" gene_ID, transcript_ID, gene_novelty, transcript_novelty, start_end_info = \ talon.process_remaining_mult_cases(chrom, positions, strand, edge_IDs, vertex_IDs, transcript_dict, gene_starts, gene_ends, edge_dict, location_dict, vertex_2_gene, run_info, cursor) correct_gene_ID = fetch_correct_ID("TG3", "gene", cursor) assert gene_ID == correct_gene_ID assert transcript_dict[frozenset(start_end_info["edge_IDs"])] != None assert gene_novelty == [] assert transcript_novelty[-1][-2] == "genomic_transcript" conn.close()