def parallel_align(self,
list_of_files,
output_directory,
output_suffix="alignment",
gap_open_penalty=None,
offset=None,
maxiterate=None,
quiet=True,
mode="globalpair",
number_of_processes=1,
anysymbol=False):
# TODO: add rest of options
options = " --thread %i" % self.threads
options += " --op %f" % gap_open_penalty if gap_open_penalty is not None else ""
options += " --ep %f" % offset if offset is not None else ""
options += " --maxiterate %i" % maxiterate if maxiterate is not None else ""
options += " --quiet" if quiet else ""
options += " --%s" % mode
options += " --anysymbol" if anysymbol else ""
options_list = []
for filename in list_of_files:
basename = FileRoutines.split_filename(filename)[1]
op = options
op += " %s" % filename
op += " > %s/%s.fasta" % (output_directory,
("%s_%s" % (basename, output_suffix))
if output_suffix else basename)
options_list.append(op)
self.parallel_execute(options_list, threads=number_of_processes)
def parallel_align(self, list_of_files, output_dir, msa_tool='prank',
seq_type=None, bootstrap_number=100, genetic_code=1, threads=None,
msa_tool_options=None, seq_cutoff=None, col_cutoff=None, mafft_bin=None,
prank_bin=None, muscle_bin=None, pagan_bin=None, ruby_bin=None, program=None,
cmd_log_file=None,
cpus_per_task=1,
handling_mode="local",
job_name=None,
log_prefix=None,
error_log_prefix=None,
max_jobs=None,
max_running_time=None,
max_memory_per_node=None,
max_memmory_per_cpu=None,
modules_list=None,
environment_variables_dict=None):
common_options = self.parse_common_options(output_dir=output_dir, msa_tool=msa_tool,
seq_type=seq_type, bootstrap_number=bootstrap_number,
genetic_code=genetic_code, threads=threads,
msa_tool_options=msa_tool_options, seq_cutoff=seq_cutoff,
col_cutoff=col_cutoff, mafft_bin=mafft_bin,
prank_bin=prank_bin, muscle_bin=muscle_bin,
pagan_bin=pagan_bin, ruby_bin=ruby_bin, program=program)
FileRoutines.safe_mkdir(output_dir)
options_list = []
for filename in list_of_files:
basename = FileRoutines.split_filename(filename)[1]
op = common_options
op += " --seqFile %s" % filename
op += " --dataset %s" % basename
options_list.append(op)
if handling_mode == "local":
self.parallel_execute(options_list)
elif handling_mode == "slurm":
cmd_list = ["%s%s %s" % ((self.path + "/") if self.path else "", self.cmd, options) for options in options_list]
self.slurm_run_multiple_jobs_in_wrap_mode(cmd_list,
cmd_log_file,
max_jobs=max_jobs,
job_name=job_name,
log_prefix=log_prefix,
error_log_prefix=error_log_prefix,
cpus_per_node=None,
max_running_jobs=None,
max_running_time=max_running_time,
cpus_per_task=cpus_per_task,
max_memory_per_node=max_memory_per_node,
max_memmory_per_cpu=max_memmory_per_cpu,
modules_list=modules_list,
environment_variables_dict=environment_variables_dict)
def parallel_align(self, list_of_files, output_directory, output_suffix=None, tree_file=None, output_format=None, show_xml=None,
show_tree=None, show_ancestral_sequences=None, show_evolutionary_events=None,
showall=None, compute_posterior_support=None, njtree=None, skip_insertions=False,
codon_alignment=None, translated_alignment=None,
cmd_log_file=None,
cpus_per_task=1,
handling_mode="local",
job_name=None,
log_prefix=None,
error_log_prefix=None,
max_jobs=None,
max_running_time=None,
max_memory_per_node=None,
max_memmory_per_cpu=None,
modules_list=None,
environment_variables_dict=None):
common_options = self.parse_common_options(tree_file=tree_file, output_format=output_format, show_xml=show_xml,
show_tree=show_tree, show_ancestral_sequences=show_ancestral_sequences,
show_evolutionary_events=show_evolutionary_events, showall=showall,
compute_posterior_support=compute_posterior_support, njtree=njtree,
skip_insertions=skip_insertions, codon_alignment=codon_alignment,
translated_alignment=translated_alignment)
FileRoutines.safe_mkdir(output_directory)
options_list = []
for filename in list_of_files:
basename = FileRoutines.split_filename(filename)[1]
op = common_options
op += " -d=%s" % filename
op += " -o=%s/%s.fasta" % (output_directory,
("%s_%s" % (basename, output_suffix)) if output_suffix else basename)
options_list.append(op)
if handling_mode == "local":
self.parallel_execute(options_list)
elif handling_mode == "slurm":
cmd_list = ["%s%s %s" % ((self.path + "/") if self.path else "", self.cmd, options) for options in options_list]
self.slurm_run_multiple_jobs_in_wrap_mode(cmd_list,
cmd_log_file,
max_jobs=max_jobs,
job_name=job_name,
log_prefix=log_prefix,
error_log_prefix=error_log_prefix,
cpus_per_node=None,
max_running_jobs=None,
max_running_time=max_running_time,
cpus_per_task=cpus_per_task,
max_memory_per_node=max_memory_per_node,
max_memmory_per_cpu=max_memmory_per_cpu,
modules_list=modules_list,
environment_variables_dict=environment_variables_dict)
def read(self, input_file, filetype="fasta", verbose=False):
list_of_files = FileRoutines.make_list_of_path_to_files(input_file)
for filename in list_of_files:
if verbose:
print("Parsing %s ..." % filename)
directory, basename, extension = FileRoutines.split_filename(filename)
try:
self.records[basename] = MultipleAlignmentStatRecord(basename, alignment=AlignIO.read(filename, filetype))
self.record_id_list.append(basename)
except:
raise ValueError("ERROR: Issues while parsing or calculating stats for %s!!!" % filename)
# collectiontype-dependent function
pass
def parallel_blast(self, blast_command, seqfile, database, outfile=None,
blast_options=None, split_dir="splited_fasta",
splited_output_dir="splited_output_dir",
evalue=None, output_format=None,
threads=None, num_of_seqs_per_scan=None,
combine_output_to_single_file=True,
async_run=False,
external_process_pool=None):
splited_dir = FileRoutines.check_path(split_dir)
splited_out_dir = FileRoutines.check_path(splited_output_dir)
self.safe_mkdir(splited_dir)
self.safe_mkdir(splited_out_dir)
number_of_files = num_of_seqs_per_scan if num_of_seqs_per_scan else 5 * threads if threads else 5 * self.threads
self.split_fasta(seqfile, splited_dir, num_of_files=number_of_files)
input_list_of_files = sorted(os.listdir(splited_dir))
list_of_files = []
for filename in input_list_of_files:
filename_prefix = FileRoutines.split_filename(filename)[1]
input_file = "%s%s" % (splited_dir, filename)
output_file = "%s%s.hits" % (splited_out_dir, filename_prefix)
list_of_files.append((input_file, output_file))
options_list = []
out_files = []
for in_file, out_filename in list_of_files:
options = " -out %s" % out_filename
options += " -db %s" % database
options += " -query %s" % in_file
options += " %s" % blast_options if blast_options else ""
options += " -evalue %s" % evalue if evalue else ""
options += " -outfmt %i" % output_format if output_format else ""
options_list.append(options)
out_files.append(out_filename)
self.parallel_execute(options_list, cmd=blast_command, threads=threads, async_run=async_run,
external_process_pool=external_process_pool)
if combine_output_to_single_file:
CGAS.cat(out_files, output=outfile)
def parallel_positive_selection_test(self,
in_dir,
tree_file,
out_dir,
results_file,
seq_type="codons",
codon_frequency="F3X4",
noisy=3,
verbose="concise",
runmode=0,
clock=0,
aminoacid_distance=None,
genetic_code=0,
fix_kappa=False,
kappa=5,
getSE=0,
RateAncestor=0,
small_difference=0.000001,
clean_data=True,
method=0):
"""
This function implements positive selection test (branch-site model)
for branch labeled in tree file using model_A vs model_A_null(omega fixed to 1) comparison
"""
FileRoutines.safe_mkdir(out_dir)
alignment_files_list = FileRoutines.make_list_of_path_to_files(in_dir)
tree_file_abs_path = os.path.abspath(tree_file)
options_list = []
dir_list = []
basename_dir_list = []
model_list = ["Model_A", "Model_A_null"]
fix_omega_dict = {"Model_A": False, "Model_A_null": True}
for filename in alignment_files_list:
directory, basename, extension = FileRoutines.split_filename(
filename)
filename_out_dir = os.path.abspath("%s/%s/" % (out_dir, basename))
basename_dir_list.append(basename)
FileRoutines.safe_mkdir(filename_out_dir)
for model in model_list:
model_dir = "%s/%s/" % (filename_out_dir, model)
FileRoutines.safe_mkdir(model_dir)
out_file = "%s/%s/%s.out" % (filename_out_dir, model, basename)
ctl_file = "%s/%s/%s.ctl" % (filename_out_dir, model, basename)
options_list.append("%s.ctl" % basename)
dir_list.append(model_dir)
self.generate_ctl_file(os.path.abspath(filename),
tree_file_abs_path,
out_file,
ctl_file,
seq_type=seq_type,
codon_frequency=codon_frequency,
noisy=noisy,
verbose=verbose,
runmode=runmode,
clock=clock,
aminoacid_distance=aminoacid_distance,
model=2,
nssites=2,
genetic_code=genetic_code,
fix_kappa=fix_kappa,
kappa=kappa,
fix_omega=fix_omega_dict[model],
omega=1,
getSE=getSE,
RateAncestor=RateAncestor,
Mgene=0,
small_difference=small_difference,
clean_data=clean_data,
method=method)
self.parallel_execute(options_list, dir_list=dir_list)
results_dict = OrderedDict()
double_delta_dict = OrderedDict()
raw_pvalues_dict = OrderedDict()
raw_pvalues_list = []
for basename in basename_dir_list:
results_dict[basename] = OrderedDict()
for model in model_list:
output_file = "%s/%s/%s/%s.out" % (out_dir, basename, model,
basename)
codeml_report = CodeMLReport(output_file)
results_dict[basename][model] = codeml_report.LnL
skipped_genes_set = set()
for basename in basename_dir_list:
for model in model_list:
if results_dict[basename][model] is None:
print("LnL was not calculated for %s" % basename)
skipped_genes_set.add(basename)
break
else:
doubled_delta = 2 * (results_dict[basename]["Model_A"] -
results_dict[basename]["Model_A_null"])
p_value = chisqprob(doubled_delta, 1) # degrees of freedom = 1
double_delta_dict[basename] = doubled_delta
raw_pvalues_dict[basename] = p_value
raw_pvalues_list.append(p_value)
adjusted_pvalues_list = fdrcorrection0(raw_pvalues_list)[1]
#print adjusted_pvalues_list
i = 0
with open(results_file, "w") as out_fd:
out_fd.write(
"id\tmodel_a_null,LnL\tmodel_a,LnL\t2*delta\traw p-value\tadjusted p-value\n"
)
for basename in basename_dir_list:
for model in model_list:
if results_dict[basename][model] is None:
print("LnL was not calculated for %s" % basename)
break
else:
#doubled_delta = 2 * (results_dict[basename]["Model_A"] - results_dict[basename]["Model_A_null"])
#p_value = chisqprob(doubled_delta, 1) # degrees of freedom = 1
#print basename, results_dict[basename]["Model_A_null"],results_dict[basename]["Model_A"], double_delta_dict[basename], raw_pvalues_dict[basename], adjusted_pvalues_list[i]
out_fd.write(
"%s\t%f\t%f\t%f\t%f\t%f\n" %
(basename, results_dict[basename]["Model_A_null"],
results_dict[basename]["Model_A"],
double_delta_dict[basename],
raw_pvalues_dict[basename], adjusted_pvalues_list[i]))
i += 1
def parallel_codeml(self,
in_dir,
tree_file,
out_dir,
seq_type="codons",
codon_frequency="F3X4",
noisy=0,
verbose="concise",
runmode=0,
clock=0,
aminoacid_distance=None,
model=1,
nssites=0,
genetic_code=0,
fix_kappa=False,
kappa=5,
fix_omega=False,
omega=0.2,
getSE=0,
RateAncestor=0,
small_difference=0.000001,
clean_data=True,
method=0,
Mgene=None):
FileRoutines.safe_mkdir(out_dir)
alignment_files_list = FileRoutines.make_list_of_path_to_files(in_dir)
tree_file_abs_path = os.path.abspath(tree_file)
options_list = []
dir_list = []
for filename in alignment_files_list:
directory, basename, extension = FileRoutines.split_filename(
filename)
filename_out_dir = os.path.abspath("%s/%s/" % (out_dir, basename))
out_file = "%s/%s.out" % (filename_out_dir, basename)
ctl_file = "%s/%s.ctl" % (filename_out_dir, basename)
options_list.append(ctl_file)
dir_list.append(filename_out_dir)
FileRoutines.safe_mkdir(filename_out_dir)
self.generate_ctl_file(os.path.abspath(filename),
tree_file_abs_path,
out_file,
ctl_file,
seq_type=seq_type,
codon_frequency=codon_frequency,
noisy=noisy,
verbose=verbose,
runmode=runmode,
clock=clock,
aminoacid_distance=aminoacid_distance,
model=model,
nssites=nssites,
genetic_code=genetic_code,
fix_kappa=fix_kappa,
kappa=kappa,
fix_omega=fix_omega,
omega=omega,
getSE=getSE,
RateAncestor=RateAncestor,
Mgene=Mgene,
small_difference=small_difference,
clean_data=clean_data,
method=method)
self.parallel_execute(options_list, dir_list=dir_list)
def parallel_search_tandem_repeat(self, query_file, output_prefix, matching_weight=2, mismatching_penalty=7,
indel_penalty=7,
match_probability=80, indel_probability=10, min_alignment_score=50, max_period=500,
report_flanking_sequences=False, splited_fasta_dir="splited_fasta_dir",
splited_result_dir="splited_output", converted_output_dir="converted_output",
max_len_per_file=100000, store_intermediate_files=False, max_repeat_length=None):
work_dir = os.getcwd()
splited_filename = FileRoutines.split_filename(query_file)
self.split_fasta_by_seq_len(query_file, splited_fasta_dir, max_len_per_file=max_len_per_file,
output_prefix=splited_filename[1])
common_options = self.parse_common_options(matching_weight=matching_weight,
mismatching_penalty=mismatching_penalty,
indel_penalty=indel_penalty, match_probability=match_probability,
indel_probability=indel_probability,
min_alignment_score=min_alignment_score,
max_period=max_period,
report_flanking_sequences=report_flanking_sequences,
make_dat_file=True, max_repeat_length=max_repeat_length)
common_options += " -h" # suppress html output
options_list = []
splited_files = os.listdir(splited_fasta_dir)
FileRoutines.safe_mkdir(splited_result_dir)
FileRoutines.safe_mkdir(converted_output_dir)
os.chdir(splited_result_dir)
input_dir = splited_fasta_dir if (splited_fasta_dir[0] == "/") or (splited_fasta_dir[0] == "~") \
else "../%s" % splited_fasta_dir
for filename in splited_files:
file_options = "%s/%s" % (input_dir, filename)
file_options += common_options
options_list.append(file_options)
self.parallel_execute(options_list)
os.chdir(work_dir)
trf_output_file_list = []
for filename in splited_files:
trf_output_file = "%s/%s.%i.%i.%i.%i.%i.%i.%i.dat" % (splited_result_dir, filename,
matching_weight, mismatching_penalty,
indel_penalty, match_probability,
indel_probability,
min_alignment_score, max_period)
trf_output_file_list.append(trf_output_file)
trf_report = self.convert_trf_report(trf_output_file_list, output_prefix)
"""
for suffix in (".rep", ".gff", ".simple.gff", ".short.tab", ".wide.tab", ".with_rep_seqs.gff", ".fasta"):
file_str = ""
merged_file = "%s%s" % (output_prefix, suffix)
for filename in splited_files:
file_str += " %s/%s%s" % (converted_output_dir, filename, suffix)
CGAS.cat(file_str, merged_file)
"""
compress_splited_out_string = "tar czf %s.splited_output.tar.gz %s" % (output_prefix, splited_result_dir)
os.system(compress_splited_out_string)
if not store_intermediate_files:
shutil.rmtree(splited_fasta_dir)
shutil.rmtree(splited_result_dir)
shutil.rmtree(converted_output_dir)
return trf_report