def intergenic(inputfile=None, outputfile=None, chrom_info=None):
"""
Extract intergenic regions.
"""
message("Searching for intergenic regions.")
gtf = GTF(inputfile)
intergenic_regions = gtf.get_intergenic(chrom_info)
nb_intergenic_region = 1
for i in intergenic_regions:
i.name = "region_" + str(nb_intergenic_region)
write_properly(chomp(str(i)), outputfile)
nb_intergenic_region += 1
gc.disable()
close_properly(outputfile, inputfile)
def coverage(
inputfile=None,
outputfile=None,
bw_list=None,
labels=None,
pseudo_count=1,
nb_window=1,
ft_type="promoter",
n_highest=None,
downstream=1000,
key_name="cov",
zero_to_na=False,
name_column=None,
upstream=1000,
chrom_info=None,
nb_proc=1,
matrix_out=False,
stat='mean'):
"""
Compute transcript coverage with one or several bigWig.
"""
# -------------------------------------------------------------------------
# Create a list of labels.
# Take user input in account
# -------------------------------------------------------------------------
bw_list = [x.name for x in bw_list]
if len(bw_list) != len(set(bw_list)):
message("Found the same bigwigs several times.",
type="ERROR")
message('Checking labels.')
if labels is not None:
labels = labels.split(",")
# Ensure the number of labels is the same as the number of bw files.
if len(labels) != len(bw_list):
message("The number of labels should be the same as the number of"
" bigwig files.", type="ERROR")
# Ensure labels are non-redondant
if len(labels) > len(set(labels)):
message("Labels must be unique.", type="ERROR")
else:
labels = []
for i in range(len(bw_list)):
labels += [
os.path.splitext(
os.path.basename(
bw_list[i]))[0]]
# -------------------------------------------------------------------------
# Check the number of windows
#
# -------------------------------------------------------------------------
if n_highest is None:
n_highest = nb_window
message('Number of bins: %d' % nb_window)
message('N highest values: %d' % n_highest)
if n_highest > nb_window:
message('The number of window used for computing the score'
' (-n) can not be greater than the number of'
' windows (-w)', type="ERROR")
sys.exit()
# -------------------------------------------------------------------------
# Check input file is in bed or GTF format
#
# -------------------------------------------------------------------------
message("Loading input file...")
if inputfile.name == '<stdin>':
gtf = GTF(inputfile.name)
is_gtf = True
else:
region_bo = BedTool(inputfile.name)
if len(region_bo) == 0:
message("Unable to find requested regions",
type="ERROR")
if region_bo.file_type == 'gff':
gtf = GTF(inputfile.name)
is_gtf = True
else:
is_gtf = False
# -------------------------------------------------------------------------
# Get regions of interest
#
# -------------------------------------------------------------------------
name_column = name_column.split(",")
if is_gtf:
message("Getting regions of interest...")
if ft_type.lower() == "intergenic":
region_bo = gtf.get_intergenic(chrom_info, 0, 0).slop(s=True,
l=upstream,
r=downstream,
g=chrom_info.name).sort()
elif ft_type.lower() == "intron":
region_bo = gtf.get_introns().slop(s=True,
l=upstream,
r=downstream,
g=chrom_info.name).sort()
elif ft_type == "intron_by_tx":
region_bo = gtf.get_introns(by_transcript=True,
name=name_column,
).slop(s=True,
l=upstream,
r=downstream,
g=chrom_info.name).sort()
elif ft_type.lower() in ["promoter", "tss"]:
region_bo = gtf.get_tss(name=name_column, ).slop(s=True,
l=upstream,
r=downstream,
g=chrom_info.name).sort()
elif ft_type.lower() in ["tts", "terminator"]:
region_bo = gtf.get_tts(name=name_column).slop(s=True,
l=upstream,
r=downstream,
g=chrom_info.name).sort()
else:
region_bo = gtf.select_by_key(
"feature",
ft_type, 0
).to_bed(name=name_column).slop(s=True,
l=upstream,
r=downstream,
g=chrom_info.name).sort()
if len(region_bo) == 0:
message("Unable to find requested regions",
type="ERROR")
else:
region_bo = region_bo.slop(s=True,
l=upstream,
r=downstream,
g=chrom_info.name).sort()
region_bed = make_tmp_file(prefix="region", suffix=".bed")
region_bo.saveas(region_bed.name)
# -------------------------------------------------------------------------
# Compute coverage
#
# -------------------------------------------------------------------------
result_bed = bw_cov_mp(bw_list=bw_list,
region_file=open(region_bed.name),
labels=labels,
bin_nb=nb_window,
pseudo_count=pseudo_count,
zero_to_na=zero_to_na,
nb_proc=nb_proc,
n_highest=n_highest,
stat=stat,
verbose=pygtftk.utils.VERBOSITY)
if matrix_out:
result_bed.close()
df_first = pd.read_csv(result_bed.name, sep="\t", header=None)
df_first = df_first.ix[:, [0, 1, 2, 3, 5, 4]]
df_list = []
for i in range(len(labels)):
# create a sub data frame containing the coverage values of the
# current bwig
str_to_find = r"^" + labels[i] + r"\|"
tmp_df = df_first[df_first[3].str.match(str_to_find)].copy()
to_replace = r"^" + labels[i] + r"\|"
tmp_df.iloc[:, 3] = tmp_df.iloc[:, 3].replace(to_replace,
r"", regex=True)
df_list += [tmp_df]
df_final = df_list.pop(0)
for i in df_list:
# Add columns to df final by joining on
# chrom, start, end, transcript_id, strand
df_final = df_final.merge(i.iloc[:,
list(range(6))], on=[0, 1,
2, 3, 5])
df_final.columns = ["chrom",
"start",
"end",
"name",
"strand"] + labels
df_final.to_csv(outputfile, sep="\t", index=False)
else:
nb_line = 0
for i in result_bed:
outputfile.write(i)
nb_line += 1
if nb_line == 0:
message("No line available in output...",
type="ERROR")
gc.disable()
close_properly(inputfile, outputfile)
