def control_dictionaries_creator():
"""
Create the control dictionary containing the values corresponding to the score of bp and ppt for every control exons
"""
exon_class.set_debug(0)
dir_path = os.path.dirname(os.path.realpath(__file__))
fasterdb = os.path.dirname(os.path.realpath(__file__)).replace(
"src/minimum_free_energy", "data/fasterDB_lite.db")
seddb = os.path.dirname(os.path.realpath(__file__)).replace(
"src/minimum_free_energy", "data/sed.db")
ctrl_dir = dir_path + "/control_dictionaries/"
cnx = sqlite3.connect(fasterdb)
cnx_sed = sqlite3.connect(seddb)
if not os.path.isdir(ctrl_dir):
os.mkdir(ctrl_dir)
exon_type = "CCE"
exon2remove = union_dataset_function.get_exon_regulated_by_sf(
cnx_sed, "down")
ctrl_exon_list = get_control_exon_information(cnx, exon_type, exon2remove)
print("retrieving upstream intron sequence")
list_exon = [
exon_class.ExonClass(cnx, exon[0], exon[1], exon[2])
for exon in ctrl_exon_list
]
print("calculating mfe")
mfe_list_3ss, mfe_list_5ss = function.mfe_calculator(list_exon)
cur_file = open(ctrl_dir + exon_type + "_mfe.py", "w")
cur_file.write("mfe_3ss=" + str(mfe_list_3ss) + "\n")
cur_file.write("mfe_5ss=" + str(mfe_list_5ss) + "\n")
cur_file.close()
def extract_exon_files(cnx, filename):
"""
:param cnx: (sqlite3 connect object) connection to fasterDB lite
:param filename: (string) the name of a file containing exons
:return: (list of Exonclass object) list of exons
"""
exon_list = []
with open(filename, "r") as outfile:
line = outfile.readline()
while line:
line = line.replace("\n", "")
line = line.split("\t")
exon = exon_class.ExonClass(cnx, str(line[0]), int(line[0]),
int(line[1]))
exon_list.append(exon)
line = outfile.readline()
return exon_list
def computing_mfe(cnx, df, output):
"""
Add a column mfe 5'ss to the existing dataframe.
:param cnx: (sqlite3 dataframe object) connection to fasterdb
:param df: (pandas dataframe) table of exons
:param output: (str) files were the mfe results will be created
:return: (pandas dataframe) table of exons with mfe data
"""
exon_class_list = []
exon_list = df[["gene_name", "gene_id", "pos"]].values
for exon in exon_list:
exon_class_list.append(
exon_class.ExonClass(cnx, exon[0], exon[1], exon[2]))
mfe_3ss, mfe_5ss = function.mfe_calculator(exon_class_list,
output,
ps=True)
df["mfe_5ss"] = mfe_5ss
return df
def control_dictionaries_creator():
"""
Create the control dictionary containing the values corresponding to the score of bp and ppt for every control exons
"""
exon_class.set_debug(0)
dir_path = os.path.dirname(os.path.realpath(__file__))
fasterdb = os.path.dirname(os.path.realpath(__file__)).replace(
"src", "data/fasterDB_lite.db")
seddb = os.path.dirname(os.path.realpath(__file__)).replace(
"src", "data/sed.db")
ctrl_dir = dir_path + "/control_dictionaries/"
cnx = sqlite3.connect(fasterdb)
cnx_sed = sqlite3.connect(seddb)
if not os.path.isdir(ctrl_dir):
os.mkdir(ctrl_dir)
exon_type = "CCE"
sizes = [100, 25, 50, 35]
exon2remove = union_dataset_function.get_exon_regulated_by_sf(
cnx_sed, "down")
ctrl_exon_list = get_control_exon_information(cnx, exon_type, exon2remove,
"down")
for size in sizes:
print("size : %s" % size)
print("retrieving upstream intron sequence")
list_exon = [
exon_class.ExonClass(cnx, exon[0], exon[1], exon[2])
for exon in ctrl_exon_list
]
print("calculating bp and ppt score")
bp_score_list, ppt_score_list, nb_bp_list, nb_good_bp_list, \
sequence_list, ag_count_list, hbound_list = function.bp_ppt_calculator(list_exon, size)
cur_file = open(
ctrl_dir + exon_type + "_" + str(size) + "_bp_ppt_score.py", "w")
cur_file.write("bp_score=" + str(bp_score_list) + "\n")
cur_file.write("ppt_score=" + str(ppt_score_list) + "\n")
cur_file.write("nb_bp=" + str(nb_bp_list) + "\n")
cur_file.write("nb_good_bp=" + str(nb_good_bp_list) + "\n")
cur_file.write("bp_seq=" + str(sequence_list) + "\n")
cur_file.write("ag_count=" + str(ag_count_list) + "\n")
cur_file.write("hbound=" + str(hbound_list) + "\n")
cur_file.close()
def extract_data(cnx, cnx_sed, list_files, list_names, pos):
"""
:param cnx: (sqlite3 connect object) connection to fasterDB lite
:param cnx_sed: (sqlite3 connect object) connection to sed
:param list_files: (list of string) list of files containing exon set
:param list_names: (list of string) the name of exon set
:param pos: (int) the position of interest within the list ``list_files`` and ``list_names``. \
Those 2 lists must hace the same lenght
:return: (list of ExonClass object) list of exon.
"""
if list_files:
exon_list = extract_exon_files(cnx, list_files[pos])
else:
exon_list_tmp = union_dataset_function.get_every_events_4_a_sl(
cnx_sed, list_names[pos], "down")
exon_list = [
exon_class.ExonClass(cnx, str(exon[0]), int(exon[0]), int(exon[1]))
for exon in exon_list_tmp
]
print("%s : %s exons" % (list_names[pos], len(exon_list)))
return exon_list
def get_exon_info(cnx, info_list, debug):
"""
Get every information we need on an exon
:param debug: (int) 0 no debug, 1 debug mode
:param cnx: (sqlite3 object) return all the information we need to connect to FasterDB lite
:param info_list: (list of list of string and int and int) each sublist contains \
a string : gene_symbol and 2 int : the gene_id and the exobn position on gene respectively
:return: (a list of ExonClass object) list of exons
"""
print("Getting exons information !")
exon_list = []
exon_class.set_debug(debug)
count = 0
ll = str(len(info_list))
for exon_info in info_list:
exon_list.append(exon_class.ExonClass(cnx, exon_info[0], exon_info[1], exon_info[2]))
count += 1
percent = round(float(count) / len(info_list) * 100, 1)
sys.stdout.write("Progression : " + str(count) + " / " + ll + " - " + str(percent) + " %\r")
sys.stdout.flush()
return exon_list
def handle_nb_bp_recovering(cnx, exon_list, output, sf_name, regulation, target):
"""
Recover nb bp for the exon list regulated by ``sf_name``
:param cnx: (sqlite3 connect object) connection to fasterDB database
:param exon_list: (list of 2 int) gene id + exon pos in gene
:param output: (string) folder where the result will be created
:param sf_name: (string) the name of the splicing factor studied
:param regulation: (string) regulation up or down
:param target: (string) the value we want to recover
:return: (list of int) the list of good quality branch point
"""
output_file = "%s%s_%s_%s_nt.py" % (output, sf_name, regulation, size_bp_up_seq)
if not os.path.isfile(output_file):
new_exon_list = [exon_class.ExonClass(cnx, str(exon[0]), int(exon[0]), int(exon[1])) for exon in exon_list]
bp_score_list, ppt_score_list, nb_bp_list, nb_good_bp_list, \
sequence_list, ag_count_list, hbound_list = function.bp_ppt_calculator(new_exon_list, size_bp_up_seq)
with open(output_file, "w") as bp_file:
bp_file.write("bp_score=%s\n" % str(bp_score_list))
bp_file.write("ppt_score=%s\n" % str(ppt_score_list))
bp_file.write("nb_bp=%s\n" % str(nb_bp_list))
bp_file.write("nb_good_bp=%s\n" % str(nb_good_bp_list))
bp_file.write("bp_seq=%s\n" % str(sequence_list))
bp_file.write("ag_count=%s\n" % str(ag_count_list))
bp_file.write("hbound=%s\n" % str(hbound_list))
else:
sys.path.insert(0, output)
mod = __import__(output_file.split("/")[-1].replace(".py", ""))
nb_good_bp_list = mod.nb_good_bp
hbound_list = mod.hbound
ag_count_list = mod.ag_count
if target == "nb_good_bp":
return nb_good_bp_list
elif target == "hbound":
return hbound_list
else:
return ag_count_list
def get_exon_info(cnx, sedb, fasterdb_file, exon_list, u1_exons, u2_exons):
"""
:param cnx: (sqlite3 connect object) connexion to fasterdb
:param fasterdb_file: (str) an sqlite3 database file
:param sedb: (str) path to sed database
:param exon_list: (list of 2 int) list of exons
:param u1_exons: (list of list of 2 int) list of exons regulated by U1
:param u2_exons: (list of list of 2 int) list of exons regulated by U2
:return: (list of list of value) list of data
"""
dic = {-1: "-", 1: "+"}
cursor = cnx.cursor()
cursor.execute("ATTACH DATABASE ? as sed", (sedb, ))
cursor.execute("ATTACH DATABASE ? as fasterdb", (fasterdb_file, ))
if exon_list is None:
query = """
SELECT t1.id_gene, t1.pos_on_gene, t1.chromosome,
t1.start_on_chromosome, t1.end_on_chromosome,
t2.strand, t3.iupac_exon, t3.upstream_intron_size,
t3.downstream_intron_size
FROM fasterdb.exons as t1, fasterdb.genes as t2, sed.sed as t3
WHERE t3.gene_id = t1.id_gene
AND t3.exon_pos = t1.pos_on_gene
AND t1.id_gene = t2.id
AND t3.exon_type LIKE '%CCE%'
"""
cursor.execute(query)
res = cursor.fetchall()
new_res = []
for exon in res:
exon = list(exon)
exon[3] = int(exon[3]) - 1
cexon = exon_class_bp.ExonClass(cnx, str(exon[0]), exon[0],
exon[1])
exon_data = bp_ppt_calculator([cexon])
mexon = exon_class.ExonClass(cnx, str(exon[0]), exon[0], exon[1])
mfe_5ss, mfe_3ss = mfe_calculator([mexon])
stretch = catch_index_error(stretch_counter([cexon])["T"], 0)
dic_info = {
"GC_content": exon[6].split(";")[4],
"upstream_intron_size": exon[7],
"downstream_intron_size": exon[8],
"UNA_count": catch_index_error(exon_data[8], 0),
"Hbound_count": catch_index_error(exon_data[6], 0),
"good_bp": catch_index_error(exon_data[3], 0),
"MFE_5SS": catch_index_error(mfe_5ss, 0),
"MFE_3SS": catch_index_error(mfe_3ss, 0),
"T_stretch": stretch,
"U1-regulated": is_in(exon[0:2], u1_exons),
"U2-regulated": is_in(exon[0:2], u2_exons),
}
new_res.append(exon[2:5] + ["%s_%s" % (exon[0], exon[1])] + \
["0", dic[exon[5]]] + [str(dic_info)])
return new_res
count = 0
tot = len(exon_list)
result = []
for exon in exon_list:
count += 1
query = """
SELECT t1.chromosome, t1.start_on_chromosome,
t1.end_on_chromosome, t2.strand, t3.iupac_exon,
t3.upstream_intron_size, t3.downstream_intron_size
FROM fasterdb.exons as t1, fasterdb.genes as t2, sed.sed as t3
WHERE t3.gene_id = t1.id_gene
AND t3.exon_pos = t1.pos_on_gene
AND t1.id_gene = t2.id
AND t3.gene_id = %s
AND t3.exon_pos = %s
""" % (exon[0], exon[1])
cursor.execute(query)
res = cursor.fetchall()
if len(res) > 1:
raise IndexError("Error only one row shoud be return for %s" %
exon)
tmp = list(res[0])
tmp[1] = int(tmp[1]) - 1
cexon = exon_class_bp.ExonClass(cnx, str(exon[0]), exon[0], exon[1])
exon_data = bp_ppt_calculator([cexon])
mexon = exon_class.ExonClass(cnx, str(exon[0]), exon[0], exon[1])
mfe_5ss, mfe_3ss = mfe_calculator([mexon])
stretch = catch_index_error(stretch_counter([cexon])["T"], 0)
dic_info = {
"GC_content": tmp[4].split(";")[4],
"upstream_intron_size": tmp[5],
"downstream_intron_size": tmp[6],
"UNA_count": catch_index_error(exon_data[8], 0),
"Hbound_count": catch_index_error(exon_data[6], 0),
"good_bp": catch_index_error(exon_data[3], 0),
"MFE_5SS": catch_index_error(mfe_5ss, 0),
"MFE_3SS": catch_index_error(mfe_3ss, 0),
"T_stretch": stretch,
"U1-regulated": is_in(exon[0:2], u1_exons),
"U2-regulated": is_in(exon[0:2], u2_exons),
}
exon_data = tmp[0:3] + ["%s_%s" % (exon[0], exon[1])] + \
["0", dic[tmp[3]]] + [str(dic_info)]
result.append(exon_data)
sys.stdout.write("Processing %s/%s\t\t\t\r" % (count, tot))
sys.stdout.flush()
return result