Mercurial > repos > nml > srst2

comparison srst2.py @ 0:6f870ed59b6e draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Uploaded
author nml
date Mon, 06 Feb 2017 12:31:04 -0500
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:6f870ed59b6e
1 #!/usr/bin/env python
2
3 # SRST2 - Short Read Sequence Typer (v2)
4 # Python Version 2.7.5
5 #
6 # Authors - Michael Inouye (minouye@unimelb.edu.au), Harriet Dashnow (h.dashnow@gmail.com),
7 # Kathryn Holt (kholt@unimelb.edu.au), Bernie Pope (bjpope@unimelb.edu.au)
8 #
9 # see LICENSE.txt for the license
10 #
11 # Dependencies:
12 # bowtie2 http://bowtie-bio.sourceforge.net/bowtie2/index.shtml version 2.1.0
13 # SAMtools http://samtools.sourceforge.net Version: 0.1.18 (Version: 0.1.19 DOES NOT WORK - loss of edge coverage)
14 # SciPy http://www.scipy.org/install.html
15 #
16 # Git repository: https://github.com/katholt/srst2/
17 # README: https://github.com/katholt/srst2/blob/master/README.md
18 # Questions or feature requests: https://github.com/katholt/srst2/issues
19 # Manuscript: http://biorxiv.org/content/early/2014/06/26/006627
20
21
22 from argparse import (ArgumentParser, FileType)
23 import logging
24 from subprocess import call, check_output, CalledProcessError, STDOUT
25 import os, sys, re, collections, operator
26 from scipy.stats import binom_test, linregress
27 from math import log
28 from itertools import groupby
29 from operator import itemgetter
30 from collections import OrderedDict
31 try:
32 from version import srst2_version
33 except:
34 srst2_version = "version unknown"
35
36 edge_a = edge_z = 2
37
38
39 def parse_args():
40 "Parse the input arguments, use '-h' for help."
41
42 parser = ArgumentParser(description='SRST2 - Short Read Sequence Typer (v2)')
43
44 # version number of srst2, print and then exit
45 parser.add_argument('--version', action='version', version='%(prog)s ' + srst2_version)
46
47 # Read inputs
48 parser.add_argument(
49 '--input_se', nargs='+',type=str, required=False,
50 help='Single end read file(s) for analysing (may be gzipped)')
51 parser.add_argument(
52 '--input_pe', nargs='+', type=str, required=False,
53 help='Paired end read files for analysing (may be gzipped)')
54 parser.add_argument(
55 '--forward', type=str, required=False, default="_1",
56 help='Designator for forward reads (only used if NOT in MiSeq format sample_S1_L001_R1_001.fastq.gz; otherwise default is _1, i.e. expect forward reads as sample_1.fastq.gz)')
57 parser.add_argument(
58 '--reverse', type=str, required=False, default="_2",
59 help='Designator for reverse reads (only used if NOT in MiSeq format sample_S1_L001_R2_001.fastq.gz; otherwise default is _2, i.e. expect forward reads as sample_2.fastq.gz')
60 parser.add_argument('--read_type', type=str, choices=['q', 'qseq', 'f'], default='q',
61 help='Read file type (for bowtie2; default is q=fastq; other options: qseq=solexa, f=fasta).')
62
63 # MLST parameters
64 parser.add_argument('--mlst_db', type=str, required=False, nargs=1, help='Fasta file of MLST alleles (optional)')
65 parser.add_argument('--mlst_delimiter', type=str, required=False,
66 help='Character(s) separating gene name from allele number in MLST database (default "-", as in arcc-1)', default="-")
67 parser.add_argument('--mlst_definitions', type=str, required=False,
68 help='ST definitions for MLST scheme (required if mlst_db supplied and you want to calculate STs)')
69 parser.add_argument('--mlst_max_mismatch', type=str, required=False, default = "10",
70 help='Maximum number of mismatches per read for MLST allele calling (default 10)')
71
72 # Gene database parameters
73 parser.add_argument('--gene_db', type=str, required=False, nargs='+', help='Fasta file/s for gene databases (optional)')
74 parser.add_argument('--no_gene_details', action="store_false", required=False, help='Switch OFF verbose reporting of gene typing')
75 parser.add_argument('--gene_max_mismatch', type=str, required=False, default = "10",
76 help='Maximum number of mismatches per read for gene detection and allele calling (default 10)')
77
78 # Cutoffs for scoring/heuristics
79 parser.add_argument('--min_coverage', type=float, required=False, help='Minimum %%coverage cutoff for gene reporting (default 90)',default=90)
80 parser.add_argument('--max_divergence', type=float, required=False, help='Maximum %%divergence cutoff for gene reporting (default 10)',default=10)
81 parser.add_argument('--min_depth', type=float, required=False, help='Minimum mean depth to flag as dubious allele call (default 5)',default=5)
82 parser.add_argument('--min_edge_depth', type=float, required=False, help='Minimum edge depth to flag as dubious allele call (default 2)',default=2)
83 parser.add_argument('--prob_err', type=float, default=0.01, help='Probability of sequencing error (default 0.01)')
84
85 # Mapping parameters for bowtie2
86 parser.add_argument('--stop_after', type=str, required=False, help='Stop mapping after this number of reads have been mapped (otherwise map all)')
87 parser.add_argument('--other', type=str, help='Other arguments to pass to bowtie2.', required=False)
88
89 # Samtools parameters
90 parser.add_argument('--mapq', type=int, default=1, help='Samtools -q parameter (default 1)')
91 parser.add_argument('--baseq', type=int, default=20, help='Samtools -Q parameter (default 20)')
92
93 # Reporting options
94 parser.add_argument('--output', type=str, required=True, help='Prefix for srst2 output files')
95 parser.add_argument('--log', action="store_true", required=False, help='Switch ON logging to file (otherwise log to stdout)')
96 parser.add_argument('--save_scores', action="store_true", required=False, help='Switch ON verbose reporting of all scores')
97 parser.add_argument('--report_new_consensus', action="store_true", required=False, help='If a matching alleles is not found, report the consensus allele. Note, only SNP differences are considered, not indels.')
98 parser.add_argument('--report_all_consensus', action="store_true", required=False, help='Report the consensus allele for the most likely allele. Note, only SNP differences are considered, not indels.')
99
100 # Run options
101 parser.add_argument('--use_existing_pileup', action="store_true", required=False,
102 help='Use existing pileups if available, otherwise they will be generated') # to facilitate testing of rescoring from pileups
103 parser.add_argument('--use_existing_scores', action="store_true", required=False,
104 help='Use existing scores files if available, otherwise they will be generated') # to facilitate testing of reporting from scores
105 parser.add_argument('--keep_interim_alignment', action="store_true", required=False, default=False,
106 help='Keep interim files (sam & unsorted bam), otherwise they will be deleted after sorted bam is created') # to facilitate testing of sam processing
107 # parser.add_argument('--keep_final_alignment', action="store_true", required=False, default=False,
108 # help='Keep interim files (sam & unsorted bam), otherwise they will be deleted after sorted bam is created') # to facilitate testing of sam processing
109
110 # Compile previous output files
111 parser.add_argument('--prev_output', nargs='+', type=str, required=False,
112 help='SRST2 results files to compile (any new results from this run will also be incorporated)')
113
114 return parser.parse_args()
115
116
117 # Exception to raise if the command we try to run fails for some reason
118 class CommandError(Exception):
119 pass
120
121 def run_command(command, **kwargs):
122 'Execute a shell command and check the exit status and any O/S exceptions'
123 command_str = ' '.join(command)
124 logging.info('Running: {}'.format(command_str))
125 try:
126 exit_status = call(command, **kwargs)
127 except OSError as e:
128 message = "Command '{}' failed due to O/S error: {}".format(command_str, str(e))
129 raise CommandError({"message": message})
130 if exit_status != 0:
131 message = "Command '{}' failed with non-zero exit status: {}".format(command_str, exit_status)
132 raise CommandError({"message": message})
133
134
135 def bowtie_index(fasta_files):
136 'Build a bowtie2 index from the given input fasta(s)'
137
138 # check that both bowtie and samtools have the right versions
139 check_command_version(['bowtie2', '--version'],
140 'bowtie2-align version 2.1.0',
141 'bowtie',
142 '2.1.0')
143
144 for fasta in fasta_files:
145 built_index = fasta + '.1.bt2'
146 if os.path.exists(built_index):
147 logging.info('Index for {} is already built...'.format(fasta))
148 else:
149 logging.info('Building bowtie2 index for {}...'.format(fasta))
150 run_command(['bowtie2-build', fasta, fasta])
151
152
153 def modify_bowtie_sam(raw_bowtie_sam,max_mismatch):
154 # fix sam flags for comprehensive pileup
155 with open(raw_bowtie_sam) as sam, open(raw_bowtie_sam + '.mod', 'w') as sam_mod:
156 for line in sam:
157 if not line.startswith('@'):
158 fields = line.split('\t')
159 flag = int(fields[1])
160 flag = (flag - 256) if (flag & 256) else flag
161 m = re.search("NM:i:(\d+)\s",line)
162 if m != None:
163 num_mismatch = m.group(1)
164 if int(num_mismatch) <= int(max_mismatch):
165 sam_mod.write('\t'.join([fields[0], str(flag)] + fields[2:]))
166 else:
167 logging.info('Excluding read from SAM file due to missing NM (num mismatches) field: ' + fields[0])
168 num_mismatch = 0
169 else:
170 sam_mod.write(line)
171 return(raw_bowtie_sam,raw_bowtie_sam + '.mod')
172
173
174 def parse_fai(fai_file,db_type,delimiter):
175 'Get sequence lengths for reference alleles - important for scoring'
176 'Get gene names also, required if no MLST definitions provided'
177 size = {}
178 gene_clusters = [] # for gene DBs, this is cluster ID
179 allele_symbols = []
180 gene_cluster_symbols = {} # key = cluster ID, value = gene symbol (for gene DBs)
181 unique_allele_symbols = True
182 unique_gene_symbols = True
183 delimiter_check = [] # list of names that may violate the MLST delimiter supplied
184 with open(fai_file) as fai:
185 for line in fai:
186 fields = line.split('\t')
187 name = fields[0] # full allele name
188 size[name] = int(fields[1]) # store length
189 if db_type!="mlst":
190 allele_info = name.split()[0].split("__")
191 if len(allele_info) > 2:
192 gene_cluster = allele_info[0] # ID number for the cluster
193 cluster_symbol = allele_info[1] # gene name for the cluster
194 name = allele_info[2] # specific allele name
195 if gene_cluster in gene_cluster_symbols:
196 if gene_cluster_symbols[gene_cluster] != cluster_symbol:
197 unique_gene_symbols = False # already seen this cluster symbol
198 logging.info( "Non-unique:" + gene_cluster + ", " + cluster_symbol)
199 else:
200 gene_cluster_symbols[gene_cluster] = cluster_symbol
201 else:
202 # treat as unclustered database, use whole header
203 gene_cluster = cluster_symbol = name
204 else:
205 gene_cluster = name.split(delimiter)[0] # accept gene clusters raw for mlst
206 # check if the delimiter makes sense
207 parts = name.split(delimiter)
208 if len(parts) != 2:
209 delimiter_check.append(name)
210 else:
211 try:
212 x = int(parts[1])
213 except:
214 delimiter_check.append(name)
215
216 # check if we have seen this allele name before
217 if name in allele_symbols:
218 unique_allele_symbols = False # already seen this allele name
219 allele_symbols.append(name)
220
221 # record gene (cluster):
222 if gene_cluster not in gene_clusters:
223 gene_clusters.append(gene_cluster)
224
225 if len(delimiter_check) > 0:
226 print "Warning! MLST delimiter is " + delimiter + " but these genes may violate the pattern and cause problems:"
227 print ",".join(delimiter_check)
228
229 return size, gene_clusters, unique_gene_symbols, unique_allele_symbols, gene_cluster_symbols
230
231
232 def read_pileup_data(pileup_file, size, prob_err, consensus_file = ""):
233 with open(pileup_file) as pileup:
234 prob_success = 1 - prob_err # Set by user, default is prob_err = 0.01
235 hash_alignment = {}
236 hash_max_depth = {}
237 hash_edge_depth = {}
238 max_depth = 1
239 avg_depth_allele = {}
240 next_to_del_depth_allele = {}
241 coverage_allele = {}
242 mismatch_allele = {}
243 indel_allele = {}
244 missing_allele = {}
245 size_allele = {}
246
247 # Split all lines in the pileup by whitespace
248 pileup_split = ( x.split() for x in pileup )
249 # Group the split lines based on the first field (allele)
250 for allele, lines in groupby(pileup_split, itemgetter(0)):
251
252 # Reset variables for new allele
253 allele_line = 1 # Keep track of line for this allele
254 exp_nuc_num = 0 # Expected position in ref allele
255 allele_size = size[allele]
256 total_depth = 0
257 depth_a = depth_z = 0
258 position_depths = [0] * allele_size # store depths in case required for penalties; then we don't need to track total_missing_bases
259 hash_alignment[allele] = []
260 total_missing_bases = 0
261 total_mismatch = 0
262 ins_poscount = 0
263 del_poscount = 0
264 next_to_del_depth = 99999
265 consensus_seq = ""
266
267 for fields in lines:
268 # Parse this line and store details required for scoring
269 nuc_num = int(fields[1]) # Actual position in ref allele
270 exp_nuc_num += 1
271 allele_line += 1
272 nuc = fields[2]
273 nuc_depth = int(fields[3])
274 position_depths[nuc_num-1] = nuc_depth
275 if len(fields) <= 5:
276 aligned_bases = ''
277 else:
278 aligned_bases = fields[4]
279
280 # Missing bases (pileup skips basepairs)
281 if nuc_num > exp_nuc_num:
282 total_missing_bases += abs(exp_nuc_num - nuc_num)
283 exp_nuc_num = nuc_num
284 if nuc_depth == 0:
285 total_missing_bases += 1
286
287 # Calculate depths for this position
288 if nuc_num <= edge_a:
289 depth_a += nuc_depth
290 if abs(nuc_num - allele_size) < edge_z:
291 depth_z += nuc_depth
292 if nuc_depth > max_depth:
293 hash_max_depth[allele] = nuc_depth
294 max_depth = nuc_depth
295
296 total_depth = total_depth + nuc_depth
297
298 # Parse aligned bases list for this position in the pileup
299 num_match = 0
300 ins_readcount = 0
301 del_readcount = 0
302 nuc_counts = {}
303
304 i = 0
305 while i < len(aligned_bases):
306
307 if aligned_bases[i] == "^":
308 # Signifies start of a read, next char is mapping quality (skip it)
309 i += 2
310 continue
311
312 if aligned_bases[i] == "+":
313 i += int(aligned_bases[i+1]) + 2 # skip to next read
314 ins_readcount += 1
315 continue
316
317 if aligned_bases[i] == "-":
318 i += int(aligned_bases[i+1]) + 2 # skip to next read
319 continue
320
321 if aligned_bases[i] == "*":
322 i += 1 # skip to next read
323 del_readcount += 1
324 continue
325
326 if aligned_bases[i] == "." or aligned_bases[i] == ",":
327 num_match += 1
328 i += 1
329 continue
330
331 elif aligned_bases[i].upper() in "ATCG":
332 this_nuc = aligned_bases[i].upper()
333 if this_nuc not in nuc_counts:
334 nuc_counts[this_nuc] = 0
335 nuc_counts[this_nuc] += 1
336
337 i += 1
338
339 # Save the most common nucleotide at this position
340 consensus_nuc = nuc # by default use reference nucleotide
341 max_freq = num_match # Number of bases matching the reference
342 for nucleotide in nuc_counts:
343 if nuc_counts[nucleotide] > max_freq:
344 consensus_nuc = nucleotide
345 max_freq = nuc_counts[nucleotide]
346 consensus_seq += (consensus_nuc)
347
348 # Calculate details of this position for scoring and reporting
349
350 # mismatches and indels
351 num_mismatch = nuc_depth - num_match
352 if num_mismatch > num_match:
353 total_mismatch += 1 # record as mismatch (could be a snp or deletion)
354 if del_readcount > num_match:
355 del_poscount += 1
356 if ins_readcount > nuc_depth / 2:
357 ins_poscount += 1
358
359 # Hash for later processing
360 hash_alignment[allele].append((num_match, num_mismatch, prob_success)) # snp or deletion
361 if ins_readcount > 0:
362 hash_alignment[allele].append((nuc_depth - ins_readcount, ins_readcount, prob_success)) # penalize for any insertion calls at this position
363
364 # Determine the consensus sequence if required
365 if consensus_file != "":
366 if consensus_file.split(".")[-2] == "new_consensus_alleles":
367 consensus_type = "variant"
368 elif consensus_file.split(".")[-2] == "all_consensus_alleles":
369 consensus_type = "consensus"
370 with open(consensus_file, "a") as consensus_outfile:
371 consensus_outfile.write(">{0}.{1} {2}\n".format(allele, consensus_type, pileup_file.split(".")[1].split("__")[1]))
372 outstring = consensus_seq + "\n"
373 consensus_outfile.write(outstring)
374
375 # Finished reading pileup for this allele
376
377 # Check for missing bases at the end of the allele
378 if nuc_num < allele_size:
379 total_missing_bases += abs(allele_size - nuc_num)
380 # determine penalty based on coverage of last 2 bases
381 penalty = float(position_depths[nuc_num-1] + position_depths[nuc_num-2])/2
382 m = min(position_depths[nuc_num-1],position_depths[nuc_num-2])
383 hash_alignment[allele].append((0, penalty, prob_success))
384 if next_to_del_depth > m:
385 next_to_del_depth = m # keep track of lowest near-del depth for reporting
386
387 # Calculate allele summary stats and save
388 avg_depth = round(total_depth / float(allele_line),3)
389 avg_a = depth_a / float(edge_a) # Avg depth at 5' end, num basepairs determined by edge_a
390 avg_z = depth_z / float(edge_z) # 3'
391 hash_max_depth[allele] = max_depth
392 hash_edge_depth[allele] = (avg_a, avg_z)
393 min_penalty = max(5, int(avg_depth))
394 coverage_allele[allele] = 100*(allele_size - total_missing_bases - del_poscount)/float(allele_size) # includes in-read deletions
395 mismatch_allele[allele] = total_mismatch - del_poscount # snps only
396 indel_allele[allele] = del_poscount + ins_poscount # insertions or deletions
397 missing_allele[allele] = total_missing_bases # truncated bases
398 size_allele[allele] = allele_size
399
400 # Penalize truncations or large deletions (i.e. positions not covered in pileup)
401 j = 0
402 while j < (len(position_depths)-2):
403 # note end-of-seq truncations are dealt with above)
404 if position_depths[j]==0 and position_depths[j+1]!=0:
405 penalty = float(position_depths[j+1]+position_depths[j+2])/2 # mean of next 2 bases
406 hash_alignment[allele].append((0, penalty, prob_success))
407 m = min(position_depths[nuc_num-1],position_depths[nuc_num-2])
408 if next_to_del_depth > m:
409 next_to_del_depth = m # keep track of lowest near-del depth for reporting
410 j += 1
411
412 # Store depth info for reporting
413 avg_depth_allele[allele] = avg_depth
414 if next_to_del_depth == 99999:
415 next_to_del_depth = "NA"
416 next_to_del_depth_allele[allele] = next_to_del_depth
417
418 return hash_alignment, hash_max_depth, hash_edge_depth, avg_depth_allele, coverage_allele, mismatch_allele, indel_allele, missing_allele, size_allele, next_to_del_depth_allele
419
420
421 def score_alleles(args, mapping_files_pre, hash_alignment, hash_max_depth, hash_edge_depth,
422 avg_depth_allele, coverage_allele, mismatch_allele, indel_allele, missing_allele,
423 size_allele, next_to_del_depth_allele, run_type):
424
425 if args.save_scores:
426 scores_output = file(mapping_files_pre + '.scores', 'w')
427 scores_output.write("Allele\tScore\tAvg_depth\tEdge1_depth\tEdge2_depth\tPercent_coverage\tSize\tMismatches\tIndels\tTruncated_bases\tDepthNeighbouringTruncation\tmaxMAF\tLeastConfident_Rate\tLeastConfident_Mismatches\tLeastConfident_Depth\tLeastConfident_Pvalue\n")
428
429 scores = {} # key = allele, value = score
430 mix_rates = {} # key = allele, value = highest minor allele frequency, 0 -> 0.5
431
432 for allele in hash_alignment:
433 if (run_type == "mlst") or (coverage_allele[allele] > args.min_coverage):
434 pvals = []
435 min_pval = 1.0
436 min_pval_data = (999,999) # (mismatch, depth) for position with lowest p-value
437 mix_rate = 0 # highest minor allele frequency 0 -> 0.5
438 for nuc_info in hash_alignment[allele]:
439 if nuc_info is not None:
440 match, mismatch, prob_success = nuc_info
441 if match > 0 or mismatch > 0:
442 if mismatch == 0:
443 p_value = 1.0
444 else:
445 p_value = binom_test([match, mismatch], None, prob_success)
446 # Weight pvalue by (depth/max_depth)
447 max_depth = hash_max_depth[allele]
448 weight = (match + mismatch) / float(max_depth)
449 p_value *= weight
450 if p_value < min_pval:
451 min_pval = p_value
452 min_pval_data = (mismatch,match + mismatch)
453 if p_value > 0:
454 p_value = -log(p_value, 10)
455 else:
456 p_value = 1000
457 pvals.append(p_value)
458 mismatch_prop = float(match)/float(match+mismatch)
459 if min(mismatch_prop, 1-mismatch_prop) > mix_rate:
460 mix_rate = min(mismatch_prop, 1-mismatch_prop)
461 # Fit linear model to observed Pval distribution vs expected Pval distribution (QQ plot)
462 pvals.sort(reverse=True)
463 len_obs_pvals = len(pvals)
464 exp_pvals = range(1, len_obs_pvals + 1)
465 exp_pvals2 = [-log(float(ep) / (len_obs_pvals + 1), 10) for ep in exp_pvals]
466
467 # Slope is score
468 slope, _intercept, _r_value, _p_value, _std_err = linregress(exp_pvals2, pvals)
469
470 # Store all scores for later processing
471 scores[allele] = slope
472 mix_rates[allele] = mix_rate
473
474 # print scores for each allele, if requested
475 if args.save_scores:
476 if allele in hash_edge_depth:
477 start_depth, end_depth = hash_edge_depth[allele]
478 edge_depth_str = str(start_depth) + '\t' + str(end_depth)
479 else:
480 edge_depth_str = "NA\tNA"
481 this_depth = avg_depth_allele.get(allele, "NA")
482 this_coverage = coverage_allele.get(allele, "NA")
483 this_mismatch = mismatch_allele.get(allele, "NA")
484 this_indel = indel_allele.get(allele, "NA")
485 this_missing = missing_allele.get(allele, "NA")
486 this_size = size_allele.get(allele, "NA")
487 this_next_to_del_depth = next_to_del_depth_allele.get(allele, "NA")
488 scores_output.write('\t'.join([allele, str(slope), str(this_depth), edge_depth_str,
489 str(this_coverage), str(this_size), str(this_mismatch), str(this_indel), str(this_missing), str(this_next_to_del_depth), str(mix_rate), str(float(min_pval_data[0])/min_pval_data[1]),str(min_pval_data[0]),str(min_pval_data[1]),str(min_pval)]) + '\n')
490
491 if args.save_scores:
492 scores_output.close()
493
494 return(scores,mix_rates)
495
496 # Check that an acceptable version of a command is installed
497 # Exits the program if it can't be found.
498 # - command_list is the command to run to determine the version.
499 # - version_identifier is the unique string we look for in the stdout of the program.
500 # - command_name is the name of the command to show in error messages.
501 # - required_version is the version number to show in error messages.
502 def check_command_version(command_list, version_identifier, command_name, required_version):
503 try:
504 command_stdout = check_output(command_list, stderr=STDOUT)
505 except OSError as e:
506 logging.error("Failed command: {}".format(' '.join(command_list)))
507 logging.error(str(e))
508 logging.error("Could not determine the version of {}.".format(command_name))
509 logging.error("Do you have {} installed in your PATH?".format(command_name))
510 exit(-1)
511 except CalledProcessError as e:
512 # some programs such as samtools return a non-zero exit status
513 # when you ask for the version (sigh). We ignore it here.
514 command_stdout = e.output
515
516 if version_identifier not in command_stdout:
517 logging.error("Incorrect version of {} installed.".format(command_name))
518 logging.error("{} version {} is required by SRST2.".format(command_name, required_version))
519 exit(-1)
520
521
522 def run_bowtie(mapping_files_pre,sample_name,fastqs,args,db_name,db_full_path):
523
524 print "Starting mapping with bowtie2"
525
526 # check that both bowtie and samtools have the right versions
527 check_command_version(['bowtie2', '--version'],
528 'bowtie2-align version 2.1.0',
529 'bowtie',
530 '2.1.0')
531
532 check_command_version(['samtools'],
533 'Version: 0.1.18',
534 'samtools',
535 '0.1.18')
536
537 command = ['bowtie2']
538
539 if len(fastqs)==1:
540 # single end
541 command += ['-U', fastqs[0]]
542 elif len(fastqs)==2:
543 # paired end
544 command += ['-1', fastqs[0], '-2', fastqs[1]]
545
546 sam = mapping_files_pre + ".sam"
547 logging.info('Output prefix set to: ' + mapping_files_pre)
548
549 command += ['-S', sam,
550 '-' + args.read_type, # add a dash to the front of the option
551 '--very-sensitive-local',
552 '--no-unal',
553 '-a', # Search for and report all alignments
554 '-x', db_full_path # The index to be aligned to
555 ]
556
557 if args.stop_after:
558 try:
559 command += ['-u',str(int(args.stop_after))]
560 except ValueError:
561 print "WARNING. You asked to stop after mapping '" + args.stop_after + "' reads. I don't understand this, and will map all reads. Please speficy an integer with --stop_after or leave this as default to map 1 million reads."
562
563 if args.other:
564 command += args.other.split()
565
566 logging.info('Aligning reads to index {} using bowtie2...'.format(db_full_path))
567
568 run_command(command)
569
570 return(sam)
571
572 def get_pileup(args,mapping_files_pre,raw_bowtie_sam,bowtie_sam_mod,fasta,pileup_file):
573 # Analyse output with SAMtools
574 logging.info('Processing Bowtie2 output with SAMtools...')
575 logging.info('Generate and sort BAM file...')
576 out_file_bam = mapping_files_pre + ".unsorted.bam"
577 run_command(['samtools', 'view', '-b', '-o', out_file_bam,
578 '-q', str(args.mapq), '-S', bowtie_sam_mod])
579 out_file_bam_sorted = mapping_files_pre + ".sorted"
580 run_command(['samtools', 'sort', out_file_bam, out_file_bam_sorted])
581
582 # Delete interim files (sam, modified sam, unsorted bam) unless otherwise specified.
583 # Note users may also want to delete final sorted bam and pileup on completion to save space.
584 if not args.keep_interim_alignment:
585 logging.info('Deleting sam and bam files that are not longer needed...')
586 del_filenames = [raw_bowtie_sam, bowtie_sam_mod, out_file_bam]
587 for f in del_filenames:
588 logging.info('Deleting ' + f)
589 os.remove(f)
590
591 logging.info('Generate pileup...')
592 with open(pileup_file, 'w') as sam_pileup:
593 run_command(['samtools', 'mpileup', '-L', '1000', '-f', fasta,
594 '-Q', str(args.baseq), '-q', str(args.mapq), out_file_bam_sorted + '.bam'],
595 stdout=sam_pileup)
596
597 def calculate_ST(allele_scores, ST_db, gene_names, sample_name, mlst_delimiter, avg_depth_allele, mix_rates):
598 allele_numbers = [] # clean allele calls for determing ST. order is taken from gene names, as in ST definitions file
599 alleles_with_flags = [] # flagged alleles for printing (* if mismatches, ? if depth issues)
600 mismatch_flags = [] # allele/diffs
601 uncertainty_flags = [] #allele/uncertainty
602 # st_flags = [] # (* if mismatches, ? if depth issues)
603 depths = [] # depths for each typed locus
604 mafs = [] # minor allele freqencies for each typed locus
605
606 # get allele numbers & info
607 for gene in gene_names:
608 if gene in allele_scores:
609 (allele,diffs,depth_problem,divergence) = allele_scores[gene]
610 allele_number = allele.split(mlst_delimiter)[-1]
611 depths.append(avg_depth_allele[allele])
612 mix_rate = mix_rates[allele]
613 mafs.append(mix_rate)
614 else:
615 allele_number = "-"
616 diffs = ""
617 depth_problem = ""
618 mix_rate = ""
619 allele_numbers.append(allele_number)
620
621 allele_with_flags = allele_number
622 if diffs != "":
623 if diffs != "trun":
624 allele_with_flags+="*" # trun indicates only that a truncated form had lower score, which isn't a mismatch
625 mismatch_flags.append(allele+"/"+diffs)
626 if depth_problem != "":
627 allele_with_flags+="?"
628 uncertainty_flags.append(allele+"/"+depth_problem)
629 alleles_with_flags.append(allele_with_flags)
630
631 # calculate ST (no flags)
632 if ST_db:
633 allele_string = " ".join(allele_numbers) # for determining ST
634 try:
635 clean_st = ST_db[allele_string]
636 except KeyError:
637 print "This combination of alleles was not found in the sequence type database:",
638 print sample_name,
639 for gene in allele_scores:
640 (allele,diffs,depth_problems,divergence) = allele_scores[gene]
641 print allele,
642 print
643 clean_st = "NF"
644 else:
645 clean_st = "ND"
646
647 # add flags for reporting
648 st = clean_st
649 if len(mismatch_flags) > 0:
650 if mismatch_flags!=["trun"]:
651 st += "*" # trun indicates only that a truncated form had lower score, which isn't a mismatch
652 else:
653 mismatch_flags = ['0'] # record no mismatches
654 if len(uncertainty_flags) > 0:
655 st += "?"
656 else:
657 uncertainty_flags = ['-']
658
659 # mean depth across loci
660 if len(depths) > 0:
661 mean_depth = float(sum(depths))/len(depths)
662 else:
663 mean_depth = 0
664
665 # maximum maf across locus
666 if len(mafs) > 0:
667 max_maf = max(mafs)
668 else:
669 max_maf = 0
670
671 return (st,clean_st,alleles_with_flags,mismatch_flags,uncertainty_flags,mean_depth,max_maf)
672
673 def parse_ST_database(ST_filename,gene_names_from_fai):
674 # Read ST definitions
675 ST_db = {} # key = allele string, value = ST
676 gene_names = []
677 num_gene_cols_expected = len(gene_names_from_fai)
678 print "Attempting to read " + str(num_gene_cols_expected) + " loci from ST database " + ST_filename
679 with open(ST_filename) as f:
680 count = 0
681 for line in f:
682 count += 1
683 line_split = line.rstrip().split("\t")
684 if count == 1: # Header
685 gene_names = line_split[1:min(num_gene_cols_expected+1,len(line_split))]
686 for g in gene_names_from_fai:
687 if g not in gene_names:
688 print "Warning: gene " + g + " in database file isn't among the columns in the ST definitions: " + ",".join(gene_names)
689 print " Any sequences with this gene identifer from the database will not be included in typing."
690 if len(line_split) == num_gene_cols_expected+1:
691 gene_names.pop() # we read too many columns
692 num_gene_cols_expected -= 1
693 for g in gene_names:
694 if g not in gene_names_from_fai:
695 print "Warning: gene " + g + " in ST definitions file isn't among those in the database " + ",".join(gene_names_from_fai)
696 print " This will result in all STs being called as unknown (but allele calls will be accurate for other loci)."
697 else:
698 ST = line_split[0]
699 if ST not in ST_db.values():
700 ST_string = " ".join(line_split[1:num_gene_cols_expected+1])
701 ST_db[ST_string] = ST
702 else:
703 print "Warning: this ST is not unique in the ST definitions file: " + ST
704 print "Read ST database " + ST_filename + " successfully"
705 return (ST_db, gene_names)
706
707 def get_allele_name_from_db(allele,unique_allele_symbols,unique_cluster_symbols,run_type,args):
708
709 if run_type != "mlst":
710 # header format: >[cluster]___[gene]___[allele]___[uniqueID] [info]
711 allele_parts = allele.split()
712 allele_detail = allele_parts.pop(0)
713 allele_info = allele_detail.split("__")
714
715 if len(allele_info)>2:
716 cluster_id = allele_info[0] # ID number for the cluster
717 gene_name = allele_info[1] # gene name/symbol for the cluster
718 allele_name = allele_info[2] # specific allele name
719 seqid = allele_info[3] # unique identifier for this seq
720 else:
721 cluster_id = gene_name = allele_name = seqid = allele_parts[0]
722
723 if not unique_allele_symbols:
724 allele_name += "_" + seqid
725
726 else:
727 gene_name = allele.split(args.mlst_delimiter)
728 allele_name = allele
729 seqid = None
730 cluster_id = None
731
732 return gene_name, allele_name, cluster_id, seqid
733
734 def create_allele_pileup(allele_name, all_pileup_file):
735 outpileup = allele_name + "." + all_pileup_file
736 with open(outpileup, 'w') as allele_pileup:
737 with open(all_pileup_file) as all_pileup:
738 for line in all_pileup:
739 if line.split()[0] == allele_name:
740 allele_pileup.write(line)
741 return outpileup
742
743 def parse_scores(run_type,args,scores, hash_edge_depth,
744 avg_depth_allele, coverage_allele, mismatch_allele, indel_allele,
745 missing_allele, size_allele, next_to_del_depth_allele,
746 unique_cluster_symbols,unique_allele_symbols, pileup_file):
747
748 # sort into hash for each gene locus
749 scores_by_gene = collections.defaultdict(dict) # key1 = gene, key2 = allele, value = score
750
751 if run_type=="mlst":
752 for allele in scores:
753 if coverage_allele[allele] > args.min_coverage:
754 allele_info = allele.split(args.mlst_delimiter)
755 scores_by_gene[allele_info[0]][allele] = scores[allele]
756 else:
757 for allele in scores:
758 if coverage_allele[allele] > args.min_coverage:
759 gene_name = get_allele_name_from_db(allele,unique_allele_symbols,unique_cluster_symbols,run_type,args)[2] # cluster ID
760 scores_by_gene[gene_name][allele] = scores[allele]
761
762 # determine best allele for each gene locus/cluster
763 results = {} # key = gene, value = (allele,diffs,depth)
764
765 for gene in scores_by_gene:
766
767 gene_hash = scores_by_gene[gene]
768 scores_sorted = sorted(gene_hash.iteritems(),key=operator.itemgetter(1)) # sort by score
769 (top_allele,top_score) = scores_sorted[0]
770
771 # check if depth is adequate for confident call
772 adequate_depth = False
773 depth_problem = ""
774 if hash_edge_depth[top_allele][0] > args.min_edge_depth and hash_edge_depth[top_allele][1] > args.min_edge_depth:
775 if next_to_del_depth_allele[top_allele] != "NA":
776 if float(next_to_del_depth_allele[top_allele]) > args.min_edge_depth:
777 if avg_depth_allele[top_allele] > args.min_depth:
778 adequate_depth = True
779 else:
780 depth_problem="depth"+str(avg_depth_allele[top_allele])
781 else:
782 depth_problem = "del"+str(next_to_del_depth_allele[top_allele])
783 elif avg_depth_allele[top_allele] > args.min_depth:
784 adequate_depth = True
785 else:
786 depth_problem="depth"+str(avg_depth_allele[top_allele])
787 else:
788 depth_problem = "edge"+str(min(hash_edge_depth[top_allele][0],hash_edge_depth[top_allele][1]))
789
790 # check if there are confident differences against this allele
791 differences = ""
792 if mismatch_allele[top_allele] > 0:
793 differences += str(mismatch_allele[top_allele])+"snp"
794 if indel_allele[top_allele] > 0:
795 differences += str(indel_allele[top_allele])+"indel"
796 if missing_allele[top_allele] > 0:
797 differences += str(missing_allele[top_allele])+"holes"
798
799 divergence = float(mismatch_allele[top_allele]) / float( size_allele[top_allele] - missing_allele[top_allele] )
800
801 # check for truncated
802 if differences != "" or not adequate_depth:
803 # if there are SNPs or not enough depth to trust the result, no need to screen next best match
804 results[gene] = (top_allele, differences, depth_problem, divergence)
805 else:
806 # looks good but this could be a truncated version of the real allele; check for longer versions
807 truncation_override = False
808 if len(scores_sorted) > 1:
809 (next_best_allele,next_best_score) = scores_sorted[1]
810 if size_allele[next_best_allele] > size_allele[top_allele]:
811 # next best is longer, top allele could be a truncation?
812 if (mismatch_allele[next_best_allele] + indel_allele[next_best_allele] + missing_allele[next_best_allele]) == 0:
813 # next best also has no mismatches
814 if (next_best_score - top_score)/top_score < 0.1:
815 # next best has score within 10% of this one
816 truncation_override = True
817 if truncation_override:
818 results[gene] = (next_best_allele, "trun", "", divergence) # no diffs but report this call is based on truncation test
819 else:
820 results[gene] = (top_allele, "", "",divergence) # no caveats to report
821
822 # Check if there are any potential new alleles
823 #depth_problem = results[gene][2]
824 #divergence = results[gene][3]
825 if depth_problem == "" and divergence > 0:
826 new_allele = True
827 # Get the consensus for this new allele and write it to file
828 if args.report_new_consensus or args.report_all_consensus:
829 new_alleles_filename = args.output + ".new_consensus_alleles.fasta"
830 allele_pileup_file = create_allele_pileup(top_allele, pileup_file) # XXX Creates a new pileup file for that allele. Not currently cleaned up
831 read_pileup_data(allele_pileup_file, size_allele, args.prob_err, consensus_file = new_alleles_filename)
832 if args.report_all_consensus:
833 new_alleles_filename = args.output + ".all_consensus_alleles.fasta"
834 allele_pileup_file = create_allele_pileup(top_allele, pileup_file)
835 read_pileup_data(allele_pileup_file, size_allele, args.prob_err, consensus_file = new_alleles_filename)
836
837 return results # (allele, diffs, depth_problem, divergence)
838
839
840 def get_readFile_components(full_file_path):
841 (file_path,file_name) = os.path.split(full_file_path)
842 m1 = re.match("(.*).gz",file_name)
843 ext = ""
844 if m1 != None:
845 # gzipped
846 ext = ".gz"
847 file_name = m1.groups()[0]
848 (file_name_before_ext,ext2) = os.path.splitext(file_name)
849 full_ext = ext2+ext
850 return(file_path,file_name_before_ext,full_ext)
851
852 def read_file_sets(args):
853
854 fileSets = {} # key = id, value = list of files for that sample
855 num_single_readsets = 0
856 num_paired_readsets = 0
857
858 if args.input_se:
859 # single end
860 for fastq in args.input_se:
861 (file_path,file_name_before_ext,full_ext) = get_readFile_components(fastq)
862 m=re.match("(.*)(_S.*)(_L.*)(_R.*)(_.*)", file_name_before_ext)
863 if m==None:
864 fileSets[file_name_before_ext] = [fastq]
865 else:
866 fileSets[m.groups()[0]] = [fastq] # Illumina names
867 num_single_readsets += 1
868
869 elif args.input_pe:
870 # paired end
871 forward_reads = {} # key = sample, value = full path to file
872 reverse_reads = {} # key = sample, value = full path to file
873 num_paired_readsets = 0
874 num_single_readsets = 0
875 for fastq in args.input_pe:
876 (file_path,file_name_before_ext,full_ext) = get_readFile_components(fastq)
877 # try to match to MiSeq format:
878 m=re.match("(.*)(_S.*)(_L.*)(_R.*)(_.*)", file_name_before_ext)
879 if m==None:
880 # not default Illumina file naming format, expect simple/ENA format
881 m=re.match("(.*)("+args.forward+")$",file_name_before_ext)
882 if m!=None:
883 # store as forward read
884 (baseName,read) = m.groups()
885 forward_reads[baseName] = fastq
886 else:
887 m=re.match("(.*)("+args.reverse+")$",file_name_before_ext)
888 if m!=None:
889 # store as reverse read
890 (baseName,read) = m.groups()
891 reverse_reads[baseName] = fastq
892 else:
893 logging.info("Could not determine forward/reverse read status for input file " + fastq)
894 else:
895 # matches default Illumina file naming format, e.g. m.groups() = ('samplename', '_S1', '_L001', '_R1', '_001')
896 baseName, read = m.groups()[0], m.groups()[3]
897 if read == "_R1":
898 forward_reads[baseName] = fastq
899 elif read == "_R2":
900 reverse_reads[baseName] = fastq
901 else:
902 logging.info( "Could not determine forward/reverse read status for input file " + fastq )
903 logging.info( " this file appears to match the MiSeq file naming convention (samplename_S1_L001_[R1]_001), but we were expecting [R1] or [R2] to designate read as forward or reverse?" )
904 fileSets[file_name_before_ext] = fastq
905 num_single_readsets += 1
906 # store in pairs
907 for sample in forward_reads:
908 if sample in reverse_reads:
909 fileSets[sample] = [forward_reads[sample],reverse_reads[sample]] # store pair
910 num_paired_readsets += 1
911 else:
912 fileSets[sample] = [forward_reads[sample]] # no reverse found
913 num_single_readsets += 1
914 logging.info('Warning, could not find pair for read:' + forward_reads[sample])
915 for sample in reverse_reads:
916 if sample not in fileSets:
917 fileSets[sample] = reverse_reads[sample] # no forward found
918 num_single_readsets += 1
919 logging.info('Warning, could not find pair for read:' + reverse_reads[sample])
920
921 if num_paired_readsets > 0:
922 logging.info('Total paired readsets found:' + str(num_paired_readsets))
923 if num_single_readsets > 0:
924 logging.info('Total single reads found:' + str(num_single_readsets))
925
926 return fileSets
927
928 def read_results_from_file(infile):
929
930 if os.stat(infile).st_size == 0:
931 logging.info("WARNING: Results file provided is empty: " + infile)
932 return False, False, False
933
934 results_info = infile.split("__")
935 if len(results_info) > 1:
936
937 if re.search("compiledResults",infile)!=None:
938 dbtype = "compiled"
939 dbname = results_info[0] # output identifier
940 else:
941 dbtype = results_info[1] # mlst or genes
942 dbname = results_info[2] # database
943
944 logging.info("Processing " + dbtype + " results from file " + infile)
945
946 if dbtype == "genes":
947 results = collections.defaultdict(dict) # key1 = sample, key2 = gene, value = allele
948 with open(infile) as f:
949 header = []
950 for line in f:
951 line_split = line.rstrip().split("\t")
952 if len(header) == 0:
953 header = line_split
954 else:
955 sample = line_split[0]
956 for i in range(1,len(line_split)):
957 gene = header[i] # cluster_id
958 results[sample][gene] = line_split[i]
959
960 elif dbtype == "mlst":
961 results = {} # key = sample, value = MLST string
962 with open(infile) as f:
963 header = 0
964 for line in f:
965 if header > 0:
966 results[line.split("\t")[0]] = line.rstrip()
967 if "maxMAF" not in header:
968 results[line.split("\t")[0]] += "\tNC" # empty column for maxMAF
969 else:
970 header = line.rstrip()
971 results[line.split("\t")[0]] = line.rstrip() # store header line too (index "Sample")
972 if "maxMAF" not in header:
973 results[line.split("\t")[0]] += "\tmaxMAF" # add column for maxMAF
974
975 elif dbtype == "compiled":
976 results = collections.defaultdict(dict) # key1 = sample, key2 = gene, value = allele
977 with open(infile) as f:
978 header = []
979 mlst_cols = 0 # INDEX of the last mlst column
980 n_cols = 0
981 for line in f:
982 line_split = line.rstrip().split("\t")
983 if len(header) == 0:
984 header = line_split
985 n_cols = len(header)
986 if n_cols > 1:
987 if header[1] == "ST":
988 # there is mlst data reported
989 mlst_cols = 2 # first locus column
990 while header[mlst_cols] != "depth":
991 mlst_cols += 1
992 results["Sample"]["mlst"] = "\t".join(line_split[0:(mlst_cols+1)])
993 results["Sample"]["mlst"] += "\tmaxMAF" # add to mlst header even if not encountered in this file, as it may be in others
994 if header[mlst_cols+1] == "maxMAF":
995 mlst_cols += 1 # record maxMAF column within MLST data, if present
996 else:
997 # no mlst data reported
998 dbtype = "genes"
999 logging.info("No MLST data in compiled results file " + infile)
1000 else:
1001 # no mlst data reported
1002 dbtype = "genes"
1003 logging.info("No MLST data in compiled results file " + infile)
1004
1005 else:
1006 sample = line_split[0]
1007 if mlst_cols > 0:
1008 results[sample]["mlst"] = "\t".join(line_split[0:(mlst_cols+1)])
1009 if "maxMAF" not in header:
1010 results[sample]["mlst"] += "\t" # add to mlst section even if not encountered in this file, as it may be in others
1011 if n_cols > mlst_cols:
1012 # read genes component
1013 for i in range(mlst_cols+1,n_cols):
1014 # note i=1 if mlst_cols==0, ie we are reading all
1015 gene = header[i]
1016 if len(line_split) > i:
1017 results[sample][gene] = line_split[i]
1018 else:
1019 results[sample][gene] = "-"
1020 else:
1021 results = False
1022 dbtype = False
1023 dbname = False
1024 logging.info("Couldn't decide what to do with file results file provided: " + infile)
1025
1026 else:
1027 results = False
1028 dbtype = False
1029 dbname = False
1030 logging.info("Couldn't decide what to do with file results file provided: " + infile)
1031
1032 return results, dbtype, dbname
1033
1034 def read_scores_file(scores_file):
1035 hash_edge_depth = {}
1036 avg_depth_allele = {}
1037 coverage_allele = {}
1038 mismatch_allele = {}
1039 indel_allele = {}
1040 missing_allele = {}
1041 size_allele = {}
1042 next_to_del_depth_allele = {}
1043 mix_rates = {}
1044 scores = {}
1045
1046 f = file(scores_file,"r")
1047
1048 for line in f:
1049 line_split = line.rstrip().split("\t")
1050 allele = line_split[0]
1051 if allele != "Allele": # skip header row
1052 scores[allele] = float(line_split[1])
1053 mix_rates[allele] = float(line_split[11])
1054 avg_depth_allele[allele] = float(line_split[2])
1055 hash_edge_depth[allele] = (float(line_split[3]),float(line_split[4]))
1056 coverage_allele[allele] = float(line_split[5])
1057 size_allele[allele] = int(line_split[6])
1058 mismatch_allele[allele] = int(line_split[7])
1059 indel_allele[allele] = int(line_split[8])
1060 missing_allele[allele] = int(line_split[9])
1061 next_to_del_depth = line_split[10]
1062 next_to_del_depth_allele[allele] = line_split[10]
1063
1064 return hash_edge_depth, avg_depth_allele, coverage_allele, mismatch_allele, indel_allele, \
1065 missing_allele, size_allele, next_to_del_depth_allele, scores, mix_rates
1066
1067 def run_srst2(args, fileSets, dbs, run_type):
1068
1069 db_reports = [] # list of db-specific output files to return
1070 db_results_list = [] # list of results hashes, one per db
1071
1072 for fasta in dbs:
1073 db_reports, db_results_list = process_fasta_db(args, fileSets, run_type, db_reports, db_results_list, fasta)
1074
1075 return db_reports, db_results_list
1076
1077 def process_fasta_db(args, fileSets, run_type, db_reports, db_results_list, fasta):
1078
1079 check_command_version(['samtools'],
1080 'Version: 0.1.18',
1081 'samtools',
1082 '0.1.18')
1083
1084 logging.info('Processing database ' + fasta)
1085
1086 db_path, db_name = os.path.split(fasta) # database
1087 (db_name,db_ext) = os.path.splitext(db_name)
1088 db_results = "__".join([args.output,run_type,db_name,"results.txt"])
1089 db_report = file(db_results,"w")
1090 db_reports.append(db_results)
1091
1092 # Get sequence lengths and gene names
1093 # lengths are needed for MLST heuristic to distinguish alleles from their truncated forms
1094 # gene names read from here are needed for non-MLST dbs
1095 fai_file = fasta + '.fai'
1096 if not os.path.exists(fai_file):
1097 run_command(['samtools', 'faidx', fasta])
1098 size, gene_names, unique_gene_symbols, unique_allele_symbols, cluster_symbols = \
1099 parse_fai(fai_file,run_type,args.mlst_delimiter)
1100
1101 # Prepare for MLST reporting
1102 ST_db = False
1103 if run_type == "mlst":
1104 results = {} # key = sample, value = ST string for printing
1105 if args.mlst_definitions:
1106 # store MLST profiles, replace gene names (we want the order as they appear in this file)
1107 ST_db, gene_names = parse_ST_database(args.mlst_definitions,gene_names)
1108 db_report.write("\t".join(["Sample","ST"]+gene_names+["mismatches","uncertainty","depth","maxMAF"]) + "\n")
1109 results["Sample"] = "\t".join(["Sample","ST"]+gene_names+["mismatches","uncertainty","depth","maxMAF"])
1110
1111 else:
1112 # store final results for later tabulation
1113 results = collections.defaultdict(dict) #key1 = sample, key2 = gene, value = allele
1114
1115 gene_list = [] # start with empty gene list; will add genes from each genedb test
1116
1117 # determine maximum mismatches per read to use for pileup
1118 if run_type == "mlst":
1119 max_mismatch = args.mlst_max_mismatch
1120 else:
1121 max_mismatch = args.gene_max_mismatch
1122
1123 # Align and score each read set against this DB
1124 for sample_name in fileSets:
1125 logging.info('Processing sample ' + sample_name)
1126 fastq_inputs = fileSets[sample_name] # reads
1127
1128 try:
1129 # try mapping and scoring this fileset against the current database
1130 # update the gene_list list and results dict with data from this strain
1131 # __mlst__ will be printed during this routine if this is a mlst run
1132 # __fullgenes__ will be printed during this routine if requested and this is a gene_db run
1133 gene_list, results = \
1134 map_fileSet_to_db(args,sample_name,fastq_inputs,db_name,fasta,size,gene_names,\
1135 unique_gene_symbols, unique_allele_symbols,run_type,ST_db,results,gene_list,db_report,cluster_symbols,max_mismatch)
1136 # if we get an error from one of the commands we called
1137 # log the error message and continue onto the next fasta db
1138 except CommandError as e:
1139 logging.error(e.message)
1140 # record results as unknown, so we know that we did attempt to analyse this readset
1141 if run_type == "mlst":
1142 st_result_string = "\t".join( [sample_name,"-"] + ["-"] * (len(gene_names)+3)) # record missing results
1143 db_report.write( st_result_string + "\n")
1144 logging.info(" " + st_result_string)
1145 results[sample_name] = st_result_string
1146 else:
1147 logging.info(" failed gene detection")
1148 results[sample_name]["failed"] = True # so we know that we tried this strain
1149
1150 if run_type != "mlst":
1151 # tabulate results across samples for this gene db (i.e. __genes__ file)
1152 logging.info('Tabulating results for database {} ...'.format(fasta))
1153 gene_list.sort()
1154 db_report.write("\t".join(["Sample"]+gene_list)+"\n") # report header row
1155 for sample_name in fileSets:
1156 db_report.write(sample_name)
1157 if sample_name in results:
1158 # print results
1159 if "failed" not in results[sample_name]:
1160 for cluster_id in gene_list:
1161 if cluster_id in results[sample_name]:
1162 db_report.write("\t"+results[sample_name][cluster_id]) # print full allele name
1163 else:
1164 db_report.write("\t-") # no hits for this gene cluster
1165 else:
1166 # no data on this, as the sample failed mapping
1167 for cluster_id in gene_list:
1168 db_report.write("\t?") #
1169 results[sample_name][cluster_id] = "?" # record as unknown
1170 else:
1171 # no data on this because genes were not found (but no mapping errors)
1172 for cluster_id in gene_list:
1173 db_report.write("\t?") #
1174 results[sample_name][cluster_id] = "-" # record as absent
1175 db_report.write("\n")
1176
1177 # Finished with this database
1178 logging.info('Finished processing for database {} ...'.format(fasta))
1179 db_report.close()
1180 db_results_list.append(results)
1181
1182 return db_reports, db_results_list
1183
1184 def map_fileSet_to_db(args,sample_name,fastq_inputs,db_name,fasta,size,gene_names,\
1185 unique_gene_symbols, unique_allele_symbols,run_type,ST_db,results,gene_list,db_report,cluster_symbols,max_mismatch):
1186
1187 mapping_files_pre = args.output + '__' + sample_name + '.' + db_name
1188 pileup_file = mapping_files_pre + '.pileup'
1189 scores_file = mapping_files_pre + '.scores'
1190
1191 # Get or read scores
1192
1193 if args.use_existing_scores and os.path.exists(scores_file):
1194
1195 logging.info(' Using existing scores in ' + scores_file)
1196
1197 # read in scores and info from existing scores file
1198 hash_edge_depth, avg_depth_allele, coverage_allele, \
1199 mismatch_allele, indel_allele, missing_allele, size_allele, \
1200 next_to_del_depth_allele, scores, mix_rates = read_scores_file(scores_file)
1201
1202 else:
1203
1204 # Get or read pileup
1205
1206 if args.use_existing_pileup and os.path.exists(pileup_file):
1207 logging.info(' Using existing pileup in ' + pileup_file)
1208
1209 else:
1210
1211 # run bowtie against this db
1212 bowtie_sam = run_bowtie(mapping_files_pre,sample_name,fastq_inputs,args,db_name,fasta)
1213
1214 # Modify Bowtie's SAM formatted output so that we get secondary
1215 # alignments in downstream pileup
1216 (raw_bowtie_sam,bowtie_sam_mod) = modify_bowtie_sam(bowtie_sam,max_mismatch)
1217
1218 # generate pileup from sam (via sorted bam)
1219 get_pileup(args,mapping_files_pre,raw_bowtie_sam,bowtie_sam_mod,fasta,pileup_file)
1220
1221 # Get scores
1222
1223 # Process the pileup and extract info for scoring and reporting on each allele
1224 logging.info(' Processing SAMtools pileup...')
1225 hash_alignment, hash_max_depth, hash_edge_depth, avg_depth_allele, coverage_allele, \
1226 mismatch_allele, indel_allele, missing_allele, size_allele, next_to_del_depth_allele= \
1227 read_pileup_data(pileup_file, size, args.prob_err)
1228
1229 # Generate scores for all alleles (prints these and associated info if verbose)
1230 # result = dict, with key=allele, value=score
1231 logging.info(' Scoring alleles...')
1232 scores, mix_rates = score_alleles(args, mapping_files_pre, hash_alignment, hash_max_depth, hash_edge_depth, \
1233 avg_depth_allele, coverage_allele, mismatch_allele, indel_allele, missing_allele, \
1234 size_allele, next_to_del_depth_allele, run_type)
1235
1236 # GET BEST SCORE for each gene/cluster
1237 # result = dict, with key = gene, value = (allele,diffs,depth_problem)
1238 # for MLST DBs, key = gene = locus, allele = gene-number
1239 # for gene DBs, key = gene = cluster ID, allele = cluster__gene__allele__id
1240 # for gene DBs, only those alleles passing the coverage cutoff are returned
1241
1242 allele_scores = parse_scores(run_type, args, scores, \
1243 hash_edge_depth, avg_depth_allele, coverage_allele, mismatch_allele, \
1244 indel_allele, missing_allele, size_allele, next_to_del_depth_allele,
1245 unique_gene_symbols, unique_allele_symbols, pileup_file)
1246
1247 # REPORT/RECORD RESULTS
1248
1249 # Report MLST results to __mlst__ file
1250 if run_type == "mlst" and len(allele_scores) > 0:
1251
1252 # Calculate ST and get info for reporting
1253 (st,clean_st,alleles_with_flags,mismatch_flags,uncertainty_flags,mean_depth,max_maf) = \
1254 calculate_ST(allele_scores, ST_db, gene_names, sample_name, args.mlst_delimiter, avg_depth_allele, mix_rates)
1255
1256 # Print to MLST report, log and save the result
1257 st_result_string = "\t".join([sample_name,st]+alleles_with_flags+[";".join(mismatch_flags),";".join(uncertainty_flags),str(mean_depth),str(max_maf)])
1258 db_report.write( st_result_string + "\n")
1259 logging.info(" " + st_result_string)
1260 results[sample_name] = st_result_string
1261
1262 # Make sure scores are printed if there was uncertainty in the call
1263 scores_output_file = mapping_files_pre + '.scores'
1264 if uncertainty_flags != ["-"] and not args.save_scores and not os.path.exists(scores_output_file):
1265 # print full score set
1266 logging.info("Printing all MLST scores to " + scores_output_file)
1267 scores_output = file(scores_output_file, 'w')
1268 scores_output.write("Allele\tScore\tAvg_depth\tEdge1_depth\tEdge2_depth\tPercent_coverage\tSize\tMismatches\tIndels\tTruncated_bases\tDepthNeighbouringTruncation\tMmaxMAF\n")
1269 for allele in scores.keys():
1270 score = scores[allele]
1271 scores_output.write('\t'.join([allele, str(score), str(avg_depth_allele[allele]), \
1272 str(hash_edge_depth[allele][0]), str(hash_edge_depth[allele][1]), \
1273 str(coverage_allele[allele]), str(size_allele[allele]), str(mismatch_allele[allele]), \
1274 str(indel_allele[allele]), str(missing_allele[allele]), str(next_to_del_depth_allele[allele]), str(round(mix_rates[allele],3))]) + '\n')
1275 scores_output.close()
1276
1277 # Record gene results for later processing and optionally print detailed gene results to __fullgenes__ file
1278 elif run_type == "genes" and len(allele_scores) > 0:
1279 if args.no_gene_details:
1280 full_results = "__".join([args.output,"full"+run_type,db_name,"results.txt"])
1281 logging.info("Printing verbose gene detection results to " + full_results)
1282 f = file(full_results,"w")
1283 f.write("\t".join(["Sample","DB","gene","allele","coverage","depth","diffs","uncertainty","divergence","length", "maxMAF","clusterid","seqid","annotation"])+"\n")
1284 for gene in allele_scores:
1285 (allele,diffs,depth_problem,divergence) = allele_scores[gene] # gene = top scoring alleles for each cluster
1286 gene_name, allele_name, cluster_id, seqid = \
1287 get_allele_name_from_db(allele,unique_allele_symbols,unique_gene_symbols,run_type,args)
1288
1289 # store for gene result table only if divergence passes minimum threshold:
1290 if divergence*100 <= float(args.max_divergence):
1291 column_header = cluster_symbols[cluster_id]
1292 results[sample_name][column_header] = allele_name
1293 if diffs != "":
1294 results[sample_name][column_header] += "*"
1295 if depth_problem != "":
1296 results[sample_name][column_header] += "?"
1297 if gene not in gene_list:
1298 gene_list.append(column_header)
1299
1300 # write details to full genes report
1301 if args.no_gene_details:
1302
1303 # get annotation info
1304 header_string = os.popen(" ".join(["grep",allele,fasta]))
1305 try:
1306 header = header_string.read().rstrip().split()
1307 header.pop(0) # remove allele name
1308 if len(header) > 0:
1309 annotation = " ".join(header) # put back the spaces
1310 else:
1311 annotation = ""
1312
1313 except:
1314 annotation = ""
1315
1316 f.write("\t".join([sample_name,db_name,gene_name,allele_name,str(round(coverage_allele[allele],3)),str(avg_depth_allele[allele]),diffs,depth_problem,str(round(divergence*100,3)),str(size_allele[allele]),str(round(mix_rates[allele],3)),cluster_id,seqid,annotation])+"\n")
1317
1318 # log the gene detection result
1319 logging.info(" " + str(len(allele_scores)) + " genes identified in " + sample_name)
1320
1321 # Finished with this read set
1322 logging.info(' Finished processing for read set {} ...'.format(sample_name))
1323
1324 return gene_list, results
1325
1326 def compile_results(args,mlst_results,db_results,compiled_output_file):
1327
1328 o = file(compiled_output_file,"w")
1329
1330 # get list of all samples and genes present in these datasets
1331 sample_list = [] # each entry is a sample present in at least one db
1332 gene_list = []
1333 mlst_cols = 0
1334 mlst_header_string = ""
1335 blank_mlst_section = ""
1336
1337 mlst_results_master = {} # compilation of all MLST results
1338 db_results_master = collections.defaultdict(dict) # compilation of all gene results
1339 st_counts = {} # key = ST, value = count
1340
1341 if len(mlst_results) > 0:
1342
1343 for mlst_result in mlst_results:
1344
1345 # check length of the mlst string
1346 if "Sample" in mlst_result:
1347 test_string = mlst_result["Sample"]
1348 if mlst_cols == 0:
1349 mlst_header_string = test_string
1350 else:
1351 test_string = mlst_result[mlst_result.keys()[0]] # no header line?
1352 test_string_split = test_string.split("\t")
1353 this_mlst_cols = len(test_string)
1354
1355 if (mlst_cols == 0) or (mlst_cols == this_mlst_cols):
1356 mlst_cols = this_mlst_cols
1357 blank_mlst_section = "\t" * (mlst_cols-1) # blank MLST string in case some samples missing
1358 # use this data
1359 for sample in mlst_result:
1360 mlst_results_master[sample] = mlst_result[sample]
1361 if sample not in sample_list:
1362 sample_list.append(sample)
1363 elif mlst_cols != this_mlst_cols:
1364 # don't process this data further
1365 logging.info("Problem reconciling MLST data from two files, first MLST results encountered had " + str(mlst_cols) + " columns, this one has " + str(this_mlst_cols) + " columns?")
1366 if args.mlst_db:
1367 logging.info("Compiled report will contain only the MLST data from this run, not previous outputs")
1368 else:
1369 logging.info("Compiled report will contain only the data from the first MLST result set provided")
1370
1371 if len(db_results) > 0:
1372 for results in db_results:
1373 for sample in results:
1374 if sample not in sample_list:
1375 sample_list.append(sample)
1376 for gene in results[sample]:
1377 if gene != "failed":
1378 db_results_master[sample][gene] = results[sample][gene]
1379 if gene not in gene_list:
1380 gene_list.append(gene)
1381
1382 if "Sample" in sample_list:
1383 sample_list.remove("Sample")
1384 sample_list.sort()
1385 gene_list.sort()
1386
1387 # print header
1388 header_elements = []
1389 if len(mlst_results) > 0:
1390 header_elements.append(mlst_header_string)
1391 else:
1392 header_elements.append("Sample")
1393 if (gene_list) > 0:
1394 header_elements += gene_list
1395 o.write("\t".join(header_elements)+"\n")
1396
1397 # print results for all samples
1398 for sample in sample_list:
1399
1400 sample_info = [] # first entry is mlst string OR sample name, rest are genes
1401
1402 # print mlst if provided, otherwise just print sample name
1403 if len(mlst_results_master) > 0:
1404 if sample in mlst_results_master:
1405 sample_info.append(mlst_results_master[sample])
1406 this_st = mlst_results_master[sample].split("\t")[1]
1407 else:
1408 sample_info.append(sample+blank_mlst_section)
1409 this_st = "unknown"
1410 # record the MLST result
1411 if this_st in st_counts:
1412 st_counts[this_st] += 1
1413 else:
1414 st_counts[this_st] = 1
1415 else:
1416 sample_info.append(sample)
1417
1418 # get gene info if provided
1419 if sample in db_results_master:
1420 for gene in gene_list:
1421 if gene in db_results_master[sample]:
1422 sample_info.append(db_results_master[sample][gene])
1423 else:
1424 sample_info.append("-")
1425 else:
1426 for gene in gene_list:
1427 sample_info.append("?") # record no gene data on this strain
1428
1429 o.write("\t".join(sample_info)+"\n")
1430
1431 o.close()
1432
1433 logging.info("Compiled data on " + str(len(sample_list)) + " samples printed to: " + compiled_output_file)
1434
1435 # log ST counts
1436 if len(mlst_results_master) > 0:
1437 logging.info("Detected " + str(len(st_counts.keys())) + " STs: ")
1438 sts = st_counts.keys()
1439 sts.sort()
1440 for st in sts:
1441 logging.info("ST" + st + "\t" + str(st_counts[st]))
1442
1443 return True
1444
1445
1446 def main():
1447 args = parse_args()
1448 if args.log is True:
1449 logfile = args.output + ".log"
1450 else:
1451 logfile = None
1452 logging.basicConfig(
1453 filename=logfile,
1454 level=logging.DEBUG,
1455 filemode='w',
1456 format='%(asctime)s %(message)s',
1457 datefmt='%m/%d/%Y %H:%M:%S')
1458 logging.info('program started')
1459 logging.info('command line: {0}'.format(' '.join(sys.argv)))
1460
1461 # Delete consensus file if it already exists (so can use append file in funtions)
1462 if args.report_new_consensus or args.report_all_consensus:
1463 new_alleles_filename = args.output + ".consensus_alleles.fasta"
1464 if os.path.exists(new_alleles_filename):
1465 os.remove(new_alleles_filename)
1466
1467 # vars to store results
1468 mlst_results_hashes = [] # dict (sample->MLST result string) for each MLST output files created/read
1469 gene_result_hashes = [] # dict (sample->gene->result) for each gene typing output files created/read
1470
1471 # parse list of file sets to analyse
1472 fileSets = read_file_sets(args) # get list of files to process
1473
1474 # run MLST scoring
1475 if fileSets and args.mlst_db:
1476
1477 if not args.mlst_definitions:
1478
1479 # print warning to screen to alert user, may want to stop and restart
1480 print "Warning, MLST allele sequences were provided without ST definitions:"
1481 print " allele sequences: " + str(args.mlst_db)
1482 print " these will be mapped and scored, but STs can not be calculated"
1483
1484 # log
1485 logging.info("Warning, MLST allele sequences were provided without ST definitions:")
1486 logging.info(" allele sequences: " + str(args.mlst_db))
1487 logging.info(" these will be mapped and scored, but STs can not be calculated")
1488
1489 bowtie_index(args.mlst_db) # index the MLST database
1490
1491 # score file sets against MLST database
1492 mlst_report, mlst_results = run_srst2(args,fileSets,args.mlst_db,"mlst")
1493
1494 logging.info('MLST output printed to ' + mlst_report[0])
1495
1496 #mlst_reports_files += mlst_report
1497 mlst_results_hashes += mlst_results
1498
1499 # run gene detection
1500 if fileSets and args.gene_db:
1501
1502 bowtie_index(args.gene_db) # index the gene databases
1503
1504 db_reports, db_results = run_srst2(args,fileSets,args.gene_db,"genes")
1505
1506 for outfile in db_reports:
1507 logging.info('Gene detection output printed to ' + outfile)
1508
1509 gene_result_hashes += db_results
1510
1511 # process prior results files
1512 if args.prev_output:
1513
1514 unique_results_files = list(OrderedDict.fromkeys(args.prev_output))
1515
1516 for results_file in unique_results_files:
1517
1518 results, dbtype, dbname = read_results_from_file(results_file)
1519
1520 if dbtype == "mlst":
1521 mlst_results_hashes.append(results)
1522
1523 elif dbtype == "genes":
1524 gene_result_hashes.append(results)
1525
1526 elif dbtype == "compiled":
1527 # store mlst in its own db
1528 mlst_results = {}
1529 for sample in results:
1530 if "mlst" in results[sample]:
1531 mlst_results[sample] = results[sample]["mlst"]
1532 del results[sample]["mlst"]
1533 mlst_results_hashes.append(mlst_results)
1534 gene_result_hashes.append(results)
1535
1536 # compile results if multiple databases or datasets provided
1537 if ( (len(gene_result_hashes) + len(mlst_results_hashes)) > 1 ):
1538 compiled_output_file = args.output + "__compiledResults.txt"
1539 compile_results(args,mlst_results_hashes,gene_result_hashes,compiled_output_file)
1540
1541 elif args.prev_output:
1542 logging.info('One previous output file was provided, but there is no other data to compile with.')
1543
1544 logging.info('SRST2 has finished.')
1545
1546
1547 if __name__ == '__main__':
1548 main()