def test_get_depths_at_position(self):
'''test get_depths_at_position'''
bam = os.path.join(
data_dir, 'samtools_variants_test_get_depths_at_position.bam')
ref_fa = os.path.join(
data_dir, 'samtools_variants_test_get_depths_at_position.ref.fa')
tmp_prefix = 'tmp.test_get_depths_at_position'
samtools_vars = samtools_variants.SamtoolsVariants(
ref_fa,
bam,
tmp_prefix,
)
samtools_vars.run()
tests = [(('ref', 425), ('C,T', 31, '18,13')),
(('not_a_ref', 10), ('ND', 'ND', 'ND')),
(('ref', 1000000000), ('ND', 'ND', 'ND'))]
for (ref, pos), expected in tests:
got = samtools_vars.get_depths_at_position(ref, pos)
self.assertEqual(expected, got)
os.unlink(samtools_vars.vcf_file)
os.unlink(samtools_vars.read_depths_file)
os.unlink(samtools_vars.read_depths_file + '.tbi')
os.unlink(samtools_vars.contig_depths_file)
def _run(self):
print('{:_^79}'.format(' LOG FILE START ' + self.name + ' '),
file=self.log_fh,
flush=True)
if self.total_reads == 0:
print('No reads left after filtering with cdhit',
file=self.log_fh,
flush=True)
self.assembled_ok = False
else:
wanted_reads = self._number_of_reads_for_assembly(
self.longest_ref_length, self.reads_insert,
self.total_reads_bases, self.total_reads,
self.assembly_coverage)
made_reads = self._make_reads_for_assembly(
wanted_reads,
self.total_reads,
self.all_reads1,
self.all_reads2,
self.reads_for_assembly1,
self.reads_for_assembly2,
random_seed=self.random_seed)
print('\nUsing',
made_reads,
'from a total of',
self.total_reads,
'for assembly.',
file=self.log_fh,
flush=True)
print('Assembling reads:', file=self.log_fh, flush=True)
self._update_threads()
self.assembly = assembly.Assembly(
self.reads_for_assembly1,
self.reads_for_assembly2,
self.reference_fa,
self.references_fa,
self.assembly_dir,
self.final_assembly_fa,
self.final_assembly_bam,
self.log_fh,
self.all_refs_fasta,
contig_name_prefix=self.name,
assembler=self.assembler,
extern_progs=self.extern_progs,
clean=self.clean,
spades_mode=self.spades_mode,
spades_options=self.spades_options,
threads=self.threads)
self.assembly.run()
self.assembled_ok = self.assembly.assembled_ok
self._clean_file(self.reads_for_assembly1)
self._clean_file(self.reads_for_assembly2)
if self.clean:
print('Deleting Assembly directory',
self.assembly_dir,
file=self.log_fh,
flush=True)
shutil.rmtree(self.assembly_dir, ignore_errors=True)
if self.assembled_ok and self.assembly.ref_seq_name is not None:
self.ref_sequence = self.refdata.sequence(
self.assembly.ref_seq_name)
is_gene, is_variant_only = self.refdata.sequence_type(
self.ref_sequence.id)
self.is_gene = '1' if is_gene == 'p' else '0'
self.is_variant_only = '1' if is_variant_only else '0'
print('\nAssembly was successful\n\nMapping reads to assembly:',
file=self.log_fh,
flush=True)
self._update_threads()
mapping.run_bowtie2(
self.all_reads1,
self.all_reads2,
self.final_assembly_fa,
self.final_assembly_bam[:-4],
threads=self.threads,
sort=True,
bowtie2=self.extern_progs.exe('bowtie2'),
bowtie2_preset='very-sensitive-local',
bowtie2_version=self.extern_progs.version('bowtie2'),
verbose=True,
verbose_filehandle=self.log_fh)
if self.assembly.has_contigs_on_both_strands:
self.status_flag.add('hit_both_strands')
print('\nMaking and checking scaffold graph',
file=self.log_fh,
flush=True)
if not self.assembly.scaff_graph_ok:
self.status_flag.add('scaffold_graph_bad')
print('Comparing assembly against reference sequence',
file=self.log_fh,
flush=True)
self.assembly_compare = assembly_compare.AssemblyCompare(
self.final_assembly_fa,
self.assembly.sequences,
self.reference_fa,
self.ref_sequence,
self.assembly_compare_prefix,
self.refdata,
nucmer_min_id=self.nucmer_min_id,
nucmer_min_len=self.nucmer_min_len,
nucmer_breaklen=self.nucmer_breaklen,
assembled_threshold=self.assembled_threshold,
unique_threshold=self.unique_threshold,
max_gene_nt_extend=self.max_gene_nt_extend,
)
self.assembly_compare.run()
self.status_flag = self.assembly_compare.update_flag(
self.status_flag)
allowed_ctg_pos, allowed_ref_pos = assembly_compare.AssemblyCompare.nucmer_hits_to_ref_and_qry_coords(
self.assembly_compare.nucmer_hits)
assembly_variants_obj = assembly_variants.AssemblyVariants(
self.refdata, self.assembly_compare.nucmer_snps_file)
self.assembly_variants = assembly_variants_obj.get_variants(
self.ref_sequence.id, allowed_ctg_pos, allowed_ref_pos)
for var_list in self.assembly_variants.values():
for var in var_list:
if var[3] not in ['.', 'SYN', None]:
self.status_flag.add('has_variant')
break
if self.status_flag.has('has_variant'):
break
print('\nCalling variants with samtools:',
file=self.log_fh,
flush=True)
self.samtools_vars = samtools_variants.SamtoolsVariants(
self.final_assembly_fa,
self.final_assembly_bam,
self.samtools_vars_prefix,
log_fh=self.log_fh,
min_var_read_depth=self.min_var_read_depth,
min_second_var_read_depth=self.min_second_var_read_depth,
max_allele_freq=self.max_allele_freq)
self.samtools_vars.run()
self.total_contig_depths = self.samtools_vars.total_depth_per_contig(
self.samtools_vars.contig_depths_file)
self.variants_from_samtools = self.samtools_vars.variants_in_coords(
self.assembly_compare.assembly_match_coords(),
self.samtools_vars.vcf_file)
if len(self.variants_from_samtools):
self.status_flag.add('variants_suggest_collapsed_repeat')
elif not self.assembled_ok:
print('\nAssembly failed\n', file=self.log_fh, flush=True)
self.status_flag.add('assembly_fail')
elif self.assembly.ref_seq_name is None:
print('\nCould not get closest reference sequence\n',
file=self.log_fh,
flush=True)
self.status_flag.add('ref_seq_choose_fail')
try:
self.report_lines = report.report_lines(self)
except:
print('Error making report for cluster ',
self.name,
'... traceback:',
file=sys.stderr)
traceback.print_exc(file=sys.stderr)
raise Error('Error making report for cluster ' + self.name)
self._clean()
atexit.unregister(self._atexit)
def test_make_vcf_and_depths_files(self):
'''test _make_vcf_and_read_depths_files'''
ref = os.path.join(
data_dir, 'samtools_variants_make_vcf_and_depths_files.asmbly.fa')
bam = os.path.join(data_dir,
'samtools_variants_make_vcf_and_depths_files.bam')
expected_vcf = os.path.join(
data_dir, 'samtools_variants_make_vcf_and_depths_files.expect.vcf')
expected_depths = os.path.join(
data_dir,
'samtools_variants_make_vcf_and_depths_files.expect.depths.gz')
expected_coverage = os.path.join(
data_dir, 'samtools_variants_make_vcf_and_depths_files.expect.cov')
tmp_prefix = 'tmp.test_make_vcf_and_depths_files'
sv = samtools_variants.SamtoolsVariants(
ref,
bam,
tmp_prefix,
)
sv._make_vcf_and_read_depths_files()
def get_vcf_call_lines(fname):
with open(fname) as f:
lines = [x for x in f.readlines() if not x.startswith('#')]
return lines
expected_lines = get_vcf_call_lines(expected_vcf)
got_lines = get_vcf_call_lines(sv.vcf_file)
# need to check that the vcf lines look the same. Column 8 is ;-delimited
# and can be an any order.
self.assertEqual(len(expected_lines), len(got_lines))
for i in range(len(expected_lines)):
expected = expected_lines[i].split('\t')
got = got_lines[i].split('\t')
self.assertEqual(len(expected), len(got))
self.assertEqual(expected[:7], got[:7])
self.assertEqual(expected[-2:], got[-2:])
exp_set = set(expected[7].split(';'))
got_set = set(got[7].split(';'))
self.assertEqual(exp_set, got_set)
# samtools-1.2 and 1.3 output not xonsistent in final column, so
# ignore those.
expected_lines = file2lines(expected_depths)
got_lines = file2lines(sv.read_depths_file)
self.assertEqual(len(expected_lines), len(got_lines))
for i in range(len(expected_lines)):
self.assertEqual(expected_lines[i].split('\t')[:-1],
got_lines[i].split('\t')[:-1])
os.unlink(sv.vcf_file)
os.unlink(sv.read_depths_file)
os.unlink(sv.read_depths_file + '.tbi')
self.assertTrue(
filecmp.cmp(expected_coverage,
tmp_prefix + '.contig_depths',
shallow=False))
os.unlink(tmp_prefix + '.contig_depths')