def init_profile_from_BAM(self):
self.progress.new('Init')
self.progress.update('Reading BAM File')
self.bam = bamops.BAMFileObject(self.input_file_path, run=self.run, progress=self.progress).get()
self.num_reads_mapped = self.bam.mapped
self.progress.end()
self.contig_names = self.bam.references
self.contig_lengths = self.bam.lengths
utils.check_contig_names(self.contig_names)
self.run.info('input_bam', self.input_file_path)
self.run.info('output_dir', self.output_directory, display_only=True)
self.run.info('total_reads_mapped', pp(int(self.num_reads_mapped)))
self.run.info('num_contigs', pp(len(self.contig_names)))
if self.contig_names_of_interest:
indexes = [self.contig_names.index(r) for r in self.contig_names_of_interest if r in self.contig_names]
self.contig_names = [self.contig_names[i] for i in indexes]
self.contig_lengths = [self.contig_lengths[i] for i in indexes]
self.run.info('num_contigs_selected_for_analysis', pp(len(self.contig_names)))
# it brings good karma to let the user know what the hell is wrong with their data:
self.check_contigs_without_any_gene_calls(self.contig_names)
# check for the -M parameter.
self.remove_contigs_based_on_min_max_contig_length()
# let's see whether the user screwed up to follow the simple instructions
# mentioned here: http://merenlab.org/2015/05/01/anvio-tutorial/#preparation
for contig_name in self.contig_names:
if contig_name not in self.contig_names_in_contigs_db:
raise ConfigError("At least one contig name in your BAM file does not match contig names stored in the\
contigs database. For instance, this is one contig name found in your BAM file: '%s',\
and this is another one found in your contigs database: '%s'. You may be using an\
contigs database for profiling that has nothing to do with the BAM file you are\
trying to profile, or you may have failed to fix your contig names in your FASTA file\
prior to mapping, which is described here: %s"\
% (contig_name, self.contig_names_in_contigs_db.pop(), 'http://goo.gl/Q9ChpS'))
self.run.info('num_contigs_after_M', self.num_contigs, display_only=True)
self.run.info('num_contigs', self.num_contigs, quiet=True)
self.run.info('num_splits', self.num_splits)
self.run.info('total_length', self.total_length)
self.run.info('max_coverage_depth', pp(self.max_coverage_depth))
profile_db = dbops.ProfileDatabase(self.profile_db_path, quiet=True)
profile_db.db.set_meta_value('num_splits', self.num_splits)
profile_db.db.set_meta_value('num_contigs', self.num_contigs)
profile_db.db.set_meta_value('total_length', self.total_length)
profile_db.disconnect()
self.layer_additional_data['total_reads_mapped'] = self.num_reads_mapped
self.layer_additional_keys.append('total_reads_mapped')
def process_db(self, entry_name, profile_db_path, bam_file_path):
"""Function that does everything.
`entry_name` is the entry name in bams and profiles file.
"""
self.progress.new(f"Processing '{entry_name}'")
################################################################################
self.progress.update("Recovering the coverage data")
################################################################################
profile_db = dbops.ProfileSuperclass(argparse.Namespace(
profile_db=profile_db_path, contigs_db=self.contigs_db_path),
r=run_quiet,
p=progress_quiet)
sample_id = profile_db.p_meta['sample_id']
# here we open our bam file with an inversions fetch filter.
# we will access to it later when it is time to get the FWD/FWD and
# REV/REV reads.
bam_file = bamops.BAMFileObject(bam_file_path, 'rb')
if self.process_only_inverted_reads:
bam_file.fetch_filter = 'inversions'
else:
bam_file.fetch_filter = None
################################################################################
self.progress.update("Computing coverage stretches")
################################################################################
# populate coverage stretches in contigs based on coverage data in this
# particular profile_db. we will then go through each stretch to find
# those that include palindromic sequences
contig_coverages = {}
coverage_stretches_in_contigs = {}
for contig_name in self.contig_names:
contig_coverage = np.array([])
split_names = self.contig_name_to_split_names[contig_name]
for i in range(len(split_names)):
split_name = split_names[i]
split_coverages = auxiliarydataops.AuxiliaryDataForSplitCoverages(
profile_db.auxiliary_data_path,
profile_db.p_meta['contigs_db_hash']).get(split_name)
contig_coverage = np.concatenate(
(contig_coverage, split_coverages[sample_id]), axis=None)
# now we know the `contig_coverage`. it is time to break it into stretches
# of 'high coverage' regions (as in coverage > `self.min_coverage_to_define_stretches`), and store that
# information into the dictionary `coverage_stretches_in_contigs`
coverage_stretches_in_contigs[contig_name] = []
# we also know the contig length here, so let's keep that in mind:
contig_length = len(contig_coverage)
# to find regions of high coverage, we first need to 'pad' our array to ensure it always
# starts and ends with 'low coverage'.
regions_of_contig_covered_enough = np.hstack(
[[False],
contig_coverage >= self.min_coverage_to_define_stretches,
[False]])
regions_of_contig_covered_enough_diff = np.diff(
regions_of_contig_covered_enough.astype(int))
cov_stretch_start_positions = np.where(
regions_of_contig_covered_enough_diff == 1)[0]
cov_stretch_end_positions = np.where(
regions_of_contig_covered_enough_diff == -1)[0]
# at this stage, `cov_stretch_start_positions` and `cov_stretch_end_positions` contain pairs of
# positions that match to the begining and end of stretches. we will remove those that are too
# short to be considered, and store the start/end positions for the remaining stretches of
# high coverage into the dictionary `coverage_stretches_in_contigs`
for i in range(0, len(cov_stretch_start_positions)):
cov_stretch_start, cov_stretch_end = cov_stretch_start_positions[
i], cov_stretch_end_positions[i]
if (cov_stretch_end -
cov_stretch_start) >= self.min_stretch_length:
coverage_stretches_in_contigs[contig_name].append(
(cov_stretch_start, cov_stretch_end), )
# now it is time to merge those stretches of coverage if they are close to one another to avoid
# over-splitting areas of coverage due to short regions with low-coverage in the middle like this,
# where we wish to identify A and B together in a single stretch:
#
# A B
#
# - -
# --- --
# ----- -----
# -------- --------
# -----------------------
# -----------------------------------------------
coverage_stretches_in_contigs[contig_name] = utils.merge_stretches(
coverage_stretches_in_contigs[contig_name],
min_distance_between_independent_stretches=self.
min_distance_between_independent_stretches)
# extend start and stop positions of merged stretches to ENSURE we are not
# missing important information because bioinformatics.
coverage_stretches_in_contigs[contig_name] = [(0 if (e[0] - self.num_nts_to_pad_a_stretch< 0) else e[0] - self.num_nts_to_pad_a_stretch,
contig_length if (e[1] + self.num_nts_to_pad_a_stretch) > contig_length else e[1] + self.num_nts_to_pad_a_stretch) \
for e in coverage_stretches_in_contigs[contig_name]]
contig_coverages[contig_name] = contig_coverage
################################################################################
self.progress.update("Getting ready to process stretches")
################################################################################
# time to go through each stretch and look for palindromes
# first, we will set up the Palindromes class
_args = argparse.Namespace(
min_palindrome_length=self.min_palindrome_length,
max_num_mismatches=self.max_num_mismatches,
min_distance=self.min_distance_palindrome)
P = Palindromes(_args, run=run_quiet, progress=progress_quiet)
P.verbose = False
# now we can go through all the stretches to look for palindromes. this is a LOOOOOONG loop.
# down below, we will got through each contig name, find stretches of good coverage of FWD/FWD
# and REV/REV reads (since their coverage values are stored in the profile db of 'inversions'
# type), find palindromes in those sequences that match to those coverage stretches, build some
# constructs, and then go through every FWD/FWD and REV/REV read from the BAM file to see if
# our constructs occur in any of them, which is the only 100% proof of an active inversion.
for contig_name in coverage_stretches_in_contigs:
contig_sequence = self.contig_sequences[contig_name]['sequence']
for start, stop in coverage_stretches_in_contigs[contig_name]:
stretch_sequence_coverage = contig_coverages[contig_name][
start:stop]
stretch_sequence = contig_sequence[start:stop]
sequence_name = f"{contig_name}_{start}_{stop}"
# if the user wants to learn about only a single sequence, we only
# focus on that one and prematurely go to the next stretch unless
# there is a match
if self.only_report_from and sequence_name != self.only_report_from:
continue
# before we go any further, let's print out the sequence in consideration
# for the user if they used `--verbose`
if anvio.DEBUG or self.verbose:
self.progress.reset()
self.run.warning(None,
header=f"Palindromes in {sequence_name}",
lc='yellow',
nl_before=3)
self.run.info_single(f"Sequence {stretch_sequence}",
cut_after=0)
self.run.info_single("Coverage:", nl_before=1, nl_after=1)
self.plot_coverage(f"{sequence_name}",
stretch_sequence_coverage)
################################################################################
self.progress.update(f"{contig_name}: looking for palindromes")
################################################################################
P.find(stretch_sequence,
sequence_name=sequence_name,
display_palindromes=False)
if not len(P.palindromes[sequence_name]):
# there is no palindrome in this one
if anvio.DEBUG or self.verbose:
self.progress.reset()
self.run.info_single("No palindromes in this one :/",
mc="red")
continue
else:
if anvio.DEBUG or self.verbose:
self.progress.reset()
self.run.info_single(
f"The sequence has {PL('palindrome', len(P.palindromes[sequence_name]))}:",
mc="green")
################################################################################
self.progress.update(f"{contig_name}: building constructs")
################################################################################
# this is important. here we are getting ready to test each our inversion candidate
# by reconstructing Florian's imaginary sequences. in the next step we will see if
# any of these sequences are in any of the FWD/FWD or REV/REV reads
inversion_candidates = []
for inversion_candidate in P.palindromes[sequence_name]:
region_A_start = inversion_candidate.first_start - 6
region_A_end = inversion_candidate.first_start
region_A = stretch_sequence[region_A_start:region_A_end]
region_B_start = inversion_candidate.first_end
region_B_end = inversion_candidate.first_end + 6
region_B = stretch_sequence[region_B_start:region_B_end]
region_C_start = inversion_candidate.second_start - 6
region_C_end = inversion_candidate.second_start
region_C = stretch_sequence[region_C_start:region_C_end]
region_D_start = inversion_candidate.second_end
region_D_end = inversion_candidate.second_end + 6
region_D = stretch_sequence[region_D_start:region_D_end]
construct_v1_left = region_A + inversion_candidate.first_sequence + utils.rev_comp(
region_C)
construct_v1_right = utils.rev_comp(
region_B) + utils.rev_comp(
inversion_candidate.second_sequence) + region_D
construct_v2_left = region_A + inversion_candidate.second_sequence + utils.rev_comp(
region_C)
construct_v2_right = utils.rev_comp(
region_B) + utils.rev_comp(
inversion_candidate.first_sequence) + region_D
# update the palindrome instance with its constructs
inversion_candidate.v1_left = construct_v1_left
inversion_candidate.v1_right = construct_v1_right
inversion_candidate.v2_left = construct_v2_left
inversion_candidate.v2_right = construct_v2_right
if anvio.DEBUG or self.verbose:
self.progress.reset()
inversion_candidate.display()
self.run.info("Construct v1 left",
construct_v1_left,
mc="cyan")
self.run.info("Construct v1 right",
construct_v1_right,
mc="cyan")
self.run.info("Construct v2 left",
construct_v2_left,
mc="cyan")
self.run.info("Construct v2 right",
construct_v2_right,
mc="cyan")
inversion_candidates.append(inversion_candidate)
# here we have, for a given `contig_name` and `start` and `stop` positions of a stretch in it, we have our inversion candidates,
################################################################################
self.progress.update(
f"{contig_name}[{start}:{stop}]: testing constructs")
################################################################################
true_inversion = None
for read in bam_file.fetch_only(contig_name,
start=start,
end=stop):
for inversion_candidate in inversion_candidates:
if inversion_candidate.v1_left in read.query_sequence:
true_inversion = inversion_candidate
break
elif inversion_candidate.v1_right in read.query_sequence:
true_inversion = inversion_candidate
break
elif inversion_candidate.v2_left in read.query_sequence:
true_inversion = inversion_candidate
break
elif inversion_candidate.v2_right in read.query_sequence:
true_inversion = inversion_candidate
break
if anvio.DEBUG or self.verbose:
if true_inversion:
self.progress.reset()
self.run.info_single(
f"Of the {PL('inversion candidate', len(inversion_candidates))} above, "
f"the one below had at least one perfect matches to their constructs in REV/REV or "
f"FWD/FWD reads from the BAM file:",
mc="green",
nl_before=1)
true_inversion.display()
else:
self.progress.reset()
self.run.info_single(
f"No true inversions in this one: none of the REV/REV or FWD/FWD reads "
f"had any of the constructs in {PL('inversion candidate', len(inversion_candidates))}.",
mc="red",
nl_before=1)
self.progress.end()
def init_profile_from_BAM(self):
self.progress.new('Init')
self.progress.update('Reading BAM File')
self.bam = bamops.BAMFileObject(self.input_file_path,
run=self.run,
progress=self.progress).get()
self.num_reads_mapped = self.bam.mapped
self.progress.end()
self.contig_names = self.bam.references
self.contig_lengths = self.bam.lengths
utils.check_contig_names(self.contig_names)
runinfo = self.generate_output_destination('RUNINFO')
self.run.init_info_file_obj(runinfo)
self.run.info('input_bam', self.input_file_path)
self.run.info('output_dir', self.output_directory, display_only=True)
self.run.info('total_reads_mapped', pp(int(self.num_reads_mapped)))
self.run.info('num_contigs', pp(len(self.contig_names)))
if self.contig_names_of_interest:
indexes = [
self.contig_names.index(r)
for r in self.contig_names_of_interest
if r in self.contig_names
]
self.contig_names = [self.contig_names[i] for i in indexes]
self.contig_lengths = [self.contig_lengths[i] for i in indexes]
self.run.info('num_contigs_selected_for_analysis',
pp(len(self.contig_names)))
# it brings good karma to let the user know what the hell is wrong with their data:
self.check_contigs_without_any_gene_calls(self.contig_names)
# check for the -M parameter.
contigs_longer_than_M = set()
for i in range(0, len(self.contig_names)):
if self.contig_lengths[i] >= self.min_contig_length:
contigs_longer_than_M.add(i)
if not len(contigs_longer_than_M):
raise ConfigError, "0 contigs larger than %s nts." % pp(
self.min_contig_length)
else:
self.contig_names = [
self.contig_names[i] for i in contigs_longer_than_M
]
self.contig_lengths = [
self.contig_lengths[i] for i in contigs_longer_than_M
]
self.num_contigs = len(
self.contig_names) # we will store these two
self.total_length = sum(
self.contig_lengths) # into the db in a second.
# let's see whether the user screwed up to follow the simple instructions
# mentioned here: http://merenlab.org/2015/05/01/anvio-tutorial/#preparation
for contig_name in self.contig_names:
if contig_name not in self.contig_names_in_contigs_db:
raise ConfigError, "At least one contig name in your BAM file does not match contig names stored in the\
contigs database. For instance, this is one contig name found in your BAM file: '%s',\
and this is another one found in your contigs database: '%s'. You may be using an\
contigs database for profiling that has nothing to do with the BAM file you are\
trying to profile, or you may have failed to fix your contig names in your FASTA file\
prior to mapping, which is described here: %s"\
% (contig_name, self.contig_names_in_contigs_db.pop(), 'http://goo.gl/Q9ChpS')
contigs_longer_than_M = set(self.contig_names) # for fast access
self.split_names = set([])
self.contig_name_to_splits = {}
for split_name in sorted(self.splits_basic_info.keys()):
parent = self.splits_basic_info[split_name]['parent']
if parent not in contigs_longer_than_M:
continue
self.split_names.add(split_name)
if self.contig_name_to_splits.has_key(parent):
self.contig_name_to_splits[parent].append(split_name)
else:
self.contig_name_to_splits[parent] = [split_name]
# we just recovered number of splits that are coming from contigs
# longer than M:
self.num_splits = len(self.split_names)
self.run.info('num_contigs_after_M',
self.num_contigs,
display_only=True)
self.run.info('num_contigs', self.num_contigs, quiet=True)
self.run.info('num_splits', self.num_splits)
self.run.info('total_length', self.total_length)
profile_db = dbops.ProfileDatabase(self.profile_db_path, quiet=True)
profile_db.db.set_meta_value('num_splits', self.num_splits)
profile_db.db.set_meta_value('num_contigs', self.num_contigs)
profile_db.db.set_meta_value('total_length', self.total_length)
profile_db.db.set_meta_value('total_reads_mapped',
int(self.num_reads_mapped))
profile_db.disconnect()
