def subset_db(self, input, output, parser_out):
# create a dir for output
create_outputdir(output)
# because of multiple possible classifier the database will be subseted in a loop,
# so that every classifier can be processed
for i in range(len(self.R_subset_classifier)):
# print actual informations about the step on stdout
print_step(self.step_number,
'Analysis',
'Subset the database for %s' % (self.R_subset_classifier[i]),
'--bitscore %s --rank %s' % (self.R_subset_bitscore,
self.R_subset_rank[i]))
newline()
# generate name for database file
outfile = '%s%s%s%s' % (output, os.sep, self.R_subset_classifier[i], '.db')
logfile = open_logfile(self.logdir + self.R_subset_classifier[i] + '.log')
# remove old databases with the same name
if os.path.exists(outfile):
os.remove(outfile)
# start the process with classifier i and the complete output from the annotation step before
p = subprocess.Popen(shlex.split('%s -i %s -o %s --classifier %s --bitscore %s --rank %s --taxon %s --blast %s'
% (self.R_subset_exe,
to_string(input),
outfile,
self.R_subset_classifier[i],
self.R_subset_bitscore,
self.R_subset_rank[i],
self.R_subset_taxon_db,
to_string(parser_out))),
stdout = subprocess.PIPE)
# during processing print output in verbose mode and update the logfile
while p.poll() is None:
if self.verbose:
print_verbose(p.stdout.readline())
logfile.write(p.stdout.readline())
else:
logfile.write(p.stdout.readline())
# wait until process is complete
p.wait()
if p.returncode:
raise SubsetDBException(self.logdir + self.R_subset_classifier[i] + '.log')
# print summary of the process after completion
print_verbose('Subsetting of annotated Blast database complete \n')
print_running_time(self.time)
newline()
def __init__(self, threads, step_number, verbose, time, logdir, input, mode,
flash_exe, concat_dir, concat_parameter, merge_uncombined,
velveth_exe, velvetg_exe, metavelvet_exe, assembly_out, kmer,
velveth_parameter, velvetg_parameter, metavelvet_parameter):
# init general variables
self.threads = threads
self.step_number = step_number
self.verbose = verbose
self.time = time
self.logdir = logdir
self.input = to_string(input)
self.mode = mode
# init flash specific variables
self.flash_exe = flash_exe
self.concat_out = concat_dir
self.concat_parameter = concat_parameter
self.merge_uncombined = merge_uncombined
# init metavelvet specific variables
self.velveth_exe = velveth_exe
self.velvetg_exe = velvetg_exe
self.metavelvet_exe = metavelvet_exe
self.assembly_out = assembly_out
self.kmer = kmer
self.velveth_parameter = velveth_parameter
self.velvetg_parameter = velvetg_parameter
self.metavelvet_parameter = metavelvet_parameter
def blastn(self, outputdir):
# create a dir for output
create_outputdir(outputdir)
# blastn can only run with fasta files, so input has to be converted
if is_fastq(self.input):
# print actual informations about the step on stdout
print_step(self.step_number,
'Annotation',
'convert fastq files',
cut_path(self.input))
newline()
self.input = convert_fastq(self.input, self.blast_dir, self.converter_exe)
# blastn can only annotated one file, so input has to be merged to one file
if is_paired(self.input):
# print actual informations about the step on stdout
print_step(self.step_number,
'Annotation',
'merging reads to on file',
cut_path(self.input))
newline()
self.input = merge_files(self.input, self.blast_dir, 'merged', 'fasta')
# define the outputformat for the blastn results
outfile = outputdir + os.sep + blast_output(self.outfmt)
# print actual informations about the step on stdout
print_step(self.step_number,
'Annotation',
'blast sequences against nt database',
self.blast_parameter)
newline()
# start blastn and wait until completion
# logfile is not requiered, because blastn has no log function and no output to stdout
p = subprocess.Popen(shlex.split('%s -db %s -query %s -out %s -num_threads %s %s ' %
(self.blastn_exe,
self.blastn_db,
to_string(self.input),
outfile,
self.threads,
self.blast_parameter)),
stderr = open_logfile(self.logdir + 'blastn.err.log'))
# wait until process is complete
p.wait()
if p.returncode:
raise BlastnException(self.logdir + 'blastn.err.log')
else:
# remove the temporary files: converted fastq files and the merged fasta files
remove_file(outputdir + os.sep, 'converted', 'fasta')
remove_file(outputdir + os.sep, 'merged', 'fasta')
# remove unused error logs
remove_empty_logfile(self.logdir + 'blastn.err.log')
# print summary of the process after completion
print_verbose('Annotation with blastn complete \n')
print_running_time(self.time)
newline()
def manage_assembly(self):
concatinated = ''
assembled = ''
# run the assembling functions when the module is initialized
if self.mode.lower() == 'flash':
# is executable existing and runnable?
if is_executable(self.flash_exe):
# start concatination and update the input for next step
self.concatinate(self.concat_out)
self.step_number += 1
# merge the concatinated reads with non concatinated rest
if (self.merge_uncombined):
self.input = merge_files([to_string(update_reads(self.concat_out, 'extendedFrags', 'fastq')),
to_string(update_reads(self.concat_out, 'out.notCombined', 'fastq'))],
self.concat_out,
'merged_concat','fastq')
else:
concatinated = update_reads(self.concat_out, 'extendedFrags', 'fastq')
self.input = concatinated
if self.mode.lower() == 'metavelvet':
# is executable existing and runnable?
if is_executable(self.velveth_exe) and is_executable(self.velveth_exe) and is_executable(self.metavelvet_exe):
# start assembly and update the input for next step
self.assemble_reads(self.assembly_out)
assembled = update_reads(self.assembly_out, 'meta-velvetg', 'fa')
self.input = assembled
self.step_number += 1
if self.mode.lower() == 'both':
#TODO: not working because of auto mode --> see logs
# is executable existing and runnable?
if is_executable(self.flash_exe) and is_executable(self.velveth_exe) and is_executable(self.velveth_exe) and is_executable(self.metavelvet_exe):
# start processing and update the input for next step
self.concatinate(self.concat_out)
concatinated = update_reads(self.out, 'extendedFrags', 'fastq')
self.input = concatinated
self.assemble_reads(self.assembly_out)
assembled = update_reads(self.assembly_out, 'meta-velvetg', 'fa')
self.step_number += 1
self.input = assembled
return [self.step_number, self.input, concatinated, assembled]
def apply_query(query, query_idx, endpoint):
query_instance = get_query_instance(query)
ep = endpoints[endpoint]
print('----apply query----', ep, query_idx)
responses = {}
if ep[TYPE] == REMOTE_EP:
qt = QueryTool(endpoint=ep[ENDPOINT],
mode=modes[ep[MODE]],
relax_num_ep=1,
disable_timeout=True)
response, stat, errors = query_instance.ask_all(query_tool=qt,
start=query_idx,
end=query_idx + 1,
prefilter=False)
if errors:
print('errors:', errors)
if response:
responses = {
'dummy':
xmltodict.parse(to_string(response))['graphqueries_responses']
}
else:
if query_instance.related_docs:
for ttl_file in query_instance.related_docs[query_idx]:
qt = QueryTool(endpoint=ep[FOLDER_PATH] + ttl_file + '.ttl',
mode=modes[ep[MODE]],
relax_num_ep=1,
use_fuseki=ep[ENDPOINT],
disable_timeout=True)
response, stat, errors = query_instance.ask_all(
query_tool=qt,
start=query_idx,
end=query_idx + 1,
root_doc=ttl_file,
prefilter=False)
if errors:
print('errors:', errors)
responses[ttl_file] = xmltodict.parse(
to_string(response))['graphqueries_responses']
return responses
def manage_analysis(self):
if self.annotation_mode in 'metacv':
print_verbose("For a detailed analysis blastn with XML output is needed")
else:
# test for blastrun with outfmt 5 mode
if is_xml(self.blast_output):
# create a SQLite DB from the xml file
self.parse_to_db(to_string(self.blast_output), self.parsed_db_out)
# test the exit code, because next script need the output as input
if self.exitcode is 0:
# update input
parser_out = absolute_path(update_reads(self.parsed_db_out,
self.parser_name,
'db'))
# raise step_number
self.step_number += 1
# create a new database with taxonomical annotations
self.annotate_db(parser_out, self.annotated_db_out)
# test the exit code, because next script need the output as input
if self.exitcode is 0:
# update input
annotated_output = absolute_path(update_reads(self.annotated_db_out,
self.R_annotate_name,
'db'))
# raise step_number
self.step_number += 1
# subset the taxonomical database for a better and
# faster analysis after the pipline has finished
self.subset_db(annotated_output, self.subseted_db_out, parser_out)
# raise step_number
self.step_number += 1
else:
print_verbose("ERROR: Annotated Database could not be subseted correctly")
# create a pie chart of the blast data with Krona Webtools
if self.krona:
self.krona_report(self.blast_output, self.krona_report_out, parser_out)
return [parser_out, annotated_output]
else:
print_verbose("ERROR: XML file could not be parsed")
# test for blast tabular output
elif is_tabular(self.blast_output) and self.krona is True:
self.krona_report(self.blast_output, self.krona_report_out, '')
return []
else:
print_verbose("ERROR: Blast output file is not in xml or tabular format.\n" +
"Please use outfmt 5 or 6 for Blast run")
return []
def annotate_db(self, input, output):
# create a dir for output
create_outputdir(output)
# generate filename for db
outfile = output + os.sep + self.R_annotate_name + '.db'
# open a logfile for annotation process
logfile = open_logfile(self.logdir + 'annotation_of_db.log')
# remove old databases with same name
if os.path.exists(outfile):
os.remove(outfile)
# print actual informations about the step on stdout
print_step(self.step_number, 'Analysis',
'Annotate taxonomical data to blast database',
self.R_annotate_parameter)
newline()
# start the parser and wait until completion
p = subprocess.Popen(shlex.split('%s -i %s -o %s %s --taxon %s'
% (self.R_annotate_exe,
to_string(input),
outfile,
self.R_annotate_parameter,
self.R_annotate_taxon_db)),
stdout = subprocess.PIPE)
# print information about the status
while p.poll() is None:
if self.verbose:
print_verbose(p.stdout.readline())
logfile.write(p.stdout.readline())
else:
logfile.write(p.stdout.readline())
# wait until process is complete
p.wait()
# save the exit code for later function calls
self.exitcode = p.returncode
# raise Exception when an error occurs during processing
if p.returncode:
raise AnnotateDBException(self.logdir + 'annotation_of_db.log')
else:
# print summary of the process after completion
print_verbose('Taxonomical annotation of blast database complete \n')
print_running_time(self.time)
newline()
def trim_and_filter(self):
# create a dir for output
create_outputdir(self.trim_dir)
# print actual informations about the step on stdout
print_step(self.step_number,
'Preprocess',
'quality based trimming and filtering',
self.trim_parameter)
newline()
# open the log file
self.logfile = open_logfile(self.logdir + 'trimming.log')
# start trim_galore with the given parameter and specified output dir
p = subprocess.Popen(shlex.split('%s %s -o %s %s' %
(self.trim_exe,
self.trim_parameter,
self.trim_dir,
to_string(self.input))),
stdout = subprocess.PIPE,
stderr = subprocess.PIPE)
# wait until process is finished
p.wait()
# after processing write all generated output to the log file
for line in p.stderr:
if self.verbose:
# in verbose mode additionally print output to stdout
print_verbose(line)
self.logfile.write(line)
else:
self.logfile.write(line)
if p.returncode:
raise TrimGaloreException(self.logfile.name)
else:
# print summary of the process after completion
print_verbose('Trimming and filtering complete \n')
print_running_time(self.time)
newline()
def qualityCheck(self):
# create a dir for output
create_outputdir(self.quality_dir)
# print actual informations about the step on stdout
print_step(self.step_number,
'Preprocess',
'quality analysis',
self.fastqc_parameter)
newline()
# run FastQC with the given parameter, in seperate threads and extract the output
p = subprocess.Popen(shlex.split('%s -t %s -o %s --extract %s %s'
% (self.fastqc_exe,
self.threads,
self.quality_dir,
self.fastqc_parameter,
to_string(self.input))),
stdout = subprocess.PIPE,
stderr = subprocess.PIPE)
# during processing pipe the output and print it on screen
while p.poll() is None:
if self.verbose:
print_verbose(p.stderr.readline())
else:
print_compact(p.stderr.readline().rstrip('\n'))
# wait until process is finished
p.wait()
if p.returncode:
raise FastQCException()
else:
# print summary of the process after completion
print_verbose('Quality check complete for %s\n' % (self.input))
print_running_time(self.time)
newline()
def metacv(self, outputdir):
# create a dir for output
create_outputdir(outputdir)
# select the input for metacv and convert it in an usable format
if self.contigs is True:
input = to_string(self.input)
else:
input = to_string(self.raw)
# print actual informations about the step on stdout
print_step(self.step_number,
'Annotation',
'Annotate bacterial reads with MetaCV',
'%s %s %s' % (self.metacv_seq,
self.metacv_mode,
self.metacv_orf))
newline()
# metacv has a maximum thread number of 64
# parameter has to be adjusted
if self.threads > 64:
threads = 64
else:
threads = self.threads
classify = open_logfile(self.logdir + 'metacv.classify.log')
# start MetaCV function and wait until completion
p = subprocess.Popen(shlex.split('%s classify %s %s %s %s %s %s --threads=%s' %
(self.metacv_exe,
self.metacv_db,
input,
self.metacv_name,
self.metacv_seq,
self.metacv_mode,
self.metacv_orf,
threads)),
stderr = subprocess.PIPE,
stdout = subprocess.PIPE,
cwd = outputdir + os.sep)
# during processing pipe the output and print it on screen
while p.poll() is None:
if self.verbose:
print_verbose(p.stderr.readline())
classify.write(p.stderr.readline())
else:
print_compact(p.stderr.readline().rstrip('\n'))
classify.write(p.stderr.readline())
# wait until process is finished
p.wait()
if p.returncode:
raise MetaCVException(self.logdir + 'metacv.classify.log')
else:
# remove unused error logs
remove_empty_logfile(self.logdir + 'metacv.classify.log')
# print actual informations about the step on stdout
print_step(self.step_number,
'Annotation',
'Analyse the results of MetaCV',
'%s %s %s' % (self.metacv_total_reads,
self.metacv_min_qual,
self.metacv_taxon))
newline()
res2table = open_logfile(self.logdir + 'metacv.res2table.log')
# start MetaCV's res2table function and wait until completion
p = subprocess.Popen(shlex.split('%s res2table %s %s %s %s %s %s --threads=%s' %
(self.metacv_exe,
self.metacv_db,
to_string(update_reads(outputdir,'metpipe','res')),
self.metacv_name + '.res2table',
self.metacv_total_reads,
self.metacv_min_qual,
self.metacv_taxon,
threads)),
stderr = subprocess.PIPE,
stdout = subprocess.PIPE,
cwd = outputdir + os.sep)
# during processing pipe the output and print it on screen
while p.poll() is None:
if self.verbose:
print_verbose(p.stderr.readline())
res2table.write(p.stderr.readline())
else:
print_compact(p.stderr.readline().rstrip('\n'))
res2table.write(p.stderr.readline())
# wait until process is finished
p.wait()
if p.returncode:
raise MetaCVSumException(self.logdir + 'metacv.res2table.log')
else:
# remove unused error logs
remove_empty_logfile(self.logdir + 'metacv.res2table.log')
# print actual informations about the step on stdout
print_step(self.step_number,
'Annotation',
'Summarize the results of MetaCV',
self.metacv_min_qual)
newline()
res2sum = open_logfile(self.logdir + 'metacv.res2sum.log')
# start MetaCV's res2sum function and wait until completion
# the workingdir must be specified to maintain the correct
# order of output files
p = subprocess.Popen(shlex.split('%s res2sum %s %s %s %s' %
(self.metacv_exe,
self.metacv_db,
to_string(update_reads(outputdir,'metpipe','res')),
self.metacv_name + '.res2sum',
self.metacv_min_qual)),
stderr = subprocess.PIPE,
stdout = subprocess.PIPE,
cwd = outputdir + os.sep)
# during processing pipe the output and print it on screen
while p.poll() is None:
if self.verbose:
print_verbose(p.stderr.readline())
res2sum.write(p.stderr.readline())
else:
print_compact(p.stderr.readline().rstrip('\n'))
res2sum.write(p.stderr.readline())
# wait until process is finished
p.wait()
if p.returncode:
raise MetaCVSumException(self.logdir + 'metacv.res2sum.log')
else:
# remove unused error logs
remove_empty_logfile(self.logdir + 'metacv.res2sum.log')
# print summary of the process after completion
print_verbose('Annotation with MetaCV complete \n')
print_running_time(self.time)
newline()
def krona_report(self, input, output, parser_output):
# create a dir for output
create_outputdir(output)
# generate path and name for output file
outfile = output + os.sep + self.krona_name + '.html'
# test type of input file
if is_tabular(input):
# print actual informations about the step on stdout
print_step(self.step_number,
'Analysis',
'Create Overview from tabular output',
self.krona_parameter)
newline()
# start the Krona import script for Blast tabular output
# pipe all output for stdout in a logfile
p = subprocess.Popen(shlex.split('perl -l %s %s -o %s %s %s'
% (self.perl_lib,
self.krona_exe,
outfile,
self.krona_parameter,
to_string(input))),
stdout = open_logfile(self.logdir + 'krona.log'),
stderr = open_logfile(self.logdir + 'krona.err.log'))
# wait until process is complete
p.wait()
if p.returncode:
raise KronaException(self.logdir + 'krona.err.log')
else:
# remove unused error logs
remove_empty_logfile(self.logdir + 'krona.err.log')
# print summary of the process after completion
print_verbose('Creation of Krona Pie Chart complete \n')
print_running_time(self.time)
newline()
elif is_xml(input) and is_db(parser_output):
print_step(self.step_number,
'Analysis',
'Create Overview from XML output',
self.krona_parameter)
# convert the values from database to tabular format
extract_tabular(to_string(parser_output), output)
# set the new input
input = update_reads(output, 'extracted_from_DB','tab')
# start the Krona import script for Blast tabular output
# pipe all output for stdout in a logfile
p = subprocess.Popen(shlex.split('perl -l %s %s -o %s %s %s'
% (self.perl_lib,
self.krona_exe,
outfile,
self.krona_parameter,
to_string(input))),
stdout = open_logfile(self.logdir + 'krona.log'),
stderr = open_logfile(self.logdir + 'krona.err.log'))
# wait until process is complete
p.wait()
if p.returncode:
raise KronaException(self.logdir + 'krona.err.log')
else:
# remove unused error logs
remove_empty_logfile(self.logdir + 'krona.err.log')
# print summary of the process after completion
print_verbose('Creation of Krona Pie Chart complete \n')
print_running_time(self.time)
newline()
elif not is_tabular(input) or not is_xml(input):
raise KronaFormatException()
else:
print_verbose('ERROR 25: Krona Report could not be generated, because of unknown reasons')
sys.exit(1)
def dumps_json_report(self):
return to_string({
'kb_id': self.kb_id,
'success': self.success,
'failed': self.failed
})
def main(argv = None):
# hardcode defaults
RESULT_DIR = '%s%sresult' % (sys.path[0], os.sep)
PARAM_FILE = '%s%sparameter.conf' % (sys.path[0], os.sep)
STEPS = ['preprocessing', 'annotate', 'assembly', 'analysis']
# Get the starting time
starting_time = time.time()
# setup Argument Parser for stdin arguments
parser = argparse.ArgumentParser(add_help = True)
# define arguments
parser.add_argument('input', nargs = '+', action = 'store',
help = 'single or paired input files in <fastq> format')
parser.add_argument('--version', action = 'version', version = '%(prog)s 0.5')
parser.add_argument('-v', dest = 'verbose', action = 'store_true', default = False,
help = 'more detailed output (default = False)')
parser.add_argument('-t', dest = 'threads', type = int, action = 'store',
default = multiprocessing.cpu_count() - 1,
help = 'number of threads to use (default = %d)'
% (multiprocessing.cpu_count() - 1))
parser.add_argument('-p', dest = 'param', action = 'store', default = PARAM_FILE,
help = 'use alternative config file (default = parameter.conf)')
parser.add_argument('-s', dest = 'skip', action = 'store', default = '',
choices = ['preprocessing', 'assembly', 'annotation','analysis'],
help = 'skip steps in the pipeline (default = None)')
parser.add_argument('-o', dest = 'output', action = 'store', default = RESULT_DIR,
help = 'use alternative output folder')
parser.add_argument('-a', dest = 'assembler', default = 'MetaVelvet',
choices = ['metavelvet', 'flash','both'],
help = 'assembling program to use (default = MetaVelvet)')
parser.add_argument('-c', dest = 'annotation', default = 'both',
choices = ['metacv', 'blastn', 'both'],
help = 'classifier to use for annotation (default = both)')
parser.add_argument('--use_contigs', dest = 'use_contigs', action = 'store_true',
default = 'False',
help = 'should MetaCV use assembled Reads or RAW Reads (default = RAW')
parser.add_argument('--notrimming', dest = 'trim', action = 'store_false', default = True,
help = 'trim and filter input reads? (default = True)')
parser.add_argument('--noquality', dest = 'quality', action = 'store_false', default = True,
help = 'create no quality report (default = True)')
parser.add_argument('--noreport', dest = 'krona', action = 'store_false', default = True,
help = 'create no pie chart with the annotated taxonomical data (default = True)')
parser.add_argument('--merge', dest = 'merge_uncombined', action = 'store_true', default = False,
help = 'merge concatinated reads with not concatinated (default = False)')
args = parser.parse_args()
# init the Pipeline
RESULT_DIR = args.output if args.output else RESULT_DIR
# check if param File exists
if os.path.isfile(args.param):
PARAM_FILE = args.param
else:
if os.path.isfile(PARAM_FILE):
sys.stderr.write('ERROR 3: Parameter File could not be found!\n')
sys.stderr.write('Use standard Parameter File:\n%s\n\n' % (PARAM_FILE))
else:
raise ParamFileNotFound(args.param)
# check if input exists
if not all(os.path.isfile(file) for file in args.input):
raise InputNotFound(to_string(args.input))
if __name__ == '__main__':
# create outputdir and log folder
create_outputdir(RESULT_DIR)
create_outputdir(RESULT_DIR + os.sep +'log')
# create the global settings object
settings = General(args.threads, args.verbose, args.skip, starting_time, args.trim,
args.quality, args.krona, args.use_contigs, args.merge_uncombined, args.assembler,
args.annotation, 1)
# setup the input, outputs and important files
files = FileSettings(absolute_path(args.input), os.path.normpath(RESULT_DIR), PARAM_FILE)
exe = Executables(PARAM_FILE)
# get the all skipped steps
skip = to_string(settings.get_skip())
try:
print "hello"
# START the modules of Pipeline and wait until completion
if skip in 'preprocessing' and skip:
skip_msg(skip)
else:
# init the preprocessing module
pre = Preprocess(settings.get_threads(),
settings.get_step_number(),
settings.get_verbose(),
settings.get_actual_time(),
files.get_input(),
files.get_logdir(),
exe.get_FastQC(),
settings.get_quality(),
files.get_quality_dir(),
parse_parameter(FastQC_Parameter(PARAM_FILE)),
exe.get_TrimGalore(),
settings.get_trim(),
files.get_trim_dir(),
parse_parameter(TrimGalore_Parameter(PARAM_FILE)))
# run preprocessing functions
results = pre.manage_preprocessing()
# update pipeline variables with results
settings.set_step_number(results[0])
if len(results) > 1:
files.set_input(absolute_path(results[1]))
files.set_preprocessed_output(absolute_path(results[1]))
if skip in 'assembly' and skip:
skip_msg(skip)
else:
# init the assembly module
assembly = Assembly(settings.get_threads(),
settings.get_step_number(),
settings.get_verbose(),
settings.get_actual_time(),
files.get_logdir(),
files.get_input(),
settings.get_assembler(),
exe.get_Flash(),
files.get_concat_dir(),
parse_parameter(FLASH_Parameter(PARAM_FILE)),
settings.get_merge_uncombined(),
exe.get_Velveth(),
exe.get_Velvetg(),
exe.get_MetaVelvet(),
files.get_assembly_dir(),
Velveth_Parameter(PARAM_FILE).get_kmer(PARAM_FILE),
parse_parameter(Velveth_Parameter(PARAM_FILE)),
parse_parameter(Velvetg_Parameter(PARAM_FILE)),
parse_parameter(MetaVelvet_Parameter(PARAM_FILE)))
# run assembly functions
results = assembly.manage_assembly()
# update pipeline variables with results
settings.set_step_number(results[0])
files.set_input(absolute_path(results[1]))
files.set_concatinated_output(absolute_path(results[2]))
files.set_assembled_output(absolute_path(results[3]))
if skip in 'annotation'and skip:
skip_msg(skip)
else:
# init the annotation module
anno = Annotation(settings.get_threads(),
settings.get_step_number(),
settings.get_verbose(),
settings.get_actual_time(),
files.get_logdir(),
files.get_input(),
files.get_raw(),
settings.get_annotation(),
settings.get_use_contigs(),
exe.get_Blastn(),
exe.get_Blastn_DB(),
exe.get_Converter(),
files.get_blastn_dir(),
Blastn_Parameter(PARAM_FILE).outfmt,
parse_parameter(Blastn_Parameter(PARAM_FILE)),
exe.get_MetaCV(),
exe.get_MetaCV_DB(),
files.get_metacv_dir(),
MetaCV_Parameter(PARAM_FILE).get_seq(),
MetaCV_Parameter(PARAM_FILE).get_mode(),
MetaCV_Parameter(PARAM_FILE).get_orf(),
MetaCV_Parameter(PARAM_FILE).get_total_reads(),
MetaCV_Parameter(PARAM_FILE).get_min_qual(),
MetaCV_Parameter(PARAM_FILE).get_taxon(),
MetaCV_Parameter(PARAM_FILE).get_name())
# run the annotation functions
results = anno.manage_annotation()
settings.set_step_number(results[0])
files.set_blastn_output(absolute_path(results[1]))
files.set_metacv_output(absolute_path(results[2]))
if skip in 'analysis' and skip:
skip_msg(skip)
else:
# init the analysis module
analysis = Analysis(settings.get_threads(),
settings.get_step_number(),
settings.get_verbose(),
settings.get_actual_time(),
files.get_logdir(),
settings.get_annotation(),
files.get_output(),
files.get_parsed_db_dir(),
files.get_annotated_db_dir(),
files.get_subseted_db_dir(),
files.get_krona_report_dir(),
files.get_blastn_output(),
files.get_metacv_output(),
exe.get_Parser(),
parse_parameter(blastParser_Parameter(PARAM_FILE)),
blastParser_Parameter(PARAM_FILE).get_name(),
exe.get_Annotate(),
parse_parameter(Rannotate_Parameter(PARAM_FILE)),
Rannotate_Parameter(PARAM_FILE).get_name(),
Rannotate_Parameter(PARAM_FILE).get_taxon_db(),
exe.get_Subset(),
subsetDB_Parameter(PARAM_FILE).get_bitscore(),
subsetDB_Parameter(PARAM_FILE).get_classifier(),
subsetDB_Parameter(PARAM_FILE).get_rank(),
subsetDB_Parameter(PARAM_FILE).get_taxon_db(),
exe.get_Krona_Blast(),
parse_parameter(Krona_Parameter(PARAM_FILE)),
Krona_Parameter(PARAM_FILE).get_name(),
settings.get_krona(),
exe.get_Perl_lib())
# run the analysis function
results = analysis.manage_analysis()
files.set_parser_output(absolute_path(results[0]))
files.set_annotated_output(absolute_path(results[1]))
except KeyboardInterrupt:
sys.stdout.write('\nERROR 1 : Operation cancelled by User!\n')
sys.exit(1)
# print ending message
print_verbose('\nPIPELINE COMPLETE!\n\n')
print_running_time(settings.get_actual_time())
def search_xml(file_path, target_qid, tag):
root = ET.parse(file_path).getroot()
for response in root.iter(tag):
if response.attrib['id'] == target_qid:
return xmltodict.parse(to_string(response))
