Mercurial > repos > nml > srst2
comparison srst2.py @ 0:6f870ed59b6e draft
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() |