class TestConverter(unittest.TestCase):
def setUp(self):
self.converter = Converter()
self.example = Example()
self.converter.gff3parser = Mock_gff3_parser
self.converter._print_rntptt_title = Mock_func().print_rntptt_title
self.converter.tsspredator = Mock_TSSPredatorReader()
self.converter._read_file = Mock_func().mock_read_file
self.gff_file = self.example.gff_file
self.ptt_out = self.example.ptt_out
self.rnt_out = self.example.rnt_out
self.srna_out = self.example.srna_out
self.embl_file = self.example.embl_file
self.embl_out = self.example.embl_out
self.multi_embl = self.example.multi_embl
self.gff_out = self.example.gff_out
self.mastertable = self.example.mastertable
self.tss_file = self.example.tss_file
self.fasta_file = self.example.fasta_file
self.transterm = self.example.transterm
self.term_file = self.example.term_file
self.circ_file = self.example.circrna_table
self.circ_all = self.example.circrna_all
self.circ_best = self.example.circrna_best
self.test_folder = "test_folder"
self.mock_args = MockClass()
if (not os.path.exists(self.test_folder)):
os.mkdir(self.test_folder)
def tearDown(self):
if os.path.exists(self.test_folder):
shutil.rmtree(self.test_folder)
def test_print_rntptt_file(self):
cdss = []
genes = []
rnas = []
gff_dict = Example().gff_dict
for gff in gff_dict:
if gff["feature"] == "gene":
genes.append(self.converter.gff3parser.entries(self, gff))
elif gff["feature"] == "CDS":
cdss.append(self.converter.gff3parser.entries(self, gff))
elif gff["feature"] == "tRNA":
rnas.append(self.converter.gff3parser.entries(self, gff))
out_p = StringIO()
out_r = StringIO()
self.converter._print_rntptt_file(out_p, cdss, genes)
self.converter._print_rntptt_file(out_r, rnas, genes)
self.assertEqual(out_p.getvalue().split("\n")[:-1],
self.example.ptt_out_list)
self.assertEqual(out_r.getvalue().split("\n")[:-1],
self.example.rnt_out_list)
out_p.close()
out_r.close()
def test_srna2pttrnt(self):
srna_input_file = os.path.join(self.test_folder, "srna.gff")
srna_output_file = os.path.join(self.test_folder, "srna.out")
with open(srna_input_file, "w") as fh:
fh.write(self.gff_file)
srnas = []
self.converter._srna2rntptt(srna_input_file, srna_output_file, srnas,
1234567)
datas = import_data(srna_output_file)
self.assertEqual(set(datas), set(self.srna_out.split("\n")))
def test_multi_embl_pos(self):
embls = []
for line in self.embl_file.split("\n"):
datas = self.converter._multi_embl_pos(line.strip())
if datas != "Wrong":
embls.append(datas)
for index in range(0, 7):
self.assertDictEqual(embls[index], self.embl_out[index])
for index in range(0, 2):
self.assertDictEqual(embls[-1]["pos"][index],
self.multi_embl[index])
def test_parser_embl_data(self):
embl_file = os.path.join(self.test_folder, "test.embl")
embl_out = os.path.join(self.test_folder, "test.embl_out")
out = StringIO()
with open(embl_file, "w") as eh:
for line in self.embl_file.split("\n"):
eh.write(line + "\n")
info = self.converter._parser_embl_data(embl_file, out)
datas = out.getvalue().split("\n")
self.assertEqual(set(datas[:-1]), set(self.gff_out.split("\n")))
self.assertEqual(info[0], "NC_007795.1")
for index in range(0, 2):
self.assertDictEqual(info[1]["pos"][index], self.multi_embl[index])
out.close()
def test_multi_tss_class(self):
nums = {"tss": 0, "tss_uni": 0, "class": 1}
utrs = {"total": [], "pri": [], "sec": []}
tss_features = {"tss_types": [], "locus_tags": [], "utr_lengths": []}
tss_index = defaultdict(lambda: 0)
master_file = os.path.join(self.test_folder, "test.tsv")
fh = StringIO(self.mastertable)
for tss in self.converter.tsspredator.entries(fh):
self.converter._multi_tss_class(tss, tss_index, tss_features, nums,
utrs)
fh.close()
self.assertDictEqual(nums, {'tss_uni': 0, 'class': 5, 'tss': 2})
def test_convert_mastertable2gff(self):
master_file = os.path.join(self.test_folder, "test.tsv")
with open(master_file, "w") as th:
th.write(self.mastertable)
out_gff = os.path.join(self.test_folder, "test.tsv_out")
self.converter.convert_mastertable2gff(master_file, "ANNOgesic", "TSS",
"aaa", out_gff)
datas = import_data(out_gff)
self.assertEqual(set(datas), set(self.tss_file.split("\n")))
def test_convert_gff2rntptt(self):
srna_input_file = os.path.join(self.test_folder, "srna.gff")
srna_output_file = os.path.join(self.test_folder, "srna.out")
gff_file = os.path.join(self.test_folder, "test.gff")
rnt_file = os.path.join(self.test_folder, "test.rnt")
ptt_file = os.path.join(self.test_folder, "test.ptt")
fasta_file = os.path.join(self.test_folder, "test.fa")
with open(srna_input_file, "w") as fh:
fh.write(self.gff_file)
with open(gff_file, "w") as fh:
fh.write(self.gff_file)
with open(fasta_file, "w") as fh:
fh.write(self.fasta_file)
self.converter.convert_gff2rntptt(gff_file, fasta_file, ptt_file,
rnt_file, srna_input_file,
srna_output_file)
self.assertTrue(srna_output_file)
self.assertTrue(rnt_file)
self.assertTrue(ptt_file)
def test_convert_embl2gff(self):
embl_file = os.path.join(self.test_folder, "test.embl")
gff_file = os.path.join(self.test_folder, "test.embl_out")
with open(embl_file, "w") as eh:
for line in self.embl_file.split("\n"):
eh.write(line + "\n")
self.converter.convert_embl2gff(embl_file, gff_file)
datas = import_data(gff_file)
self.assertEqual(set(datas[1:-2]), set(self.gff_out.split("\n")))
def test_convert_transtermhp2gff(self):
transterm_file = os.path.join(self.test_folder,
"test_best_terminator_after_gene.bag")
gff_file = os.path.join(self.test_folder, "transterm.gff")
with open(transterm_file, "w") as th:
th.write(self.transterm)
self.converter.convert_transtermhp2gff(transterm_file, gff_file)
datas = import_data(gff_file)
self.assertEqual(set(datas), set(self.term_file.split("\n")))
def get_info(datas):
f_datas = []
for data in datas:
if not data.startswith("#"):
f_datas.append("\t".join(data.split("\t")[:8]))
return f_datas
def test_convert_circ2gff(self):
circ_file = os.path.join(self.test_folder, "circ.csv")
out_all = os.path.join(self.test_folder, "all.gff")
out_filter = os.path.join(self.test_folder, "best.gff")
with open(circ_file, "w") as ch:
ch.write(self.circ_file)
args = self.mock_args.mock()
args.start_ratio = 0.5
args.end_ratio = 0.5
args.support = 5
self.converter.convert_circ2gff(circ_file, args, out_all, out_filter)
datas = import_data(out_all)
f_datas = []
for data in datas:
if not data.startswith("#"):
f_datas.append("\t".join(data.split("\t")[:8]))
c_datas = []
for data in self.circ_all.split("\n"):
if not data.startswith("#"):
c_datas.append("\t".join(data.split("\t")[:8]))
self.assertListEqual(f_datas, c_datas)
datas = import_data(out_filter)
f_datas = []
for data in datas:
if not data.startswith("#"):
f_datas.append("\t".join(data.split("\t")[:8]))
c_datas = []
for data in self.circ_best.split("\n"):
if not data.startswith("#"):
c_datas.append("\t".join(data.split("\t")[:8]))
self.assertListEqual(f_datas, c_datas)
class Terminator(object):
'''detection of terminator'''
def __init__(self, args_term):
self.multiparser = Multiparser()
self.helper = Helper()
self.converter = Converter()
self.gff_parser = Gff3Parser()
self.gff_path = os.path.join(args_term.gffs, "tmp")
self.fasta_path = os.path.join(args_term.fastas, "tmp")
self.tran_path = os.path.join(args_term.trans, "tmp")
self.outfolder = {
"term": os.path.join(args_term.out_folder, "gffs"),
"csv": os.path.join(args_term.out_folder, "tables")
}
self.terms = {
"all": os.path.join(self.outfolder["term"], "all_candidates"),
"express": os.path.join(self.outfolder["term"],
"expressed_candidates"),
"best": os.path.join(self.outfolder["term"], "best_candidates"),
"non": os.path.join(self.outfolder["term"],
"non_expressed_candidates")
}
self.csvs = {
"all": os.path.join(self.outfolder["csv"], "all_candidates"),
"express": os.path.join(self.outfolder["csv"],
"expressed_candidates"),
"best": os.path.join(self.outfolder["csv"], "best_candidates"),
"non": os.path.join(self.outfolder["csv"],
"non_expressed_candidates")
}
self.combine_path = os.path.join(self.gff_path, "combine")
self.tmps = {
"transterm": os.path.join(os.getcwd(), "tmp_transterm"),
"hp": "transtermhp",
"hp_gff": "transtermhp.gff",
"hp_path": "tmp_transterm/tmp",
"term_table": os.path.join(os.getcwd(), "tmp_term_table"),
"merge": os.path.join(os.getcwd(), "tmp_merge_gff"),
"gff": "tmp.gff",
"folder": os.path.join(os.getcwd(), "tmp")
}
self.suffixs = {
"gff": "term.gff",
"csv": "term.csv",
"allgff": "term_all.gff"
}
if args_term.srnas:
self.srna_path = os.path.join(args_term.srnas, "tmp")
else:
self.srna_path = None
self._make_gff_folder()
def _combine_annotation(self, combine_file, files):
with open(combine_file, 'w') as result:
for file_ in files:
check_start = False
fh = open(file_, 'r')
for line in fh:
if check_start:
result.write(line)
if "Location" in line:
check_start = True
if "\n" not in line:
result.write("\n")
fh.close()
def _make_gff_folder(self):
self.helper.check_make_folder(self.terms["all"])
self.helper.check_make_folder(self.csvs["all"])
self.helper.check_make_folder(self.terms["best"])
self.helper.check_make_folder(self.csvs["best"])
self.helper.check_make_folder(self.terms["express"])
self.helper.check_make_folder(self.csvs["express"])
self.helper.check_make_folder(self.terms["non"])
self.helper.check_make_folder(self.csvs["non"])
def _convert_gff2rntptt(self, gff_path, fasta_path, sRNAs):
file_types = {}
prefixs = []
for gff in os.listdir(gff_path):
if gff.endswith(".gff"):
filename = gff.split("/")
prefix = filename[-1][:-4]
prefixs.append(prefix)
gff_file = os.path.join(gff_path, gff)
rnt_file = os.path.join(gff_path, gff.replace(".gff", ".rnt"))
ptt_file = os.path.join(gff_path, gff.replace(".gff", ".ptt"))
fasta = self.helper.get_correct_file(fasta_path, ".fa", prefix,
None, None)
if not fasta:
print("Error: {0}.fa can not be found!".format(prefix))
sys.exit()
if sRNAs:
self.multiparser.parser_gff(sRNAs, "sRNA")
srna = self.helper.get_correct_file(
self.srna_path, "_sRNA.gff", prefix, None, None)
if (srna) and (fasta):
self.converter.convert_gff2rntptt(
gff_file, fasta, ptt_file, rnt_file, srna,
srna.replace(".gff", ".rnt"))
file_types[prefix] = "srna"
if (not srna) and (fasta):
self.converter.convert_gff2rntptt(
gff_file, fasta, ptt_file, rnt_file, None, None)
file_types[prefix] = "normal"
else:
self.converter.convert_gff2rntptt(gff_file, fasta,
ptt_file, rnt_file, None,
None)
file_types[prefix] = "normal"
return file_types, prefixs
def _combine_ptt_rnt(self, gff_path, file_types, srna_path):
self.helper.check_make_folder(self.combine_path)
for prefix, file_type in file_types.items():
combine_file = os.path.join(self.combine_path, prefix + '.ptt')
if file_type == "normal":
files = [
os.path.join(gff_path, prefix + ".ptt"),
os.path.join(gff_path, prefix + ".rnt")
]
self._combine_annotation(combine_file, files)
elif file_type == "srna":
files = [
os.path.join(gff_path, prefix + ".ptt"),
os.path.join(gff_path, prefix + ".rnt"),
os.path.join(srna_path, "_".join([prefix, "sRNA.rnt"]))
]
self._combine_annotation(combine_file, files)
def _TransTermHP(self, fasta, file_, out_path, prefix, out, args_term):
call([
args_term.TransTermHP_path, "-p", args_term.expterm_path, fasta,
os.path.join(self.combine_path, file_), "--t2t-perf",
os.path.join(
out_path, "_".join([
prefix,
"terminators_within_robust_tail-to-tail_regions.t2t"
])), "--bag-output",
os.path.join(out_path, "_".join(
[prefix, "best_terminator_after_gene.bag"]))
],
stdout=out)
def _run_TransTermHP(self, args_term):
self.helper.check_make_folder(self.tmps["transterm"])
for file_ in os.listdir(self.combine_path):
if ".ptt" in file_:
prefix = file_.replace(".ptt", "")
fasta = self.helper.get_correct_file(self.fasta_path, ".fa",
prefix, None, None)
if not fasta:
print("Error: {0}.fa can not be found!".format(prefix))
sys.exit()
out_path = os.path.join(args_term.hp_folder, prefix)
self.helper.check_make_folder(out_path)
out = open(
os.path.join(out_path,
"_".join([prefix, "terminators.txt"])), "w")
self._TransTermHP(fasta, file_, out_path, prefix, out,
args_term)
out.close()
shutil.rmtree(self.combine_path)
def _convert_to_gff(self, prefixs, args_term):
for prefix in prefixs:
for folder in os.listdir(args_term.hp_folder):
if prefix == folder:
out_path = os.path.join(args_term.hp_folder, folder)
for file_ in os.listdir(out_path):
if file_.endswith(".bag"):
out_file = os.path.join(
self.tmps["transterm"],
"_".join([prefix, self.tmps["hp_gff"]]))
self.converter.convert_transtermhp2gff(
os.path.join(out_path, file_), out_file)
self.multiparser.combine_gff(args_term.gffs, self.tmps["transterm"],
None, self.tmps["hp"])
def _combine_wigs(self, args_term):
if (args_term.tex_wigs is not None) and (args_term.frag_wigs
is not None):
folder = args_term.tex_wigs.split("/")
folder = "/".join(folder[:-1])
merge_wigs = os.path.join(folder, "merge_wigs")
self.helper.check_make_folder(merge_wigs)
for wig in os.listdir(args_term.tex_wigs):
if os.path.isdir(os.path.join(args_term.tex_wigs, wig)):
pass
else:
shutil.copy(os.path.join(args_term.tex_wigs, wig),
merge_wigs)
for wig in os.listdir(args_term.frag_wigs):
if os.path.isdir(os.path.join(args_term.frag_wigs, wig)):
pass
else:
shutil.copy(os.path.join(args_term.frag_wigs, wig),
merge_wigs)
elif (args_term.tex_wigs is not None):
merge_wigs = args_term.tex_wigs
elif (args_term.frag_wigs is not None):
merge_wigs = args_term.frag_wigs
else:
print("Error: Wiggle files are not assigned!")
sys.exit()
return merge_wigs
def _merge_sRNA(self, sRNAs, prefixs, gff_path):
'''searching the terminator with sRNA information'''
if sRNAs is not None:
self.multiparser.parser_gff(sRNAs, "sRNA")
self.helper.check_make_folder(self.tmps["merge"])
for prefix in prefixs:
tmp_gff = os.path.join(self.tmps["merge"], self.tmps["gff"])
if self.tmps["gff"] in os.listdir(self.tmps["merge"]):
os.remove(tmp_gff)
self.helper.merge_file(os.path.join(gff_path, prefix + ".gff"),
tmp_gff)
self.helper.merge_file(
os.path.join(self.srna_path,
"_".join([prefix, "sRNA.gff"])), tmp_gff)
self.helper.sort_gff(
tmp_gff, os.path.join(self.tmps["merge"], prefix + ".gff"))
os.remove(tmp_gff)
merge_path = self.tmps["merge"]
else:
merge_path = gff_path
return merge_path
def _move_file(self, term_outfolder, csv_outfolder):
for gff in os.listdir(term_outfolder):
if gff.endswith("_term.gff"):
self.helper.sort_gff(os.path.join(term_outfolder, gff),
self.tmps["gff"])
shutil.move(self.tmps["gff"],
os.path.join(term_outfolder, gff))
prefix = gff.replace("_term.gff", "")
new_gff = os.path.join(
self.terms["all"],
"_".join([prefix, self.suffixs["allgff"]]))
csv_file = os.path.join(
os.path.join(self.csvs["all"],
"_".join([prefix, self.suffixs["csv"]])))
out = open(new_gff, "w")
out.write("##gff-version 3\n")
out.close()
self.helper.merge_file(
os.path.join(term_outfolder, gff),
os.path.join(self.terms["all"],
"_".join([prefix, self.suffixs["allgff"]])))
os.remove(os.path.join(term_outfolder, gff))
pre_strain = ""
if ("_".join([prefix, self.suffixs["csv"]])
in os.listdir(self.csvs["all"])):
os.remove(csv_file)
out_csv = open(csv_file, "w")
out_csv.write("\t".join([
"Genome", "Name", "Start", "End", "Strand", "Detect",
"Coverage_decrease", "Coverage_detail"
]) + "\n")
out_csv.close()
fh = open(new_gff)
for entry in self.gff_parser.entries(fh):
if entry.seq_id != pre_strain:
self.helper.merge_file(
os.path.join(
self.tmps["term_table"],
"_".join([entry.seq_id, "term_raw.csv"])),
os.path.join(
self.csvs["all"],
"_".join([prefix, self.suffixs["csv"]])))
pre_strain = entry.seq_id
fh.close()
def _run_rnafold(self, RNAfold_path, tmp_seq, tmp_sec, prefix):
print("Computing secondray structures of {0}".format(prefix))
self.helper.check_make_folder(self.tmps["folder"])
pre_cwd = os.getcwd()
os.chdir(self.tmps["folder"])
os.system(" ".join([
RNAfold_path, "<",
os.path.join("..", tmp_seq), ">",
os.path.join("..", tmp_sec)
]))
os.chdir(pre_cwd)
shutil.rmtree(self.tmps["folder"])
def _compute_intersection_forward_reverse(self, prefixs, merge_path,
wig_path, merge_wigs, args_term):
'''the approach for searching gene converged region terminator'''
for prefix in prefixs:
tmp_seq = os.path.join(args_term.out_folder,
"_".join(["inter_seq", prefix]))
tmp_index = os.path.join(args_term.out_folder,
"_".join(["inter_index", prefix]))
tmp_sec = os.path.join(args_term.out_folder,
"_".join(["inter_sec", prefix]))
tran_file = os.path.join(self.tran_path,
"_".join([prefix, "transcript.gff"]))
gff_file = os.path.join(merge_path, prefix + ".gff")
tmp_cand = tmp_cand = os.path.join(
args_term.out_folder, "_".join(["term_candidates", prefix]))
if os.path.exists(tran_file):
print("Extracting sequences of {0}".format(prefix))
intergenic_seq(os.path.join(self.fasta_path,
prefix + ".fa"), tran_file,
gff_file, tmp_seq, tmp_index, args_term)
self._run_rnafold(args_term.RNAfold_path, tmp_seq, tmp_sec,
prefix)
extract_info_sec(tmp_sec, tmp_seq, tmp_index)
os.remove(tmp_index)
poly_t(tmp_seq, tmp_sec, gff_file, tran_file, tmp_cand,
args_term)
print("Detecting terminators for " + prefix)
detect_coverage(
tmp_cand, os.path.join(merge_path, prefix + ".gff"),
os.path.join(self.tran_path,
"_".join([prefix, "transcript.gff"])),
os.path.join(self.fasta_path, prefix + ".fa"),
os.path.join(wig_path, "_".join([prefix, "forward.wig"])),
os.path.join(wig_path, "_".join([prefix, "reverse.wig"])),
os.path.join(self.tmps["hp_path"],
"_".join([prefix, self.tmps["hp_gff"]])),
merge_wigs,
os.path.join(self.outfolder["term"],
"_".join([prefix, self.suffixs["gff"]])),
os.path.join(self.tmps["term_table"],
"_".join([prefix, "term_raw.csv"])), args_term)
self.multiparser.combine_gff(args_term.gffs, self.outfolder["term"],
None, "term")
self._move_file(self.outfolder["term"], self.outfolder["csv"])
def _remove_tmp_file(self, merge_wigs, args_term):
self.helper.remove_tmp_dir(args_term.gffs)
self.helper.remove_tmp_dir(args_term.fastas)
if args_term.srnas is not None:
self.helper.remove_tmp(args_term.srnas)
shutil.rmtree(self.tmps["merge"])
if (args_term.tex_wigs is not None) and (args_term.frag_wigs
is not None):
shutil.rmtree(merge_wigs)
self.helper.remove_tmp_dir(args_term.trans)
if "tmp_wig" in os.listdir(args_term.out_folder):
shutil.rmtree(os.path.join(args_term.out_folder, "tmp_wig"))
self.helper.remove_tmp(self.outfolder["term"])
shutil.rmtree(self.tmps["transterm"])
shutil.rmtree(self.tmps["term_table"])
self.helper.remove_all_content(args_term.out_folder, "inter_seq_",
"file")
self.helper.remove_all_content(self.outfolder["term"], "_term.gff",
"file")
self.helper.remove_all_content(args_term.out_folder, "inter_sec_",
"file")
self.helper.remove_all_content(args_term.out_folder,
"term_candidates_", "file")
def _compute_stat(self, args_term):
new_prefixs = []
for gff in os.listdir(self.terms["all"]):
if gff.endswith("_term_all.gff"):
out_tmp = open(self.tmps["gff"], "w")
out_tmp.write("##gff-version 3\n")
new_prefix = gff.replace("_term_all.gff", "")
new_prefixs.append(gff.replace("_term_all.gff", ""))
num = 0
fh = open(os.path.join(self.terms["all"], gff))
for entry in self.gff_parser.entries(fh):
name = '%0*d' % (5, num)
entry.attributes["ID"] = (entry.seq_id + "_terminator" +
str(num))
entry.attributes["Name"] = "_".join(["terminator_" + name])
entry.attribute_string = ";".join([
"=".join(items) for items in entry.attributes.items()
])
out_tmp.write("\t".join([
entry.info_without_attributes, entry.attribute_string
]) + "\n")
num += 1
out_tmp.close()
fh.close()
shutil.move(
self.tmps["gff"],
os.path.join(self.terms["all"],
"_".join([new_prefix, self.suffixs["gff"]])))
stat_path = os.path.join(args_term.out_folder, "statistics")
for prefix in new_prefixs:
stat_term(
os.path.join(self.terms["all"],
"_".join([prefix, self.suffixs["gff"]])),
os.path.join(self.csvs["all"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(stat_path, "_".join(["stat", prefix + ".csv"])),
os.path.join(self.terms["best"], "_".join([prefix, "term"])),
os.path.join(self.terms["express"], "_".join([prefix,
"term"])),
os.path.join(self.terms["non"], "_".join([prefix, "term"])))
shutil.move(
os.path.join(self.terms["best"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(self.csvs["best"],
"_".join([prefix, self.suffixs["csv"]])))
shutil.move(
os.path.join(self.terms["express"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(self.csvs["express"],
"_".join([prefix, self.suffixs["csv"]])))
shutil.move(
os.path.join(self.terms["non"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(self.csvs["non"],
"_".join([prefix, self.suffixs["csv"]])))
os.remove(
os.path.join(self.terms["all"],
"_".join([prefix, self.suffixs["allgff"]])))
def _check_gff_file(self, folder):
for file_ in os.listdir(folder):
if file_.endswith(".gff"):
self.helper.check_uni_attributes(os.path.join(folder, file_))
def _compare_term_tran(self, args_term, prefixs):
'''searching the associated terminator to transcript'''
self.multiparser.combine_gff(args_term.gffs, self.tran_path, None,
"transcript")
prefixs = []
print("Comparing terminators with transcripts now")
for file_ in os.listdir(self.tran_path):
if file_.endswith("_transcript.gff"):
prefixs.append(file_.replace("_transcript.gff", ""))
for type_ in ("best_candidates", "expressed_candidates",
"all_candidates"):
compare_term_tran(self.tran_path,
os.path.join(self.outfolder["term"], type_),
args_term.fuzzy_up_ta, args_term.fuzzy_down_ta,
args_term.out_folder, "terminator",
self.outfolder["term"], args_term.trans)
for prefix in prefixs:
shutil.move(
os.path.join(
args_term.out_folder, "statistics",
"stat_compare_transcript_terminator_" + prefix +
".csv"),
os.path.join(
args_term.out_folder, "statistics", "_".join([
"stat_compare_terminator_transcript", prefix,
type_ + ".csv"
])))
def run_terminator(self, args_term):
self._check_gff_file(args_term.gffs)
self._check_gff_file(args_term.trans)
self.multiparser.parser_fasta(args_term.fastas)
if (not args_term.gffs) or (not args_term.fastas):
print("Error: Please assign gff files " "and fasta files!")
sys.exit()
file_types, prefixs = self._convert_gff2rntptt(self.gff_path,
self.fasta_path,
args_term.srnas)
self._combine_ptt_rnt(self.gff_path, file_types, self.srna_path)
self._run_TransTermHP(args_term)
self._convert_to_gff(prefixs, args_term)
self.helper.remove_tmp(self.gff_path)
self.multiparser.parser_gff(args_term.trans, "transcript")
self.helper.check_make_folder(self.tmps["term_table"])
self.multiparser.parser_gff(self.tmps["transterm"], self.tmps["hp"])
merge_path = self._merge_sRNA(args_term.srnas, prefixs, self.gff_path)
self._compute_intersection_forward_reverse(prefixs, merge_path,
args_term.wig_path,
args_term.merge_wigs,
args_term)
self._compute_stat(args_term)
self._compare_term_tran(args_term, prefixs)
self._remove_tmp_file(args_term.merge_wigs, args_term)
class Terminator(object):
'''detection of terminator'''
def __init__(self, args_term):
self.multiparser = Multiparser()
self.helper = Helper()
self.converter = Converter()
self.gff_parser = Gff3Parser()
self.gff_path = os.path.join(args_term.gffs, "tmp")
self.fasta_path = os.path.join(args_term.fastas, "tmp")
self.tran_path = os.path.join(args_term.trans, "tmp")
self.outfolder = {"term": os.path.join(args_term.out_folder, "gffs"),
"csv": os.path.join(args_term.out_folder, "tables")}
self.terms = {"all": os.path.join(self.outfolder["term"],
"all_candidates"),
"express": os.path.join(self.outfolder["term"],
"expressed_candidates"),
"best": os.path.join(self.outfolder["term"],
"best_candidates"),
"non": os.path.join(self.outfolder["term"],
"non_expressed_candidates")}
self.csvs = {"all": os.path.join(self.outfolder["csv"],
"all_candidates"),
"express": os.path.join(self.outfolder["csv"],
"expressed_candidates"),
"best": os.path.join(self.outfolder["csv"],
"best_candidates"),
"non": os.path.join(self.outfolder["csv"],
"non_expressed_candidates")}
self.combine_path = os.path.join(self.gff_path, "combine")
self.tmps = {"transterm": os.path.join(os.getcwd(), "tmp_transterm"),
"hp": "transtermhp", "hp_gff": "transtermhp.gff",
"hp_path": "tmp_transterm/tmp",
"term_table": os.path.join(os.getcwd(), "tmp_term_table"),
"merge": os.path.join(os.getcwd(), "tmp_merge_gff"),
"gff": "tmp.gff",
"folder": os.path.join(os.getcwd(), "tmp")}
self.suffixs = {"gff": "term.gff", "csv": "term.csv",
"allgff": "term_all.gff"}
if args_term.srnas:
self.srna_path = os.path.join(args_term.srnas, "tmp")
else:
self.srna_path = None
self._make_gff_folder()
def _combine_annotation(self, combine_file, files):
with open(combine_file, 'w') as result:
for file_ in files:
if (file_.endswith(".ptt")) and (os.stat(file_).st_size == 0):
print("Warning: No CDS information, "
"TransTermHP can not work!")
return "NO_CDS"
if os.path.exists(file_) and (
os.stat(file_).st_size != 0):
check_start = False
fh = open(file_, 'r')
for line in fh:
if check_start:
result.write(line)
if "Location" in line:
check_start = True
if "\n" not in line:
result.write("\n")
fh.close()
return "Normal"
def _make_gff_folder(self):
self.helper.check_make_folder(self.terms["all"])
self.helper.check_make_folder(self.csvs["all"])
self.helper.check_make_folder(self.terms["best"])
self.helper.check_make_folder(self.csvs["best"])
self.helper.check_make_folder(self.terms["express"])
self.helper.check_make_folder(self.csvs["express"])
self.helper.check_make_folder(self.terms["non"])
self.helper.check_make_folder(self.csvs["non"])
def _convert_gff2rntptt(self, gff_path, fasta_path, sRNAs, log):
file_types = {}
prefixs = []
for gff in os.listdir(gff_path):
if gff.endswith(".gff"):
filename = gff.split("/")
prefix = filename[-1][:-4]
prefixs.append(prefix)
gff_file = os.path.join(gff_path, gff)
rnt_file = os.path.join(gff_path, gff.replace(".gff", ".rnt"))
ptt_file = os.path.join(gff_path, gff.replace(".gff", ".ptt"))
fasta = self.helper.get_correct_file(
fasta_path, ".fa", prefix, None, None)
if not fasta:
log.write("{0}.fa can not be found.\n".format(prefix))
print("Error: {0}.fa can not be found!".format(prefix))
sys.exit()
if sRNAs:
self.multiparser.parser_gff(sRNAs, "sRNA")
srna = self.helper.get_correct_file(
self.srna_path, "_sRNA.gff", prefix, None, None)
if (srna) and (fasta):
log.write("Running converter.py to convert {0} and "
"{1} to {2}, {3}, and {4}.\n".format(
gff_file, srna, ptt_file, rnt_file,
srna.replace(".gff", ".rnt")))
self.converter.convert_gff2rntptt(
gff_file, fasta, ptt_file, rnt_file, srna,
srna.replace(".gff", ".rnt"))
file_types[prefix] = "srna"
log.write("The following files are generated:\n")
log.write("\t{0}\n\t{1}\n\t{2}\n".format(
ptt_file, rnt_file, srna.replace(".gff", ".rnt")))
if (not srna) and (fasta):
log.write("Running converter.py to convert {0} "
"to {1}, and {2}.\n".format(
gff_file, ptt_file, rnt_file))
self.converter.convert_gff2rntptt(
gff_file, fasta, ptt_file, rnt_file, None, None)
file_types[prefix] = "normal"
log.write("The following files are generated:\n")
log.write("\t{0}\n\t{1}\n".format(ptt_file, rnt_file))
else:
log.write("Running converter.py to convert {0} "
"to {1}, and {2}.\n".format(
gff_file, ptt_file, rnt_file))
self.converter.convert_gff2rntptt(
gff_file, fasta, ptt_file, rnt_file, None, None)
file_types[prefix] = "normal"
log.write("The following files are generated:\n")
log.write("\t{0}\n\t{1}\n".format(ptt_file, rnt_file))
return file_types, prefixs
def _combine_ptt_rnt(self, gff_path, file_types, srna_path):
self.helper.check_make_folder(self.combine_path)
for prefix, file_type in file_types.items():
combine_file = os.path.join(self.combine_path, prefix + '.ptt')
if file_type == "normal":
files = [os.path.join(gff_path, prefix + ".ptt"),
os.path.join(gff_path, prefix + ".rnt")]
check = self._combine_annotation(combine_file, files)
elif file_type == "srna":
files = [os.path.join(gff_path, prefix + ".ptt"),
os.path.join(gff_path, prefix + ".rnt"),
os.path.join(srna_path,
"_".join([prefix, "sRNA.rnt"]))]
check = self._combine_annotation(combine_file, files)
return check
def _TransTermHP(self, fasta, file_, out_path, prefix, out, args_term, log):
call([args_term.TransTermHP_path, "-p", args_term.expterm_path,
fasta, os.path.join(self.combine_path, file_), "--t2t-perf",
os.path.join(out_path, "_".join([
prefix,
"terminators_within_robust_tail-to-tail_regions.t2t"])),
"--bag-output", os.path.join(out_path, "_".join([
prefix, "best_terminator_after_gene.bag"]))],
stdout=out)
log.write(" ".join([args_term.TransTermHP_path, "-p", args_term.expterm_path,
fasta, os.path.join(self.combine_path, file_), "--t2t-perf",
os.path.join(out_path, "_".join([
prefix,
"terminators_within_robust_tail-to-tail_regions.t2t"])),
"--bag-output", os.path.join(out_path, "_".join([
prefix, "best_terminator_after_gene.bag"]))]) + "\n")
def _run_TransTermHP(self, args_term, log):
self.helper.check_make_folder(self.tmps["transterm"])
log.write("Running TransTermHP.\n")
log.write("Make sure the version is at least 2.09.\n")
for file_ in os.listdir(self.combine_path):
if ".ptt" in file_:
prefix = file_.replace(".ptt", "")
fasta = self.helper.get_correct_file(
self.fasta_path, ".fa", prefix, None, None)
if not fasta:
log.write("{0}.fa can not be found!.\n".format(prefix))
print("Error: {0}.fa can not be found!".format(prefix))
sys.exit()
out_path = os.path.join(args_term.hp_folder, prefix)
self.helper.check_make_folder(out_path)
out = open(os.path.join(out_path,
"_".join([prefix, "terminators.txt"])), "w")
self._TransTermHP(fasta, file_, out_path,
prefix, out, args_term, log)
log.write("Done!\n")
log.write("The following files are generated in {0}.\n".format(
out_path))
for file_ in os.listdir(out_path):
log.write("\t" + file_ + "\n")
out.close()
shutil.rmtree(self.combine_path)
def _convert_to_gff(self, prefixs, args_term, log):
log.write("Running coverter.py to convert the results of TransTermHP "
"to gff3 format.\n")
for prefix in prefixs:
for folder in os.listdir(args_term.hp_folder):
if prefix == folder:
out_path = os.path.join(args_term.hp_folder, folder)
for file_ in os.listdir(out_path):
if file_.endswith(".bag"):
out_file = os.path.join(
self.tmps["transterm"],
"_".join([prefix, self.tmps["hp_gff"]]))
self.converter.convert_transtermhp2gff(
os.path.join(out_path, file_), out_file)
log.write("\t" + out_file + " is generated.\n")
self.multiparser.combine_gff(args_term.gffs, self.tmps["transterm"],
None, self.tmps["hp"])
def _combine_wigs(self, args_term):
if (args_term.tex_wigs is not None) and (
args_term.frag_wigs is not None):
folder = args_term.tex_wigs.split("/")
folder = "/".join(folder[:-1])
merge_wigs = os.path.join(folder, "merge_wigs")
self.helper.check_make_folder(merge_wigs)
for wig in os.listdir(args_term.tex_wigs):
if os.path.isdir(os.path.join(args_term.tex_wigs, wig)):
pass
else:
shutil.copy(os.path.join(args_term.tex_wigs, wig),
merge_wigs)
for wig in os.listdir(args_term.frag_wigs):
if os.path.isdir(os.path.join(args_term.frag_wigs, wig)):
pass
else:
shutil.copy(os.path.join(args_term.frag_wigs, wig),
merge_wigs)
elif (args_term.tex_wigs is not None):
merge_wigs = args_term.tex_wigs
elif (args_term.frag_wigs is not None):
merge_wigs = args_term.frag_wigs
else:
print("Error: Wiggle files are not assigned!")
sys.exit()
return merge_wigs
def _merge_sRNA(self, sRNAs, prefixs, gff_path):
'''searching the terminator with sRNA information'''
if sRNAs is not None:
self.multiparser.parser_gff(sRNAs, "sRNA")
self.helper.check_make_folder(self.tmps["merge"])
for prefix in prefixs:
tmp_gff = os.path.join(self.tmps["merge"], self.tmps["gff"])
if self.tmps["gff"] in os.listdir(self.tmps["merge"]):
os.remove(tmp_gff)
self.helper.merge_file(os.path.join(gff_path, prefix + ".gff"),
tmp_gff)
self.helper.merge_file(os.path.join(
self.srna_path, "_".join([prefix, "sRNA.gff"])), tmp_gff)
self.helper.sort_gff(tmp_gff, os.path.join(
self.tmps["merge"], prefix + ".gff"))
os.remove(tmp_gff)
merge_path = self.tmps["merge"]
else:
merge_path = gff_path
return merge_path
def _move_file(self, term_outfolder, csv_outfolder):
for gff in os.listdir(term_outfolder):
if gff.endswith("_term.gff"):
self.helper.sort_gff(os.path.join(term_outfolder, gff),
self.tmps["gff"])
shutil.move(self.tmps["gff"],
os.path.join(term_outfolder, gff))
prefix = gff.replace("_term.gff", "")
new_gff = os.path.join(self.terms["all"], "_".join([
prefix, self.suffixs["allgff"]]))
csv_file = os.path.join(
os.path.join(self.csvs["all"], "_".join([
prefix, self.suffixs["csv"]])))
out = open(new_gff, "w")
out.write("##gff-version 3\n")
out.close()
self.helper.merge_file(
os.path.join(term_outfolder, gff),
os.path.join(
self.terms["all"], "_".join([
prefix, self.suffixs["allgff"]])))
os.remove(os.path.join(term_outfolder, gff))
pre_strain = ""
if ("_".join([prefix, self.suffixs["csv"]]) in
os.listdir(self.csvs["all"])):
os.remove(csv_file)
out_csv = open(csv_file, "w")
out_csv.write("\t".join(["Genome", "Name", "Start", "End",
"Strand", "Detect", "Coverage_decrease",
"Coverage_detail"]) + "\n")
out_csv.close()
fh = open(new_gff)
for entry in self.gff_parser.entries(fh):
if entry.seq_id != pre_strain:
self.helper.merge_file(os.path.join(
self.tmps["term_table"], "_".join([
entry.seq_id, "term_raw.csv"])),
os.path.join(self.csvs["all"], "_".join([
prefix, self.suffixs["csv"]])))
pre_strain = entry.seq_id
fh.close()
def _run_rnafold(self, RNAfold_path, tmp_seq, tmp_sec, prefix, log):
log.write("Computing secondray structures of {0}.\n".format(prefix))
log.write("Make sure the version of Vienna RNA package is at least 2.3.2.\n")
print("Computing secondray structures of {0}".format(prefix))
self.helper.check_make_folder(self.tmps["folder"])
pre_cwd = os.getcwd()
os.chdir(self.tmps["folder"])
log.write(" ".join([RNAfold_path, "<", os.path.join("..", tmp_seq),
">", os.path.join("..", tmp_sec)]) + "\n")
os.system(" ".join([RNAfold_path, "<", os.path.join("..", tmp_seq),
">", os.path.join("..", tmp_sec)]))
log.write("Done!\n")
log.write("\t" + tmp_sec + " is generated for storing secondary "
"structure.\n")
os.chdir(pre_cwd)
shutil.rmtree(self.tmps["folder"])
def _compute_intersection_forward_reverse(
self, prefixs, merge_path, wig_path, merge_wigs, args_term, log):
'''the approach for searching gene converged region terminator'''
log.write("Searching terminators which located in gene converged "
"region.\n")
for prefix in prefixs:
tmp_seq = os.path.join(args_term.out_folder,
"_".join(["inter_seq", prefix]))
tmp_index = os.path.join(args_term.out_folder,
"_".join(["inter_index", prefix]))
tmp_sec = os.path.join(args_term.out_folder,
"_".join(["inter_sec", prefix]))
tran_file = os.path.join(self.tran_path,
"_".join([prefix, "transcript.gff"]))
gff_file = os.path.join(merge_path, prefix + ".gff")
tmp_cand = tmp_cand = os.path.join(args_term.out_folder,
"_".join(["term_candidates", prefix]))
if os.path.exists(tran_file):
print("Extracting sequences of {0}".format(prefix))
log.write("Running get_inter_seq.py to extract the potential "
"sequences from {0}.\n".format(prefix))
intergenic_seq(os.path.join(self.fasta_path, prefix + ".fa"),
tran_file, gff_file, tmp_seq, tmp_index, args_term)
log.write("\t" + tmp_seq + " is generated for storing the "
"potential sequences.\n")
self._run_rnafold(args_term.RNAfold_path, tmp_seq, tmp_sec,
prefix, log)
log.write("Running extract_sec_info.py to extract the "
"information of secondary structure from {0}.\n".format(
prefix))
extract_info_sec(tmp_sec, tmp_seq, tmp_index)
os.remove(tmp_index)
log.write("Running get_polyT.py to detect the "
"terminator candidates for {0}.\n".format(prefix))
poly_t(tmp_seq, tmp_sec, gff_file, tran_file, tmp_cand, args_term)
log.write("\t" + tmp_cand + " which temporary stores terminator "
"candidates is generated.\n")
print("Detecting terminators for " + prefix)
log.write("Running detect_coverage_term.py to gain "
"high-confidence terminators for {0}.\n".format(prefix))
detect_coverage(
tmp_cand, os.path.join(merge_path, prefix + ".gff"),
os.path.join(self.tran_path, "_".join([
prefix, "transcript.gff"])),
os.path.join(self.fasta_path, prefix + ".fa"),
os.path.join(wig_path, "_".join([prefix, "forward.wig"])),
os.path.join(wig_path, "_".join([prefix, "reverse.wig"])),
os.path.join(self.tmps["hp_path"], "_".join([
prefix, self.tmps["hp_gff"]])), merge_wigs,
os.path.join(self.outfolder["term"], "_".join([
prefix, self.suffixs["gff"]])),
os.path.join(self.tmps["term_table"], "_".join([
prefix, "term_raw.csv"])), args_term)
self.multiparser.combine_gff(args_term.gffs, self.outfolder["term"],
None, "term")
self._move_file(self.outfolder["term"], self.outfolder["csv"])
def _remove_tmp_file(self, merge_wigs, args_term):
self.helper.remove_tmp_dir(args_term.gffs)
self.helper.remove_tmp_dir(args_term.fastas)
if args_term.srnas is not None:
self.helper.remove_tmp(args_term.srnas)
shutil.rmtree(self.tmps["merge"])
if (args_term.tex_wigs is not None) and (
args_term.frag_wigs is not None):
shutil.rmtree(merge_wigs)
self.helper.remove_tmp_dir(args_term.trans)
if "tmp_wig" in os.listdir(args_term.out_folder):
shutil.rmtree(os.path.join(args_term.out_folder, "tmp_wig"))
self.helper.remove_tmp(self.outfolder["term"])
shutil.rmtree(self.tmps["transterm"])
shutil.rmtree(self.tmps["term_table"])
self.helper.remove_all_content(args_term.out_folder,
"inter_seq_", "file")
self.helper.remove_all_content(self.outfolder["term"],
"_term.gff", "file")
self.helper.remove_all_content(args_term.out_folder,
"inter_sec_", "file")
self.helper.remove_all_content(args_term.out_folder,
"term_candidates_", "file")
def _compute_stat(self, args_term, log):
new_prefixs = []
for gff in os.listdir(self.terms["all"]):
if gff.endswith("_term_all.gff"):
out_tmp = open(self.tmps["gff"], "w")
out_tmp.write("##gff-version 3\n")
new_prefix = gff.replace("_term_all.gff", "")
new_prefixs.append(gff.replace("_term_all.gff", ""))
num = 0
fh = open(os.path.join(self.terms["all"], gff))
for entry in self.gff_parser.entries(fh):
name = '%0*d' % (5, num)
entry.attributes["ID"] = (
entry.seq_id + "_terminator" + str(num))
entry.attributes["Name"] = "_".join(["terminator_" + name])
entry.attribute_string = ";".join([
"=".join(items) for items in entry.attributes.items()])
out_tmp.write("\t".join([entry.info_without_attributes,
entry.attribute_string]) + "\n")
num += 1
out_tmp.close()
fh.close()
shutil.move(self.tmps["gff"], os.path.join(self.terms["all"],
"_".join([new_prefix, self.suffixs["gff"]])))
log.write("Running stat_term.py to do statistics.\n")
stat_path = os.path.join(args_term.out_folder, "statistics")
log.write("The following files are generated:\n")
for prefix in new_prefixs:
stat_term(os.path.join(self.terms["all"],
"_".join([prefix, self.suffixs["gff"]])),
os.path.join(self.csvs["all"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(stat_path,
"_".join(["stat", prefix + ".csv"])),
os.path.join(self.terms["best"],
"_".join([prefix, "term"])),
os.path.join(self.terms["express"],
"_".join([prefix, "term"])),
os.path.join(self.terms["non"],
"_".join([prefix, "term"])))
shutil.move(os.path.join(self.terms["best"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(self.csvs["best"],
"_".join([prefix, self.suffixs["csv"]])))
shutil.move(os.path.join(self.terms["express"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(self.csvs["express"],
"_".join([prefix, self.suffixs["csv"]])))
shutil.move(os.path.join(self.terms["non"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(self.csvs["non"],
"_".join([prefix, self.suffixs["csv"]])))
os.remove(os.path.join(self.terms["all"],
"_".join([prefix, self.suffixs["allgff"]])))
log.write("\t" + os.path.join(self.terms["all"],
"_".join([prefix, self.suffixs["gff"]])) + "\n")
log.write("\t" + os.path.join(self.terms["best"],
"_".join([prefix, self.suffixs["gff"]])) + "\n")
log.write("\t" + os.path.join(self.terms["express"],
"_".join([prefix, self.suffixs["gff"]])) + "\n")
log.write("\t" + os.path.join(self.terms["non"],
"_".join([prefix, self.suffixs["gff"]])) + "\n")
log.write("\t" + os.path.join(self.csvs["all"],
"_".join([prefix, self.suffixs["csv"]])) + "\n")
log.write("\t" + os.path.join(stat_path,
"_".join(["stat", prefix + ".csv"])) + "\n")
log.write("\t" + os.path.join(self.csvs["best"],
"_".join([prefix, self.suffixs["csv"]])) + "\n")
log.write("\t" + os.path.join(self.csvs["express"],
"_".join([prefix, self.suffixs["csv"]])) + "\n")
log.write("\t" + os.path.join(self.csvs["non"],
"_".join([prefix, self.suffixs["csv"]])) + "\n")
def _check_gff_file(self, folder):
for file_ in os.listdir(folder):
if file_.endswith(".gff"):
self.helper.check_uni_attributes(os.path.join(folder, file_))
def _compare_term_tran(self, args_term, prefixs, log):
'''searching the associated terminator to transcript'''
self.multiparser.combine_gff(args_term.gffs, self.tran_path,
None, "transcript")
prefixs = []
print("Comparing terminators with transcripts now")
for file_ in os.listdir(self.tran_path):
if file_.endswith("_transcript.gff"):
prefixs.append(file_.replace("_transcript.gff", ""))
log.write("Running compare_tran_term.py for comparing transcripts "
"and terminators.\n")
log.write("The following files are generated:\n")
for type_ in ("best_candidates", "expressed_candidates",
"all_candidates"):
compare_term_tran(self.tran_path,
os.path.join(self.outfolder["term"], type_),
args_term.fuzzy_up_ta, args_term.fuzzy_down_ta,
args_term.out_folder, "terminator",
self.outfolder["term"], args_term.trans)
for prefix in prefixs:
shutil.move(
os.path.join(
args_term.out_folder, "statistics",
"stat_compare_transcript_terminator_" + prefix + ".csv"),
os.path.join(
args_term.out_folder, "statistics",
"_".join(["stat_compare_terminator_transcript", prefix,
type_ + ".csv"])))
log.write("\t" + os.path.join(
args_term.out_folder, "statistics",
"_".join(["stat_compare_terminator_transcript", prefix,
type_ + ".csv"])) + "\n")
def _re_table(self, args_term, prefixs, log):
log.write("Running re_table.py to generate coverage information.\n")
log.write("The following files are updated:\n")
for type_ in ["all_candidates", "best_candidates",
"expressed_candidates", "non_expressed_candidates"]:
for table in os.listdir(os.path.join(
args_term.out_folder, "tables", type_)):
term_table = os.path.join(args_term.out_folder, "tables",
type_, table)
reorganize_table(args_term.libs, args_term.merge_wigs,
"Coverage_detail", term_table)
log.write("\t" + term_table + "\n")
def run_terminator(self, args_term, log):
self._check_gff_file(args_term.gffs)
self._check_gff_file(args_term.trans)
self.multiparser.parser_fasta(args_term.fastas)
if (not args_term.gffs) or (not args_term.fastas):
print("Error: Please assign gff files "
"and fasta files!")
sys.exit()
file_types, prefixs = self._convert_gff2rntptt(
self.gff_path, self.fasta_path, args_term.srnas, log)
check = self._combine_ptt_rnt(self.gff_path, file_types,
self.srna_path)
self._run_TransTermHP(args_term, log)
self._convert_to_gff(prefixs, args_term, log)
self.helper.remove_tmp(self.gff_path)
self.multiparser.parser_gff(args_term.trans, "transcript")
self.helper.check_make_folder(self.tmps["term_table"])
if check != "NO_CDS":
self.multiparser.parser_gff(self.tmps["transterm"],
self.tmps["hp"])
merge_path = self._merge_sRNA(args_term.srnas, prefixs, self.gff_path)
self._compute_intersection_forward_reverse(
prefixs, merge_path, args_term.wig_path,
args_term.merge_wigs, args_term, log)
self._compute_stat(args_term, log)
self._compare_term_tran(args_term, prefixs, log)
self._re_table(args_term, prefixs, log)
self._remove_tmp_file(args_term.merge_wigs, args_term)
class Terminator(object):
def __init__(self, args_term):
self.multiparser = Multiparser()
self.helper = Helper()
self.converter = Converter()
self.gff_parser = Gff3Parser()
self.gff_path = os.path.join(args_term.gffs, "tmp")
self.fasta_path = os.path.join(args_term.fastas, "tmp")
self.tran_path = os.path.join(args_term.trans, "tmp")
self.outfolder = {"term": os.path.join(args_term.out_folder, "gffs"),
"csv": os.path.join(args_term.out_folder, "tables")}
self.terms = {"all": os.path.join(self.outfolder["term"],
"all_candidates"),
"express": os.path.join(self.outfolder["term"],
"express"),
"best": os.path.join(self.outfolder["term"], "best"),
"non": os.path.join(self.outfolder["term"],
"non_express")}
self.csvs = {"all": os.path.join(self.outfolder["csv"],
"all_candidates"),
"express": os.path.join(self.outfolder["csv"], "express"),
"best": os.path.join(self.outfolder["csv"], "best"),
"non": os.path.join(self.outfolder["csv"], "non_express")}
self.combine_path = os.path.join(self.gff_path, "combine")
self.tmps = {"transterm": os.path.join(os.getcwd(), "tmp_transterm"),
"hp": "transtermhp", "hp_gff": "transtermhp.gff",
"hp_path": "tmp_transterm/tmp",
"term_table": os.path.join(os.getcwd(), "tmp_term_table"),
"merge": os.path.join(os.getcwd(), "tmp_merge_gff"),
"gff": "tmp.gff",
"folder": os.path.join(os.getcwd(), "tmp")}
self.suffixs = {"gff": "term.gff", "csv": "term.csv",
"allgff": "term_all.gff"}
if args_term.srnas:
self.srna_path = os.path.join(args_term.srnas, "tmp")
else:
self.srna_path = None
self._make_gff_folder()
def _combine_annotation(self, combine_file, files):
with open(combine_file, 'w') as result:
for file_ in files:
check_start = False
fh = open(file_, 'r')
for line in fh:
if check_start:
result.write(line)
if "Location" in line:
check_start = True
if "\n" not in line:
result.write("\n")
fh.close()
def _make_gff_folder(self):
self.helper.check_make_folder(self.terms["all"])
self.helper.check_make_folder(self.csvs["all"])
self.helper.check_make_folder(self.terms["best"])
self.helper.check_make_folder(self.csvs["best"])
self.helper.check_make_folder(self.terms["express"])
self.helper.check_make_folder(self.csvs["express"])
self.helper.check_make_folder(self.terms["non"])
self.helper.check_make_folder(self.csvs["non"])
def _convert_gff2rntptt(self, gff_path, fasta_path, sRNAs):
file_types = {}
prefixs = []
for gff in os.listdir(gff_path):
if gff.endswith(".gff"):
filename = gff.split("/")
prefix = filename[-1][:-4]
prefixs.append(prefix)
gff_file = os.path.join(gff_path, gff)
rnt_file = os.path.join(gff_path, gff.replace(".gff", ".rnt"))
ptt_file = os.path.join(gff_path, gff.replace(".gff", ".ptt"))
fasta = self.helper.get_correct_file(
fasta_path, ".fa", prefix, None, None)
if not fasta:
print("Error: no proper file - {0}.fa".format(prefix))
sys.exit()
if sRNAs:
self.multiparser.parser_gff(sRNAs, "sRNA")
srna = self.helper.get_correct_file(
self.srna_path, "_sRNA.gff", prefix, None, None)
if (srna) and (fasta):
self.converter.convert_gff2rntptt(
gff_file, fasta, ptt_file, rnt_file, srna,
srna.replace(".gff", ".rnt"))
file_types[prefix] = "srna"
if (not srna) and (fasta):
self.converter.convert_gff2rntptt(
gff_file, fasta, ptt_file, rnt_file, None, None)
file_types[prefix] = "normal"
else:
self.converter.convert_gff2rntptt(
gff_file, fasta, ptt_file, rnt_file, None, None)
file_types[prefix] = "normal"
return file_types, prefixs
def _combine_ptt_rnt(self, gff_path, file_types, srna_path):
self.helper.check_make_folder(self.combine_path)
for prefix, file_type in file_types.items():
combine_file = os.path.join(self.combine_path, prefix + '.ptt')
if file_type == "normal":
files = [os.path.join(gff_path, prefix + ".ptt"),
os.path.join(gff_path, prefix + ".rnt")]
self._combine_annotation(combine_file, files)
elif file_type == "srna":
files = [os.path.join(gff_path, prefix + ".ptt"),
os.path.join(gff_path, prefix + ".rnt"),
os.path.join(srna_path,
"_".join([prefix, "sRNA.rnt"]))]
self._combine_annotation(combine_file, files)
def _TransTermHP(self, fasta, file_, out_path, prefix, out, args_term):
call([args_term.TransTermHP_path, "-p", args_term.expterm_path,
fasta, os.path.join(self.combine_path, file_), "--t2t-perf",
os.path.join(out_path, "_".join([
prefix,
"terminators_within_robust_tail-to-tail_regions.t2t"])),
"--bag-output", os.path.join(out_path, "_".join([
prefix, "best_terminator_after_gene.bag"]))],
stdout=out)
def _run_TransTermHP(self, args_term):
self.helper.check_make_folder(self.tmps["transterm"])
for file_ in os.listdir(self.combine_path):
if ".ptt" in file_:
prefix = file_.replace(".ptt", "")
fasta = self.helper.get_correct_file(
self.fasta_path, ".fa", prefix, None, None)
if not fasta:
print("Error: no proper file - {0}.fa".format(prefix))
sys.exit()
out_path = os.path.join(args_term.hp_folder, prefix)
self.helper.check_make_folder(out_path)
out = open(os.path.join(out_path,
"_".join([prefix, "terminators.txt"])), "w")
self._TransTermHP(fasta, file_, out_path,
prefix, out, args_term)
out.close()
shutil.rmtree(self.combine_path)
def _convert_to_gff(self, prefixs, args_term):
for prefix in prefixs:
for folder in os.listdir(args_term.hp_folder):
if prefix == folder:
out_path = os.path.join(args_term.hp_folder, folder)
for file_ in os.listdir(out_path):
if file_.endswith(".bag"):
out_file = os.path.join(
self.tmps["transterm"],
"_".join([prefix, self.tmps["hp_gff"]]))
self.converter.convert_transtermhp2gff(
os.path.join(out_path, file_), out_file)
self.multiparser.combine_gff(args_term.gffs, self.tmps["transterm"],
None, self.tmps["hp"])
def _combine_wigs(self, args_term):
if (args_term.tex_wigs is not None) and (
args_term.frag_wigs is not None):
folder = args_term.tex_wigs.split("/")
folder = "/".join(folder[:-1])
merge_wigs = os.path.join(folder, "merge_wigs")
self.helper.check_make_folder(merge_wigs)
for wig in os.listdir(args_term.tex_wigs):
if os.path.isdir(os.path.join(args_term.tex_wigs, wig)):
pass
else:
shutil.copy(os.path.join(args_term.tex_wigs, wig),
merge_wigs)
for wig in os.listdir(args_term.frag_wigs):
if os.path.isdir(os.path.join(args_term.frag_wigs, wig)):
pass
else:
shutil.copy(os.path.join(args_term.frag_wigs, wig),
merge_wigs)
elif (args_term.tex_wigs is not None):
merge_wigs = args_term.tex_wigs
elif (args_term.frag_wigs is not None):
merge_wigs = args_term.frag_wigs
else:
print("Error: no proper wig files!!!")
sys.exit()
return merge_wigs
def _merge_sRNA(self, sRNAs, prefixs, gff_path):
if sRNAs is not None:
self.multiparser.parser_gff(sRNAs, "sRNA")
self.helper.check_make_folder(self.tmps["merge"])
for prefix in prefixs:
tmp_gff = os.path.join(self.tmps["merge"], self.tmps["gff"])
if self.tmps["gff"] in os.listdir(self.tmps["merge"]):
os.remove(tmp_gff)
self.helper.merge_file(os.path.join(gff_path, prefix + ".gff"),
tmp_gff)
self.helper.merge_file(os.path.join(
self.srna_path, "_".join([prefix, "sRNA.gff"])), tmp_gff)
self.helper.sort_gff(tmp_gff, os.path.join(
self.tmps["merge"], prefix + ".gff"))
os.remove(tmp_gff)
merge_path = self.tmps["merge"]
else:
merge_path = gff_path
return merge_path
def _move_file(self, term_outfolder, csv_outfolder):
for gff in os.listdir(term_outfolder):
if gff.endswith("_term.gff"):
self.helper.sort_gff(os.path.join(term_outfolder, gff),
self.tmps["gff"])
shutil.move(self.tmps["gff"],
os.path.join(term_outfolder, gff))
prefix = gff.replace("_term.gff", "")
new_gff = os.path.join(self.terms["all"], "_".join([
prefix, self.suffixs["allgff"]]))
csv_file = os.path.join(
os.path.join(self.csvs["all"], "_".join([
prefix, self.suffixs["csv"]])))
out = open(new_gff, "w")
out.write("##gff-version 3\n")
out.close()
self.helper.merge_file(
os.path.join(term_outfolder, gff),
os.path.join(
self.terms["all"], "_".join([
prefix, self.suffixs["allgff"]])))
os.remove(os.path.join(term_outfolder, gff))
pre_strain = ""
if ("_".join([prefix, self.suffixs["csv"]]) in
os.listdir(self.csvs["all"])):
os.remove(csv_file)
out_csv = open(csv_file, "w")
out_csv.write("\t".join(["strain", "name", "start", "end",
"strand", "detect", "coverage_detail"]) + "\n")
out_csv.close()
fh = open(new_gff)
for entry in self.gff_parser.entries(fh):
if entry.seq_id != pre_strain:
self.helper.merge_file(os.path.join(
self.tmps["term_table"], "_".join([
entry.seq_id, "term_raw.csv"])),
os.path.join(self.csvs["all"], "_".join([
prefix, self.suffixs["csv"]])))
pre_strain = entry.seq_id
fh.close()
def _run_rnafold(self, RNAfold_path, tmp_seq, tmp_sec, prefix):
print("Computing secondray structure of {0}".format(prefix))
self.helper.check_make_folder(self.tmps["folder"])
pre_cwd = os.getcwd()
os.chdir(self.tmps["folder"])
os.system(" ".join([RNAfold_path, "<", os.path.join("..", tmp_seq),
">", os.path.join("..", tmp_sec)]))
os.chdir(pre_cwd)
shutil.rmtree(self.tmps["folder"])
def _compute_intersection_forward_reverse(
self, prefixs, merge_path, wig_path, merge_wigs, args_term):
for prefix in prefixs:
tmp_seq = os.path.join(args_term.out_folder,
"_".join(["inter_seq", prefix]))
tmp_sec = os.path.join(args_term.out_folder,
"_".join(["inter_sec", prefix]))
tran_file = os.path.join(self.tran_path,
"_".join([prefix, "transcript.gff"]))
gff_file = os.path.join(merge_path, prefix + ".gff")
print("Extracting seq of {0}".format(prefix))
intergenic_seq(os.path.join(self.fasta_path, prefix + ".fa"),
tran_file, gff_file, tmp_seq)
self._run_rnafold(args_term.RNAfold_path, tmp_seq, tmp_sec, prefix)
tmp_cand = os.path.join(args_term.out_folder,
"_".join(["term_candidates", prefix]))
poly_t(tmp_seq, tmp_sec, gff_file, tran_file, tmp_cand, args_term)
print("detection of terminator")
detect_coverage(
tmp_cand, os.path.join(merge_path, prefix + ".gff"),
os.path.join(self.tran_path, "_".join([
prefix, "transcript.gff"])),
os.path.join(self.fasta_path, prefix + ".fa"),
os.path.join(wig_path, "_".join([prefix, "forward.wig"])),
os.path.join(wig_path, "_".join([prefix, "reverse.wig"])),
os.path.join(self.tmps["hp_path"], "_".join([
prefix, self.tmps["hp_gff"]])), merge_wigs,
os.path.join(self.outfolder["term"], "_".join([
prefix, self.suffixs["gff"]])),
os.path.join(self.tmps["term_table"], "_".join([
prefix, "term_raw.csv"])), args_term)
self.multiparser.combine_gff(args_term.gffs, self.outfolder["term"],
None, "term")
self._move_file(self.outfolder["term"], self.outfolder["csv"])
def _remove_tmp_file(self, merge_wigs, args_term):
self.helper.remove_tmp(args_term.gffs)
self.helper.remove_tmp(args_term.fastas)
if args_term.srnas is not None:
self.helper.remove_tmp(args_term.srnas)
shutil.rmtree(self.tmps["merge"])
if (args_term.tex_wigs is not None) and (
args_term.frag_wigs is not None):
shutil.rmtree(merge_wigs)
self.helper.remove_tmp(args_term.trans)
self.helper.remove_tmp(args_term.tex_wigs)
self.helper.remove_tmp(args_term.frag_wigs)
self.helper.remove_tmp(self.outfolder["term"])
shutil.rmtree(self.tmps["transterm"])
shutil.rmtree(self.tmps["term_table"])
self.helper.remove_all_content(args_term.out_folder,
"inter_seq_", "file")
self.helper.remove_all_content(args_term.out_folder,
"inter_sec_", "file")
self.helper.remove_all_content(args_term.out_folder,
"term_candidates_", "file")
def _compute_stat(self, args_term):
new_prefixs = []
for gff in os.listdir(self.terms["all"]):
if gff.endswith("_term_all.gff"):
out_tmp = open(self.tmps["gff"], "w")
out_tmp.write("##gff-version 3\n")
new_prefix = gff.replace("_term_all.gff", "")
new_prefixs.append(gff.replace("_term_all.gff", ""))
num = 0
fh = open(os.path.join(self.terms["all"], gff))
for entry in self.gff_parser.entries(fh):
name = '%0*d' % (5, num)
entry.attributes["ID"] = "term" + str(num)
entry.attributes["Name"] = "_".join(["Terminator_" + name])
entry.attribute_string = ";".join([
"=".join(items) for items in entry.attributes.items()])
out_tmp.write("\t".join([entry.info_without_attributes,
entry.attribute_string]) + "\n")
num += 1
out_tmp.close()
fh.close()
shutil.move(self.tmps["gff"], os.path.join(self.terms["all"],
"_".join([new_prefix, self.suffixs["gff"]])))
if args_term.stat:
stat_path = os.path.join(args_term.out_folder, "statistics")
for prefix in new_prefixs:
stat_term(os.path.join(self.terms["all"],
"_".join([prefix, self.suffixs["gff"]])),
os.path.join(self.csvs["all"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(stat_path,
"_".join(["stat", prefix + ".csv"])),
os.path.join(self.terms["best"],
"_".join([prefix, "term"])),
os.path.join(self.terms["express"],
"_".join([prefix, "term"])),
os.path.join(self.terms["non"],
"_".join([prefix, "term"])))
shutil.move(os.path.join(self.terms["best"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(self.csvs["best"],
"_".join([prefix, self.suffixs["csv"]])))
shutil.move(os.path.join(self.terms["express"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(self.csvs["express"],
"_".join([prefix, self.suffixs["csv"]])))
shutil.move(os.path.join(self.terms["non"],
"_".join([prefix, self.suffixs["csv"]])),
os.path.join(self.csvs["non"],
"_".join([prefix, self.suffixs["csv"]])))
os.remove(os.path.join(self.terms["all"],
"_".join([prefix, self.suffixs["allgff"]])))
def _check_gff_file(self, folder):
for file_ in os.listdir(folder):
if file_.endswith(".gff"):
self.helper.check_uni_attributes(os.path.join(folder, file_))
def _compare_term_tran(self, args_term):
self.multiparser.combine_gff(args_term.gffs, self.tran_path,
None, "transcript")
for type_ in ("best", "express", "all_candidates"):
compare_term_tran(self.tran_path,
os.path.join(self.outfolder["term"], type_),
args_term.fuzzy_up_ta, args_term.fuzzy_down_ta,
args_term.out_folder, "terminator")
shutil.move(
os.path.join(
args_term.out_folder, "statistics",
"stat_comparison_terminator_transcript.csv"),
os.path.join(
args_term.out_folder, "statistics",
"stat_comparison_terminator_transcript_" + type_ + ".csv"))
def run_terminator(self, args_term):
self._check_gff_file(args_term.gffs)
self._check_gff_file(args_term.trans)
self.multiparser.parser_fasta(args_term.fastas)
if (not args_term.gffs) or (not args_term.fastas):
print("Error: please assign gff annotation folder "
"and fasta folder!!!")
sys.exit()
file_types, prefixs = self._convert_gff2rntptt(
self.gff_path, self.fasta_path, args_term.srnas)
self._combine_ptt_rnt(self.gff_path, file_types, self.srna_path)
self._run_TransTermHP(args_term)
self._convert_to_gff(prefixs, args_term)
self.helper.remove_tmp(self.gff_path)
self.multiparser.parser_gff(args_term.trans, "transcript")
self.helper.check_make_folder(self.tmps["term_table"])
self.multiparser.parser_gff(self.tmps["transterm"], self.tmps["hp"])
merge_path = self._merge_sRNA(args_term.srnas, prefixs, self.gff_path)
self._compute_intersection_forward_reverse(
prefixs, merge_path, args_term.wig_path,
args_term.merge_wigs, args_term)
self._compute_stat(args_term)
self._compare_term_tran(args_term)
self._remove_tmp_file(args_term.merge_wigs, args_term)
class TestConverter(unittest.TestCase):
def setUp(self):
self.converter = Converter()
self.example = Example()
self.converter.gff3parser = Mock_gff3_parser
self.converter._print_rntptt_title = Mock_func().print_rntptt_title
self.converter.tsspredator = Mock_TSSPredatorReader()
self.converter._read_file = Mock_func().mock_read_file
self.gff_file = self.example.gff_file
self.ptt_out = self.example.ptt_out
self.rnt_out = self.example.rnt_out
self.srna_out = self.example.srna_out
self.embl_file = self.example.embl_file
self.embl_out = self.example.embl_out
self.multi_embl = self.example.multi_embl
self.gff_out = self.example.gff_out
self.mastertable = self.example.mastertable
self.tss_file = self.example.tss_file
self.fasta_file = self.example.fasta_file
self.transterm = self.example.transterm
self.term_file = self.example.term_file
self.circ_file = self.example.circrna_table
self.circ_all = self.example.circrna_all
self.circ_best = self.example.circrna_best
self.test_folder = "test_folder"
self.mock_args = MockClass()
if (not os.path.exists(self.test_folder)):
os.mkdir(self.test_folder)
def tearDown(self):
if os.path.exists(self.test_folder):
shutil.rmtree(self.test_folder)
def test_print_rntptt_file(self):
cdss = []
genes = []
rnas = []
gff_dict = Example().gff_dict
for gff in gff_dict:
if gff["feature"] == "gene":
genes.append(self.converter.gff3parser.entries(self, gff))
elif gff["feature"] == "CDS":
cdss.append(self.converter.gff3parser.entries(self, gff))
elif gff["feature"] == "tRNA":
rnas.append(self.converter.gff3parser.entries(self, gff))
out_p = StringIO()
out_r = StringIO()
self.converter._print_rntptt_file(out_p, cdss, genes)
self.converter._print_rntptt_file(out_r, rnas, genes)
self.assertEqual(out_p.getvalue().split("\n")[:-1],
self.example.ptt_out_list)
self.assertEqual(out_r.getvalue().split("\n")[:-1],
self.example.rnt_out_list)
out_p.close()
out_r.close()
def test_srna2pttrnt(self):
srna_input_file = os.path.join(self.test_folder, "srna.gff")
srna_output_file = os.path.join(self.test_folder, "srna.out")
with open(srna_input_file, "w") as fh:
fh.write(self.gff_file)
srnas = []
self.converter._srna2rntptt(srna_input_file, srna_output_file,
srnas, 1234567)
datas = import_data(srna_output_file)
self.assertEqual(set(datas), set(self.srna_out.split("\n")))
def test_multi_embl_pos(self):
embls = []
for line in self.embl_file.split("\n"):
datas = self.converter._multi_embl_pos(line.strip())
if datas != "Wrong":
embls.append(datas)
for index in range(0, 7):
self.assertDictEqual(embls[index], self.embl_out[index])
for index in range(0, 2):
self.assertDictEqual(embls[-1]["pos"][index],
self.multi_embl[index])
def test_parser_embl_data(self):
embl_file = os.path.join(self.test_folder, "test.embl")
embl_out = os.path.join(self.test_folder, "test.embl_out")
out = StringIO()
with open(embl_file, "w") as eh:
for line in self.embl_file.split("\n"):
eh.write(line + "\n")
info = self.converter._parser_embl_data(embl_file, out)
datas = out.getvalue().split("\n")
self.assertEqual(set(datas[:-1]), set(self.gff_out.split("\n")))
self.assertEqual(info[0], "NC_007795.1")
for index in range(0, 2):
self.assertDictEqual(info[1]["pos"][index], self.multi_embl[index])
out.close()
def test_multi_tss_class(self):
nums = {"tss": 0, "tss_uni": 0, "class": 1}
utrs = {"total": [], "pri": [], "sec": []}
tss_features = {"tss_types": [], "locus_tags": [], "utr_lengths": []}
tss_index = defaultdict(lambda: 0)
master_file = os.path.join(self.test_folder, "test.tsv")
fh = StringIO(self.mastertable)
for tss in self.converter.tsspredator.entries(fh):
self.converter._multi_tss_class(
tss, tss_index, tss_features, nums, utrs)
fh.close()
self.assertDictEqual(nums, {'tss_uni': 0, 'class': 5, 'tss': 2})
def test_convert_mastertable2gff(self):
master_file = os.path.join(self.test_folder, "test.tsv")
with open(master_file, "w") as th:
th.write(self.mastertable)
out_gff = os.path.join(self.test_folder, "test.tsv_out")
self.converter.convert_mastertable2gff(master_file, "ANNOgesic", "TSS",
"aaa", out_gff)
datas = import_data(out_gff)
self.assertEqual(set(datas), set(self.tss_file.split("\n")))
def test_convert_gff2rntptt(self):
srna_input_file = os.path.join(self.test_folder, "srna.gff")
srna_output_file = os.path.join(self.test_folder, "srna.out")
gff_file = os.path.join(self.test_folder, "test.gff")
rnt_file = os.path.join(self.test_folder, "test.rnt")
ptt_file = os.path.join(self.test_folder, "test.ptt")
fasta_file = os.path.join(self.test_folder, "test.fa")
with open(srna_input_file, "w") as fh:
fh.write(self.gff_file)
with open(gff_file, "w") as fh:
fh.write(self.gff_file)
with open(fasta_file, "w") as fh:
fh.write(self.fasta_file)
self.converter.convert_gff2rntptt(
gff_file, fasta_file, ptt_file, rnt_file,
srna_input_file, srna_output_file)
self.assertTrue(srna_output_file)
self.assertTrue(rnt_file)
self.assertTrue(ptt_file)
def test_convert_embl2gff(self):
embl_file = os.path.join(self.test_folder, "test.embl")
gff_file = os.path.join(self.test_folder, "test.embl_out")
with open(embl_file, "w") as eh:
for line in self.embl_file.split("\n"):
eh.write(line + "\n")
self.converter.convert_embl2gff(embl_file, gff_file)
datas = import_data(gff_file)
self.assertEqual(set(datas[1:-2]), set(self.gff_out.split("\n")))
def test_convert_transtermhp2gff(self):
transterm_file = os.path.join(
self.test_folder, "test_best_terminator_after_gene.bag")
gff_file = os.path.join(self.test_folder, "transterm.gff")
with open(transterm_file, "w") as th:
th.write(self.transterm)
self.converter.convert_transtermhp2gff(transterm_file, gff_file)
datas = import_data(gff_file)
self.assertEqual(set(datas), set(self.term_file.split("\n")))
def get_info(datas):
f_datas = []
for data in datas:
if not data.startswith("#"):
f_datas.append("\t".join(data.split("\t")[:8]))
return f_datas
def test_convert_circ2gff(self):
circ_file = os.path.join(self.test_folder, "circ.csv")
out_all = os.path.join(self.test_folder, "all.gff")
out_filter = os.path.join(self.test_folder, "best.gff")
with open(circ_file, "w") as ch:
ch.write(self.circ_file)
args = self.mock_args.mock()
args.start_ratio = 0.5
args.end_ratio = 0.5
args.support = 5
self.converter.convert_circ2gff(circ_file, args, out_all, out_filter)
datas = import_data(out_all)
f_datas = []
for data in datas:
if not data.startswith("#"):
f_datas.append("\t".join(data.split("\t")[:8]))
c_datas = []
for data in self.circ_all.split("\n"):
if not data.startswith("#"):
c_datas.append("\t".join(data.split("\t")[:8]))
self.assertListEqual(f_datas, c_datas)
datas = import_data(out_filter)
f_datas = []
for data in datas:
if not data.startswith("#"):
f_datas.append("\t".join(data.split("\t")[:8]))
c_datas = []
for data in self.circ_best.split("\n"):
if not data.startswith("#"):
c_datas.append("\t".join(data.split("\t")[:8]))
self.assertListEqual(f_datas, c_datas)
