def test_hello_world_diamond(self):
gpkg=os.path.join(path_to_data, "bootstrapper", "D1_gpkg_for_diamond.gpkg")
expandsearcher = ExpandSearcher(search_hmm_files = [os.path.join(path_to_data,'bootstrapper','DNGNGWU00001.hmm')],
evalue='1e-5',
maximum_range=1000,
threads=1,
graftm_package=GraftMPackage.acquire(gpkg))
with tempfile.NamedTemporaryFile() as tf:
self.assertEqual(True,
expandsearcher.generate_expand_search_database_from_contigs(\
[os.path.join(path_to_data,'bootstrapper','diamond_bootstrap_contigs.fna')],
tf.name,
"diamond"))
def test_no_hits(self):
expandsearcher = ExpandSearcher(search_hmm_files = [os.path.join(path_to_data,'bootstrapper','DNGNGWU00001.hmm')],
evalue='1e-5',
maximum_range=1000,
threads=1)
with tempfile.NamedTemporaryFile(suffix=".fasta") as contigs:
contigs.write(">contig\n")
contigs.write('A'*300+"\n")
contigs.flush()
with tempfile.NamedTemporaryFile() as tf:
self.assertEqual(False,
expandsearcher.generate_expand_search_database_from_contigs(\
[contigs.name],
tf.name,
"hmmsearch"))
def test_no_hits(self):
expandsearcher = ExpandSearcher(search_hmm_files=[
os.path.join(path_to_data, 'bootstrapper', 'DNGNGWU00001.hmm')
],
evalue='1e-5',
maximum_range=1000,
threads=1)
with tempfile.NamedTemporaryFile(suffix=".fasta") as contigs:
contigs.write(">contig\n")
contigs.write('A' * 300 + "\n")
contigs.flush()
with tempfile.NamedTemporaryFile() as tf:
self.assertEqual(False,
expandsearcher.generate_expand_search_database_from_contigs(\
[contigs.name],
tf.name,
"hmmsearch"))
def test_hello_world(self):
expandsearcher = ExpandSearcher(search_hmm_files = [os.path.join(path_to_data,'bootstrapper','DNGNGWU00001.hmm')],
evalue='1e-5',
maximum_range=1000,
threads=1)
with tempfile.NamedTemporaryFile() as tf:
self.assertEqual(True,
expandsearcher.generate_expand_search_database_from_contigs(\
[os.path.join(path_to_data,'bootstrapper','contigs.fna')],
tf.name,
"hmmsearch"))
self.assertTrue(subprocess.check_output("head -n1 %s" % tf.name,
shell=True) in
["HMMER3/f [3.1b2 | February 2015]\n",
"HMMER3/f [3.2.1 | June 2018]\n"])
self.assertEqual('NSEQ 2\n', open(tf.name).readlines()[10])
def test_hello_world_diamond(self):
gpkg = os.path.join(path_to_data, "bootstrapper",
"D1_gpkg_for_diamond.gpkg")
expandsearcher = ExpandSearcher(
search_hmm_files=[
os.path.join(path_to_data, 'bootstrapper', 'DNGNGWU00001.hmm')
],
evalue='1e-5',
maximum_range=1000,
threads=1,
graftm_package=GraftMPackage.acquire(gpkg))
with tempfile.NamedTemporaryFile() as tf:
self.assertEqual(True,
expandsearcher.generate_expand_search_database_from_contigs(\
[os.path.join(path_to_data,'bootstrapper','diamond_bootstrap_contigs.fna')],
tf.name,
"diamond"))
def test_hello_world(self):
expandsearcher = ExpandSearcher(search_hmm_files=[
os.path.join(path_to_data, 'bootstrapper', 'DNGNGWU00001.hmm')
],
evalue='1e-5',
maximum_range=1000,
threads=1)
with tempfile.NamedTemporaryFile() as tf:
self.assertEqual(True,
expandsearcher.generate_expand_search_database_from_contigs(\
[os.path.join(path_to_data,'bootstrapper','contigs.fna')],
tf.name,
"hmmsearch"))
self.assertEqual(
"HMMER3/f [3.1b2 | February 2015]\n",
subprocess.check_output("head -n1 %s" % tf.name, shell=True))
self.assertEqual('NSEQ 2\n', open(tf.name).readlines()[10])
def test_hello_world(self):
expandsearcher = ExpandSearcher(search_hmm_files=[
os.path.join(path_to_data, 'bootstrapper', 'DNGNGWU00001.hmm')
],
evalue='1e-5',
maximum_range=1000,
threads=1)
with tempfile.NamedTemporaryFile() as tf:
self.assertEqual(True,
expandsearcher.generate_expand_search_database_from_contigs(\
[os.path.join(path_to_data,'bootstrapper','contigs.fna')],
tf.name,
"hmmsearch"))
with open(tf.name) as tf2:
lines = list(tf2.readlines())
first_line = lines[0]
self.assertTrue(first_line in [
"HMMER3/f [3.1b2 | February 2015]\n",
"HMMER3/f [3.2.1 | June 2018]\n"
],
msg=f'first_line was {first_line}')
self.assertEqual('NSEQ 2\n', lines[10])
def main(self):
if self.args.subparser_name == 'graft':
if self.args.verbosity >= self._MIN_VERBOSITY_FOR_ART:
print('''
GRAFT
Joel Boyd, Ben Woodcroft
__/__
______|
_- - _ ________| |_____/
- - - | |____/_
- _ >>>> - >>>> ____|
- _- - - | ______
- _ |_____|
- |______
''')
self.graft()
elif self.args.subparser_name == 'create':
if self.args.verbosity >= self._MIN_VERBOSITY_FOR_ART:
print('''
CREATE
Joel Boyd, Ben Woodcroft
/
>a /
------------- /
>b | |
-------- >>> | GPKG |
>c |________|
----------
''')
if self.args.dereplication_level < 0:
logging.error(
"Invalid dereplication level selected! please enter a positive integer"
)
exit(1)
else:
if not self.args.sequences:
if not self.args.alignment and not self.args.rerooted_annotated_tree \
and not self.args.rerooted_tree:
logging.error(
"Some sort of sequence data must be provided to run graftM create"
)
exit(1)
if self.args.taxonomy:
if self.args.rerooted_annotated_tree:
logging.error(
"--taxonomy is incompatible with --rerooted_annotated_tree"
)
exit(1)
if self.args.taxtastic_taxonomy or self.args.taxtastic_seqinfo:
logging.error(
"--taxtastic_taxonomy and --taxtastic_seqinfo are incompatible with --taxonomy"
)
exit(1)
elif self.args.rerooted_annotated_tree:
if self.args.taxtastic_taxonomy or self.args.taxtastic_seqinfo:
logging.error(
"--taxtastic_taxonomy and --taxtastic_seqinfo are incompatible with --rerooted_annotated_tree"
)
exit(1)
else:
if not self.args.taxtastic_taxonomy or not self.args.taxtastic_seqinfo:
logging.error(
"--taxonomy, --rerooted_annotated_tree or --taxtastic_taxonomy/--taxtastic_seqinfo is required"
)
exit(1)
if bool(self.args.taxtastic_taxonomy) ^ bool(
self.args.taxtastic_seqinfo):
logging.error(
"Both or neither of --taxtastic_taxonomy and --taxtastic_seqinfo must be defined"
)
exit(1)
if self.args.alignment and self.args.hmm:
logging.warn(
"Using both --alignment and --hmm is rarely useful, but proceding on the assumption you understand."
)
if len([
_f for _f in [
self.args.rerooted_tree,
self.args.rerooted_annotated_tree, self.args.tree
] if _f
]) > 1:
logging.error("Only 1 input tree can be specified")
exit(1)
self.create.main(
dereplication_level=self.args.dereplication_level,
sequences=self.args.sequences,
alignment=self.args.alignment,
taxonomy=self.args.taxonomy,
rerooted_tree=self.args.rerooted_tree,
unrooted_tree=self.args.tree,
tree_log=self.args.tree_log,
prefix=self.args.output,
rerooted_annotated_tree=self.args.rerooted_annotated_tree,
min_aligned_percent=float(self.args.min_aligned_percent) /
100,
taxtastic_taxonomy=self.args.taxtastic_taxonomy,
taxtastic_seqinfo=self.args.taxtastic_seqinfo,
hmm=self.args.hmm,
search_hmm_files=self.args.search_hmm_files,
force=self.args.force,
threads=self.args.threads)
elif self.args.subparser_name == 'update':
logging.info(
"GraftM package %s specified to update with sequences in %s" %
(self.args.graftm_package, self.args.sequences))
if self.args.regenerate_diamond_db:
gpkg = GraftMPackage.acquire(self.args.graftm_package)
logging.info("Regenerating diamond DB..")
gpkg.create_diamond_db()
logging.info("Diamond database regenerated.")
return
elif not self.args.sequences:
logging.error(
"--sequences is required unless regenerating the diamond DB"
)
exit(1)
if not self.args.output:
if self.args.graftm_package.endswith(".gpkg"):
self.args.output = self.args.graftm_package.replace(
".gpkg", "-updated.gpkg")
else:
self.args.output = self.args.graftm_package + '-update.gpkg'
Update(
ExternalProgramSuite([
'taxit', 'FastTreeMP', 'hmmalign', 'mafft'
])).update(input_sequence_path=self.args.sequences,
input_taxonomy_path=self.args.taxonomy,
input_graftm_package_path=self.args.graftm_package,
output_graftm_package_path=self.args.output)
elif self.args.subparser_name == 'expand_search':
args = self.args
if not args.graftm_package and not args.search_hmm_files:
logging.error(
"expand_search mode requires either --graftm_package or --search_hmm_files"
)
exit(1)
if args.graftm_package:
pkg = GraftMPackage.acquire(args.graftm_package)
else:
pkg = None
expandsearcher = ExpandSearcher(
search_hmm_files=args.search_hmm_files,
maximum_range=args.maximum_range,
threads=args.threads,
evalue=args.evalue,
min_orf_length=args.min_orf_length,
graftm_package=pkg)
expandsearcher.generate_expand_search_database_from_contigs(
args.contigs,
args.output_hmm,
search_method=ExpandSearcher.HMM_SEARCH_METHOD)
elif self.args.subparser_name == 'tree':
if self.args.graftm_package:
# shim in the paths from the graftm package, not overwriting
# any of the provided paths.
gpkg = GraftMPackage.acquire(self.args.graftm_package)
if not self.args.rooted_tree:
self.args.rooted_tree = gpkg.reference_package_tree_path()
if not self.args.input_greengenes_taxonomy:
if not self.args.input_taxtastic_seqinfo:
self.args.input_taxtastic_seqinfo = gpkg.taxtastic_seqinfo_path(
)
if not self.args.input_taxtastic_taxonomy:
self.args.input_taxtastic_taxonomy = gpkg.taxtastic_taxonomy_path(
)
if self.args.rooted_tree:
if self.args.unrooted_tree:
logging.error(
"Both a rooted tree and an un-rooted tree were provided, so it's unclear what you are asking GraftM to do. \
If you're unsure see graftM tree -h")
exit(1)
elif self.args.reference_tree:
logging.error(
"Both a rooted tree and reference tree were provided, so it's unclear what you are asking GraftM to do. \
If you're unsure see graftM tree -h")
exit(1)
if not self.args.decorate:
logging.error(
"It seems a rooted tree has been provided, but --decorate has not been specified so it is unclear what you are asking graftM to do."
)
exit(1)
dec = Decorator(tree_path=self.args.rooted_tree)
elif self.args.unrooted_tree and self.args.reference_tree:
logging.debug(
"Using provided reference tree %s to reroot %s" %
(self.args.reference_tree, self.args.unrooted_tree))
dec = Decorator(reference_tree_path=self.args.reference_tree,
tree_path=self.args.unrooted_tree)
else:
logging.error(
"Some tree(s) must be provided, either a rooted tree or both an unrooted tree and a reference tree"
)
exit(1)
if self.args.output_taxonomy is None and self.args.output_tree is None:
logging.error(
"Either an output tree or taxonomy must be provided")
exit(1)
if self.args.input_greengenes_taxonomy:
if self.args.input_taxtastic_seqinfo or self.args.input_taxtastic_taxonomy:
logging.error(
"Both taxtastic and greengenes taxonomy were provided, so its unclear what taxonomy you want graftM to decorate with"
)
exit(1)
logging.debug("Using input GreenGenes style taxonomy file")
dec.main(self.args.input_greengenes_taxonomy,
self.args.output_tree, self.args.output_taxonomy,
self.args.no_unique_tax, self.args.decorate, None)
elif self.args.input_taxtastic_seqinfo and self.args.input_taxtastic_taxonomy:
logging.debug("Using input taxtastic style taxonomy/seqinfo")
dec.main(self.args.input_taxtastic_taxonomy,
self.args.output_tree, self.args.output_taxonomy,
self.args.no_unique_tax, self.args.decorate,
self.args.input_taxtastic_seqinfo)
else:
logging.error(
"Either a taxtastic taxonomy or seqinfo file was provided. GraftM cannot continue without both."
)
exit(1)
elif self.args.subparser_name == 'archive':
# Back slashes in the ASCII art are escaped.
if self.args.verbosity >= self._MIN_VERBOSITY_FOR_ART:
print("""
ARCHIVE
Joel Boyd, Ben Woodcroft
____.----.
____.----' \\
\\ \\
\\ \\
\\ \\
\\ ____.----'`--.__
\\___.----' | `--.____
/`-._ | __.-' \\
/ `-._ ___.---' \\
/ `-.____.---' \\ +------+
/ / | \\ \\ |`. |`.
/ / | \\ _.--' <===> | `+--+---+
`-. / | \\ __.--' | | | |
`-._ / | \\ __.--' | | | | |
| `-./ | \\_.-' | +---+--+ |
| | | `. | `. |
| | | `+------+
| | |
| | |
| | |
| | |
| | |
`-. | _.-'
`-. | __..--'
`-. | __.-'
`-|__.--'
""")
if self.args.create:
if self.args.extract:
logging.error(
"Please specify whether to either create or export a GraftM package"
)
exit(1)
if not self.args.graftm_package:
logging.error(
"Creating a GraftM package archive requires an package to be specified"
)
exit(1)
if not self.args.archive:
logging.error(
"Creating a GraftM package archive requires an output archive path to be specified"
)
exit(1)
archive = Archive()
archive.create(self.args.graftm_package,
self.args.archive,
force=self.args.force)
elif self.args.extract:
archive = Archive()
archive.extract(self.args.archive,
self.args.graftm_package,
force=self.args.force)
else:
logging.error(
"Please specify whether to either create or export a GraftM package"
)
exit(1)
else:
raise Exception("Unexpected subparser name %s" %
self.args.subparser_name)
def graft(self):
# The Graft pipeline:
# Searches for reads using hmmer, and places them in phylogenetic
# trees to derive a community structure.
if self.args.graftm_package:
gpkg = GraftMPackage.acquire(self.args.graftm_package)
else:
gpkg = None
REVERSE_PIPE = (True if self.args.reverse else False)
INTERLEAVED = (True if self.args.interleaved else False)
base_list = []
seqs_list = []
search_results = []
hit_read_count_list = []
db_search_results = []
if gpkg:
maximum_range = gpkg.maximum_range()
if self.args.search_diamond_file:
self.args.search_method = self.hk.DIAMOND_SEARCH_METHOD
diamond_db = self.args.search_diamond_file[0]
else:
diamond_db = gpkg.diamond_database_path()
if self.args.search_method == self.hk.DIAMOND_SEARCH_METHOD:
if not diamond_db:
logging.error(
"%s search method selected, but no diamond database specified. \
Please either provide a gpkg to the --graftm_package flag, or a diamond \
database to the --search_diamond_file flag." %
self.args.search_method)
raise Exception()
else:
# Get the maximum range, if none exists, make one from the HMM profile
if self.args.maximum_range:
maximum_range = self.args.maximum_range
else:
if self.args.search_method == self.hk.HMMSEARCH_SEARCH_METHOD:
if not self.args.search_only:
maximum_range = self.hk.get_maximum_range(
self.args.aln_hmm_file)
else:
logging.debug(
"Running search only pipeline. maximum_range not configured."
)
maximum_range = None
else:
logging.warning(
'Cannot determine maximum range when using %s pipeline and with no GraftM package specified'
% self.args.search_method)
logging.warning(
'Setting maximum_range to None (linked hits will not be detected)'
)
maximum_range = None
if self.args.search_diamond_file:
diamond_db = self.args.search_diamond_file
else:
if self.args.search_method == self.hk.HMMSEARCH_SEARCH_METHOD:
diamond_db = None
else:
logging.error(
"%s search method selected, but no gpkg or diamond database selected"
% self.args.search_method)
if self.args.assignment_method == Run.DIAMOND_TAXONOMIC_ASSIGNMENT:
if self.args.reverse:
logging.warn(
"--reverse reads specified with --assignment_method diamond. Reverse reads will be ignored."
)
self.args.reverse = None
# If merge reads is specified, check that there are reverse reads to merge with
if self.args.merge_reads and not hasattr(self.args, 'reverse'):
raise Exception("Programming error")
# Set the output directory if not specified and create that directory
logging.debug('Creating working directory: %s' %
self.args.output_directory)
self.hk.make_working_directory(self.args.output_directory,
self.args.force)
# Set pipeline and evalue by checking HMM format
if self.args.search_only:
if self.args.search_method == self.hk.HMMSEARCH_SEARCH_METHOD:
hmm_type, hmm_tc = self.hk.setpipe(
self.args.search_hmm_files[0])
logging.debug("HMM type: %s Trusted Cutoff: %s" %
(hmm_type, hmm_tc))
else:
hmm_type, hmm_tc = self.hk.setpipe(self.args.aln_hmm_file)
logging.debug("HMM type: %s Trusted Cutoff: %s" %
(hmm_type, hmm_tc))
if self.args.search_method == self.hk.HMMSEARCH_SEARCH_METHOD:
setattr(self.args, 'type', hmm_type)
if hmm_tc:
setattr(self.args, 'evalue', '--cut_tc')
else:
setattr(self.args, 'type', self.PIPELINE_AA)
if self.args.filter_minimum is not None:
filter_minimum = self.args.filter_minimum
else:
if self.args.type == self.PIPELINE_NT:
filter_minimum = Run.MIN_ALIGNED_FILTER_FOR_NUCLEOTIDE_PACKAGES
else:
filter_minimum = Run.MIN_ALIGNED_FILTER_FOR_AMINO_ACID_PACKAGES
# Generate expand_search database if required
if self.args.expand_search_contigs:
if self.args.graftm_package:
pkg = GraftMPackage.acquire(self.args.graftm_package)
else:
pkg = None
boots = ExpandSearcher(search_hmm_files=self.args.search_hmm_files,
maximum_range=self.args.maximum_range,
threads=self.args.threads,
evalue=self.args.evalue,
min_orf_length=self.args.min_orf_length,
graftm_package=pkg)
# this is a hack, it should really use GraftMFiles but that class isn't currently flexible enough
new_database = (os.path.join(self.args.output_directory, "expand_search.hmm") \
if self.args.search_method == self.hk.HMMSEARCH_SEARCH_METHOD \
else os.path.join(self.args.output_directory, "expand_search")
)
if boots.generate_expand_search_database_from_contigs(
self.args.expand_search_contigs, new_database,
self.args.search_method):
if self.args.search_method == self.hk.HMMSEARCH_SEARCH_METHOD:
self.ss.search_hmm.append(new_database)
else:
diamond_db = new_database
first_search_method = self.args.search_method
if self.args.decoy_database:
decoy_filter = DecoyFilter(
Diamond(diamond_db, threads=self.args.threads),
Diamond(self.args.decoy_database, threads=self.args.threads))
doing_decoy_search = True
elif self.args.search_method == self.hk.HMMSEARCH_AND_DIAMOND_SEARCH_METHOD:
decoy_filter = DecoyFilter(
Diamond(diamond_db, threads=self.args.threads))
doing_decoy_search = True
first_search_method = self.hk.HMMSEARCH_SEARCH_METHOD
else:
doing_decoy_search = False
# For each pair (or single file passed to GraftM)
logging.debug('Working with %i file(s)' % len(self.sequence_pair_list))
for pair in self.sequence_pair_list:
# Guess the sequence file type, if not already specified to GraftM
unpack = UnpackRawReads(pair[0], self.args.input_sequence_type,
INTERLEAVED)
# Set the basename, and make an entry to the summary table.
base = unpack.basename()
pair_direction = ['forward', 'reverse']
logging.info("Working on %s" % base)
# Make the working base subdirectory
self.hk.make_working_directory(
os.path.join(self.args.output_directory, base),
self.args.force)
# for each of the paired end read files
for read_file in pair:
unpack = UnpackRawReads(read_file,
self.args.input_sequence_type,
INTERLEAVED)
if read_file is None:
# placeholder for interleaved (second file is None)
continue
if not os.path.isfile(read_file): # Check file exists
logging.info('%s does not exist! Skipping this file..' %
read_file)
continue
# Set the output file_name
if len(pair) == 2:
direction = 'interleaved' if pair[1] is None \
else pair_direction.pop(0)
logging.info("Working on %s reads" % direction)
self.gmf = GraftMFiles(base, self.args.output_directory,
direction)
self.hk.make_working_directory(
os.path.join(self.args.output_directory, base,
direction), self.args.force)
else:
direction = False
self.gmf = GraftMFiles(base, self.args.output_directory,
direction)
if self.args.type == self.PIPELINE_AA:
logging.debug("Running protein pipeline")
try:
search_time, (
result,
complement_information) = self.ss.aa_db_search(
self.gmf,
base,
unpack,
first_search_method,
maximum_range,
self.args.threads,
self.args.evalue,
self.args.min_orf_length,
self.args.restrict_read_length,
diamond_db,
self.args.diamond_performance_parameters,
)
except NoInputSequencesException as e:
logging.error(
"No sufficiently long open reading frames were found, indicating"
" either the input sequences are too short or the min orf length"
" cutoff is too high. Cannot continue sorry. Alternatively, there"
" is something amiss with the installation of OrfM. The specific"
" command that failed was: %s" % e.command)
exit(Run.NO_ORFS_EXITSTATUS)
# Or the DNA pipeline
elif self.args.type == self.PIPELINE_NT:
logging.debug("Running nucleotide pipeline")
search_time, (
result, complement_information) = self.ss.nt_db_search(
self.gmf, base, unpack, self.args.euk_check,
self.args.search_method, maximum_range,
self.args.threads, self.args.evalue)
reads_detected = True
if not result.hit_fasta() or os.path.getsize(
result.hit_fasta()) == 0:
logging.info('No reads found in %s' % base)
reads_detected = False
if self.args.search_only:
db_search_results.append(result)
base_list.append(base)
continue
# Filter out decoys if specified
if reads_detected and doing_decoy_search:
with tempfile.NamedTemporaryFile(prefix="graftm_decoy",
suffix='.fa') as f:
tmpname = f.name
any_remaining = decoy_filter.filter(
result.hit_fasta(), tmpname)
if any_remaining:
shutil.move(tmpname, result.hit_fasta())
else:
# No hits remain after decoy filtering.
os.remove(result.hit_fasta())
continue
if self.args.assignment_method == Run.PPLACER_TAXONOMIC_ASSIGNMENT:
logging.info(
'aligning reads to reference package database')
hit_aligned_reads = self.gmf.aligned_fasta_output_path(
base)
if reads_detected:
aln_time, aln_result = self.ss.align(
result.hit_fasta(), hit_aligned_reads,
complement_information, self.args.type,
filter_minimum)
else:
aln_time = 'n/a'
if not os.path.exists(
hit_aligned_reads
): # If all were filtered out, or there just was none..
with open(hit_aligned_reads, 'w') as f:
pass # just touch the file, nothing else
seqs_list.append(hit_aligned_reads)
db_search_results.append(result)
base_list.append(base)
search_results.append(result.search_result)
hit_read_count_list.append(result.hit_count)
# Write summary table
srchtw = SearchTableWriter()
srchtw.build_search_otu_table(
[x.search_objects for x in db_search_results], base_list,
self.gmf.search_otu_table())
if self.args.search_only:
logging.info(
'Stopping before alignment and taxonomic assignment phase\n')
exit(0)
if self.args.merge_reads: # not run when diamond is the assignment mode- enforced by argparse grokking
logging.debug("Running merge reads output")
if self.args.interleaved:
fwd_seqs = seqs_list
rev_seqs = []
else:
base_list = base_list[0::2]
fwd_seqs = seqs_list[0::2]
rev_seqs = seqs_list[1::2]
merged_output=[GraftMFiles(base, self.args.output_directory, False).aligned_fasta_output_path(base) \
for base in base_list]
logging.debug("merged reads to %s", merged_output)
self.ss.merge_forev_aln(fwd_seqs, rev_seqs, merged_output)
seqs_list = merged_output
REVERSE_PIPE = False
elif REVERSE_PIPE:
base_list = base_list[0::2]
# Leave the pipeline if search only was specified
if self.args.search_and_align_only:
logging.info('Stopping before taxonomic assignment phase\n')
exit(0)
elif not any(base_list):
logging.error(
'No hits in any of the provided files. Cannot continue with no reads to assign taxonomy to.\n'
)
exit(0)
self.gmf = GraftMFiles('', self.args.output_directory, False)
if self.args.assignment_method == Run.PPLACER_TAXONOMIC_ASSIGNMENT:
clusterer = Clusterer()
# Classification steps
seqs_list = clusterer.cluster(seqs_list, REVERSE_PIPE)
logging.info("Placing reads into phylogenetic tree")
taxonomic_assignment_time, assignments = self.p.place(
REVERSE_PIPE, seqs_list, self.args.resolve_placements,
self.gmf, self.args, result.slash_endings,
gpkg.taxtastic_taxonomy_path(), clusterer)
assignments = clusterer.uncluster_annotations(
assignments, REVERSE_PIPE)
elif self.args.assignment_method == Run.DIAMOND_TAXONOMIC_ASSIGNMENT:
logging.info("Assigning taxonomy with diamond")
taxonomic_assignment_time, assignments = self._assign_taxonomy_with_diamond(\
base_list,
db_search_results,
gpkg,
self.gmf,
self.args.diamond_performance_parameters)
aln_time = 'n/a'
else:
raise Exception("Unexpected assignment method encountered: %s" %
self.args.placement_method)
self.summarise(base_list, assignments, REVERSE_PIPE,
[search_time, aln_time, taxonomic_assignment_time],
hit_read_count_list, self.args.max_samples_for_krona)