diff --git "a/data/dataset_Viral.csv" "b/data/dataset_Viral.csv" new file mode 100644--- /dev/null +++ "b/data/dataset_Viral.csv" @@ -0,0 +1,44213 @@ +"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language" +"Viral","chrisruis/MutTui","setup.py",".py","1557","53","from setuptools import setup +from glob import glob +import re +import io +import os + + +# Get version strip +def read(*names, **kwargs): + with io.open(os.path.join(os.path.dirname(__file__), *names), + encoding=kwargs.get(""encoding"", ""utf8"")) as fp: + return fp.read() + +def find_version(*file_paths): + version_file = read(*file_paths) + version_match = re.search(r""^__version__ = ['\""]([^'\""]*)['\""]"", + version_file, re.M) + if version_match: + return version_match.group(1) + raise RuntimeError(""Unable to find version string."") + + +setup( + name=""MutTui"", + version=find_version(""MutTui/__init__.py""), + author=""Christopher Ruis"", + description= + ""A pipeline to reconstruct mutational spectra for bacterial and viral datasets"", + long_description_content_type=""text/markdown"", + url=""https://github.com/chrisruis/MutTui"", + install_requires=[ + 'gffutils', 'biopython', 'phylo-treetime', 'PyQt5', 'matplotlib', 'pandas', 'scikit-learn' + ], + python_requires='>=3.8.0', + packages=['MutTui'], + keywords='transmission clustering metagenomics', + classifiers=[ + ""Programming Language :: Python :: 3"", + ""License :: OSI Approved :: MIT License"", + ""Operating System :: OS Independent"", + 'Intended Audience :: Science/Research', + 'Topic :: Scientific/Engineering :: Bio-Informatics', + ], + entry_points={ + 'console_scripts': + ['MutTui = MutTui.__main__:main',], + }, + extras_require={""test"": ""pytest""}, +) + + + +","Python" +"Viral","chrisruis/MutTui","label-tree-runner.py",".py","161","8","#!/usr/bin/env python +""""""Wrapper for running label_tree directly from source tree."""""" + +from MutTui.label_tree import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","combine-spectra-catalog-runner.py",".py","197","8","#!/usr/bin/env python +""""""Wrapper for running combine_spectra_into_catalog directly from source tree."""""" + +from MutTui.combine_spectra_into_catalog import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","add-labels-runner.py",".py","181","8","#!/usr/bin/env python +""""""Wrapper for running add_tree_node_labels directly from source tree."""""" + +from MutTui.add_tree_node_labels import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","cluster-spectra-runner.py",".py","171","8","#!/usr/bin/env python +""""""Wrapper for running cluster_spectra directly from source tree."""""" + +from MutTui.cluster_spectra import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","combine-spectra-runner.py",".py","171","8","#!/usr/bin/env python +""""""Wrapper for running combine_spectra directly from source tree."""""" + +from MutTui.combine_spectra import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","plot-spectrum-runner.py",".py","167","8","#!/usr/bin/env python +""""""Wrapper for running plot_spectrum directly from source tree."""""" + +from MutTui.plot_spectrum import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","muttui-runner.py",".py","155","8","#!/usr/bin/env python +""""""Wrapper for running muttui directly from source tree."""""" + +from MutTui.__main__ import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","korimuto-runner.py",".py","157","8","#!/usr/bin/env python +""""""Wrapper for running korimuto directly from source tree."""""" + +from MutTui.korimuto import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","compare-spectra-runner.py",".py","171","8","#!/usr/bin/env python +""""""Wrapper for running compare_spectra directly from source tree."""""" + +from MutTui.compare_spectra import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","convert-vcf-runner.py",".py","205","8","#!/usr/bin/env python +""""""Wrapper for running convert_vcf_position_translation directly from source tree."""""" + +from MutTui.convert_vcf_position_translation import main + +if __name__ == '__main__': + main() +","Python" +"Viral","chrisruis/MutTui","MutTui/wilson_score_index.py",".py","1056","40","import argparse +from math import sqrt + +def wilsonSI(s, pr, n): + z = 1.96 + + if n == 0: + return(0) + + if s: + if int(s) == 0: + return(0) + p = float(s)/n + else: + if float(pr) == float(0): + return(0) + p = float(pr) + + denominator = 1 + z**2/n + centre_adjusted_probability = p + z*z / (2*n) + adjusted_standard_deviation = sqrt((p*(1 - p) + z*z / (4*n)) / n) + lower_bound = (centre_adjusted_probability - z*adjusted_standard_deviation) / denominator + upper_bound = (centre_adjusted_probability + z*adjusted_standard_deviation) / denominator + + if s: + print((lower_bound * n), (upper_bound * n)) + else: + print(lower_bound, upper_bound) + +parser = argparse.ArgumentParser() + +ns = parser.add_mutually_exclusive_group(required = True) + +ns.add_argument(""-s"", help = ""Number of sucesses"") +ns.add_argument(""-p"", help = ""Proportion of sucesses"") + +parser.add_argument(""-n"", help = ""Number of trials"") +args = parser.parse_args() + +wilsonSI(args.s, args.p, float(args.n))","Python" +"Viral","chrisruis/MutTui","MutTui/compare_spectra.py",".py","4477","117","#Functions for comparing spectra +#Run on multiple spectra output from MutTui and/or combined with combine_spectra.py +#Converts each spectrum from mutation counts to mutation proportions and compares the proportions +#Can carry out statistical tests to identify significantly different mutations between 2 spectra + +import argparse +from .reconstruct_spectrum import getMutationDict +from .plot_spectrum import * + +#Converts a given spectrum from number of mutations to proportion of mutations and returns the spectrum as a dictionary +#def convertSpectrumProportions(spectrum): +# totalMutations = float(0) +# +# for mutation in spectrum: +# totalMutations += float(spectrum[mutation]) +# +# for eachMutation in spectrum: +# spectrum[eachMutation] = float(spectrum[eachMutation])/totalMutations +# +# return(spectrum) + +#Converts a given spectrum from number of mutations to proportion of mutations and returns a list of proportions +#def convertSpectrumProportions(spectrum): +# totalMutations = float(0) +# +# for mutation in spectrum: +# totalMutations += float(spectrum[mutation]) +# +# sL = list() +# +# for eachMutation in spectrum: +# sL.append(float(spectrum[eachMutation])/totalMutations) +# +# return(sL) + +def compare_spectra_parser(parser): + + parser.description = ""Subtracts one mutational spectrum from another"" + + parser.add_argument(""-s"", + ""--spectra"", + dest = ""spectra"", + required = True, + nargs = 2, + help = ""The 2 spectra that will be compared. The second provided spectrum will be "" + + ""subtracted from the first. Provide both spectra to -s separated by a space"", + type = argparse.FileType(""r"")) + parser.add_argument(""--proportions"", + dest = ""proportions"", + help = ""Specify if the spectra to be compared are proportions rather than numbers of mutations, "" + + ""e.g. if comparing SigProfilerExtractor signatures"", + action = ""store_true"", + default = False) + parser.add_argument(""--rna"", + dest = ""rna"", + help = ""Specify if using an RNA pathogen"", + action = ""store_true"", + default = False) + parser.add_argument(""-o"", + ""--out"", + dest = ""out_prefix"", + required = True, + help = ""The prefix of the output files"") + + parser.set_defaults(func=compare_spectra) + + return(parser) + +def compare_spectra(args): + + #Import the spectra into dictionaries + if args.proportions: + spectrum1Proportions = convertSpectrumDictProportions(args.spectra[0]) + spectrum2Proportions = convertSpectrumDictProportions(args.spectra[1]) + else: + spectrum1 = convertSpectrumDict(args.spectra[0]) + spectrum2 = convertSpectrumDict(args.spectra[1]) + #Convert the spectra to proportions + spectrum1Proportions = convertSpectrumProportions(spectrum1) + spectrum2Proportions = convertSpectrumProportions(spectrum2) + + #Will be filled with the difference between each mutation type + spectrumDifference = {} + + #Iterate through the mutations and add to spectrumDifference + for mutation in spectrum1Proportions: + spectrumDifference[mutation] = spectrum1Proportions[mutation] - spectrum2Proportions[mutation] + + outFile = open(args.out_prefix + "".csv"", ""w"") + outFile.write(""Substitution,Difference_in_spectra\n"") + + for eachMutation in spectrumDifference: + outFile.write(eachMutation + "","" + str(spectrumDifference[eachMutation]) + ""\n"") + + outFile.close() + + if not args.rna: + plotSpectrumComparison(spectrumDifference, args.out_prefix + ""_spectrum_comparison.pdf"") + plotSpectrumPointComparison(spectrum1Proportions, spectrum2Proportions, args.out_prefix + ""_proportion_comparison.pdf"") + else: + plotRNASpectrumComparison(spectrumDifference, args.out_prefix + ""_spectrum_comparison.pdf"") + + return + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = compare_spectra_parser(parser) + args = parser.parse_args() + + # run compare_spectra + args.func(args) + + return + +if __name__ == ""__main__"": + main()","Python" +"Viral","chrisruis/MutTui","MutTui/label_tree.py",".py","5627","151","#Labels all branches in a given tree +#Takes a specified root state with -r and the branches and state changes where the label changes with -s +#Uses the node numbers from add_tree_node_labels.py to specify internal branches and the taxon IDs to specify tip branches + +import argparse +from Bio import Phylo +from .add_tree_node_labels import cleanTree + +#Labels the nodes and tips of the tree with their names +def labelAllClades(tree): + #Will be incremented with each node + nodeIterator = 1 + + #Iterate through the clades and add labels + for clade in tree.find_clades(): + if clade.is_terminal(): + clade.node_name = clade.name + else: + clade.node_name = ""Node"" + str(nodeIterator) + nodeIterator += 1 + + return(tree) + +#Extracts dictionary from state changes, nodes as keys, states as values +def getStateDict(states, stateFile): + stateDict = {} + + if states: + for state in states: + stateDict[state.split(""____"")[0]] = state.split(""____"")[1] + else: + with open(stateFile.name) as fileobject: + for line in fileobject: + stateDict[line.strip().split(""\t"")[0]] = line.strip().split(""\t"")[1] + + return(stateDict) + +#Gets the state of the upstream clade +def getParentState(tree, clade): + #Check if the clade is one downstream of the root + if len(tree.get_path(clade)) >= 2: + nodeState = tree.get_path(clade)[-2].name + else: + nodeState = str(tree.root.name) + + return(nodeState) + +#Labels each internal node and tip in a tree with their state +#Sets the root state to the provided root state and changes the state along specified branches +def labelTreeState(tree, root_state, stateDict): + #Set the root state + tree.root.name = root_state + + #Iterate through the clades, check if their state needs to be changed + #otherwise use the state at the parent node + for clade in tree.find_clades(): + #Do not analyse the root + if len(tree.get_path(clade)) != 0: + #Check if the state changes along the branch + if clade.node_name in stateDict: + if clade.is_terminal(): + clade.name = clade.name + ""____"" + stateDict[clade.node_name] + else: + clade.name = stateDict[clade.node_name] + + #Infer and keep the state at the parent node + else: + if clade.is_terminal(): + clade.name = clade.name + ""____"" + getParentState(tree, clade) + else: + clade.name = getParentState(tree, clade) + + return(tree) + + +def label_tree_parser(parser): + + parser.description = ""Labels nodes in a phylogenetic tree for use with MutTui"" + + parser.add_argument(""-t"", + ""--tree"", + dest = ""tree"", + required = True, + help = ""Newick tree file"", + type = argparse.FileType(""r"")) + parser.add_argument(""-r"", + ""--root_state"", + dest = ""root_state"", + required = True, + help = ""The state at the root of the tree. For example using -r A will set the state to A at the root"") + states = parser.add_mutually_exclusive_group(required = True) + states.add_argument(""-s"", + ""--state_changes"", + dest = ""state_changes"", + nargs = ""+"", + help = ""Branches and state changes. Give the name of the branch along which the state "" + + ""change occured and the state at the end of the branch. Separate the branch name and state "" + + ""with ____ (4 underscores). Get the branch names from add_tree_node_labels.py. "" + + ""For example, giving Node2____S will change the state at the end of branch Node2 to S. Either -s or -sf is required"") + states.add_argument(""-sf"", + ""--state_file"", + dest = ""state_file"", + help = ""File containing branches on which the label should change. This file needs 2 columns, separated by a tab "" + + ""with no header. The first column contains the branches on which the label should change, the second contains the label that should "" + + ""be changed to. Either -s or -sf is required"", + type = argparse.FileType(""r"")) + parser.add_argument(""-o"", + ""--outfile"", + dest = ""outFile"", + required = True, + help = ""Output newick tree file"") + + parser.set_defaults(func = label_tree) + + return(parser) + +def label_tree(args): + + #Clean the tree to remove any bootstrap supports + tree = cleanTree(Phylo.read(args.tree.name, ""newick"")) + + #Label the tree + labelledTree = labelAllClades(tree) + + #Extract the state changes to a dictionary, node names as keys, states as values + stateDict = getStateDict(args.state_changes, args.state_file) + + #Label the tree with the given state + stateTree = labelTreeState(labelledTree, args.root_state, stateDict) + + #Write the state labelled tree + Phylo.write(stateTree, args.outFile, ""newick"") + + return + + + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = label_tree_parser(parser) + args = parser.parse_args() + + # run label_tree + args.func(args) + + return + +if __name__ == ""__main__"": + main() +","Python" +"Viral","chrisruis/MutTui","MutTui/combine_spectra_into_catalog.py",".py","5635","140","#Combines multiple spectra from MutTui into a single catalog that can be submitted to signal for spectrum decomposition +#Can combine full mutational spectra or mutational type counts +#Each column in the combined catalog is a single input spectrum +#Can take an optional csv conversion file to rename samples in the output. This has 2 columns - column 1 is +#the path to the file, column 2 is its conversion name +#Also outputs a file containing the column names in the combined catalog and the corresponding original spectrum + +import argparse +from .plot_spectrum import convertSpectrumDict, convertSpectrumDictProportions + + +def combine_spectra_into_catalog(args): + + #Check a maximum of 1 label option is provided + if args.conversion and args.labels: + raise RuntimeError(""Please provide either labels with -l or a label file with -c, not both"") + + outFile = open(args.outFile + "".csv"", ""w"") + outFileMatrix = open(args.outFile + "".txt"", ""w"") + + #List of spectra + spectraDict = {} + + #Extract the spectra into spectraDict + for spectrum in args.spectra: + if args.proportions: + spectraDict[spectrum.name] = convertSpectrumDictProportions(spectrum) + else: + spectraDict[spectrum.name] = convertSpectrumDict(spectrum) + + #Dictionary with sample names as keys and files as values + sampleDict = {} + #If conversion provided, use this conversion + if args.conversion: + cFile = open(args.conversion.name).readlines() + for line in cFile: + sampleDict[line.strip().split(""\t"")[1]] = line.strip().split(""\t"")[0] + #If labels are provided, use these + elif args.labels: + if len(args.spectra) != len(args.labels): + raise RuntimeError(""The number of labels needs to match the number of spectra"") + for i in range(len(args.spectra)): + sampleDict[args.labels[i]] = args.spectra[i].name + #Otherwise name samples as Sample i + else: + for i, spectrum in enumerate(args.spectra): + sampleDict[""Sample"" + str(i + 1)] = spectrum.name + + #Write the sample to file conversion + conversionFile = open(""sample_in_catalog_to_file_conversion.csv"", ""w"") + conversionFile.write(""File,Sample_in_combined_catalog\n"") + for eachSample in sampleDict: + conversionFile.write(sampleDict[eachSample] + "","" + eachSample + ""\n"") + + #Write the header to the output files + outFile.write(""Substitution"") + outFileMatrix.write(""Mutation Types"") + for sample in sampleDict: + outFile.write("","" + sample) + outFileMatrix.write(""\t"" + sample) + outFile.write(""\n"") + outFileMatrix.write(""\n"") + + #Iterate through the mutations and write their number in each sample + firstKey = list(spectraDict.keys())[0] + for mutation in spectraDict[firstKey]: + outFile.write(mutation) + outFileMatrix.write(mutation) + for sample in sampleDict: + outFile.write("","" + str(spectraDict[sampleDict[sample]][mutation])) + outFileMatrix.write(""\t"" + str(spectraDict[sampleDict[sample]][mutation])) + outFile.write(""\n"") + outFileMatrix.write(""\n"") + + outFile.close() + conversionFile.close() + + return + + +def combine_spectra_into_catalog_parser(parser): + + parser.description = ""Combines multiple input spectra and/or catalogues into a single output catalogue"" + + + parser.add_argument(""-s"", + ""--spectra"", + dest = ""spectra"", + required = True, + nargs = ""+"", + help = ""Set of spectra to be combined into a single catalog"", + type = argparse.FileType(""r"")) + parser.add_argument(""-c"", + ""--conversion"", + dest = ""conversion"", + help = ""Optional tab separated file containing sample name conversion. Should have "" + + ""two columns with no header. Column 1 is the path to the file as it will "" + + ""be given to the script. Column 2 is the name of the sample in the output"", + type = argparse.FileType(""r""), + default = False) + parser.add_argument(""-l"", + ""--labels"", + dest = ""labels"", + nargs = ""+"", + help = ""Optional labels to be given to spectra in the combined catalogue. Needs to have "" + + ""one label for each spectrum provided with -s"", + default = False) + parser.add_argument(""--proportions"", + dest = ""proportions"", + help = ""Specify if the spectra are proportions rather than numbers of mutations, "" + + ""e.g. if using SigProfilerExtractor signatures"", + action = ""store_true"", + default = False) + parser.add_argument(""-o"", + ""--outFile"", + dest = ""outFile"", + required = True, + help = ""Output file prefix. Two files will be written - a csv catalog"" + + "" and a tab separated mutation matrix"") + + parser.set_defaults(func=combine_spectra_into_catalog) + + return(parser) + + + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = combine_spectra_into_catalog_parser(parser) + args = parser.parse_args() + + # run combine_spectra_into_catalog + args.func(args) + + return + +if __name__ == ""__main__"": + main() +","Python" +"Viral","chrisruis/MutTui","MutTui/summarise_branch_mutations.py",".py","11641","311","#Calculates the number and proportion of each mutation type on each branch +#Writes a csv summary containing the number and proportion of mutations of each type on each branch +#Writes a labelled tree containing the number and proportion of each mutation on each branch +#Run on all_included_mutations.csv from MutTui and annotated_tree.nexus from treetime (in the MutTui output) +#To run: python3 summarise_branch_mutations.py -m all_included_mutations.csv -t annotated_tree.nexus -o output_prefix + +import argparse +from Bio import Phylo +import os + +#Extracts depths from a tree, returns a dictionary with clade names as keys and depths as values +def extractDepths(tree): + #Extract depths of all nodes + depths = tree.depths() + + #Node names as keys, depths as values + nodeDepths = dict() + + #Root branch length, often not zero so need to subtract from other depths + rootBranch = tree.root.branch_length + + #Iterate through the nodes and add to nodeDepths + for clade in tree.find_clades(): + if clade.is_terminal(): + nodeDepths[clade.name] = depths[clade] - rootBranch + else: + nodeDepths[clade.confidence] = depths[clade] - rootBranch + + return(nodeDepths) + +#Extracts branch lengths from a tree, returns a dictionary with clade names as keys and branch lengths as values +def extractBLs(tree): + #Node names as keys, branch lengths as values + bl = dict() + + #Iterate through the nodes and add to bl + for clade in tree.find_clades(): + if clade.is_terminal(): + bl[clade.name] = clade.branch_length + else: + bl[clade.confidence] = clade.branch_length + + return(bl) + +#Labels each branch in a tree with its total mutations and mutation proportions +def convertTreeMutations(tree, bM, bMT): + #Iterate through the clades and label them with their mutation proportions + for clade in tree.find_clades(): + #print(clade.name, depths[clade]) + #Do not analyse the root + if len(tree.get_path(clade)) != 0: + + if clade.name: + cladeName = clade.name + else: + cladeName = clade.confidence + + if clade.is_terminal(): + clade.name = clade.name + ""[&"" + elif clade.confidence: + clade.name = ""[&label="" + clade.confidence + else: + clade.name = ""[&label="" + clade.name + + #Label the branch with the total number of mutations and mutations of each type + if cladeName in bM: + totalM = float(bM[cladeName]) + + #Calculate the number and proportion of each mutation type + if (cladeName + "":C>A"") in bMT: + CA = float(bMT[cladeName + "":C>A""]) + P_CA = CA/totalM + else: + CA = float(0) + P_CA = float(0) + + if (cladeName + "":C>G"") in bMT: + CG = float(bMT[cladeName + "":C>G""]) + P_CG = CG/totalM + else: + CG = float(0) + P_CG = float(0) + + if (cladeName + "":C>T"") in bMT: + CT = float(bMT[cladeName + "":C>T""]) + P_CT = CT/totalM + else: + CT = float(0) + P_CT = float(0) + + if (cladeName + "":T>A"") in bMT: + TA = float(bMT[cladeName + "":T>A""]) + P_TA = TA/totalM + else: + TA = float(0) + P_TA = float(0) + + if (cladeName + "":T>C"") in bMT: + TC = float(bMT[cladeName + "":T>C""]) + P_TC = TC/totalM + else: + TC = float(0) + P_TC = float(0) + + if (cladeName + "":T>G"") in bMT: + TG = float(bMT[cladeName + "":T>G""]) + P_TG = TG/totalM + else: + TG = float(0) + P_TG = float(0) + + if clade.is_terminal(): + clade.name += ""total_mutations="" + str(totalM) + else: + clade.name += "",total_mutations="" + str(totalM) + clade.name += "",C_A="" + str(CA) + clade.name += "",C_G="" + str(CG) + clade.name += "",C_T="" + str(CT) + clade.name += "",T_A="" + str(TA) + clade.name += "",T_C="" + str(TC) + clade.name += "",T_G="" + str(TG) + clade.name += "",P_C_A="" + str(P_CA) + clade.name += "",P_C_G="" + str(P_CG) + clade.name += "",P_C_T="" + str(P_CT) + clade.name += "",P_T_A="" + str(P_TA) + clade.name += "",P_T_C="" + str(P_TC) + clade.name += "",P_T_G="" + str(P_TG) + + #If the clade has no mutations, all of its mutations will be 0 + else: + clade.name += "",total_mutations=0,C_A=0,C_G=0,C_T=0,T_A=0,T_C=0,T_G=0,P_C_A=0,P_C_G=0,P_C_T=0,P_T_A=0,P_T_C=0,P_T_G=0"" + + clade.name += ""]"" + + else: + clade.name = None + + clade.confidence = None + clade.comment = None + + return(tree) + +#Convert node labels imported as confidence values to labels +def labelNodeNames(tree): + for clade in tree.get_nonterminals(): + if clade.confidence: + clade.label = clade.confidence + else: + clade.label = clade.name + return(tree) + +#Converts tip names to a dictionary, used to write trees in BEAST format +def convertTipDict(tree): + tips = dict() + + tipList = list() + + for i, tip in enumerate(tree.get_terminals()): + tips[tip.name] = i + 1 + tipList.append(tip.name) + + return(tips, tipList) + +if __name__ == ""__main__"": + description = ""Generates a branch-specific summary of mutations in a mutational spectrum"" + parser = argparse.ArgumentParser(description = description) + + parser.add_argument(""-m"", + dest = ""mutations"", + required = True, + help = ""all_included_mutations.csv from MutTui"", + type = argparse.FileType(""r"")) + parser.add_argument(""-t"", + dest = ""tree"", + required = True, + help = ""annotated_tree.nexus from treetime (in MutTui output directory)"", + type = argparse.FileType(""r"")) + parser.add_argument(""-o"", + dest = ""outfile"", + required = True, + help = ""Output file prefix. Output csv will be this followed by .csv. "" + + ""Output tree will be this followed by .nex"") + args = parser.parse_args() + + #Open output files + outFile = open(args.outfile + "".csv"", ""w"") + outFile.write(""Branch,Branch_depth,Branch_length,Total_mutations,Transitions,Transversions,Tr_Tv_ratio,C>A,C>G,C>T,T>A,T>C,T>G,C>A_proportion,C>G_proportion,C>T_proportion,T>A_proportion,T>C_proportion,T>G_proportion\n"") + outFile_tree = open(args.outfile + ""_temp.nex"", ""w"") + outFile_tree_2 = open(args.outfile + "".nex"", ""w"") + + #Will be filled with branches as keys and total number of mutations as values + bM = dict() + #Will be filled with branch:mutation as keys and number of mutations as values + bMT = dict() + + #Import the tree + tree = Phylo.read(args.tree.name, ""nexus"") + #Extract tree depths + nodeDepths = extractDepths(tree) + #Extract tree branch lengths + branchLengths = extractBLs(tree) + + #The mutation types to be examined + mutationTypes = [""C>A"", ""C>G"", ""C>T"", ""T>A"", ""T>C"", ""T>G""] + transitions = [""C>T"", ""T>C""] + transversions = [""C>A"", ""C>G"", ""T>A"", ""T>G""] + + #Iterate through the mutations and add to bM and bMT + with open(args.mutations.name) as fileobject: + next(fileobject) + for line in fileobject: + + m = line.strip().split("","")[2].split(""["")[1].split(""]"")[0] + b = line.strip().split("","")[3] + + if b in bM: + bM[b] += 1 + else: + bM[b] = 1 + + if (b + "":"" + m) in bMT: + bMT[b + "":"" + m] += 1 + else: + bMT[b + "":"" + m] = 1 + + #Write the mutations on each branch + for branch in bM: + outFile.write(branch + "","" + str(nodeDepths[branch]) + "","" + str(branchLengths[branch]) + "","" + str(bM[branch]) + "","") + tM = float(bM[branch]) + + #Calculate transition/transversion ratio + tr = float(0) + tv = float(0) + for eM in transitions: + if (branch + "":"" + eM) in bMT: + tr += float(bMT[branch + "":"" + eM]) + for eM in transversions: + if (branch + "":"" + eM) in bMT: + tv += float(bMT[branch + "":"" + eM]) + + outFile.write(str(tr) + "","" + str(tv) + "","") + if tv != float(0): + outFile.write(str(tr/tv) + "","") + else: + outFile.write(""NA,"") + + for mt in mutationTypes: + if (branch + "":"" + mt) in bMT: + outFile.write(str(bMT[branch + "":"" + mt]) + "","") + else: + outFile.write(""0,"") + + for mt in mutationTypes: + if (branch + "":"" + mt) in bMT: + outFile.write(str(float(bMT[branch + "":"" + mt])/tM) + "","") + else: + outFile.write(""0,"") + + outFile.write(""\n"") + + #Convert the tips so they can be written in BEAST format + tipDict, tipList = convertTipDict(tree) + #Change the tip names in the tree to their numeric identifier + for tip in tree.get_terminals(): + #Add each numeric identifier to bM and bMT so the tip stats can be added to the tree + if tip.name in bM: + bM[str(tipDict[tip.name])] = bM[tip.name] + for mT in mutationTypes: + if (tip.name + "":"" + mT) in bMT: + bMT[str(tipDict[tip.name]) + "":"" + mT] = bMT[tip.name + "":"" + mT] + tip.name = str(tipDict[tip.name]) + + #Convert node labels from confidence to labels + #tree = labelNodeNames(tree) + #Label each branch with its mutation proportions + labelledTree = convertTreeMutations(tree, bM, bMT) + + #Write the labelled tree + outFile_tree.write(""#NEXUS\n\nBegin Taxa;\n\tDimensions NTax="") + outFile_tree.write(str(len(tipList))) + outFile_tree.write("";\n\t\tTaxLabels\n"") + for t in tipList: + outFile_tree.write(""\t\t\t"" + t + ""\n"") + outFile_tree.write(""\t\t\t;\nEnd;\nBegin trees;\n\tTranslate\n"") + for t in tipDict: + outFile_tree.write(""\t\t"") + nD = len(str(tipDict[t])) + if nD == 1: + outFile_tree.write("" "") + elif nD == 2: + outFile_tree.write("" "") + elif nD == 3: + outFile_tree.write("" "") + outFile_tree.write(str(tipDict[t]) + "" "" + t + "",\n"") + outFile_tree.write("";\ntree TREE1 = "") + Phylo.write(labelledTree, outFile_tree, ""newick"") + outFile_tree.write(""End;"") + + outFile.close() + outFile_tree.close() + + #Remove quotes from the tree + treeString = open(outFile_tree.name).readlines() + for line in treeString: + outFile_tree_2.write(line.replace(""\n"", """").replace(""'"", """") + ""\n"") + + #Remove the temp tree file + if os.path.exists(args.outfile + ""_temp.nex""): + os.remove(args.outfile + ""_temp.nex"") + + outFile_tree_2.close()","Python" +"Viral","chrisruis/MutTui","MutTui/muttui.py",".py","29792","530","#Runs the MutTui pipeline on an input tree and alignment + +import os +import argparse +from .treetime import run_treetime, change_gaps_to_Ns, run_treetime_mugration +from .isvalid import * +from Bio import AlignIO, Phylo +from .add_tree_node_labels import * +from .branch_labelling import * +from .reconstruct_spectrum import * +from .plot_spectrum import * +from .gff_conversion import * + +from .__init__ import __version__ + + + + +def muttui_parser(parser): + + parser.description = ""Run the MutTui pipeline on a given alignment and tree"" + + #Options for input and output files + io_opts = parser.add_argument_group(""Input/output"") + io_opts.add_argument(""-a"", + ""--alignment"", + dest = ""alignment"", + required = True, + help = ""Input fasta alignment"", + type = argparse.FileType(""r"")) + io_opts.add_argument(""-t"", + ""--tree"", + dest = ""tree"", + required = True, + help = ""Newick tree file"", + type = argparse.FileType(""r"")) + io_opts.add_argument(""-o"", + ""--out_dir"", + dest = ""output_dir"", + required = True, + help = ""Location of output directory, should already be created and ideally be empty"", + type = lambda x: is_valid_folder(parser, x)) + io_opts.add_argument(""-l"", + ""--labels"", + dest = ""labels"", + help = ""Comma separated file with sequences and their clade labels to divide the spectrum. "" + + ""If this option is included, treetime mugration will be run to identify changes in the label across the tree. "" + + ""Does not need to include all taxa. Taxa not included will be given a label of OTHER by default, "" + + ""or OTHER_A if OTHER is already taken. This file should have a header."", + default = None) + io_opts.add_argument(""-lt"", + ""--labelled_tree"", + dest = ""labelled_tree"", + help = ""Tree with state labels, should be the same tree as that provided with -t but with nodes "" + + ""labelled with their state from label_tree.py"", + default = None, + type = argparse.FileType(""r"")) + io_opts.add_argument(""-r"", + ""--reference"", + dest = ""reference"", + help = ""Reference genome sequence containing all sites, used to get context of mutations, not required if using --all_sites"", + type = argparse.FileType(""r""), + default = None) + io_opts.add_argument(""-c"", + ""--conversion"", + dest = ""conversion"", + help = ""Conversion file for alignment position to genome position, used to get context of mutations, not required if using --all_sites"", + type = argparse.FileType(""r""), + default = None) + io_opts.add_argument(""-g"", + ""--gff"", + dest = ""gff"", + help = ""GFF reference containing gene coordinates in reference sequence. Used to split mutations into transcription strands "" + + ""and identify synonymous mutations when --synonymous is used"", + type = argparse.FileType(""r""), + default = None) + io_opts.add_argument(""-to"", + ""--treetime_out"", + dest = ""treetime_out"", + help = ""The location of the directory containing treetime output files from ancestral reconstruction. Only "" + + ""used if option --start_from_treetime is specified, in which case the output files in this directory will "" + + ""be used to calculate the mutational spectrum"", + default = None) + io_opts.add_argument(""-bm"", + ""--branch_mutations"", + dest = ""branch_mutations"", + help = ""The minimum number of mutations on a branch to calculate its mutational spectrum. Only used when "" + + ""specifying --branch_specific which will output the spectrum for each branch with more than this number of "" + + ""mutations separately. Default = 50"", + default = ""50"") + + #Options to include in treetime reconstruction + treetime = parser.add_argument_group(""treetime command"") + treetime.add_argument(""--add_treetime_cmds"", + dest = ""add_treetime_cmds"", + help = ""Additional options to supply to treetime (these are not checked). Supply these together in quotes"", + type = str, + default = None) + + #Other options + parser.add_argument(""--rna"", + dest = ""rna"", + help = ""Specify if using an RNA pathogen, MutTui will output an RNA mutational spectrum"", + action = ""store_true"", + default = False) + parser.add_argument(""--reverse_strand"", + dest = ""reverse_strand"", + help = ""Specify if using a negative strand RNA pathogen where the input alignment is cRNA. "" + + ""This will reverse the spectrum calculated from the input alignment to reflect the spectrum in the genomic RNA"", + action = ""store_true"", + default = False) + parser.add_argument(""--all_sites"", + dest = ""all_sites"", + help = ""Specify that the alignment contains all sites, in which case a reference genome does not need to be provided"", + action = ""store_true"", + default = False) + parser.add_argument(""--include_all_branches"", + dest = ""include_all_branches"", + help = ""Use when specifying a labelled tree with -lt. By default, the branches along which the label "" + + ""changes are excluded as it is often not clear at what point along the branch the label changed. With "" + + ""adding --include_all_branches, all of the branches along which a label changes will be included in the "" + + ""spectrum of the downstream label"", + action = ""store_true"", + default = False) + parser.add_argument(""--include_root_branches"", + dest = ""include_root_branches"", + help = ""Use to include mutations on the two branches that branch directly from the root node. These branches are excluded "" + + ""by default as the direction of mutations is typically uncertain"", + action = ""store_true"", + default = False) + parser.add_argument(""-rs"", + ""--root_state"", + dest = ""root_state"", + help = ""Specify the root state of the given label if known. "" + + ""The root state is calculated by treetime mugration and in almost all cases will be resolved. "" + + ""If the root state has multiple assignments that are equally likely, it cannot be assigned from "" + + ""treetime mugration output. In these rare cases, use this option to assign the root state. This option "" + + ""can also be used to assign a root state if you'd like but its recommended to use the mugration state"", + default = None) + parser.add_argument(""--start_from_treetime"", + dest = ""start_from_treetime"", + help = ""Use this option to start with treetime output and so skip inference of ancestral mutations. Use this "" + + ""if you have already run treetime. The directory containing the treetime output files needs to be provided with -to"", + action = ""store_true"", + default = False) + parser.add_argument(""--strand_bias"", + dest = ""strand_bias"", + help = ""Split mutations into transcribed and untranscribed strands to test for transcription strand bias. A GFF "" + + ""file will need to be provided with option -g to identify genes"", + action = ""store_true"", + default = False) + parser.add_argument(""--synonymous"", + dest = ""synonymous"", + help = ""Use non-coding and synonymous mutations only to calculate the mutational spectrum. A GFF file will need to be "" + + ""provided with option -g which will be used to identify genes"", + action = ""store_true"", + default = False) + parser.add_argument(""--branch_specific"", + dest = ""branch_specific"", + help = ""Calculate the mutational spectrum for each branch in the tree separately. Only branches containing at least "" + + ""the number of mutations specified with -bm will be included"", + action = ""store_true"", + default = False) + parser.add_argument(""--version"", + action = ""version"", + version = ""%(prog)s "" + __version__) + + parser.set_defaults(func=muttui) + + return parser + + + +def muttui(args): + + #Make sure trailing forward slash is present in output directory + args.output_dir = os.path.join(args.output_dir, """") + + #Reverse stand can only be used for RNA virus datasets + if args.reverse_strand and not args.rna: + raise RuntimeError(""--reverse_strand can only be specified with --rna"") + + #If --branch_specific is used, set --include_all_branches to true + if args.branch_specific: + args.include_all_branches = True + + #Minimum mutations to include a branch, only used with --branch_specific + minimumMutations = int(args.branch_mutations) + + #Open output files + outMutationsNotUsed = open(args.output_dir + ""mutations_not_included.csv"", ""w"") + outMutationsNotUsed.write(""Mutation_in_alignment,Mutation_in_genome,Branch,Reason_not_included\n"") + + outAllMutations = open(args.output_dir + ""all_included_mutations.csv"", ""w"") + outAllMutations.write(""Mutation_in_alignment,Mutation_in_genome,Substitution,Branch\n"") + + outAllDouble = open(args.output_dir + ""all_included_double_substitutions.csv"", ""w"") + outAllDouble.write(""Mutation_in_alignment,Mutation_in_genome,Substitution,Branch,Original_mutation\n"") + + if not args.start_from_treetime: + print(""Running treetime ancestral reconstruction to identify mutations"") + + #Convert gaps to Ns in the alignment, run treetime on the new alignment + change_gaps_to_Ns(args.alignment, args.output_dir) + run_treetime(open(args.output_dir + ""gaps_to_N_alignment.fasta""), args.tree, args.output_dir, args.add_treetime_cmds) + + print(""treetime reconstruction complete. Importing alignment from reconstruction and tree"") + + #Import the alignment from treetime + alignment = AlignIO.read(args.output_dir + ""ancestral_sequences.fasta"", ""fasta"") + + else: + #Import the already calculated alignment from treetime + print(""Importing alignment from reconstruction and tree"") + #Make sure the trailing forward slash is present in output directory + args.treetime_out = os.path.join(args.treetime_out, """") + + #Import the alignment from treetime + alignment = AlignIO.read(args.treetime_out + ""ancestral_sequences.fasta"", ""fasta"") + + #Import the original unlabelled tree + tree = Phylo.read(args.tree.name, ""newick"") + #Ladderize the tree so the branches are in the same order as the treetime tree + tree.ladderize() + tree = labelBranchesTreetime(tree) + + print(""Alignment and tree imported. Reconstructing spectrum"") + + #Check if a GFF file is needed, if so read it in and process it + if args.strand_bias or args.synonymous: + if not args.gff: + raise RuntimeError(""GFF file needs to be provided with -g when using --strand_bias or --synonymous"") + else: + geneCoordinates, positionGene = convertGFF(args.gff.name) + + #Label branches in the tree into categories, each category will have a separate spectrum + if args.labels: + ####The code in this if statement has not been altered with branch_mutations.txt + ####The elif and else sections have been altered + #Extract the labels to a dictionary and add taxa without a label + labelDict = getLabelDict(tree, args.labels) + + #Write the labels to a csv that can be used by treetime mugration + writeLabels(labelDict, args.output_dir) + + #Run treetime mugration to reconstruct the clade labels across the tree + run_treetime_mugration(args.output_dir + ""annotated_tree.nexus"", args.output_dir + ""all_taxon_labels.csv"", args.output_dir) + + #Import the files from treetime mugration + mugrationTree = Phylo.read(args.output_dir + ""mugration_out/annotated_tree.nexus"", ""nexus"") + confidence = open(args.output_dir + ""mugration_out/confidence.csv"").readlines() + gtr = open(args.output_dir + ""mugration_out/GTR.txt"").readlines() + + #Identify the root state and add it to the mugrationTree + mugrationTree = rootState(mugrationTree, confidence, gtr, args.root_state) + + labelledTree, treeLabels = labelBranchesMugration(tree, mugrationTree) + #Label branches from the provided tree + elif args.labelled_tree: + labelledTree, treeLabels = getLabelledTreeLabels(tree, args.labelled_tree) + #Label branches with their branch name + elif args.branch_specific: + labelledTree, treeLabels = labelBranchesNames(tree) + #Label all branches with the same label + else: + labelledTree, treeLabels = labelAllBranches(tree) + + #Branch categories as keys, spectra as values + spectraDict = {} + doubleSpectraDict = {} + if args.strand_bias: + sbDict = {} + #Create empty spectrum for each branch category + if args.rna: + for label in treeLabels: + spectraDict[label] = getRNADict() + doubleSpectraDict[label] = getRNADoubleSubstitutionDict() + else: + for label in treeLabels: + spectraDict[label] = getMutationDict() + doubleSpectraDict[label] = getDoubleSubstitutionDict() + if args.strand_bias: + sbDict[label] = getStrandBiasDict() + + #The 4 nucleotides, used to check if mutated, upstream and downstream bases are nucleotides + nucleotides = [""A"",""C"",""G"",""T""] + + #Convert the positions in the alignment to genome positions, if --all_sites specified the positions will be the same + if args.all_sites: + positionTranslation = allSitesTranslation(alignment) + else: + positionTranslation = convertTranslation(args.conversion) + + #Extracts mutations to a dictionary from the treetime annotated_tree.nexus + if not args.start_from_treetime: + branchMutationDict = getBranchMutationNexusDict(args.output_dir + ""annotated_tree.nexus"", positionTranslation) + else: + branchMutationDict = getBranchMutationNexusDict(args.treetime_out + ""annotated_tree.nexus"", positionTranslation) + + #Get the reference sequence, if -r specified this will be the provided genome, otherwise all sites in the alignment are assumed + #and the root sequence from the ancestral reconstruction is used + referenceSequence = getReference(args.reference, args.all_sites, alignment, positionTranslation) + referenceLength = len(referenceSequence) + + #Iterate through the branches, get the category of the branch, identify the contextual mutations, add to the corresponding spectrum + for clade in labelledTree.find_clades(): + #Check if there are mutations along the current branch, only need to analyse branches with mutations + if clade.name in branchMutationDict: + #The label of the current branch, this will be None if the label changes along this branch + branchCategory = getBranchCategory(labelledTree, clade, args.include_all_branches) + + #Extract the mutations along the branch. This will be None if there are no mutations but treetime has still added the mutation comment + branchMutations = branchMutationDict[clade.name] + + #If using --branch_specific, check if the branch contains at least -bm mutations, if so + #add the branch to spectraDict. If not, set branchCategory to None so it won't be analysed + if args.branch_specific: + if len(branchMutations) >= minimumMutations: + if args.rna: + spectraDict[clade.name] = getRNADict() + else: + spectraDict[clade.name] = getMutationDict() + else: + branchCategory = None + + #If --include_root_branches is not specified, check if the branch comes off the root, if so set the branchCategory + #to None so it won't be analysed + if not args.include_root_branches: + if len(labelledTree.get_path(clade)) == 1: + branchCategory = None + + #Check if the branch has a category, will be None if the branch is a transition between categories + #and option --include_all_branches is not specified + if branchCategory is not None: + #Extract double substitutions, remove mutations at the ends of the genome or not involving 2 nucleotides + bM = [] + for eBM in branchMutations: + bM.append(eBM) + branchMutations, doubleSubstitutions = filterMutations(bM, clade, nucleotides, referenceLength, outMutationsNotUsed) + + #Update the reference sequence to get the current context + updatedReference = updateReference(tree, clade, branchMutationDict, referenceSequence) + + #Check if only synonymous mutations should be included, if so filter the mutations + if args.synonymous: + bM = list() + for eBM in branchMutations: + bM.append(eBM) + branchMutations = extractSynonymous(bM, updatedReference, geneCoordinates, positionGene) + + for mutation in branchMutations: + mutationContext = getContext(mutation, updatedReference) + + #Check if the upstream or downstream nucleotides are not A, C, G or T + if (mutationContext[0] not in nucleotides) or (mutationContext[1] not in nucleotides): + outMutationsNotUsed.write(mutation[0] + str(mutation[1]) + mutation[3] + "","" + mutation[0] + str(mutation[2]) + mutation[3] + "","" + clade.name + "",Surrounding_position_not_nucleotide\n"") + else: + #This will be true for all RNA mutations and half of DNA mutations + if (mutationContext[0] + mutation[0] + mutation[3] + mutationContext[1]) in spectraDict[branchCategory]: + spectraDict[branchCategory][mutationContext[0] + mutation[0] + mutation[3] + mutationContext[1]] += 1 + outAllMutations.write(mutation[0] + str(mutation[1]) + mutation[3] + "","" + mutation[0] + str(mutation[2]) + mutation[3] + "","" + mutationContext[0] + ""["" + mutation[0] + "">"" + mutation[3] + ""]"" + mutationContext[1] + "","" + clade.name + ""\n"") + #Add to the corresponding complement + else: + spectraDict[branchCategory][complement(mutationContext[1]) + complement(mutation[0]) + complement(mutation[3]) + complement(mutationContext[0])] += 1 + outAllMutations.write(complement(mutation[0]) + str(mutation[1]) + complement(mutation[3]) + "","" + complement(mutation[0]) + str(mutation[2]) + complement(mutation[3]) + "","" + complement(mutationContext[1]) + ""["" + complement(mutation[0]) + "">"" + complement(mutation[3]) + ""]"" + complement(mutationContext[0]) + "","" + clade.name + ""\n"") + + #If calculating strand bias, check if the mutation position is in a gene, if so extract its strand bias + if (args.strand_bias) and (mutation[2] in positionGene): + sb = getStrandBias(mutation, updatedReference, geneCoordinates, positionGene) + #Exclude genes in multiple genes on different strands + if sb is not None: + #Add to the corresponding dictionary + if (sb + mutationContext[0] + mutation[0] + mutation[3] + mutationContext[1]) in sbDict[branchCategory]: + sbDict[branchCategory][sb + mutationContext[0] + mutation[0] + mutation[3] + mutationContext[1]] += 1 + else: + sbDict[branchCategory][sb + complement(mutationContext[1]) + complement(mutation[0]) + complement(mutation[3]) + complement(mutationContext[0])] += 1 + + #Add double substitutions to the corresponding spectrum + if len(doubleSubstitutions) > 0: + dsIter = iter(doubleSubstitutions) + for s1, s2 in zip(dsIter, dsIter): + #Check if both mutations involve nucleotides, if not write both to the unused file + if (s1[0] not in nucleotides) or (s1[3] not in nucleotides) or (s2[0] not in nucleotides) or (s2[3] not in nucleotides): + outMutationsNotUsed.write(s1[0] + str(s1[1]) + s1[3] + "","" + s1[0] + str(s1[2]) + s1[3] + "","" + clade.name + "",Double_substitution_does_not_involve_two_nucleotides\n"") + outMutationsNotUsed.write(s2[0] + str(s2[1]) + s2[3] + "","" + s2[0] + str(s2[2]) + s2[3] + "","" + clade.name + "",Double_substitution_does_not_involve_two_nucleotides\n"") + else: + #This will be true for all RNA mutations and half of DNA mutations + if (s1[0] + s2[0] + s1[3] + s2[3]) in doubleSpectraDict[branchCategory]: + doubleSpectraDict[branchCategory][s1[0] + s2[0] + s1[3] + s2[3]] += 1 + outAllDouble.write(s1[0] + s2[0] + str(s1[1]) + s1[3] + s2[3] + "","" + s1[0] + s2[0] + str(s1[2]) + s1[3] + s2[3] + "","" + s1[0] + s2[0] + "">"" + s1[3] + s2[3] + "","" + clade.name + "",Forward\n"") + else: + doubleSpectraDict[branchCategory][complement(s2[0]) + complement(s1[0]) + complement(s2[3]) + complement(s1[3])] += 1 + outAllDouble.write(complement(s2[0]) + complement(s1[0]) + str(s1[1]) + complement(s2[3]) + complement(s1[3]) + "","" + complement(s2[0]) + complement(s1[0]) + str(s1[2]) + complement(s2[3]) + complement(s1[3]) + "","" + complement(s2[0]) + complement(s1[0]) + "">"" + complement(s2[3]) + complement(s1[3]) + "","" + clade.name + "",Reverse\n"") + #Write the mutations on the branch to the not used file + else: + for eM in branchMutations: + outMutationsNotUsed.write(eM[0] + str(eM[1]) + eM[3] + "","" + eM[0] + str(eM[2]) + eM[3] + "","" + clade.name + "",Label_changes_on_branch\n"") + + #Calculate contexts in the reference to enable rescaling + if not args.reverse_strand: + refContexts = calculateContexts(referenceSequence, args.rna) + else: + #Reverse the reference if using the reverse strand + reverseReference = """" + for eachN in reversed(referenceSequence): + reverseReference += complement(eachN) + refContexts = calculateContexts(reverseReference, args.rna) + + #Write the spectra to separate files + for eachLabel in spectraDict: + #Reverse the spectrum if needed + if args.reverse_strand: + spectraDict[eachLabel] = reverseSpectrum(spectraDict[eachLabel]) + doubleSpectraDict[eachLabel] = reverseDouble(doubleSpectraDict[eachLabel]) + + outFile = open(args.output_dir + ""mutational_spectrum_label_"" + eachLabel + "".csv"", ""w"") + outFile.write(""Substitution,Number_of_mutations\n"") + for eachMutation in spectraDict[eachLabel]: + outFile.write(eachMutation[0] + ""["" + eachMutation[1] + "">"" + eachMutation[2] + ""]"" + eachMutation[3] + "","" + str(spectraDict[eachLabel][eachMutation]) + ""\n"") + outFile.close() + + #Plot the spectrum + outSpectrum = open(args.output_dir + ""mutational_spectrum_label_"" + eachLabel + "".pdf"", ""w"") + spectrumFormat = convertSpectrumFormat(spectraDict[eachLabel]) + if not args.rna: + plotSpectrumFromDict(spectrumFormat, False, outSpectrum) + else: + plotRNA(spectrumFormat, False, outSpectrum) + outSpectrum.close() + + #Rescale the spectrum + rescaledSpectrum = rescaleSBS(spectraDict[eachLabel], refContexts, 1000000, args.rna) + outRescaled = open(args.output_dir + ""mutational_spectrum_label_"" + eachLabel + ""_rescaled.csv"", ""w"") + outRescaled.write(""Substitution,Number_of_mutations\n"") + for eachMutation in rescaledSpectrum: + outRescaled.write(eachMutation[0] + ""["" + eachMutation[1] + "">"" + eachMutation[2] + ""]"" + eachMutation[3] + "","" + str(rescaledSpectrum[eachMutation]) + ""\n"") + outRescaled.close() + + #Plot the rescaled spectrum + outRSpectrum = open(args.output_dir + ""mutational_spectrum_label_"" + eachLabel + ""_rescaled.pdf"", ""w"") + spectrumFormat = convertSpectrumFormat(rescaledSpectrum) + if not args.rna: + plotSpectrumFromDict(spectrumFormat, False, outRSpectrum) + else: + plotRNA(spectrumFormat, False, outRSpectrum) + outRSpectrum.close() + + #Calculate the number of each type of mutation + mtCounts = mutationTypeCount(spectraDict[eachLabel], args.rna) + #Write the mutation type counts + outMT = open(args.output_dir + ""mutation_types_label_"" + eachLabel + "".csv"", ""w"") + outMT.write(""Mutation_type,Number_of_mutations\n"") + for m in mtCounts: + outMT.write(m + "","" + str(mtCounts[m]) + ""\n"") + outMT.close() + + #Plot the mutation type counts + outMTSpectrum = open(args.output_dir + ""mutation_types_label_"" + eachLabel + "".pdf"", ""w"") + if not args.rna: + plotMutationType(mtCounts, outMTSpectrum) + else: + plotRNAMT(mtCounts, outMTSpectrum) + outMTSpectrum.close() + + #Write the double substitution spectrum + outDouble = open(args.output_dir + ""DBS_label_"" + eachLabel + "".csv"", ""w"") + outDouble.write(""Substitution,Number_of_mutations\n"") + for eachMutation in doubleSpectraDict[eachLabel]: + outDouble.write(eachMutation[:2] + "">"" + eachMutation[2:] + "","" + str(doubleSpectraDict[eachLabel][eachMutation]) + ""\n"") + + #Plot the double substitution spectrum + outDoubleSpectrum = open(args.output_dir + ""DBS_label_"" + eachLabel + "".pdf"", ""w"") + doubleFormat = convertSpectrumFormat(doubleSpectraDict[eachLabel]) + if not args.rna: + plotDouble(doubleFormat, False, outDoubleSpectrum) + else: + plotRNADouble(doubleFormat, False, outDoubleSpectrum) + outDoubleSpectrum.close() + + #Write the strand bias spectrum + if args.strand_bias: + outSB = open(args.output_dir + ""strand_bias_label_"" + eachLabel + "".csv"", ""w"") + outSB.write(""Strand,Substitution,Number_of_mutations\n"") + for sbm in sbDict[eachLabel]: + outSB.write(sbm[0] + "","" + sbm[1:] + "","" + str(sbDict[eachLabel][sbm]) + ""\n"") + outSB.close() + + #Plot the strand bias spectrum + outSBP = open(args.output_dir + ""strand_bias_label_"" + eachLabel + "".pdf"", ""w"") + plotSB(sbDict[eachLabel], False, outSBP) + outSBP.close() + + #Write the spectra to a combined catalog if there is more than 1 label + if len(spectraDict.keys()) > 1: + outCombined = open(args.output_dir + ""combined_catalog.csv"", ""w"") + outCombined.write(""Substitution"") + for eachLabel in spectraDict: + outCombined.write("","" + eachLabel) + outCombined.write(""\n"") + + for eachMutation in spectraDict[list(spectraDict.keys())[0]]: + outCombined.write(eachMutation) + for eachLabel in spectraDict: + outCombined.write("","" + str(spectraDict[eachLabel][eachMutation])) + outCombined.write(""\n"") + + outCombined.close() + + #Close output files + outMutationsNotUsed.close() + outAllMutations.close() + outAllDouble.close() + + return + + + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = muttui_parser(parser) + args = parser.parse_args() + + # run muttui + args.func(args) + + return + +if __name__ == ""__main__"": + main()","Python" +"Viral","chrisruis/MutTui","MutTui/add_tree_node_labels.py",".py","2146","78","#Adds node labels to a tree +#First processing step to label a tree for MutTui + +import argparse +from Bio import Phylo + +#Removes confidence values from the tree +#These will be bootstrap supports, etc that will be written with the node labels if not removed +def cleanTree(tree): + #Iterate through the clades and remove clade confidence values + for clade in tree.find_clades(): + if clade.confidence or (clade.confidence == 0.0): + clade.confidence = None + + return(tree) + +#Adds node labels to a given tree +def labelTreeNodes(tree): + #Will be incremented with each node + nodeIterator = 1 + + #Iterate through the internal nodes and add labels + for clade in tree.find_clades(): + if not clade.is_terminal(): + clade.name = ""Node"" + str(nodeIterator) + nodeIterator += 1 + + return(tree) + +def add_tree_node_labels_parser(parser): + + parser.description = ""Adds numerical node labels to a given tree to enable labelling of the tree into groups"" + + parser.add_argument(""-t"", + ""--tree"", + dest = ""tree"", + required = True, + help = ""Newick tree file to be labelled"", + type = argparse.FileType(""r"")) + parser.add_argument(""-o"", + ""--outfile"", + dest = ""outFile"", + required = True, + help = ""Name of output tree file"") + + parser.set_defaults(func=add_tree_node_labels) + + return(parser) + + +def add_tree_node_labels(args): + + #Clean the tree to remove any bootstrap supports + tree = cleanTree(Phylo.read(args.tree.name, ""newick"")) + + #Label the tree nodes + labelledTree = labelTreeNodes(tree) + + #Write the labelled tree + Phylo.write(labelledTree, args.outFile, ""newick"") + + return + + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = add_tree_node_labels_parser(parser) + args = parser.parse_args() + + # run add_tree_node_labels + args.func(args) + + return + +if __name__ == ""__main__"": + main() +","Python" +"Viral","chrisruis/MutTui","MutTui/convert_vcf_position_translation.py",".py","2070","69","#Converts a VCF file created to a conversion between alignment position and genome position +#In output, column 1 is alignment position, column 2 is genome position + +import argparse + +def convert_vcf_position_translation_parser(parser): + + parser.description = ""Creates the position conversion file for MutTui from a VCF file"" + + parser.add_argument(""-v"", + ""--vcf"", + dest = ""vcf"", + required = True, + help = ""VCF file to be converted"") + parser.add_argument(""-f"", + ""--format"", + dest = ""format"", + help = ""The format of the VCF file to be converted. Options are:\n"" + + ""gubbins\n"" + + ""gubbins is the default"", + default = ""gubbins"") + parser.add_argument(""-o"", + ""--out"", + dest = ""outfile"", + required = True, + help = ""Name of output file"") + + parser.set_defaults(func=convert_vcf_position_translation) + + return(parser) + +def convert_vcf_position_translation(args): + + #Import the vcf file + vcf = open(args.vcf).readlines() + + outFile = open(args.outfile, ""w"") + + #Will be incremented with each alignment position + iterator = 1 + + #Check if the VCF file is in gubbins format + if args.format == ""gubbins"": + + #Iterate through the VCF file and write the conversion between alignment and genome positions + for line in vcf: + if line.strip()[0] != ""#"": + outFile.write(str(iterator) + ""\t"" + line.strip().split(""\t"")[1] + ""\n"") + iterator += 1 + + outFile.close() + + return + + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = convert_vcf_position_translation_parser(parser) + args = parser.parse_args() + + # run convert_vcf_position_translation + args.func(args) + + return + +if __name__ == ""__main__"": + main() +","Python" +"Viral","chrisruis/MutTui","MutTui/combine_spectra.py",".py","2008","65","#Functions to combine mutational spectra +#Typically run after MutTui to combine multiple calculated spectra into a single spectrum + +import argparse +from .plot_spectrum import convertSpectrumDict + +def combine_spectra_parser(parser): + + parser.description = ""Sums the mutations in a number of input spectra to form a single output spectrum"" + + parser.add_argument(""-s"", + ""--spectra"", + dest = ""spectra"", + required = True, + nargs = ""+"", + help = ""Spectrum files to be combined. All files specified with -s will be combined"", + type = argparse.FileType(""r"")) + parser.add_argument(""-o"", + ""--outFile"", + dest = ""outFile"", + required = True, + help = ""Name of the output file to which the combined spectrum will be written"") + + parser.set_defaults(func=combine_spectra) + + return(parser) + +def combine_spectra(args): + + #Import the first spectrum, convert it to a dictionary that the others will be combined into + combinedDict = convertSpectrumDict(args.spectra[0]) + + outFile = open(args.outFile, ""w"") + outFile.write(""Substitution,Number_of_mutations\n"") + + #Iterate through the remaining spectra and add them to combinedDict + for spectrumFile in args.spectra[1:]: + spectrum = convertSpectrumDict(spectrumFile) + + for mutation in combinedDict: + combinedDict[mutation] += spectrum[mutation] + + #Write the combined spectrum + for eachMutation in combinedDict: + outFile.write(eachMutation + "","" + str(combinedDict[eachMutation]) + ""\n"") + + outFile.close() + + return + + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = combine_spectra_parser(parser) + args = parser.parse_args() + + # run combine_spectra + args.func(args) + + return + +if __name__ == ""__main__"": + main() +","Python" +"Viral","chrisruis/MutTui","MutTui/__init__.py",".py","107","4","'''A pipeline to reconstruct mutational spectra for bacterial and viral datasets''' + +__version__ = '2.0.2' +","Python" +"Viral","chrisruis/MutTui","MutTui/label_tree_gene_mutations.py",".py","5693","136","#Labels a tree for use with MutTui based on branches where a given gene mutates + +import argparse +import pandas as pd +from Bio import Phylo + +#Extract mutations from a variant effect file +#Returns dictionary with node names as keys and mutations as values +def extractMutationEffects(mFile, genes, effects): + #Import mutations + mutations = pd.read_csv(mFile.name, sep = ""\t"") + + #Empty dictionary + mD = dict() + + #Iterate through the mutations, check if they are in a gene of interest + #with an effect of interest and if so add to mD + for i in range(mutations.shape[0]): + if (mutations[""locus_tag""][i] in genes) and (mutations[""impact""][i] in effects): + if mutations[""node""][i] in mD: + mD[mutations[""node""][i]].append(mutations[""locus_tag""][i]) + else: + mD[mutations[""node""][i]] = [mutations[""locus_tag""][i]] + + return(mD) + +#From label_tree.py +#Gets the state of the upstream clade +def getParentState(tree, clade): + #Check if the clade is one downstream of the root + if len(tree.get_path(clade)) >= 2: + nodeState = tree.get_path(clade)[-2].state + else: + nodeState = str(tree.root.state) + + return(nodeState) + +#Labels a tree based on gene mutations +def labelTreeMutations(tree, mutations): + #Label the root + tree.root.state = ""R"" + + #Keys are branch names, values are labels + branches = dict() + + #Iterate through the clades in the tree, check if they have mutations in mutations, + #update their label if necessary, if not add label from parent clade + for clade in tree.find_clades(): + upstreamLabel = getParentState(tree, clade) + + #Add the gene label if there are mutations on the branch + if clade.name in mutations: + #Reset the label if it hasn't changed since the root + if upstreamLabel == ""R"": + upstreamLabel = """" + + #Add the genes to the node label + for gene in mutations[clade.name]: + if gene not in upstreamLabel.split(""....""): + if upstreamLabel == """": + upstreamLabel = gene + else: + upstreamLabel = upstreamLabel + ""...."" + gene + + clade.state = upstreamLabel + + #Relabel the tree names with the state so the tree can be saved with labels + #Append to the taxon name if a tip branch, assign to the clade name if an internal branch + for clade in tree.find_clades(): + branches[clade.name] = clade.state + if clade.is_terminal(): + clade.name = clade.name + ""____"" + clade.state + else: + clade.name = clade.state + + return(tree, branches) + +if __name__ == ""__main__"": + description = ""Labels a tree for MutTui based on mutations in one or more genes"" + parser = argparse.ArgumentParser(description = description) + parser.add_argument(""-t"", + ""--tree"", + dest = ""tree"", + required = True, + help = ""Newick tree file to the tree that will be labelled"", + type = argparse.FileType(""r"")) + parser.add_argument(""-m"", + ""--mutations"", + dest = ""mutations"", + required = True, + help = ""Mutation effect prediction file. This needs to contain columns: node containing branch names that match those "" + + ""in the tree provided with -t, locus_tag containing the gene names and impact containing the predicted mutation effect"", + type = argparse.FileType(""r"")) + parser.add_argument(""-g"", + ""--genes"", + dest = ""genes"", + required = True, + nargs = ""+"", + help = ""List of genes that will be used to label the tree. Mutations in any of the "" + + ""genes in this list with one of the effects provided with -e will be labelled"") + parser.add_argument(""-e"", + ""--effect"", + dest = ""effect"", + nargs = ""+"", + help = ""The mutation effects that will result in a mutation being added to the tree. "" + + ""By default, this will include LOW, MODERATE and HIGH effects so will include all mutations. Provide "" + + ""one or more of those labels to only include those effects"", + default = [""LOW"", ""MODERATE"", ""HIGH""]) + parser.add_argument(""-o"", + ""--outFile"", + dest = ""outFile"", + help = ""Output file prefix. 2 output files are writte: a .nwk file containing the labelled tree "" + + ""and a .csv file containg the branch in column 1 and its label in column 2"") + + args = parser.parse_args() + + #Import the tree + tree = Phylo.read(args.tree.name, ""newick"") + + #Import the mutations and extract to dictionary with node names as keys and mutations to be labelled as values + mutations = extractMutationEffects(args.mutations, args.genes, args.effect) + + #Label the tree based on mutations + stateTree, branches = labelTreeMutations(tree, mutations) + + #Write the tree + Phylo.write(stateTree, args.outFile + "".nwk"", ""newick"") + + #Write the branch conversion + outFile = open(args.outFile + "".csv"", ""w"") + outFile.write(""branch,label\n"") + + for branch in branches: + outFile.write(str(branch) + "","" + branches[branch] + ""\n"") + + outFile.close()","Python" +"Viral","chrisruis/MutTui","MutTui/isvalid.py",".py","257","9","#Functions to check if files and directories are valid + +import os + +def is_valid_folder(parser, arg): + if not os.path.isdir(arg): + parser.error(""The folder %s does not exist, please create the folder then rerun"" % arg) + else: + return(arg)","Python" +"Viral","chrisruis/MutTui","MutTui/cluster_spectra.py",".py","15551","409","#Calculates the distance between all pairs of mutational spectra and clusters based on these distances +#Calculates distance using either the Bhattacharyya distance or Jensen-Shannon distance +#Can optionally take a file with information to colour the points +#The colouring file has 2 columns - column 1 is the file paths as they will be given to the script, column 2 is the colours + +import os +import argparse +import numpy as np +from scipy import spatial +from sklearn import manifold, decomposition +import pandas as pd +import matplotlib +matplotlib.use('AGG') +from matplotlib import pyplot as plt +from .plot_spectrum import convertSpectrumDictProportions + +#Converts a set of spectra into a list of dictionaries +def convertSpectraList(spectra, labels): + #List of spectra dictionaries + spectraList = [{} for i in range(len(spectra))] + + sampleNames = list() + + #Iterate through the spectra, convert to proportions and add to spectraList + for i, spectrum in enumerate(spectra): + if labels: + sampleNames.append(labels[i]) + else: + sampleNames.append(spectrum.name) + + #Calculate the total number of mutations in the spectrum + totalMutations = float(0) + mD = convertSpectrumDictProportions(spectrum) + for m in mD: + totalMutations += mD[m] + + #Calculate the proportion of each mutation and add to spectraList and sL + for m in mD: + spectraList[i][m] = mD[m]/totalMutations + + return(spectraList, sampleNames) + +#Converts a multi-sample catalog into a list of dictionaries +def convertCatalog(catalogFile): + catalog = open(catalogFile.name).readlines() + + sampleNames = catalog[0].strip().split("","")[1:] + + #List of spectra dictionaries + spectraList = [{} for i in range(len(sampleNames))] + + #Calculate the total mutations in each sample if the spectra are not proportions + totalMutations = [0] * len(sampleNames) + for row in catalog[1:]: + for sample in range(len(sampleNames)): + totalMutations[sample] += float(row.strip().split("","")[sample + 1]) + + #Calculate the proportion of each mutation in each sample + for row in catalog[1:]: + for sample in range(len(sampleNames)): + spectraList[sample][row.strip().split("","")[0]] = float(row.strip().split("","")[sample + 1])/totalMutations[sample] + + return(spectraList, sampleNames) + +#Converts a given colouring file to a dictionary with files as keys and colours as values and +#an array of colours for umap +def getColourDict(colourFile): + if colourFile is None: + return(None, None) + + else: + colourDict = {} + + #Conversion from label to identifier + conversion = dict() + #Incremented with each new label + iterator = 0 + colourList = [] + + #Iterate through the labels, add the label to colourList + #Add to the label conversion if not already present + with open(colourFile.name) as fileobject: + for line in fileobject: + l = line.strip().split(""\t"")[1] + colourDict[line.strip().split(""\t"")[0]] = l + if l not in conversion: + conversion[l] = iterator + iterator += 1 + colourList.append(conversion[l]) + + return(colourDict, colourList) + +#Calculates the cosine distance between 2 given spectra +#Used to allow multiple distance metrics, now only supports cosine distance +def calculateSpectraDistance(spectrum1, spectrum2): + s1 = list(spectrum1.values()) + s2 = list(spectrum2.values()) + distance = spatial.distance.cosine(s1, s2) + + return(distance) + +#Creates a matrix of zeros with number of rows and columns equal to the provided number of samples +def getZerosMatrix(nSamples): + dist_mat = np.zeros((nSamples, nSamples), dtype = float) + + return(dist_mat) + +#Calculates a distance matrix between all pairs of spectra +def getDistanceMatrix(spectraList): + #Distance matrix of zeros + distances = getZerosMatrix(len(spectraList)) + + #Iterate through the pairs of spectra and calculate their distance + for spectrum1 in range(len(spectraList) - 1): + for spectrum2 in range((spectrum1 + 1), len(spectraList)): + distances[spectrum1, spectrum2] = calculateSpectraDistance(spectraList[spectrum1], spectraList[spectrum2]) + distances[spectrum2, spectrum1] = distances[spectrum1, spectrum2] + + return(distances) + +#Converts a list of spectrum dictionaries to an array +def arraySpectra(spectra, rna): + #Extract mutations from keys + m = spectra[0].keys() + + if not rna: + sa = np.zeros((len(spectra), 96)) + else: + sa = np.zeros((len(spectra), 192)) + + for i, s in enumerate(spectra): + for j, em in enumerate(m): + sa[i,j] = s[em] + + return(sa) + +#PCA of SBS spectra based on mutation proportions +def sbsPCA(spectra, sn, col, cl, output_dir): + #PCA of spectra + pca = decomposition.PCA(n_components = 2) + pc = pca.fit_transform(spectra) + + #Extract coordinates to plot + x = list() + y = list() + for i in pc: + x.append(i[0]) + y.append(i[1]) + + #Colours for plot + if col is None: + colours = [""black"" for i in range(len(sn))] + else: + colours = [] + for s in sn: + colours.append(col[s]) + + #Write PCA coordinates + with open(output_dir + ""SBS_PCA_coordinates.csv"", ""w"") as outP: + outP.write(""Sample,Principle_component_1,Principle_component_2\n"") + for es in range(len(sn)): + outP.write(sn[es] + "","" + str(x[es]) + "","" + str(y[es]) + ""\n"") + + #Data frame for plotting + pDF = pd.DataFrame({""x"": x, ""y"": y, ""cols"": colours}) + + #Plot PCA + plt.style.use(""ggplot"") + fig = plt.figure() + #Colour column is labels + if col and not cl: + groups = pDF.groupby(""cols"") + for name, group in groups: + plt.scatter(group.x, group.y, label = name) + #Colour column is colours + else: + plt.scatter(pDF.x, pDF.y, color = pDF.cols) + plt.grid(True) + plt.xlabel(""Principle component 1"") + plt.ylabel(""Principle component 2"") + plt.tight_layout() + fig.savefig(output_dir + ""SBS_PCA.pdf"") + +#Plots a multidimensional scaling based on a given distance matrix +def plotMDS(distances, file_names, colourDict, output_dir): + #MDS of the distances + mds = manifold.MDS(n_components = 2, dissimilarity = ""precomputed"") + projection = mds.fit(distances) + coords = projection.embedding_ + + #Extract the colours of each point + #colourDict = getColourDict(colourFile) + colours = [] + if colourDict is None: + for eachFile in file_names: + colours.append(""blue"") + else: + for eachFile in file_names: + #Removed .name from after eachFile as it seems like this will have strings as keys + #if a colour file is provided + colours.append(colourDict[eachFile]) + + #Write MDS coordinates + with open(output_dir + ""distance_mds_coordinates.txt"", ""w"") as points_out: + points_out.write(""Sample\tx_coordinate\ty_coordinate\n"") + for i, coord in zip(file_names, coords): + points_out.write(""%s\t%s\t%s\n"" % (i, coord[0], coord[1])) + + #Identify plot margins + c_min = np.min(coords) - abs(np.quantile(coords, 0.05)) + c_max = np.max(coords) + abs(np.quantile(coords, 0.05)) + + #Plot MDS + plt.style.use(""ggplot"") + fig = plt.figure() + plt.scatter(coords[:, 0], coords[:, 1], color = colours) + plt.grid(True) + plt.xlabel(""MDS dimension 1"") + plt.ylabel(""MDS dimension 2"") + plt.xlim((c_min, c_max)) + plt.ylim((c_min, c_max)) + plt.tight_layout() + fig.savefig(output_dir + ""distance_MDS.pdf"") + +#OLD FUNCTION USED TO PLOT UMAP BASED ON SAMPLE DISTANCES +#UMAP NO LONGER PLOTTED +#UMAP clustering and plotting +def plotUMAP(distances, colours, output_dir): + distanceMap = umap.UMAP(n_neighbors = 5, metric = ""cosine"").fit(distances) + + if colours is not None: + labels = np.array(colours) + umapFig = umap.plot.points(distanceMap, labels = labels) + else: + umapFig = umap.plot.points(distanceMap) + + umapFig.figure.savefig(output_dir + ""sample_umap.pdf"") + +#OLD FUNCTION USED TO RUN UMAP ON A SET OF SPECTRA +#UMAP NO LONGER USED +#Calculates a UMAP embedding for a set of spectra +def extractUMAP(sL, labels, colours, output_dir): + #Convert to array + sL = np.asarray(sL) + + reducer = umap.UMAP() + + embedding = reducer.fit_transform(sL) + + #Write the sample coordinates + out_coordinates = open(output_dir + ""sample_umap_coordinates.csv"", ""w"") + out_coordinates.write(""Sample,x_coordinate,y_coordinate\n"") + for l in range(len(embedding)): + out_coordinates.write(labels[l] + "","" + str(embedding[l][0]) + "","" + str(embedding[l][1]) + ""\n"") + out_coordinates.close() + + fig = plt.figure() + plt.scatter(embedding[:, 0], embedding[:, 1]) + plt.gca().set_aspect(""equal"", ""datalim"") + fig.savefig(output_dir + ""test.pdf"") + + distanceMap = umap.UMAP().fit(sL) + if colours is not None: + labels = np.array(colours) + umapFig = umap.plot.points(distanceMap, labels = labels) + else: + umapFig = umap.plot.points(distanceMap) + + umapFig.figure.savefig(output_dir + ""sample_umap.pdf"") + + +def cluster_spectra(args): + #If using labels, verify that there are the same number of labels as spectra + if args.labels: + if len(args.spectra) != len(args.labels): + raise RuntimeError(""The number of labels provided with -l must match the number of spectra provided with -s"") + + #Make sure trailing forward slash is present in output directory + args.output_dir = os.path.join(args.output_dir, """") + + #If multiple spectra are provided, extract these to lists + if args.spectra: + spectraList, sampleNames = convertSpectraList(args.spectra, args.labels) + else: + #Extract the catalog into spectraList + spectraList, sampleNames = convertCatalog(args.catalog) + + #Calculate distances between all pairs of spectra + distances = getDistanceMatrix(spectraList) + + #Write cosine similarity and distances + s_out = open(args.output_dir + ""cosine_similarity.csv"", ""w"") + d_out = open(args.output_dir + ""cosine_distances.csv"", ""w"") + s_out.write(""Sample"") + d_out.write(""Sample"") + for sample in sampleNames: + s_out.write("","" + sample) + d_out.write("","" + sample) + s_out.write(""\n"") + d_out.write(""\n"") + for row in range(len(distances)): + s_out.write(sampleNames[row]) + d_out.write(sampleNames[row]) + for column in distances[row]: + s_out.write("","" + str(1 - column)) + d_out.write("","" + str(column)) + s_out.write(""\n"") + d_out.write(""\n"") + s_out.close() + d_out.close() + + #Extract the colours from the colour file if present + colourDict, cConversion = getColourDict(args.colour_file) + + #Extract spectra to arrays + sA = arraySpectra(spectraList, args.rna) + + #MDS of mutation proportions + sbsPCA(sA, sampleNames, colourDict, args.colour_labels, args.output_dir) + + #MDS of sample distances + if args.mds_distance: + plotMDS(distances, sampleNames, colourDict, args.output_dir) + + return + +def cluster_spectra_parser(parser): + + parser.description = ""Calculate distances and cluster a set of input SBS spectra. These can be provided as individual spectrum files with -s or as a combined catalogue with -c"" + + spectra = parser.add_mutually_exclusive_group(required = True) + spectra.add_argument(""-s"", + ""--spectra"", + dest = ""spectra"", + nargs = ""+"", + help = ""SBS spectrum files to be clustered. All files specified with -s will be clustered"", + type = argparse.FileType(""r"")) + spectra.add_argument(""-c"", + ""--catalog"", + dest = ""catalog"", + help = ""Multi-sample catalogue containing SBS spectra, samples as columns and mutation counts/proportions as rows"", + type = argparse.FileType(""r"")) + + parser.add_argument(""-l"", + ""--labels"", + dest = ""labels"", + nargs = ""+"", + help = ""Labels for each spectrum provided with -s. If not provided, the file names will be used as labels"", + default = None) + parser.add_argument(""-cl"", + ""--colours"", + dest = ""colour_file"", + default = None, + help = ""Optional file containing information to colour points in the output clustering. "" + + ""This file should contain 2 columns separated by tabs with no header. Column 1 is the "" + + ""name of the sample. If providing labels with -l, these names should match the labels. If "" + + ""using a catalog, these names should match the column names. If using file paths, these names should "" + + ""match the file paths, as provided to -s. Column 2 contains information for colouring. This can either be "" + + ""the group to which the sample name belongs (e.g. enteric or group1) or a colour for each sample. If "" + + ""using colours, add the --colour_labels option"", + type = argparse.FileType(""r"")) + parser.add_argument(""--mutation_types"", + dest = ""mt"", + help = ""Run PCA on mutation proportions within each of the 6 mutation types. This will output "" + + ""6 additional csv files and 6 additional plots, one per mutation type in each case. This calculates "" + + ""the proportion of each contextual mutation within the respective mutation type (e.g. the proportion of "" + + ""C>A mutations that are T[C>A]G) ands runs a PCA on those 16 proportions across spectra"", + action = ""store_true"", + default = False) + parser.add_argument(""--plot_mds_distance"", + dest = ""mds_distance"", + help = ""Output an MDS plot based on sample distances"", + action = ""store_true"", + default = False) + parser.add_argument(""--colour_labels"", + dest = ""colour_labels"", + help = ""Specify that the sample labels in the file provided with -cl are colours"", + action = ""store_true"", + default = False) + parser.add_argument(""--rna"", + dest = ""rna"", + help = ""Specify if using an RNA pathogen"", + action = ""store_true"", + default = False) + parser.add_argument(""-o"", + ""--out_prefix"", + dest = ""output_dir"", + required = True, + help = ""Output directory"") + + parser.set_defaults(func=cluster_spectra) + + return(parser) + + + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = cluster_spectra_parser(parser) + args = parser.parse_args() + + # run cluster_spectra + args.func(args) + + return + +if __name__ == ""__main__"": + main()","Python" +"Viral","chrisruis/MutTui","MutTui/gff_conversion.py",".py","2156","58","#Functions to work with GFF files + +from io import StringIO +from Bio import SeqIO +import gffutils as gff + +#Clean other ""##"" starting lines from gff file, as it confuses parsers +#Taken from prokka.py in Panaroo +def clean_gff_string(gff_string): + splitlines = gff_string.splitlines() + lines_to_delete = [] + for index in range(len(splitlines)): + if '##sequence-region' in splitlines[index]: + lines_to_delete.append(index) + for index in sorted(lines_to_delete, reverse=True): + del splitlines[index] + cleaned_gff = ""\n"".join(splitlines) + return cleaned_gff + +#Takes a GFF file and returns a list of lists +#Each entry in list is a gene with 4 components - gene name, gene start, gene end, strand +def convertGFF(gff_file_name): + gff_file = open(gff_file_name, ""r"") + + #Open file, split into genes and sequence + lines = gff_file.read().replace("","", """") + split = lines.split(""##FASTA"") + + if len(split) != 2: + print(""Problem reading GFF file"", gff_file.name) + raise RuntimeError(""Error reading GFF file"") + + #Convert GFF sequence to fasta format + with StringIO(split[1]) as temp_fasta: + sequences = list(SeqIO.parse(temp_fasta, ""fasta"")) + + parsed_gff = gff.create_db(clean_gff_string(split[0]), + dbfn = "":memory:"", + force = True, + keep_order = True, + from_string = True) + + geneCoordinates = dict() + geneDict = dict() + + for entry in parsed_gff.all_features(featuretype = ()): + if ""CDS"" not in entry.featuretype: + continue + else: + geneCoordinates[entry.id] = [entry.start, entry.stop, entry.strand] + for position in range(entry.start, (entry.stop + 1)): + #If the position is in overlapping genes, all genes will be included separated by ____ + if position in geneDict: + geneDict[position] = geneDict[position] + ""____"" + entry.id + else: + geneDict[position] = entry.id + + return(geneCoordinates, geneDict)","Python" +"Viral","chrisruis/MutTui","MutTui/plot_mutation_type_comparison.py",".py","5249","146","#Plots the proportion of each mutation type across a set of samples +#Runs on a multi-sample catalog which can be produced from a set of MutTui output spectra using combine_spectra_into_catalog.py +#This plots the 6 mutation types, not spectra + +import argparse +import matplotlib +matplotlib.use('AGG') +import matplotlib.pyplot as plt +import sys + +#Verifies that the mutations are in the expected order +def verifyOrder(catalog): + inOrder = True + + if catalog[1].strip().split("","")[0] != ""CA"": + inOrder = False + if catalog[2].strip().split("","")[0] != ""CG"": + inOrder = False + if catalog[3].strip().split("","")[0] != ""CT"": + inOrder = False + if catalog[4].strip().split("","")[0] != ""TA"": + inOrder = False + if catalog[5].strip().split("","")[0] != ""TC"": + inOrder = False + if catalog[6].strip().split("","")[0] != ""TG"": + inOrder = False + + return(inOrder) + +#Converts the mutations in a catalog to proportions +def convertCatalogProportion(catalog): + #Samples as keys, mutation type proportions as values + sM = dict() + + for s in range(1, len(catalog[0].strip().split("",""))): + sampleName = catalog[0].strip().split("","")[s] + tM = float(0) + + for line in catalog[1:]: + tM += float(line.strip().split("","")[s]) + + sM[sampleName] = list() + + for line in catalog[1:]: + sM[sampleName].append(float(line.strip().split("","")[s])/tM) + + return(sM) + +#Extracts colours from a colour file to a list +def getColours(colourFile, samples): + colours = open(colourFile).readlines() + + colourDict = dict() + for c in colours: + colourDict[c.strip().split("","")[0]] = c.strip().split("","")[1] + + colourList = list() + for s in colourDict: + colourList.append(colourDict[s]) + + return(colourList) + +#Plots and saves a bar plot of mutation proportions +def plotProportions(xList, yList, colours, outFile): + fig = plt.figure() + ax = plt.subplot(111) + ax.bar(xList, yList, color = colours) + plt.xticks(rotation = ""vertical"") + plt.subplots_adjust(bottom = 0.15) + + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots the proportion of each mutation type in each of a set of samples +#The mutations are in order CA, CG, CT, TA, TC, TG, as verified by verifyOrder +def plotTypeComparison(catalogDict, colourFile): + #Sample names for the plot + samples = list() + for s in catalogDict: + samples.append(s) + + #Create lists for the proportion of each mutation type + ca = list() + cg = list() + ct = list() + ta = list() + tc = list() + tg = list() + + #Iterate through the samples and add to the lists + for s in catalogDict: + ca.append(catalogDict[s][0]) + cg.append(catalogDict[s][1]) + ct.append(catalogDict[s][2]) + ta.append(catalogDict[s][3]) + tc.append(catalogDict[s][4]) + tg.append(catalogDict[s][5]) + + if not colourFile: + plotProportions(samples, ca, ""blue"", ""proportion_C_A.pdf"") + plotProportions(samples, cg, ""black"", ""proportion_C_G.pdf"") + plotProportions(samples, ct, ""red"", ""proportion_C_T.pdf"") + plotProportions(samples, ta, ""grey"", ""proportion_T_A.pdf"") + plotProportions(samples, tc, ""green"", ""proportion_T_C.pdf"") + plotProportions(samples, tg, ""pink"", ""proportion_T_G.pdf"") + else: + colours = getColours(colourFile, samples) + plotProportions(samples, ca, colours, ""proportion_C_A.pdf"") + plotProportions(samples, cg, colours, ""proportion_C_G.pdf"") + plotProportions(samples, ct, colours, ""proportion_C_T.pdf"") + plotProportions(samples, ta, colours, ""proportion_T_A.pdf"") + plotProportions(samples, tc, colours, ""proportion_T_C.pdf"") + plotProportions(samples, tg, colours, ""proportion_T_G.pdf"") + +if __name__ == ""__main__"": + description = ""Plots mutation type proportions from a catalogue"" + parser = argparse.ArgumentParser(description = description) + + parser.add_argument(""-c"", + ""--catalog"", + dest = ""catalog"", + required = True, + help = ""Mutational catalog containing samples to be plotted. "" + + ""This should contain the six mutational types, not whole spectra, "" + + ""and can be generated using combine_spectra_into_catalog.py"", + type = argparse.FileType(""r"")) + parser.add_argument(""-l"", + ""--colours"", + dest = ""colours"", + default = False, + help = ""Optional csv containing colours. Two columns with no header. "" + + ""Column 1 is the sample name as it appears in the catalog, column 2 is the colour"") + + args = parser.parse_args() + + #Import the catalog + catalog = open(args.catalog.name).readlines() + + if verifyOrder(catalog) == False: + sys.exit(""Catalog is not in the correct order. Check the mutational order is CA, CG, CT, TA, TC, TG and try again"") + + catalogProportions = convertCatalogProportion(catalog) + + plotTypeComparison(catalogProportions, args.colours)","Python" +"Viral","chrisruis/MutTui","MutTui/generate_enriched_spectrum.py",".py","5347","101","#Creates a spectrum containing only the mutation types that are elevated in one spectrum relative to another +#Used to create a condition-specific spectrum to examine the signatures that are more active in one condition relative to another +#The generated spectrum will contain the number of mutations provided with -n, default 10000 + +import argparse +from plot_spectrum import convertSpectrumDict +from compare_spectra import convertSpectrumProportions + +#Calculates the difference in mutation proportions between 2 spectra +def sDifference(s1, s2, mutations): + sDiff = dict() + + for m in mutations: + sDiff[m] = s1[m] - s2[m] + + return(sDiff) + +#Calculates the proportion of mutations to be assigned to each mutation type in a comparison spectrum +#Takes a comparison spectrum from sDifference +#Keeps mutations that are >0 in this comparison spectrum and converts each mutation to proportion of that +#mutation in the enriched mutations +def getMutationProportions(s, mutations): + #Sum of the proportions that are >0 + totMut = float(0) + + #Iterate through the mutations, check if they are >0 in s, add to totMut if they are, change to 0 if they are not + for m in mutations: + if s[m] > 0.0: + totMut += s[m] + else: + s[m] = 0.0 + + #Iterate through the mutations and change to their scaled value + #Will be 0 if they were <=0 in the original spectrum + #Will be scaled to their original value/total proportion of mutations >0 if they were originally >0 + for mut in mutations: + s[mut] = s[mut]/totMut + + return(s) + +if __name__ == ""__main__"": + description = ""Creates a spectrum containing mutations elevated in one spectrum over another, in proportion to their elevation"" + parser = argparse.ArgumentParser(description = description) + + parser.add_argument(""-s1"", + ""--spectrum1"", + dest = ""spectrum1"", + required = True, + help = ""Spectrum csv from MutTui. Mutation types enriched in this spectrum above "" + + ""the spectrum provided with -s2 will be included in the output spectrum"", + type = argparse.FileType(""r"")) + parser.add_argument(""-s2"", + ""--spectrum2"", + dest = ""spectrum2"", + required = True, + help = ""Spectrum csv from MutTui. This spectrum is used as the background. "" + + ""Mutations in the spectrum provided with -s1 that are above this spectrum will be "" + + ""included in the output spectrum"", + type = argparse.FileType(""r"")) + parser.add_argument(""-n"", + ""--number_mutations"", + dest = ""n_mut"", + help = ""The number of mutations in the output spectrum, default is 10,000"", + default = ""10000"") + parser.add_argument(""-o"", + ""--output_spectrum"", + dest = ""out_file"", + required = True, + help = ""File to which the mutations enriched in spectrum -s1 relative to spectrum "" + + ""-s2 will be written"") + + args = parser.parse_args() + + #Import the spectra and convert them to dictionaries + s1 = convertSpectrumDict(args.spectrum1) + s2 = convertSpectrumDict(args.spectrum2) + #Convert to dictionaries of proportions + sp1 = convertSpectrumProportions(s1) + sp2 = convertSpectrumProportions(s2) + + #The number of mutations in the enriched spectrum + nMut = float(args.n_mut) + + outFile = open(args.out_file, ""w"") + outFile.write(""Substitution,Sample1\n"") + + #The 96 DNA mutations as a list, used so they are always in the same order + mutations = [""A[C>A]A"",""A[C>A]C"",""A[C>A]G"",""A[C>A]T"",""C[C>A]A"",""C[C>A]C"",""C[C>A]G"",""C[C>A]T"",""G[C>A]A"",""G[C>A]C"",""G[C>A]G"",""G[C>A]T"",""T[C>A]A"",""T[C>A]C"",""T[C>A]G"",""T[C>A]T"",""A[C>G]A"",""A[C>G]C"",""A[C>G]G"",""A[C>G]T"",""C[C>G]A"",""C[C>G]C"",""C[C>G]G"",""C[C>G]T"",""G[C>G]A"",""G[C>G]C"",""G[C>G]G"",""G[C>G]T"",""T[C>G]A"",""T[C>G]C"",""T[C>G]G"",""T[C>G]T"",""A[C>T]A"",""A[C>T]C"",""A[C>T]G"",""A[C>T]T"",""C[C>T]A"",""C[C>T]C"",""C[C>T]G"",""C[C>T]T"",""G[C>T]A"",""G[C>T]C"",""G[C>T]G"",""G[C>T]T"",""T[C>T]A"",""T[C>T]C"",""T[C>T]G"",""T[C>T]T"",""A[T>A]A"",""A[T>A]C"",""A[T>A]G"",""A[T>A]T"",""C[T>A]A"",""C[T>A]C"",""C[T>A]G"",""C[T>A]T"",""G[T>A]A"",""G[T>A]C"",""G[T>A]G"",""G[T>A]T"",""T[T>A]A"",""T[T>A]C"",""T[T>A]G"",""T[T>A]T"",""A[T>C]A"",""A[T>C]C"",""A[T>C]G"",""A[T>C]T"",""C[T>C]A"",""C[T>C]C"",""C[T>C]G"",""C[T>C]T"",""G[T>C]A"",""G[T>C]C"",""G[T>C]G"",""G[T>C]T"",""T[T>C]A"",""T[T>C]C"",""T[T>C]G"",""T[T>C]T"",""A[T>G]A"",""A[T>G]C"",""A[T>G]G"",""A[T>G]T"",""C[T>G]A"",""C[T>G]C"",""C[T>G]G"",""C[T>G]T"",""G[T>G]A"",""G[T>G]C"",""G[T>G]G"",""G[T>G]T"",""T[T>G]A"",""T[T>G]C"",""T[T>G]G"",""T[T>G]T""] + + #Subtract spectrum 2 from spectrum 1 + sDiff = sDifference(sp1, sp2, mutations) + + #Convert the mutation proportions so mutations more common in -s2 are set to 0 and + #mutations more common in -s1 are set to their relative proportion in the mutations that are enriched in -s1 + sEnriched = getMutationProportions(sDiff, mutations) + + #Write the mutations + for mutation in mutations: + outFile.write(mutation + "","" + str(int(round((sEnriched[mutation] * nMut),0))) + ""\n"") + + outFile.close()","Python" +"Viral","chrisruis/MutTui","MutTui/rescale_spectrum.py",".py","12711","352","#Rescales a mutational spectrum with a contexts file +#The relative height of each peak in the spectrum will be scaled by the proportion of the context in the given file + +import argparse +from collections import OrderedDict, Counter +from Bio import SeqIO +from plot_spectrum import convertSpectrumDict +from reconstruct_spectrum import getMutationDict, getRNADict, getDoubleSubstitutionDict, complement + +#Removes the brackets and > from spectrum keys +def convertSpectrumKeys(spectrum): + s = dict() + + for k in spectrum: + s[k[0] + k[2] + k[4] + k[6]] = spectrum[k] + + return(s) + +#Removes the > from keys in a double substitution spectrum +def convertDoubleKeys(spectrum): + s = dict() + + for k in spectrum: + s[k[0] + k[1] + k[3] + k[4]] = spectrum[k] + + return(s) + +#Creates an empty dictionary of triplets +def getTripletDict(): + tripletDict = OrderedDict() + tripletDict[""ACA""] = 0 + tripletDict[""ACC""] = 0 + tripletDict[""ACG""] = 0 + tripletDict[""ACT""] = 0 + tripletDict[""CCA""] = 0 + tripletDict[""CCC""] = 0 + tripletDict[""CCG""] = 0 + tripletDict[""CCT""] = 0 + tripletDict[""GCA""] = 0 + tripletDict[""GCC""] = 0 + tripletDict[""GCG""] = 0 + tripletDict[""GCT""] = 0 + tripletDict[""TCA""] = 0 + tripletDict[""TCC""] = 0 + tripletDict[""TCG""] = 0 + tripletDict[""TCT""] = 0 + tripletDict[""ATA""] = 0 + tripletDict[""ATC""] = 0 + tripletDict[""ATG""] = 0 + tripletDict[""ATT""] = 0 + tripletDict[""CTA""] = 0 + tripletDict[""CTC""] = 0 + tripletDict[""CTG""] = 0 + tripletDict[""CTT""] = 0 + tripletDict[""GTA""] = 0 + tripletDict[""GTC""] = 0 + tripletDict[""GTG""] = 0 + tripletDict[""GTT""] = 0 + tripletDict[""TTA""] = 0 + tripletDict[""TTC""] = 0 + tripletDict[""TTG""] = 0 + tripletDict[""TTT""] = 0 + + return(tripletDict) + +#Creates an empty dictionary of RNA triplets +def getRNATripletDict(): + tripletDict = OrderedDict() + tripletDict[""ACA""] = 0 + tripletDict[""ACC""] = 0 + tripletDict[""ACG""] = 0 + tripletDict[""ACT""] = 0 + tripletDict[""CCA""] = 0 + tripletDict[""CCC""] = 0 + tripletDict[""CCG""] = 0 + tripletDict[""CCT""] = 0 + tripletDict[""GCA""] = 0 + tripletDict[""GCC""] = 0 + tripletDict[""GCG""] = 0 + tripletDict[""GCT""] = 0 + tripletDict[""TCA""] = 0 + tripletDict[""TCC""] = 0 + tripletDict[""TCG""] = 0 + tripletDict[""TCT""] = 0 + tripletDict[""ATA""] = 0 + tripletDict[""ATC""] = 0 + tripletDict[""ATG""] = 0 + tripletDict[""ATT""] = 0 + tripletDict[""CTA""] = 0 + tripletDict[""CTC""] = 0 + tripletDict[""CTG""] = 0 + tripletDict[""CTT""] = 0 + tripletDict[""GTA""] = 0 + tripletDict[""GTC""] = 0 + tripletDict[""GTG""] = 0 + tripletDict[""GTT""] = 0 + tripletDict[""TTA""] = 0 + tripletDict[""TTC""] = 0 + tripletDict[""TTG""] = 0 + tripletDict[""TTT""] = 0 + tripletDict[""AAA""] = 0 + tripletDict[""AAC""] = 0 + tripletDict[""AAG""] = 0 + tripletDict[""AAT""] = 0 + tripletDict[""CAA""] = 0 + tripletDict[""CAC""] = 0 + tripletDict[""CAG""] = 0 + tripletDict[""CAT""] = 0 + tripletDict[""GAA""] = 0 + tripletDict[""GAC""] = 0 + tripletDict[""GAG""] = 0 + tripletDict[""GAT""] = 0 + tripletDict[""TAA""] = 0 + tripletDict[""TAC""] = 0 + tripletDict[""TAG""] = 0 + tripletDict[""TAT""] = 0 + tripletDict[""AGA""] = 0 + tripletDict[""AGC""] = 0 + tripletDict[""AGG""] = 0 + tripletDict[""AGT""] = 0 + tripletDict[""CGA""] = 0 + tripletDict[""CGC""] = 0 + tripletDict[""CGG""] = 0 + tripletDict[""CGT""] = 0 + tripletDict[""GGA""] = 0 + tripletDict[""GGC""] = 0 + tripletDict[""GGG""] = 0 + tripletDict[""GGT""] = 0 + tripletDict[""TGA""] = 0 + tripletDict[""TGC""] = 0 + tripletDict[""TGG""] = 0 + tripletDict[""TGT""] = 0 + + return(tripletDict) + +#Creates an empty dictionary of dinucleotides +def getDinucleotideDict(): + dnDict = OrderedDict() + dnDict[""AA""] = 0 + dnDict[""AC""] = 0 + dnDict[""AG""] = 0 + dnDict[""AT""] = 0 + dnDict[""CA""] = 0 + dnDict[""CC""] = 0 + dnDict[""CG""] = 0 + dnDict[""GA""] = 0 + dnDict[""GC""] = 0 + dnDict[""TA""] = 0 + + return(dnDict) + +#Calculates the number of each triplet in a given sequence +def calculateContexts(sequence, rna): + if not rna: + tripletDict = getTripletDict() + else: + tripletDict = getRNATripletDict() + + nucleotides = [""A"", ""C"", ""G"", ""T""] + + for i in range(len(sequence) - 2): + t = sequence[i:(i+3)] + if (t[0] in nucleotides) and (t[1] in nucleotides) and (t[2] in nucleotides): + if t in tripletDict: + tripletDict[t] += 1 + else: + tripletDict[complement(t[2]) + complement(t[1]) + complement(t[0])] += 1 + + #Add the reverse complement contexts from the reverse strand if the sequence is DNA + if not rna: + for c in tripletDict: + tripletDict[c] = tripletDict[c] * 2 + + return(tripletDict) + +#Calculates the number of each dinucleotide in a given sequence +def calculateDinucleotides(sequence, rna): + dnDict = getDinucleotideDict() + + for i in range(len(sequence) - 1): + if (sequence[i] + sequence[i + 1]) in dnDict: + dnDict[sequence[i] + sequence[i + 1]] += 1 + else: + dnDict[complement(sequence[i + 1]) + complement(sequence[i])] += 1 + + #Add the reverse complement contexts from the reverse strand if the sequence is DNA + if not rna: + for c in dnDict: + dnDict[c] = dnDict[c] * 2 + + return(dnDict) + +#Rescales a SBS mutational spectrum +def rescaleSBS(spectrum, reference, scalar, rna): + #Update spectrum keys + spectrum = convertSpectrumKeys(spectrum) + + #Extract all triplet contexts from the reference + for record in SeqIO.parse(reference, ""fasta""): + contexts = calculateContexts(record.seq.upper(), rna) + + #Will be filled with the rescaled spectrum + if args.rna: + rescaledSpectrum = getRNADict() + else: + rescaledSpectrum = getMutationDict() + + #Iterate through the contextual mutations, scale their counts and add to rescaledSpectrum + for m in spectrum: + rescaledSpectrum[m] = round((spectrum[m]/contexts[m[0] + m[1] + m[3]]) * scalar) + + return(rescaledSpectrum, contexts) + +#Rescales a mutation type spectrum +def rescaleMT(spectrum, reference, scalar, rna): + #Count the number of each nucleotide in the refernece, combine AT and GC if not rna + for record in SeqIO.parse(reference, ""fasta""): + c = Counter(record.seq.upper()) + + conversion = dict() + if rna: + conversion[""A""] = c[""A""] + conversion[""C""] = c[""C""] + conversion[""G""] = c[""G""] + conversion[""T""] = c[""T""] + else: + conversion[""A""] = c[""A""] + c[""T""] + conversion[""C""] = c[""C""] + c[""G""] + conversion[""G""] = c[""C""] + c[""G""] + conversion[""T""] = c[""A""] + c[""T""] + + #Empty mutation type dicts + if rna: + rescaledSpectrum = {""CA"": 0, ""CG"": 0, ""CT"": 0, ""TA"": 0, ""TC"": 0, ""TG"": 0, ""GT"": 0, ""GC"": 0, ""GA"": 0, ""AC"": 0, ""AG"": 0, ""AT"": 0} + else: + rescaledSpectrum = {""CA"": 0, ""CG"": 0, ""CT"": 0, ""TA"": 0, ""TC"": 0, ""TG"": 0} + + #Rescale the mutations based on their original nucleotide + for m in spectrum: + rescaledSpectrum[m] = round((spectrum[m]/conversion[m[0]]) * scalar) + + return(rescaledSpectrum, conversion) + +#Rescales a double substitution spectrum +def rescaleDouble(spectrum, reference, scalar, rna): + #Convert spectrum keys + spectrum = convertDoubleKeys(spectrum) + + #Count dinucleotide pairs in reference + for sequence in SeqIO.parse(reference, ""fasta""): + dn = calculateDinucleotides(sequence.seq.upper(), rna) + + #Empty DBS dict + rescaledSpectrum = getDoubleSubstitutionDict() + + #Iterate through the mutations and rescale by their starting context availability + for m in spectrum: + rescaledSpectrum[m] = round((spectrum[m]/dn[m[0] + m[1]]) * scalar) + + return(rescaledSpectrum, dn) + +if __name__ == ""__main__"": + description = ""Rescales a mutational spectrum based on triplet availability in a given reference"" + parser = argparse.ArgumentParser(description = description) + + parser.add_argument(""-s"", + ""--spectrum"", + dest = ""spectrum"", + required = True, + help = ""Mutational spectrum to be rescaled"", + type = argparse.FileType(""r"")) + parser.add_argument(""-r"", + ""--reference"", + dest = ""reference"", + help = ""Fasta format sequence to be examined. This should be a single sequence"", + type = argparse.FileType(""r"")) + parser.add_argument(""-f"", + ""--scale_factor"", + dest = ""scale_factor"", + help = ""The scalar each mutation/context will be multiplied by to obtain a rescaled mutation count, default 1,000,000. "" + + ""This may need to be increased if the number of mutations is very small compared to the genome length"", + default = ""1000000"") + parser.add_argument(""--mutation_type"", + dest = ""mt"", + help = ""Specify if rescaling a spectrum of the 6 mutation types rather than a 96 bar spectrum of contextual mutations. The "" + + ""input spectrum will be rescaled by the number of each starting nucleotide in the genome"", + action = ""store_true"", + default = False) + parser.add_argument(""--double"", + dest = ""double"", + help = ""Specify if rescaling a double substitution spectrum rather than a 96 bar spectrum of contextual mutations. The "" + + ""input spectrum will be rescaled by the number of each dinucleotide pair in the genome"", + action = ""store_true"", + default = False) + parser.add_argument(""--rna"", + dest = ""rna"", + help = ""Specify if using an RNA pathogen"", + action = ""store_true"", + default = False) + parser.add_argument(""--write_ref_contexts"", + dest = ""write_rc"", + help = ""Specify to write the reference context counts to a csv file. If specified, the counts will be written to "" + + ""reference_context_counts.csv by default. The name of the file can be updated with -rc"", + action = ""store_true"", + default = False) + parser.add_argument(""-rc"", + dest = ""rc"", + help = ""Name of file to which reference context counts will be written if --write_ref_contexts is specified, default "" + + ""reference_context_counts.csv"", + default = ""reference_context_counts.csv"") + parser.add_argument(""-o"", + ""--outfile"", + dest = ""outFile"", + required = True, + help = ""Output csv to which the rescaled spectrum will be written"") + + args = parser.parse_args() + + #Import the spectrum and convert to a dictionary + spectrum = convertSpectrumDict(args.spectrum) + + #The scalar each mutation/context will be multiplied by to obtain a rescaled mutation count + scalar = float(args.scale_factor) + + outFile = open(args.outFile, ""w"") + outFile.write(""Substitution,Number_of_mutations\n"") + + #Rescale DNA or RNA mutation type spectrum + if args.mt: + rescaledSpectrum, contexts = rescaleMT(spectrum, args.reference, scalar, args.rna) + for eachMutation in rescaledSpectrum: + outFile.write(eachMutation + "","" + str(rescaledSpectrum[eachMutation]) + ""\n"") + #Rescale DNA double substitution spectrum + elif args.double: + rescaledSpectrum, contexts = rescaleDouble(spectrum, args.reference, scalar, args.rna) + for eachMutation in rescaledSpectrum: + outFile.write(eachMutation[:2] + "">"" + eachMutation[2:] + "","" + str(rescaledSpectrum[eachMutation]) + ""\n"") + #Rescale DNA SBS spectrum + else: + rescaledSpectrum, contexts = rescaleSBS(spectrum, args.reference, scalar, args.rna) + for eachMutation in rescaledSpectrum: + outFile.write(eachMutation[0] + ""["" + eachMutation[1] + "">"" + eachMutation[2] + ""]"" + eachMutation[3] + "","" + str(rescaledSpectrum[eachMutation]) + ""\n"") + + outFile.close() + + #Write reference context counts if specified + if args.write_rc: + outC = open(args.rc, ""w"") + outC.write(""Context,Number_of_occurrences\n"") + for eC in contexts: + outC.write(eC + "","" + str(contexts[eC]) + ""\n"") + outC.close()","Python" +"Viral","chrisruis/MutTui","MutTui/compare_mutation_ratios.py",".py","2637","46","#Compares the ratios of each mutation type between a set of mutational spectra +#Run on mutation_types_label_X.csv files from MutTui +#Outputs the ratio between the number of each pair of mutation types in each spectrum + +import argparse +from plot_spectrum import convertSpectrumDict + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser() + parser.add_argument(""-s"", + ""--spectra"", + dest = ""spectra"", + required = True, + nargs = ""+"", + help = ""mutation_types_label.csv files from MutTui to be compared"", + type = argparse.FileType(""r"")) + parser.add_argument(""-l"", + ""--labels"", + dest = ""labels"", + nargs = ""+"", + help = ""Label of each spectrum, one per spectrum. Samples will be labelled with this "" + + ""in the output file. Default is to name each spectrum as it is given to -s"", + default = None) + parser.add_argument(""-o"", + help = ""Name of output file"") + args = parser.parse_args() + + outFile = open(args.o, ""w"") + outFile.write(""Spectrum,C>A/C>G,C>A/C>T,C>A/T>A,C>A/T>C,C>A/T>G,C>G/C>T,C>G/T>A,C>G/T>C,C>G/T>G,C>T/T>A,C>T/T>C,C>T/T>G,T>A/T>C,T>A/T>G,T>C/T>G\n"") + + #Set the sample labels + if args.labels: + if len(args.spectra) != len(args.labels): + raise RuntimeError(""The number of labels provided with -l needs to match the number of spectra provided with -s. Please check the labels"") + labels = args.labels + else: + labels = list() + for s in args.spectra: + labels.append(s.name) + + #Iterate through the spectra, calculate the ratios of each mutation type and write + for i, s in enumerate(args.spectra): + spectrum = convertSpectrumDict(s) + outFile.write(labels[i] + "","" + str(spectrum[""CA""]/spectrum[""CG""]) + "","" + str(spectrum[""CA""]/spectrum[""CT""]) + "","" + str(spectrum[""CA""]/spectrum[""TA""]) + "","" + str(spectrum[""CA""]/spectrum[""TC""]) + "","" + str(spectrum[""CA""]/spectrum[""TG""]) + "","" + str(spectrum[""CG""]/spectrum[""CT""]) + "","" + str(spectrum[""CG""]/spectrum[""TA""]) + "","" + str(spectrum[""CG""]/spectrum[""TC""]) + "","" + str(spectrum[""CG""]/spectrum[""TG""]) + "","" + str(spectrum[""CT""]/spectrum[""TA""]) + "","" + str(spectrum[""CT""]/spectrum[""TC""]) + "","" + str(spectrum[""CT""]/spectrum[""TG""]) + "","" + str(spectrum[""TA""]/spectrum[""TC""]) + "","" + str(spectrum[""TA""]/spectrum[""TG""]) + "","" + str(spectrum[""TC""]/spectrum[""TG""]) + ""\n"") + + outFile.close()","Python" +"Viral","chrisruis/MutTui","MutTui/__main__.py",".py","3174","77","import os, sys +import argparse + +from .__init__ import __version__ + +from .muttui import muttui_parser +from .add_tree_node_labels import add_tree_node_labels_parser +from .cluster_spectra import cluster_spectra_parser +from .combine_spectra import combine_spectra_parser +from .combine_spectra_into_catalog import combine_spectra_into_catalog_parser +from .compare_spectra import compare_spectra_parser +from .convert_vcf_position_translation import convert_vcf_position_translation_parser +from .korimuto import korimuto_parser +from .label_tree import label_tree_parser +from .plot_spectrum import plot_spectrum_parser + +def main(): + + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest=""command"", title=""Available commands"") + + parser.add_argument( + ""--version"", action=""version"", version=""%(prog)s "" + __version__ + ) + + # add subcommands + muttui_subparser = subparsers.add_parser(""run"", + help=""run the MutTui pipeline"") + muttui_subparser = muttui_parser(muttui_subparser) + + korimuto_subparser = subparsers.add_parser(""korimuto"", + help=""calculates a mutational spectrum from SNP data"") + korimuto_subparser = korimuto_parser(korimuto_subparser) + + plot_spectrum_subparser = subparsers.add_parser(""plot"", + help=""plot a mutational spectrum"") + plot_spectrum_subparser = plot_spectrum_parser(plot_spectrum_subparser) + + convert_vcf_subparser = subparsers.add_parser(""convert-vcf"", + help=""creates the position conversion file for MutTui from a VCF file"") + convert_vcf_subparser = convert_vcf_position_translation_parser(convert_vcf_subparser) + + compare_spectra_subparser = subparsers.add_parser(""compare"", + help=""subtracts one mutational spectrum from another"") + compare_spectra_subparser = compare_spectra_parser(compare_spectra_subparser) + + cluster_spectra_subparser = subparsers.add_parser(""cluster"", + help=""cluster spectra using a given tree"") + cluster_spectra_subparser = cluster_spectra_parser(cluster_spectra_subparser) + + combine_spectra_subparser = subparsers.add_parser(""combine"", + help=""sums the mutations in a number of input spectra to form a single output spectrum"") + combine_spectra_subparser = combine_spectra_parser(combine_spectra_subparser) + + combine_spectra_into_catalog_subparser = subparsers.add_parser(""catalogue"", + help=""combines multiple input spectra and/or catalogues into a single output catalogue"") + combine_spectra_into_catalog_subparser = combine_spectra_into_catalog_parser(combine_spectra_into_catalog_subparser) + + label_nodes_subparser = subparsers.add_parser(""label-nodes"", + help=""add numerical node labels to a given tree to enable labelling of the tree into groups"") + label_nodes_subparser = add_tree_node_labels_parser(label_nodes_subparser) + + label_tree_subparser = subparsers.add_parser(""label-tree"", + help=""labels nodes in a phylogenetic tree for use with MutTui"") + label_tree_subparser = label_tree_parser(label_tree_subparser) + + + # parse arguments and run function + args = parser.parse_args() + args.func(args) + + return + + +if __name__ == ""__main__"": + main() +","Python" +"Viral","chrisruis/MutTui","MutTui/reconstruct_spectrum.py",".py","53549","1473","#Takes the alignment and tree output by treetime and reconstructs the mutational spectrum + +import argparse +from Bio import AlignIO, Phylo +from Bio.Seq import Seq +from collections import OrderedDict, defaultdict +import numpy as np +import array +from treetime import * +import re + +translation_table = np.array([[[b'K', b'N', b'K', b'N', b'X'], + [b'T', b'T', b'T', b'T', b'T'], + [b'R', b'S', b'R', b'S', b'X'], + [b'I', b'I', b'M', b'I', b'X'], + [b'X', b'X', b'X', b'X', b'X']], + [[b'Q', b'H', b'Q', b'H', b'X'], + [b'P', b'P', b'P', b'P', b'P'], + [b'R', b'R', b'R', b'R', b'R'], + [b'L', b'L', b'L', b'L', b'L'], + [b'X', b'X', b'X', b'X', b'X']], + [[b'E', b'D', b'E', b'D', b'X'], + [b'A', b'A', b'A', b'A', b'A'], + [b'G', b'G', b'G', b'G', b'G'], + [b'V', b'V', b'V', b'V', b'V'], + [b'X', b'X', b'X', b'X', b'X']], + [[b'*', b'Y', b'*', b'Y', b'X'], + [b'S', b'S', b'S', b'S', b'S'], + [b'*', b'C', b'W', b'C', b'X'], + [b'L', b'F', b'L', b'F', b'X'], + [b'X', b'X', b'X', b'X', b'X']], + [[b'X', b'X', b'X', b'X', b'X'], + [b'X', b'X', b'X', b'X', b'X'], + [b'X', b'X', b'X', b'X', b'X'], + [b'X', b'X', b'X', b'X', b'X'], + [b'X', b'X', b'X', b'X', b'X']]]) + +reduce_array = np.full(200, 4) +reduce_array[[65, 97]] = 0 +reduce_array[[67, 99]] = 1 +reduce_array[[71, 103]] = 2 +reduce_array[[84, 116]] = 3 + +#Converts the positional translation to a dictionary with alignment positions as keys and genome positions as values +def convertTranslation(positionsFile): + #Import the translation file + positions = open(positionsFile.name).readlines() + + conversion = {} + + for eachPosition in positions: + conversion[int(eachPosition.strip().split(""\t"")[0])] = int(eachPosition.strip().split(""\t"")[1]) + + return(conversion) + +#Creates a positional translation dictionary with alignment sites as keys and values +#Used when --all_sites is specified so there is no need to convert the sites +def allSitesTranslation(alignment): + conversion = {} + + for eachPosition in range(len(alignment[0].seq)): + conversion[int(eachPosition) + 1] = int(eachPosition) + 1 + + return(conversion) + +#Extracts the mutations and positions along a given branch +def getMutations(branch, translation): + mutations = [] + for mutation in branch.split('=""')[1].split('""')[0].split("",""): + mutations.append([mutation[0], int(mutation[1:-1]), translation[int(mutation[1:-1])], mutation[-1]]) + + return(mutations) + +#Gets the name of the upstream clade +def getParentName(tree, clade): + #Check if the clade is one downstream of the root + if len(tree.get_path(clade)) >= 2: + #Nodes with no mutations along the upstream branch have their IDs imported as name, nodes with mutations as confidence + if tree.get_path(clade)[-2].confidence: + node = tree.get_path(clade)[-2].confidence + else: + node = tree.get_path(clade)[-2].name + else: + node = str(tree.root) + return(node) + +#Identifies the name of the branch +def getBranchName(tree, clade): + parentNode = getParentName(tree, clade) + + if clade.is_terminal(): + return(parentNode + ""->"" + clade.name) + elif clade.confidence: + return(parentNode + ""->"" + clade.confidence) + else: + return(parentNode + ""->"" + clade.name) + +#Extracts the mutations to a dictionary with branch names as keys and mutations as values +def getBranchDict(tree, positionTranslation): + branchDict = {} + + for clade in tree.find_clades(): + #Do not analyse the root + if len(tree.get_path(clade)) != 0: + #Check if there are mutations along the branch + if (clade.comment) and (clade.comment != '[&mutations=""""]'): + branchDict[getBranchName(tree, clade)] = getMutations(clade.comment, positionTranslation) + else: + branchDict[getBranchName(tree, clade)] = ""None"" + + return(branchDict) + +#Extracts the mutations in branch_mutations.txt to a dictionary with branch names as keys and mutations as values +def getBranchMutationNexusDict(NexusFile, translation): + branchDict = defaultdict(list) + + with open(NexusFile, 'r') as infile: + matches = re.findall(""[^,\(\)]+:[.0-9]+\[\&mutations\=\""[,A-Z0-9]*"", infile.read()) + for m in matches: + bname = m.split(':')[0] + muts = m.split('=""')[1].split("","") + if muts[0] == '': continue + for mut in muts: + branchDict[bname].append([mut[0], int(mut[1:-1]), translation[int(mut[1:-1])], mut[-1]]) + + return(branchDict) + + +#Extracts the mutations in branch_mutations.txt to a dictionary with branch names as keys and mutations as values +# def getBranchMutationDict(branchFile, translation): +# branchDict = {} + +# #Iterate through the mutations and add to branchDict +# with open(branchFile) as fileobject: +# #Skip header +# next(fileobject) + +# for line in fileobject: +# node = line.strip().split(""\t"")[0] + +# if node in branchDict: +# branchDict[node].append([line.strip().split(""\t"")[1], int(line.strip().split(""\t"")[2]), translation[int(line.strip().split(""\t"")[2])], line.strip().split(""\t"")[3]]) +# else: +# branchDict[node] = [[line.strip().split(""\t"")[1], int(line.strip().split(""\t"")[2]), translation[int(line.strip().split(""\t"")[2])], line.strip().split(""\t"")[3]]] + +# return(branchDict) + + +#Get the reference sequence, if -r specified this will be the provided genome, otherwise all sites in the alignment are assumed +#and the root sequence from the ancestral reconstruction is used +def getReference(reference, all_sites, alignment, positionTranslation): + if all_sites: + #Get the reference as the root of the reconstruction + for sequence in alignment: + if sequence.name == ""NODE_0000000"": + referenceSequence = sequence.seq + + #Use the provided reference as the reference sequence and substitute in the nucleotides in the inferred root + #sequence at each variable position. This means the updateReference function uses the root sequence as a + #starting sequence and updates based on this + else: + ref = AlignIO.read(reference.name, ""fasta"") + #Extract the sequence of the reference and ensure it is uppercase + refSeq = ref[0].seq.upper() + + #Reverse the position translation so genome positions are keys and alignment positions are values + #Can then iterate through the genome positions and check if they are in this + toChange = {j:i for i, j in positionTranslation.items()} + + #Extract the root sequences from the reconstruction + for sequence in alignment: + if sequence.name == ""NODE_0000000"": + root_seq = sequence.seq + + #Will be the original reference with the root sequence base substituted at each reconstructed position + referenceSequence = """" + + #Iterate through the length of the reference genome. If the position is in toChange, take the dictionary value position from + #the root sequence which only contains positions in the translate file. Otherwise, take the position from the reference + for pos in range(len(refSeq)): + #Check if the position is variable and needs to be taken from the root + if (pos + 1) in toChange: + referenceSequence += root_seq[toChange[pos + 1] - 1] + else: + referenceSequence += refSeq[pos] + + return(referenceSequence) + +#Updates the original reference sequence so it includes the mutations acquired up to the given clade +#Converts the reference to an array, iterates through the upstream branches and updates each of the positions +#that mutated along an upstream branch to the mutated base +#If a position has changed multiple times along the upstream branches, this keeps the most recent change as the +#clades are iterated through from the root through to the most recent upstream branch +####Used when reading in the annotated tree +####def updateReference(tree, clade, branchMutationDict, refSeq): + ####Convert the reference sequence to an array + ####referenceArray = array.array(""u"", refSeq) + + ####Iterate through the upstream branches leading to the node at the start of the current branch + ####for upstreamClade in tree.get_path(clade)[:-1]: + ####Check if there are any mutations along the current upstream branch + ####if branchMutationDict[getBranchName(tree, upstreamClade)] != ""None"": + ####Iterate through the previous mutations and update the reference sequence + ####for eachMutation in branchMutationDict[getBranchName(tree, upstreamClade)]: + ####referenceArray[eachMutation[2] - 1] = eachMutation[3] + + ####return("""".join(referenceArray)) + +#Updates the original reference sequence so it includes the mutations acquired up to the given clade +#Converts the reference to an array, iterates through the upstream branches and updates each of the positions +#that mutated along an upstream branch to the mutated base +#If a position has changed multiple times along the upstream branches, this keeps the most recent change as the +#clades are iterated through from the root through to the most recent upstream branch +def updateReference(tree, clade, branchMutationDict, refSeq): + #Convert the reference sequence to an array + referenceArray = array.array(""u"", refSeq) + + #Iterate through the upstream branches leading to the node at the start of the current branch + for upstreamClade in tree.get_path(clade)[:-1]: + #Check if there are any mutations along the current upstream branch + if upstreamClade.name in branchMutationDict: + #Iterate through the previous mutations and update the reference sequence + for eachMutation in branchMutationDict[upstreamClade.name]: + referenceArray[eachMutation[2] - 1] = eachMutation[3] + + return("""".join(referenceArray)) + +#Identifies the label category of a given branch +#By default returns None if the branch is a transition between labels +#If --include_all_branches is used, no branches are labelled None and transition branches are +#labelled with the downstream node's label +def getBranchCategory(tree, clade, include_all_branches): + #Identify the label of the upstream node + #Check if the upstream node is the root + if len(tree.get_path(clade)) >= 2: + #Check if the label of the upstream clade is the same as the clade + if clade.clade_label == tree.get_path(clade)[-2].clade_label: + return(clade.clade_label) + elif include_all_branches: + return(clade.clade_label) + else: + return(None) + + else: + if clade.clade_label == tree.root.clade_label: + return(clade.clade_label) + elif include_all_branches: + return(clade.clade_label) + else: + return(None) + +#Removes mutations that are at the start or end of the genome or do not involve 2 nucleotides +#Writes the removed mutations to outMutationsNotUsed +#Splits double substitutions into a separate list +#Returns the filtered mutations as a list +def filterMutations(branchMutations, clade, nucleotides, referenceLength, outMutationsNotUsed): + positionsToRemove = [] + doubleSubstitutions = [] + #Used to distinguish double substitutions from longer tracts of substitutions + #positionsToExclude = [] + #doubleSubstitutionPositions = [] + + #print(""LENGTH:"", len(branchMutations)) + + #Check if there are double substitutions along the branch and remove these mutations + for mutation1 in range(len(branchMutations)): + #Check if the position is the last mutation, if so don't compare it to the next one. Needed + #so the final mutation on the branch can still be checked for being at the start or end of the genome + if (mutation1 + 1) != len(branchMutations): + #Check if the following mutation is at the adjacent genome position + if branchMutations[mutation1 + 1][2] == (branchMutations[mutation1][2] + 1): + if mutation1 in doubleSubstitutions: + positionsToRemove.append(mutation1 - 1) + positionsToRemove.append(mutation1) + positionsToRemove.append(mutation1 + 1) + #positionsToRemove.append(mutation1) + #positionsToRemove.append(mutation1 + 1) + #doubleSubstitutions.append(branchMutations[mutation1]) + #doubleSubstitutions.append(branchMutations[mutation1 + 1]) + doubleSubstitutions.append(mutation1) + doubleSubstitutions.append(mutation1 + 1) + #Check if the position is at the start or end of the genome + if (branchMutations[mutation1][2] == 1) or (branchMutations[mutation1][2] == referenceLength): + positionsToRemove.append(mutation1) + #Write the mutation to the mutations not used file + outMutationsNotUsed.write(branchMutations[mutation1][0] + str(branchMutations[mutation1][1]) + branchMutations[mutation1][3] + "","" + branchMutations[mutation1][0] + str(branchMutations[mutation1][2]) + branchMutations[mutation1][3] + "","" + clade.name + "",End_of_genome\n"") + #Check if the mutation does not involve 2 nucleotides + elif ((branchMutations[mutation1][0] not in nucleotides) or (branchMutations[mutation1][3] not in nucleotides)) and (mutation1 not in doubleSubstitutions): + positionsToRemove.append(mutation1) + outMutationsNotUsed.write(branchMutations[mutation1][0] + str(branchMutations[mutation1][1]) + branchMutations[mutation1][3] + "","" + branchMutations[mutation1][0] + str(branchMutations[mutation1][2]) + branchMutations[mutation1][3] + "","" + clade.name + "",Mutation_does_not_involve_two_nucleotides\n"") + + #If there is a tract of 3 or more substitutions at adjacent positions, some of the mutations + #will be in doubleSubstitutions twice. Extract the unique double substitution positions + if len(doubleSubstitutions) != 0: + doubleSubstitutionPositions = [ position for position in doubleSubstitutions if position not in positionsToRemove ] + doubleSubstitutionMutations = [ branchMutations[i] for i in doubleSubstitutionPositions ] + #Ensure the double substitutions are sorted by genome position + doubleSubstitutionMutations.sort(key = lambda x: x[2]) + #Write the positions in a 3 or more substitution tract + for s in set(doubleSubstitutions): + if s in positionsToRemove: + outMutationsNotUsed.write(branchMutations[s][0] + str(branchMutations[s][1]) + branchMutations[s][3] + "","" + branchMutations[s][0] + str(branchMutations[s][2]) + branchMutations[s][3] + "","" + clade.name + "",In_tract_of_three_or_more_substitutions\n"") + else: + doubleSubstitutionMutations = [] + + #uniqueDoubleSubstitutions = [] + #if len(doubleSubstitutions) != 0: + #if len(doubleSubstitutionMutations) > 0: + # dsSet = set() + # for ds in doubleSubstitutions: + # if tuple(ds) not in dsSet: + # uniqueDoubleSubstitutions.append(ds) + # dsSet.add(tuple(ds)) + ####Write the double substitutions + ####Will be removed once double substitutions are incorporated + #for uds in uniqueDoubleSubstitutions: + # outMutationsNotUsed.write(uds[0] + str(uds[1]) + uds[3] + "","" + uds[0] + str(uds[2]) + uds[3] + "","" + clade.name + "",Double_substitution\n"") + + #Add the double substitutions into the positions to be removed from the single substitutions + for eachPosition in doubleSubstitutions: + if eachPosition not in positionsToRemove: + positionsToRemove.append(eachPosition) + positionsToRemove = set(positionsToRemove) + + #Remove the positions that will not be included in the spectrum + if len(positionsToRemove) != 0: + #Identify the unique set of positions, if there are 3 or more consecutive positions to be removed, + #at least one of these positions will be in positionsToRemove more than once + uniquePositionsToRemove = list(set(positionsToRemove)) + #Remove the positions from the mutations + for ele in sorted(uniquePositionsToRemove, reverse = True): + del branchMutations[ele] + + return(branchMutations, doubleSubstitutionMutations) + +#Translates a given nucleotide sequence to protein +def translateSequence(sequence, strand): + if strand == ""+"": + return(Seq("""".join(sequence)).translate()) + else: + return(Seq("""".join(sequence)).reverse_complement().translate()) + +#Identifies the amino acid position of a nucleotide within a gene +#If the gene is on the positive strand, this is the nucleotide position divided by 3, rounded up +#If the gene is on the negative strand, this is the nucleotide position from the end of the gene divided by 3, rounded up +def extractPosition(geneCoordinates, positionInGene): + #Remove zero basing + positionInGene = positionInGene + 1 + if geneCoordinates[2] == ""+"": + return(int(positionInGene/3) + (positionInGene % 3 > 0)) + else: + reversePosition = geneCoordinates[1] - (geneCoordinates[0] + positionInGene) + 1 + return(int(reversePosition/3) + (reversePosition % 3 > 0)) + +#Extracts synonymous mutations along a given branch +#Used when --synonymous is specified +def extractSynonymous(branchMutations, updatedReference, geneCoordinates, positionGene): + #Gene sequences at the upstream node + upstreamGenes = dict() + #Gene sequences containing mutations along the branch + downstreamGenes = dict() + + positionsToRemove = [] + + #Iterate through the mutations to create dictionaries of each gene that mutates along the branch + #with their nucleotide sequences pre and post mutations + for mutation in branchMutations: + #Check if the mutation is in a gene, if the position isn't in positionGene, the position is intergenic + if mutation[2] not in positionGene: + continue + #Iterate through the genes the position is in, check if they are already present, mutate if so, if not + #add to dictionaries and mutate + for geneName in positionGene[mutation[2]].split(""____""): + #Position of the mutation in the gene, zero based + positionInGene = mutation[2] - geneCoordinates[geneName][0] + if geneName in downstreamGenes: + downstreamGenes[geneName][positionInGene] = mutation[3] + else: + upstreamGenes[geneName] = array.array(""u"", updatedReference[(geneCoordinates[geneName][0] - 1):geneCoordinates[geneName][1]]) + downstreamGenes[geneName] = array.array(""u"", updatedReference[(geneCoordinates[geneName][0] - 1):geneCoordinates[geneName][1]]) + #Mutate the position in the downstream gene + downstreamGenes[geneName][positionInGene] = mutation[3] + + #Iterate through the mutations again, check if the translated position of the mutation changes along the branch + #Second iteration needed because 1st and 3rd codon positions may both change along a branch + for i, mutation in enumerate(branchMutations): + #Check if the mutation is in a gene, if the position isn't in positionGene, the position is intergenic + if mutation[2] not in positionGene: + continue + #Will change to False if the amino acid of the mutation has changed in any gene it is present in + synonymous = True + #Iterate through the genes the position is in, check if the position's amino acid changes, if so change synonymous to False + for geneName in positionGene[mutation[2]].split(""____""): + #Position of the mutation in the gene, zero based + positionInGene = mutation[2] - geneCoordinates[geneName][0] + upstreamAA = translateSequence(upstreamGenes[geneName], geneCoordinates[geneName][2]) + downstreamAA = translateSequence(downstreamGenes[geneName], geneCoordinates[geneName][2]) + aaPosition = extractPosition(geneCoordinates[geneName], positionInGene) - 1 + + if upstreamAA[aaPosition] != downstreamAA[aaPosition]: + synonymous = False + + #If the mutation is nonsynonymous within any gene, remove it + if synonymous == False: + positionsToRemove.append(i) + + #Remove the positions that will not be included in the spectrum + if len(positionsToRemove) != 0: + #Identify the unique set of positions + uniquePositionsToRemove = list(set(positionsToRemove)) + #Remove the positions from the mutations + for ele in sorted(uniquePositionsToRemove, reverse = True): + del branchMutations[ele] + + return(branchMutations) + +#Identifies the strand bias of each mutation +def getStrandBias(mutation, updatedReference, geneCoordinates, positionGene): + #print(mutation) + #Strands of the genes the mutation is in, used to exclude mutations in multiple genes on opposing strands + ss = set() + + #Get the strand of each gene the mutation is in and add to ss + for g in positionGene[mutation[2]].split(""____""): + ss.add(geneCoordinates[g][2]) + + #Transition mutations + transitions = [""C"", ""T""] + + #Check if the mutation is in multiple genes on different strands, if so exclude + if len(ss) == 1: + if ((""+"" in ss) and (mutation[0] in transitions)) or ((""-"" in ss) and (mutation[0] not in transitions)): + return(""t"") + else: + return(""u"") + else: + return(None) + +#Identifies the context of a mutation +def getContext(mutation, updatedReference): + return(updatedReference[mutation[2] - 2], updatedReference[mutation[2]]) + +#Takes a base and returns the complement base +def complement(base): + if base == ""A"": + return ""T"" + elif base == ""C"": + return ""G"" + elif base == ""G"": + return ""C"" + elif base == ""T"": + return ""A"" + +#Creates an empty mutational spectrum dictionary for DNA datasets, i.e. combining symmetric mutations +def getMutationDict(): + mutation = OrderedDict() + mutation[""ACAA""] = 0 + mutation[""ACAC""] = 0 + mutation[""ACAG""] = 0 + mutation[""ACAT""] = 0 + mutation[""CCAA""] = 0 + mutation[""CCAC""] = 0 + mutation[""CCAG""] = 0 + mutation[""CCAT""] = 0 + mutation[""GCAA""] = 0 + mutation[""GCAC""] = 0 + mutation[""GCAG""] = 0 + mutation[""GCAT""] = 0 + mutation[""TCAA""] = 0 + mutation[""TCAC""] = 0 + mutation[""TCAG""] = 0 + mutation[""TCAT""] = 0 + mutation[""ACGA""] = 0 + mutation[""ACGC""] = 0 + mutation[""ACGG""] = 0 + mutation[""ACGT""] = 0 + mutation[""CCGA""] = 0 + mutation[""CCGC""] = 0 + mutation[""CCGG""] = 0 + mutation[""CCGT""] = 0 + mutation[""GCGA""] = 0 + mutation[""GCGC""] = 0 + mutation[""GCGG""] = 0 + mutation[""GCGT""] = 0 + mutation[""TCGA""] = 0 + mutation[""TCGC""] = 0 + mutation[""TCGG""] = 0 + mutation[""TCGT""] = 0 + mutation[""ACTA""] = 0 + mutation[""ACTC""] = 0 + mutation[""ACTG""] = 0 + mutation[""ACTT""] = 0 + mutation[""CCTA""] = 0 + mutation[""CCTC""] = 0 + mutation[""CCTG""] = 0 + mutation[""CCTT""] = 0 + mutation[""GCTA""] = 0 + mutation[""GCTC""] = 0 + mutation[""GCTG""] = 0 + mutation[""GCTT""] = 0 + mutation[""TCTA""] = 0 + mutation[""TCTC""] = 0 + mutation[""TCTG""] = 0 + mutation[""TCTT""] = 0 + mutation[""ATAA""] = 0 + mutation[""ATAC""] = 0 + mutation[""ATAG""] = 0 + mutation[""ATAT""] = 0 + mutation[""CTAA""] = 0 + mutation[""CTAC""] = 0 + mutation[""CTAG""] = 0 + mutation[""CTAT""] = 0 + mutation[""GTAA""] = 0 + mutation[""GTAC""] = 0 + mutation[""GTAG""] = 0 + mutation[""GTAT""] = 0 + mutation[""TTAA""] = 0 + mutation[""TTAC""] = 0 + mutation[""TTAG""] = 0 + mutation[""TTAT""] = 0 + mutation[""ATCA""] = 0 + mutation[""ATCC""] = 0 + mutation[""ATCG""] = 0 + mutation[""ATCT""] = 0 + mutation[""CTCA""] = 0 + mutation[""CTCC""] = 0 + mutation[""CTCG""] = 0 + mutation[""CTCT""] = 0 + mutation[""GTCA""] = 0 + mutation[""GTCC""] = 0 + mutation[""GTCG""] = 0 + mutation[""GTCT""] = 0 + mutation[""TTCA""] = 0 + mutation[""TTCC""] = 0 + mutation[""TTCG""] = 0 + mutation[""TTCT""] = 0 + mutation[""ATGA""] = 0 + mutation[""ATGC""] = 0 + mutation[""ATGG""] = 0 + mutation[""ATGT""] = 0 + mutation[""CTGA""] = 0 + mutation[""CTGC""] = 0 + mutation[""CTGG""] = 0 + mutation[""CTGT""] = 0 + mutation[""GTGA""] = 0 + mutation[""GTGC""] = 0 + mutation[""GTGG""] = 0 + mutation[""GTGT""] = 0 + mutation[""TTGA""] = 0 + mutation[""TTGC""] = 0 + mutation[""TTGG""] = 0 + mutation[""TTGT""] = 0 + + return(mutation) + +#Creates an empty strand bias spectrum dictionary for DNA datasets, each mutation is in the dictionary twice: +#once on the transcribed strand (preceded by t) and once on the untranscribed strand (preceded by u) +def getStrandBiasDict(): + mutation = OrderedDict() + mutation[""tACAA""] = 0 + mutation[""tACAC""] = 0 + mutation[""tACAG""] = 0 + mutation[""tACAT""] = 0 + mutation[""tCCAA""] = 0 + mutation[""tCCAC""] = 0 + mutation[""tCCAG""] = 0 + mutation[""tCCAT""] = 0 + mutation[""tGCAA""] = 0 + mutation[""tGCAC""] = 0 + mutation[""tGCAG""] = 0 + mutation[""tGCAT""] = 0 + mutation[""tTCAA""] = 0 + mutation[""tTCAC""] = 0 + mutation[""tTCAG""] = 0 + mutation[""tTCAT""] = 0 + mutation[""tACGA""] = 0 + mutation[""tACGC""] = 0 + mutation[""tACGG""] = 0 + mutation[""tACGT""] = 0 + mutation[""tCCGA""] = 0 + mutation[""tCCGC""] = 0 + mutation[""tCCGG""] = 0 + mutation[""tCCGT""] = 0 + mutation[""tGCGA""] = 0 + mutation[""tGCGC""] = 0 + mutation[""tGCGG""] = 0 + mutation[""tGCGT""] = 0 + mutation[""tTCGA""] = 0 + mutation[""tTCGC""] = 0 + mutation[""tTCGG""] = 0 + mutation[""tTCGT""] = 0 + mutation[""tACTA""] = 0 + mutation[""tACTC""] = 0 + mutation[""tACTG""] = 0 + mutation[""tACTT""] = 0 + mutation[""tCCTA""] = 0 + mutation[""tCCTC""] = 0 + mutation[""tCCTG""] = 0 + mutation[""tCCTT""] = 0 + mutation[""tGCTA""] = 0 + mutation[""tGCTC""] = 0 + mutation[""tGCTG""] = 0 + mutation[""tGCTT""] = 0 + mutation[""tTCTA""] = 0 + mutation[""tTCTC""] = 0 + mutation[""tTCTG""] = 0 + mutation[""tTCTT""] = 0 + mutation[""tATAA""] = 0 + mutation[""tATAC""] = 0 + mutation[""tATAG""] = 0 + mutation[""tATAT""] = 0 + mutation[""tCTAA""] = 0 + mutation[""tCTAC""] = 0 + mutation[""tCTAG""] = 0 + mutation[""tCTAT""] = 0 + mutation[""tGTAA""] = 0 + mutation[""tGTAC""] = 0 + mutation[""tGTAG""] = 0 + mutation[""tGTAT""] = 0 + mutation[""tTTAA""] = 0 + mutation[""tTTAC""] = 0 + mutation[""tTTAG""] = 0 + mutation[""tTTAT""] = 0 + mutation[""tATCA""] = 0 + mutation[""tATCC""] = 0 + mutation[""tATCG""] = 0 + mutation[""tATCT""] = 0 + mutation[""tCTCA""] = 0 + mutation[""tCTCC""] = 0 + mutation[""tCTCG""] = 0 + mutation[""tCTCT""] = 0 + mutation[""tGTCA""] = 0 + mutation[""tGTCC""] = 0 + mutation[""tGTCG""] = 0 + mutation[""tGTCT""] = 0 + mutation[""tTTCA""] = 0 + mutation[""tTTCC""] = 0 + mutation[""tTTCG""] = 0 + mutation[""tTTCT""] = 0 + mutation[""tATGA""] = 0 + mutation[""tATGC""] = 0 + mutation[""tATGG""] = 0 + mutation[""tATGT""] = 0 + mutation[""tCTGA""] = 0 + mutation[""tCTGC""] = 0 + mutation[""tCTGG""] = 0 + mutation[""tCTGT""] = 0 + mutation[""tGTGA""] = 0 + mutation[""tGTGC""] = 0 + mutation[""tGTGG""] = 0 + mutation[""tGTGT""] = 0 + mutation[""tTTGA""] = 0 + mutation[""tTTGC""] = 0 + mutation[""tTTGG""] = 0 + mutation[""tTTGT""] = 0 + mutation[""uACAA""] = 0 + mutation[""uACAC""] = 0 + mutation[""uACAG""] = 0 + mutation[""uACAT""] = 0 + mutation[""uCCAA""] = 0 + mutation[""uCCAC""] = 0 + mutation[""uCCAG""] = 0 + mutation[""uCCAT""] = 0 + mutation[""uGCAA""] = 0 + mutation[""uGCAC""] = 0 + mutation[""uGCAG""] = 0 + mutation[""uGCAT""] = 0 + mutation[""uTCAA""] = 0 + mutation[""uTCAC""] = 0 + mutation[""uTCAG""] = 0 + mutation[""uTCAT""] = 0 + mutation[""uACGA""] = 0 + mutation[""uACGC""] = 0 + mutation[""uACGG""] = 0 + mutation[""uACGT""] = 0 + mutation[""uCCGA""] = 0 + mutation[""uCCGC""] = 0 + mutation[""uCCGG""] = 0 + mutation[""uCCGT""] = 0 + mutation[""uGCGA""] = 0 + mutation[""uGCGC""] = 0 + mutation[""uGCGG""] = 0 + mutation[""uGCGT""] = 0 + mutation[""uTCGA""] = 0 + mutation[""uTCGC""] = 0 + mutation[""uTCGG""] = 0 + mutation[""uTCGT""] = 0 + mutation[""uACTA""] = 0 + mutation[""uACTC""] = 0 + mutation[""uACTG""] = 0 + mutation[""uACTT""] = 0 + mutation[""uCCTA""] = 0 + mutation[""uCCTC""] = 0 + mutation[""uCCTG""] = 0 + mutation[""uCCTT""] = 0 + mutation[""uGCTA""] = 0 + mutation[""uGCTC""] = 0 + mutation[""uGCTG""] = 0 + mutation[""uGCTT""] = 0 + mutation[""uTCTA""] = 0 + mutation[""uTCTC""] = 0 + mutation[""uTCTG""] = 0 + mutation[""uTCTT""] = 0 + mutation[""uATAA""] = 0 + mutation[""uATAC""] = 0 + mutation[""uATAG""] = 0 + mutation[""uATAT""] = 0 + mutation[""uCTAA""] = 0 + mutation[""uCTAC""] = 0 + mutation[""uCTAG""] = 0 + mutation[""uCTAT""] = 0 + mutation[""uGTAA""] = 0 + mutation[""uGTAC""] = 0 + mutation[""uGTAG""] = 0 + mutation[""uGTAT""] = 0 + mutation[""uTTAA""] = 0 + mutation[""uTTAC""] = 0 + mutation[""uTTAG""] = 0 + mutation[""uTTAT""] = 0 + mutation[""uATCA""] = 0 + mutation[""uATCC""] = 0 + mutation[""uATCG""] = 0 + mutation[""uATCT""] = 0 + mutation[""uCTCA""] = 0 + mutation[""uCTCC""] = 0 + mutation[""uCTCG""] = 0 + mutation[""uCTCT""] = 0 + mutation[""uGTCA""] = 0 + mutation[""uGTCC""] = 0 + mutation[""uGTCG""] = 0 + mutation[""uGTCT""] = 0 + mutation[""uTTCA""] = 0 + mutation[""uTTCC""] = 0 + mutation[""uTTCG""] = 0 + mutation[""uTTCT""] = 0 + mutation[""uATGA""] = 0 + mutation[""uATGC""] = 0 + mutation[""uATGG""] = 0 + mutation[""uATGT""] = 0 + mutation[""uCTGA""] = 0 + mutation[""uCTGC""] = 0 + mutation[""uCTGG""] = 0 + mutation[""uCTGT""] = 0 + mutation[""uGTGA""] = 0 + mutation[""uGTGC""] = 0 + mutation[""uGTGG""] = 0 + mutation[""uGTGT""] = 0 + mutation[""uTTGA""] = 0 + mutation[""uTTGC""] = 0 + mutation[""uTTGG""] = 0 + mutation[""uTTGT""] = 0 + + return(mutation) + +#Creates an empty mutational spectrum dictionary for RNA datasets, i.e. not combining symmetric mutations +def getRNADict(): + mutation = OrderedDict() + mutation[""ACAA""] = 0 + mutation[""ACAC""] = 0 + mutation[""ACAG""] = 0 + mutation[""ACAT""] = 0 + mutation[""CCAA""] = 0 + mutation[""CCAC""] = 0 + mutation[""CCAG""] = 0 + mutation[""CCAT""] = 0 + mutation[""GCAA""] = 0 + mutation[""GCAC""] = 0 + mutation[""GCAG""] = 0 + mutation[""GCAT""] = 0 + mutation[""TCAA""] = 0 + mutation[""TCAC""] = 0 + mutation[""TCAG""] = 0 + mutation[""TCAT""] = 0 + mutation[""ACGA""] = 0 + mutation[""ACGC""] = 0 + mutation[""ACGG""] = 0 + mutation[""ACGT""] = 0 + mutation[""CCGA""] = 0 + mutation[""CCGC""] = 0 + mutation[""CCGG""] = 0 + mutation[""CCGT""] = 0 + mutation[""GCGA""] = 0 + mutation[""GCGC""] = 0 + mutation[""GCGG""] = 0 + mutation[""GCGT""] = 0 + mutation[""TCGA""] = 0 + mutation[""TCGC""] = 0 + mutation[""TCGG""] = 0 + mutation[""TCGT""] = 0 + mutation[""ACTA""] = 0 + mutation[""ACTC""] = 0 + mutation[""ACTG""] = 0 + mutation[""ACTT""] = 0 + mutation[""CCTA""] = 0 + mutation[""CCTC""] = 0 + mutation[""CCTG""] = 0 + mutation[""CCTT""] = 0 + mutation[""GCTA""] = 0 + mutation[""GCTC""] = 0 + mutation[""GCTG""] = 0 + mutation[""GCTT""] = 0 + mutation[""TCTA""] = 0 + mutation[""TCTC""] = 0 + mutation[""TCTG""] = 0 + mutation[""TCTT""] = 0 + mutation[""ATAA""] = 0 + mutation[""ATAC""] = 0 + mutation[""ATAG""] = 0 + mutation[""ATAT""] = 0 + mutation[""CTAA""] = 0 + mutation[""CTAC""] = 0 + mutation[""CTAG""] = 0 + mutation[""CTAT""] = 0 + mutation[""GTAA""] = 0 + mutation[""GTAC""] = 0 + mutation[""GTAG""] = 0 + mutation[""GTAT""] = 0 + mutation[""TTAA""] = 0 + mutation[""TTAC""] = 0 + mutation[""TTAG""] = 0 + mutation[""TTAT""] = 0 + mutation[""ATCA""] = 0 + mutation[""ATCC""] = 0 + mutation[""ATCG""] = 0 + mutation[""ATCT""] = 0 + mutation[""CTCA""] = 0 + mutation[""CTCC""] = 0 + mutation[""CTCG""] = 0 + mutation[""CTCT""] = 0 + mutation[""GTCA""] = 0 + mutation[""GTCC""] = 0 + mutation[""GTCG""] = 0 + mutation[""GTCT""] = 0 + mutation[""TTCA""] = 0 + mutation[""TTCC""] = 0 + mutation[""TTCG""] = 0 + mutation[""TTCT""] = 0 + mutation[""ATGA""] = 0 + mutation[""ATGC""] = 0 + mutation[""ATGG""] = 0 + mutation[""ATGT""] = 0 + mutation[""CTGA""] = 0 + mutation[""CTGC""] = 0 + mutation[""CTGG""] = 0 + mutation[""CTGT""] = 0 + mutation[""GTGA""] = 0 + mutation[""GTGC""] = 0 + mutation[""GTGG""] = 0 + mutation[""GTGT""] = 0 + mutation[""TTGA""] = 0 + mutation[""TTGC""] = 0 + mutation[""TTGG""] = 0 + mutation[""TTGT""] = 0 + mutation[""AGTA""] = 0 + mutation[""AGTC""] = 0 + mutation[""AGTG""] = 0 + mutation[""AGTT""] = 0 + mutation[""CGTA""] = 0 + mutation[""CGTC""] = 0 + mutation[""CGTG""] = 0 + mutation[""CGTT""] = 0 + mutation[""GGTA""] = 0 + mutation[""GGTC""] = 0 + mutation[""GGTG""] = 0 + mutation[""GGTT""] = 0 + mutation[""TGTA""] = 0 + mutation[""TGTC""] = 0 + mutation[""TGTG""] = 0 + mutation[""TGTT""] = 0 + mutation[""AGCA""] = 0 + mutation[""AGCC""] = 0 + mutation[""AGCG""] = 0 + mutation[""AGCT""] = 0 + mutation[""CGCA""] = 0 + mutation[""CGCC""] = 0 + mutation[""CGCG""] = 0 + mutation[""CGCT""] = 0 + mutation[""GGCA""] = 0 + mutation[""GGCC""] = 0 + mutation[""GGCG""] = 0 + mutation[""GGCT""] = 0 + mutation[""TGCA""] = 0 + mutation[""TGCC""] = 0 + mutation[""TGCG""] = 0 + mutation[""TGCT""] = 0 + mutation[""AGAA""] = 0 + mutation[""AGAC""] = 0 + mutation[""AGAG""] = 0 + mutation[""AGAT""] = 0 + mutation[""CGAA""] = 0 + mutation[""CGAC""] = 0 + mutation[""CGAG""] = 0 + mutation[""CGAT""] = 0 + mutation[""GGAA""] = 0 + mutation[""GGAC""] = 0 + mutation[""GGAG""] = 0 + mutation[""GGAT""] = 0 + mutation[""TGAA""] = 0 + mutation[""TGAC""] = 0 + mutation[""TGAG""] = 0 + mutation[""TGAT""] = 0 + mutation[""AATA""] = 0 + mutation[""AATC""] = 0 + mutation[""AATG""] = 0 + mutation[""AATT""] = 0 + mutation[""CATA""] = 0 + mutation[""CATC""] = 0 + mutation[""CATG""] = 0 + mutation[""CATT""] = 0 + mutation[""GATA""] = 0 + mutation[""GATC""] = 0 + mutation[""GATG""] = 0 + mutation[""GATT""] = 0 + mutation[""TATA""] = 0 + mutation[""TATC""] = 0 + mutation[""TATG""] = 0 + mutation[""TATT""] = 0 + mutation[""AAGA""] = 0 + mutation[""AAGC""] = 0 + mutation[""AAGG""] = 0 + mutation[""AAGT""] = 0 + mutation[""CAGA""] = 0 + mutation[""CAGC""] = 0 + mutation[""CAGG""] = 0 + mutation[""CAGT""] = 0 + mutation[""GAGA""] = 0 + mutation[""GAGC""] = 0 + mutation[""GAGG""] = 0 + mutation[""GAGT""] = 0 + mutation[""TAGA""] = 0 + mutation[""TAGC""] = 0 + mutation[""TAGG""] = 0 + mutation[""TAGT""] = 0 + mutation[""AACA""] = 0 + mutation[""AACC""] = 0 + mutation[""AACG""] = 0 + mutation[""AACT""] = 0 + mutation[""CACA""] = 0 + mutation[""CACC""] = 0 + mutation[""CACG""] = 0 + mutation[""CACT""] = 0 + mutation[""GACA""] = 0 + mutation[""GACC""] = 0 + mutation[""GACG""] = 0 + mutation[""GACT""] = 0 + mutation[""TACA""] = 0 + mutation[""TACC""] = 0 + mutation[""TACG""] = 0 + mutation[""TACT""] = 0 + + return(mutation) + +#Creates an empty double substitution mutational spcetrum dictionary for DNA datasets, i.e. combining symmetric mutations +#Each entry is reference 1, reference 2, mutation 1, mutation 2 +def getDoubleSubstitutionDict(): + mutation = OrderedDict() + mutation[""AACC""] = 0 + mutation[""AACG""] = 0 + mutation[""AACT""] = 0 + mutation[""AAGC""] = 0 + mutation[""AAGG""] = 0 + mutation[""AAGT""] = 0 + mutation[""AATC""] = 0 + mutation[""AATG""] = 0 + mutation[""AATT""] = 0 + mutation[""ACCA""] = 0 + mutation[""ACCG""] = 0 + mutation[""ACCT""] = 0 + mutation[""ACGA""] = 0 + mutation[""ACGG""] = 0 + mutation[""ACGT""] = 0 + mutation[""ACTA""] = 0 + mutation[""ACTG""] = 0 + mutation[""ACTT""] = 0 + mutation[""AGCA""] = 0 + mutation[""AGCC""] = 0 + mutation[""AGCT""] = 0 + mutation[""AGGA""] = 0 + mutation[""AGGC""] = 0 + mutation[""AGGT""] = 0 + mutation[""AGTA""] = 0 + mutation[""AGTC""] = 0 + mutation[""AGTT""] = 0 + mutation[""ATCA""] = 0 + mutation[""ATCC""] = 0 + mutation[""ATCG""] = 0 + mutation[""ATGA""] = 0 + mutation[""ATGC""] = 0 + mutation[""ATTA""] = 0 + mutation[""CAAC""] = 0 + mutation[""CAAG""] = 0 + mutation[""CAAT""] = 0 + mutation[""CAGC""] = 0 + mutation[""CAGG""] = 0 + mutation[""CAGT""] = 0 + mutation[""CATC""] = 0 + mutation[""CATG""] = 0 + mutation[""CATT""] = 0 + mutation[""CCAA""] = 0 + mutation[""CCAG""] = 0 + mutation[""CCAT""] = 0 + mutation[""CCGA""] = 0 + mutation[""CCGG""] = 0 + mutation[""CCGT""] = 0 + mutation[""CCTA""] = 0 + mutation[""CCTG""] = 0 + mutation[""CCTT""] = 0 + mutation[""CGAA""] = 0 + mutation[""CGAC""] = 0 + mutation[""CGAT""] = 0 + mutation[""CGGA""] = 0 + mutation[""CGGC""] = 0 + mutation[""CGTA""] = 0 + mutation[""GAAC""] = 0 + mutation[""GAAG""] = 0 + mutation[""GAAT""] = 0 + mutation[""GACC""] = 0 + mutation[""GACG""] = 0 + mutation[""GACT""] = 0 + mutation[""GATC""] = 0 + mutation[""GATG""] = 0 + mutation[""GATT""] = 0 + mutation[""GCAA""] = 0 + mutation[""GCAG""] = 0 + mutation[""GCAT""] = 0 + mutation[""GCCA""] = 0 + mutation[""GCCG""] = 0 + mutation[""GCTA""] = 0 + mutation[""TAAC""] = 0 + mutation[""TAAG""] = 0 + mutation[""TAAT""] = 0 + mutation[""TACC""] = 0 + mutation[""TACG""] = 0 + mutation[""TAGC""] = 0 + return(mutation) + +#Creates an empty double substitution mutational spcetrum dictionary for RNA datasets, i.e. not combining symmetric mutations +#Each entry is reference 1, reference 2, mutation 1, mutation 2 +def getRNADoubleSubstitutionDict(): + mutation = OrderedDict() + mutation[""AACC""] = 0 + mutation[""AACG""] = 0 + mutation[""AACT""] = 0 + mutation[""AAGC""] = 0 + mutation[""AAGG""] = 0 + mutation[""AAGT""] = 0 + mutation[""AATC""] = 0 + mutation[""AATG""] = 0 + mutation[""AATT""] = 0 + mutation[""ACCA""] = 0 + mutation[""ACCG""] = 0 + mutation[""ACCT""] = 0 + mutation[""ACGA""] = 0 + mutation[""ACGG""] = 0 + mutation[""ACGT""] = 0 + mutation[""ACTA""] = 0 + mutation[""ACTG""] = 0 + mutation[""ACTT""] = 0 + mutation[""AGCA""] = 0 + mutation[""AGCC""] = 0 + mutation[""AGCT""] = 0 + mutation[""AGGA""] = 0 + mutation[""AGGC""] = 0 + mutation[""AGGT""] = 0 + mutation[""AGTA""] = 0 + mutation[""AGTC""] = 0 + mutation[""AGTT""] = 0 + mutation[""ATCA""] = 0 + mutation[""ATCC""] = 0 + mutation[""ATCG""] = 0 + mutation[""ATGA""] = 0 + mutation[""ATGC""] = 0 + mutation[""ATGG""] = 0 + mutation[""ATTA""] = 0 + mutation[""ATTC""] = 0 + mutation[""ATTG""] = 0 + mutation[""CAAC""] = 0 + mutation[""CAAG""] = 0 + mutation[""CAAT""] = 0 + mutation[""CAGC""] = 0 + mutation[""CAGG""] = 0 + mutation[""CAGT""] = 0 + mutation[""CATC""] = 0 + mutation[""CATG""] = 0 + mutation[""CATT""] = 0 + mutation[""CCAA""] = 0 + mutation[""CCAG""] = 0 + mutation[""CCAT""] = 0 + mutation[""CCGA""] = 0 + mutation[""CCGG""] = 0 + mutation[""CCGT""] = 0 + mutation[""CCTA""] = 0 + mutation[""CCTG""] = 0 + mutation[""CCTT""] = 0 + mutation[""CGAA""] = 0 + mutation[""CGAC""] = 0 + mutation[""CGAT""] = 0 + mutation[""CGGA""] = 0 + mutation[""CGGC""] = 0 + mutation[""CGGT""] = 0 + mutation[""CGTA""] = 0 + mutation[""CGTC""] = 0 + mutation[""CGTT""] = 0 + mutation[""CTAA""] = 0 + mutation[""CTAC""] = 0 + mutation[""CTAG""] = 0 + mutation[""CTGA""] = 0 + mutation[""CTGC""] = 0 + mutation[""CTGG""] = 0 + mutation[""CTTA""] = 0 + mutation[""CTTC""] = 0 + mutation[""CTTG""] = 0 + mutation[""GAAC""] = 0 + mutation[""GAAG""] = 0 + mutation[""GAAT""] = 0 + mutation[""GACC""] = 0 + mutation[""GACG""] = 0 + mutation[""GACT""] = 0 + mutation[""GATC""] = 0 + mutation[""GATG""] = 0 + mutation[""GATT""] = 0 + mutation[""GCAA""] = 0 + mutation[""GCAG""] = 0 + mutation[""GCAT""] = 0 + mutation[""GCCA""] = 0 + mutation[""GCCG""] = 0 + mutation[""GCCT""] = 0 + mutation[""GCTA""] = 0 + mutation[""GCTG""] = 0 + mutation[""GCTT""] = 0 + mutation[""GGAA""] = 0 + mutation[""GGAC""] = 0 + mutation[""GGAT""] = 0 + mutation[""GGCA""] = 0 + mutation[""GGCC""] = 0 + mutation[""GGCT""] = 0 + mutation[""GGTA""] = 0 + mutation[""GGTC""] = 0 + mutation[""GGTT""] = 0 + mutation[""GTAA""] = 0 + mutation[""GTAC""] = 0 + mutation[""GTAG""] = 0 + mutation[""GTCA""] = 0 + mutation[""GTCC""] = 0 + mutation[""GTCG""] = 0 + mutation[""GTTA""] = 0 + mutation[""GTTC""] = 0 + mutation[""GTTG""] = 0 + mutation[""TAAC""] = 0 + mutation[""TAAG""] = 0 + mutation[""TAAT""] = 0 + mutation[""TACC""] = 0 + mutation[""TACG""] = 0 + mutation[""TACT""] = 0 + mutation[""TAGC""] = 0 + mutation[""TAGG""] = 0 + mutation[""TAGT""] = 0 + mutation[""TCAA""] = 0 + mutation[""TCAG""] = 0 + mutation[""TCAT""] = 0 + mutation[""TCCA""] = 0 + mutation[""TCCG""] = 0 + mutation[""TCCT""] = 0 + mutation[""TCGA""] = 0 + mutation[""TCGG""] = 0 + mutation[""TCGT""] = 0 + mutation[""TGAA""] = 0 + mutation[""TGAC""] = 0 + mutation[""TGAT""] = 0 + mutation[""TGCA""] = 0 + mutation[""TGCC""] = 0 + mutation[""TGCT""] = 0 + mutation[""TGGA""] = 0 + mutation[""TGGC""] = 0 + mutation[""TGGT""] = 0 + mutation[""TTAA""] = 0 + mutation[""TTAC""] = 0 + mutation[""TTAG""] = 0 + mutation[""TTCA""] = 0 + mutation[""TTCC""] = 0 + mutation[""TTCG""] = 0 + mutation[""TTGA""] = 0 + mutation[""TTGC""] = 0 + mutation[""TTGG""] = 0 + return(mutation) + +#Calculates the number of each mutation type in the spectrum +#Takes a mutational spectrum dictionary +#Returns a dictionary with mutation types as keys and counts as values +def mutationTypeCount(spectrum, rna): + #Empty dictionary of mutation counts + if rna: + mtDict = {""CA"": 0, ""CG"": 0, ""CT"": 0, ""TA"": 0, ""TC"": 0, ""TG"": 0, ""GT"": 0, ""GC"": 0, ""GA"": 0, ""AC"": 0, ""AG"": 0, ""AT"": 0} + else: + mtDict = {""CA"": 0, ""CG"": 0, ""CT"": 0, ""TA"": 0, ""TC"": 0, ""TG"": 0} + + #Iterate through the mutations in the spectrum, extract their mutation type and add to the corresponding dictionary mutation + for m in spectrum: + mtDict[m[1] + m[2]] += spectrum[m] + + return(mtDict) + +#Creates an empty dictionary of triplets +def getTripletDict(): + tripletDict = OrderedDict() + tripletDict[""ACA""] = 0 + tripletDict[""ACC""] = 0 + tripletDict[""ACG""] = 0 + tripletDict[""ACT""] = 0 + tripletDict[""CCA""] = 0 + tripletDict[""CCC""] = 0 + tripletDict[""CCG""] = 0 + tripletDict[""CCT""] = 0 + tripletDict[""GCA""] = 0 + tripletDict[""GCC""] = 0 + tripletDict[""GCG""] = 0 + tripletDict[""GCT""] = 0 + tripletDict[""TCA""] = 0 + tripletDict[""TCC""] = 0 + tripletDict[""TCG""] = 0 + tripletDict[""TCT""] = 0 + tripletDict[""ATA""] = 0 + tripletDict[""ATC""] = 0 + tripletDict[""ATG""] = 0 + tripletDict[""ATT""] = 0 + tripletDict[""CTA""] = 0 + tripletDict[""CTC""] = 0 + tripletDict[""CTG""] = 0 + tripletDict[""CTT""] = 0 + tripletDict[""GTA""] = 0 + tripletDict[""GTC""] = 0 + tripletDict[""GTG""] = 0 + tripletDict[""GTT""] = 0 + tripletDict[""TTA""] = 0 + tripletDict[""TTC""] = 0 + tripletDict[""TTG""] = 0 + tripletDict[""TTT""] = 0 + + return(tripletDict) + +#Creates an empty dictionary of RNA triplets +def getRNATripletDict(): + tripletDict = OrderedDict() + tripletDict[""ACA""] = 0 + tripletDict[""ACC""] = 0 + tripletDict[""ACG""] = 0 + tripletDict[""ACT""] = 0 + tripletDict[""CCA""] = 0 + tripletDict[""CCC""] = 0 + tripletDict[""CCG""] = 0 + tripletDict[""CCT""] = 0 + tripletDict[""GCA""] = 0 + tripletDict[""GCC""] = 0 + tripletDict[""GCG""] = 0 + tripletDict[""GCT""] = 0 + tripletDict[""TCA""] = 0 + tripletDict[""TCC""] = 0 + tripletDict[""TCG""] = 0 + tripletDict[""TCT""] = 0 + tripletDict[""ATA""] = 0 + tripletDict[""ATC""] = 0 + tripletDict[""ATG""] = 0 + tripletDict[""ATT""] = 0 + tripletDict[""CTA""] = 0 + tripletDict[""CTC""] = 0 + tripletDict[""CTG""] = 0 + tripletDict[""CTT""] = 0 + tripletDict[""GTA""] = 0 + tripletDict[""GTC""] = 0 + tripletDict[""GTG""] = 0 + tripletDict[""GTT""] = 0 + tripletDict[""TTA""] = 0 + tripletDict[""TTC""] = 0 + tripletDict[""TTG""] = 0 + tripletDict[""TTT""] = 0 + tripletDict[""AAA""] = 0 + tripletDict[""AAC""] = 0 + tripletDict[""AAG""] = 0 + tripletDict[""AAT""] = 0 + tripletDict[""CAA""] = 0 + tripletDict[""CAC""] = 0 + tripletDict[""CAG""] = 0 + tripletDict[""CAT""] = 0 + tripletDict[""GAA""] = 0 + tripletDict[""GAC""] = 0 + tripletDict[""GAG""] = 0 + tripletDict[""GAT""] = 0 + tripletDict[""TAA""] = 0 + tripletDict[""TAC""] = 0 + tripletDict[""TAG""] = 0 + tripletDict[""TAT""] = 0 + tripletDict[""AGA""] = 0 + tripletDict[""AGC""] = 0 + tripletDict[""AGG""] = 0 + tripletDict[""AGT""] = 0 + tripletDict[""CGA""] = 0 + tripletDict[""CGC""] = 0 + tripletDict[""CGG""] = 0 + tripletDict[""CGT""] = 0 + tripletDict[""GGA""] = 0 + tripletDict[""GGC""] = 0 + tripletDict[""GGG""] = 0 + tripletDict[""GGT""] = 0 + tripletDict[""TGA""] = 0 + tripletDict[""TGC""] = 0 + tripletDict[""TGG""] = 0 + tripletDict[""TGT""] = 0 + + return(tripletDict) + +#Calculates the number of each triplet in a given sequence +def calculateContexts(sequence, rna): + if not rna: + tripletDict = getTripletDict() + else: + tripletDict = getRNATripletDict() + + nucleotides = [""A"", ""C"", ""G"", ""T""] + + for i in range(len(sequence) - 2): + t = sequence[i:(i+3)] + if (t[0] in nucleotides) and (t[1] in nucleotides) and (t[2] in nucleotides): + if t in tripletDict: + tripletDict[t] += 1 + else: + tripletDict[complement(t[2]) + complement(t[1]) + complement(t[0])] += 1 + + #Add the reverse complement contexts from the reverse strand if the sequence is DNA + if not rna: + for c in tripletDict: + tripletDict[c] = tripletDict[c] * 2 + + return(tripletDict) + +#Rescales a SBS spectrum by the triplet availability in a provided reference genome +#Uses code from rescale_spectrum.py but differs as this function doesn't update spectrum keys +def rescaleSBS(spectrum, contexts, scalar, rna): + #Will be filled with the rescaled spectrum + if rna: + rescaledSpectrum = getRNADict() + else: + rescaledSpectrum = getMutationDict() + + #Iterate through the contextual mutations, scale their counts and add to rescaledSpectrum + for m in spectrum: + rescaledSpectrum[m] = round((spectrum[m]/contexts[m[0] + m[1] + m[3]]) * scalar) + + return(rescaledSpectrum) + +#Reverses a SBS spectrum for reverse strand RNA viruses +def reverseSpectrum(spectrum): + #Will be RNA dictionary as DNA cannot be reverse stranded + reverseDict = getRNADict() + + #Iterate through the mutations in the spectrum, reverse them and add to the corresponding + #mutation in the reverse spectrum + for eachM in spectrum: + reverseDict[complement(eachM[-1]) + complement(eachM[1]) + complement(eachM[2]) + complement(eachM[0])] = spectrum[eachM] + + return(reverseDict) + +#Reverses a DBS spectrum for reverse strand RNA viruses +def reverseDouble(spectrum): + #Will be RNA dictionary as DNA cannot be reverse stranded + reverseDict = getRNADoubleSubstitutionDict() + + #Iterate through the mutations in the spectrum, reverse them and add to the corresponding + #mutation in the reverse spectrum + for eachM in spectrum: + reverseDict[complement(eachM[1]) + complement(eachM[0]) + complement(eachM[3]) + complement(eachM[2])] = spectrum[eachM] + + return(reverseDict) + +if __name__ == ""__main__"": + parser = argparse.ArgumentParser() + parser.add_argument(""-a"", help = ""ancestral_sequences.fasta from treetime"") + parser.add_argument(""-t"", help = ""annotated_tree.nexus from treetime"") + parser.add_argument(""-r"", help = ""Reference genome in fasta format"") + parser.add_argument(""-p"", help = ""Translation of alignment positions to genome positions, tab separated, no header, alignment positions in column 1, genome positions in column 2"") + parser.add_argument(""-o"", help = ""Output file prefix, default reconstructions if none given"", default = ""reconstructions"") + args = parser.parse_args() + + #Import the ancestral sequence alignment + alignment = AlignIO.read(args.a, ""fasta"") + + #Import the annotated tree + tree = Phylo.read(args.t, ""nexus"") + + #Import the reference genome sequence + reference = AlignIO.read(args.r, ""fasta"") + referenceLength = len(reference[0]) + referenceSequence = str(reference[0].seq) + + #Import the translation file + alignmentGenome = open(args.p).readlines() + + #Will contain the number of each contextual mutation + outMutations = open(args.o + ""_mutational_spectrum.txt"", ""w"") + outMutations.write(""Mutation_with_context,Number_of_mutations\n"") + + #Will contain the mutations that were not included in the contextual spectrum due to lack of surrounding context, includes mutations next to gaps and mutations at the end of the sequence + outMutationsNotUsed = open(args.o + ""_mutations_not_included.txt"", ""w"") + outMutationsNotUsed.write(""Mutation,Branch,Reason_not_included\n"") + + #Convert the translation file to a dictionary + positionTranslation = convertTranslation(alignmentGenome) + + #Identify the variable positions in the genome + variablePositions = getVariablePositions(positionTranslation) + + #Extract the mutations in each branch into a dictionary + branchMutationDict = getBranchDict(tree, positionTranslation) + + #Create an empty mutational spectrum + spectrum = getMutationDict() + + #The 4 nucleotides, used to check if upstream and downstream bases are nucleotides + nucleotides = [""A"",""C"",""G"",""T""] + + #Iterate through the branches, extract the mutations, get their context and add to mutationSpectrum + for clade in tree.find_clades(): + #Do not analyse the root + if len(tree.get_path(clade)) != 0: + #Identify the name of the branch for saving mutations + branchName = getBranchName(tree, clade) + #Check if there are mutations along the branch, the .comment is only added to the clade if there are + if clade.comment: + branchMutations = getMutations(clade.comment, positionTranslation) + + #Check if there are double substitutions along the branch and remove these mutations + if len(branchMutations) > 1: + positionsToRemove = [] + for mutation1 in range(0, (len(branchMutations) - 1)): + for mutation2 in range((mutation1 + 1), len(branchMutations)): + if branchMutations[mutation2][2] == (branchMutations[mutation1][2] + 1): + positionsToRemove.append(mutation1) + positionsToRemove.append(mutation2) + if len(positionsToRemove) != 0: + #Write the positions to the mutations not analysed file + for removePosition in positionsToRemove: + outMutationsNotUsed.write(branchMutations[removePosition][0] + str(branchMutations[removePosition][1]) + branchMutations[removePosition][3] + "","" + branchName + "",Double_substitution\n"") + #Remove the positions from the mutations + for ele in sorted(positionsToRemove, reverse = True): + del branchMutations[ele] + + #Update the reference sequence to get the current context + updatedReference = updateReference(tree, clade, branchMutationDict, referenceSequence) + + for mutation in branchMutations: + #Check if the mutation is at the end of the genome, if it is it does not have context so cannt be analysed + if (mutation[2] == 1) or (mutation[2] == referenceLength): + outMutationsNotUsed.write(mutation[0] + str(mutation[1]) + mutation[3] + "","" + branchName + "",End_of_genome\n"") + #Check if the mutation does not involve 2 nucleotides + elif (mutation[0] not in nucleotides) or (mutation[3] not in nucleotides): + outMutationsNotUsed.write(mutation[0] + str(mutation[1]) + mutation[3] + "","" + branchName + "",Mutation_does_not_involve_two_nucleotides\n"") + else: + mutationContext = getContext(mutation, updatedReference) + + #Check if the upstream or downstream nucleotides are not A, C, G or T + if (mutationContext[0] not in nucleotides) or (mutationContext[1] not in nucleotides): + outMutationsNotUsed.write(mutation[0] + str(mutation[1]) + mutation[3] + "","" + branchName + "",Surrounding_position_not_nucleotide\n"") + else: + if (mutationContext[0] + mutation[0] + mutation[3] + mutationContext[1]) in spectrum: + spectrum[mutationContext[0] + mutation[0] + mutation[3] + mutationContext[1]] += 1 + else: + spectrum[complement(mutationContext[0]) + complement(mutation[0]) + complement(mutation[3]) + complement(mutationContext[1])] += 1 + + #Write the mutational spectrum + for eachSpectrum in spectrum: + outMutations.write(eachSpectrum + "","" + str(spectrum[eachSpectrum]) + ""\n"") + + outMutations.close() + outMutationsNotUsed.close()","Python" +"Viral","chrisruis/MutTui","MutTui/plot_spectrum.py",".py","37860","621","#Functions to plot mutational spectra +#Used by muttui.py to plot spectra but can also be run as a standalone script on a MutTui output spectrum + +import argparse +import numpy as np +import matplotlib +matplotlib.use('AGG') +import matplotlib.pyplot as plt +from matplotlib.lines import Line2D + + + +#Converts an input spectrum from a csv file to a dictionary +def convertSpectrumDict(spectrumFile): + spectrum = open(spectrumFile.name).readlines() + + spectrumDict = {} + + for mutation in spectrum[1:]: + spectrumDict[mutation.strip().split("","")[0]] = int(mutation.strip().split("","")[1]) + + return(spectrumDict) + +#Converts an input spectrum of proportions from a csv file to a dictionary +def convertSpectrumDictProportions(spectrumFile): + spectrum = open(spectrumFile.name).readlines() + + spectrumDict = {} + + for mutation in spectrum[1:]: + spectrumDict[mutation.strip().split("","")[0]] = float(mutation.strip().split("","")[1]) + + return(spectrumDict) + +#Converts a spectrum to the required format for plotting +#Converts from format ACAA to A[C>A]A +def convertSpectrumFormat(spectrum): + spectrumDict = {} + + for mutation in spectrum: + spectrumDict[mutation[0] + ""["" + mutation[1] + "">"" + mutation[2] + ""]"" + mutation[3]] = spectrum[mutation] + + return(spectrumDict) + +#Converts a given spectrum from number of mutations to proportion of mutations and returns the spectrum as a dictionary +def convertSpectrumProportions(spectrum): + totalMutations = float(0) + + for mutation in spectrum: + totalMutations += float(spectrum[mutation]) + + for eachMutation in spectrum: + spectrum[eachMutation] = float(spectrum[eachMutation])/totalMutations + + return(spectrum) + +#Converts a strand bias spectrum +def convertSB(spectrum): + spectrumDict = {} + + with open(spectrum.name) as f: + next(f) + for l in f: + spectrumDict[l.strip().split("","")[0] + l.strip().split("","")[1]] = int(l.strip().split("","")[2]) + + return(spectrumDict) + +#Plots a SBS spectrum from a dictionary with mutations as keys and mutation counts as values +def plotSpectrumFromDict(spectrum, proportion, outFile): + #The 96 DNA mutations as a list, used so they are always in the same order + mutations = [""A[C>A]A"",""A[C>A]C"",""A[C>A]G"",""A[C>A]T"",""C[C>A]A"",""C[C>A]C"",""C[C>A]G"",""C[C>A]T"",""G[C>A]A"",""G[C>A]C"",""G[C>A]G"",""G[C>A]T"",""T[C>A]A"",""T[C>A]C"",""T[C>A]G"",""T[C>A]T"",""A[C>G]A"",""A[C>G]C"",""A[C>G]G"",""A[C>G]T"",""C[C>G]A"",""C[C>G]C"",""C[C>G]G"",""C[C>G]T"",""G[C>G]A"",""G[C>G]C"",""G[C>G]G"",""G[C>G]T"",""T[C>G]A"",""T[C>G]C"",""T[C>G]G"",""T[C>G]T"",""A[C>T]A"",""A[C>T]C"",""A[C>T]G"",""A[C>T]T"",""C[C>T]A"",""C[C>T]C"",""C[C>T]G"",""C[C>T]T"",""G[C>T]A"",""G[C>T]C"",""G[C>T]G"",""G[C>T]T"",""T[C>T]A"",""T[C>T]C"",""T[C>T]G"",""T[C>T]T"",""A[T>A]A"",""A[T>A]C"",""A[T>A]G"",""A[T>A]T"",""C[T>A]A"",""C[T>A]C"",""C[T>A]G"",""C[T>A]T"",""G[T>A]A"",""G[T>A]C"",""G[T>A]G"",""G[T>A]T"",""T[T>A]A"",""T[T>A]C"",""T[T>A]G"",""T[T>A]T"",""A[T>C]A"",""A[T>C]C"",""A[T>C]G"",""A[T>C]T"",""C[T>C]A"",""C[T>C]C"",""C[T>C]G"",""C[T>C]T"",""G[T>C]A"",""G[T>C]C"",""G[T>C]G"",""G[T>C]T"",""T[T>C]A"",""T[T>C]C"",""T[T>C]G"",""T[T>C]T"",""A[T>G]A"",""A[T>G]C"",""A[T>G]G"",""A[T>G]T"",""C[T>G]A"",""C[T>G]C"",""C[T>G]G"",""C[T>G]T"",""G[T>G]A"",""G[T>G]C"",""G[T>G]G"",""G[T>G]T"",""T[T>G]A"",""T[T>G]C"",""T[T>G]G"",""T[T>G]T""] + + #Calculate scale factor to rescale spectrum by, if proportions is used this is the total mutations to + #rescale to proportions, if not this is 1 so the mutations stay the same + if proportion: + tM = float(0) + for m in mutations: + tM += float(spectrum[m]) + else: + tM = float(1) + + #Extract number/proportion of each mutation to plot + mutationCounts = [] + #Iterate through the mutations and add their count to mutationCounts + for mutation in mutations: + mutationCounts.append(float(spectrum[mutation])/tM) + + #Colours of the bars + colourSet = [""blue"", ""black"", ""red"", ""grey"", ""green"", ""pink""] + colours = [i for i in colourSet for j in range(16)] + + #Used to plot the rectangles above the plot containing the mutation type + rect_lower = float(np.max(mutationCounts)) + float(np.max(mutationCounts) * 0.05) + rect_width = float(np.max(mutationCounts)) * 0.1 + + #Coordinates of the mutation type rectangles and text + mutation_types = [""C>A"", ""C>G"", ""C>T"", ""T>A"", ""T>C"", ""T>G""] + rect_coords = [-0.5, 15.5, 31.5, 47.5, 63.5, 79.5] + text_coords = [4, 20, 36, 52, 68, 84] + + fig = plt.figure() + ax = plt.subplot(111) + ax.bar(mutations, mutationCounts, color = colours) + #ax.add_patch(plt.Rectangle((80, rect_lower), 15, rect_width, clip_on = False)) + for i, rect in enumerate(rect_coords): + ax.add_patch(plt.Rectangle((rect, rect_lower), 16, rect_width, facecolor = colourSet[i])) + ax.text(text_coords[i], (rect_lower + (rect_width/3)), mutation_types[i], color = ""white"", fontweight = ""bold"") + ax.spines[""top""].set_visible(False) + ax.spines[""right""].set_visible(False) + ax.set_xticks(range(len(mutations))) + ax.set_xticklabels([""""] * len(mutations)) + plt.xlabel(""Mutation"") + if proportion: + plt.ylabel(""Proportion of mutations"") + else: + plt.ylabel(""Number of mutations"") + plt.margins(0) + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots a RNA SBS spectrum +def plotRNA(spectrum, proportion, outFile): + allM = [""A[C>A]A"",""A[C>A]C"",""A[C>A]G"",""A[C>A]T"",""C[C>A]A"",""C[C>A]C"",""C[C>A]G"",""C[C>A]T"",""G[C>A]A"",""G[C>A]C"",""G[C>A]G"",""G[C>A]T"",""T[C>A]A"",""T[C>A]C"",""T[C>A]G"",""T[C>A]T"",""A[C>G]A"",""A[C>G]C"",""A[C>G]G"",""A[C>G]T"",""C[C>G]A"",""C[C>G]C"",""C[C>G]G"",""C[C>G]T"",""G[C>G]A"",""G[C>G]C"",""G[C>G]G"",""G[C>G]T"",""T[C>G]A"",""T[C>G]C"",""T[C>G]G"",""T[C>G]T"",""A[C>T]A"",""A[C>T]C"",""A[C>T]G"",""A[C>T]T"",""C[C>T]A"",""C[C>T]C"",""C[C>T]G"",""C[C>T]T"",""G[C>T]A"",""G[C>T]C"",""G[C>T]G"",""G[C>T]T"",""T[C>T]A"",""T[C>T]C"",""T[C>T]G"",""T[C>T]T"",""A[T>A]A"",""A[T>A]C"",""A[T>A]G"",""A[T>A]T"",""C[T>A]A"",""C[T>A]C"",""C[T>A]G"",""C[T>A]T"",""G[T>A]A"",""G[T>A]C"",""G[T>A]G"",""G[T>A]T"",""T[T>A]A"",""T[T>A]C"",""T[T>A]G"",""T[T>A]T"",""A[T>C]A"",""A[T>C]C"",""A[T>C]G"",""A[T>C]T"",""C[T>C]A"",""C[T>C]C"",""C[T>C]G"",""C[T>C]T"",""G[T>C]A"",""G[T>C]C"",""G[T>C]G"",""G[T>C]T"",""T[T>C]A"",""T[T>C]C"",""T[T>C]G"",""T[T>C]T"",""A[T>G]A"",""A[T>G]C"",""A[T>G]G"",""A[T>G]T"",""C[T>G]A"",""C[T>G]C"",""C[T>G]G"",""C[T>G]T"",""G[T>G]A"",""G[T>G]C"",""G[T>G]G"",""G[T>G]T"",""T[T>G]A"",""T[T>G]C"",""T[T>G]G"",""T[T>G]T"",""A[G>T]A"",""A[G>T]C"",""A[G>T]G"",""A[G>T]T"",""C[G>T]A"",""C[G>T]C"",""C[G>T]G"",""C[G>T]T"",""G[G>T]A"",""G[G>T]C"",""G[G>T]G"",""G[G>T]T"",""T[G>T]A"",""T[G>T]C"",""T[G>T]G"",""T[G>T]T"",""A[G>C]A"",""A[G>C]C"",""A[G>C]G"",""A[G>C]T"",""C[G>C]A"",""C[G>C]C"",""C[G>C]G"",""C[G>C]T"",""G[G>C]A"",""G[G>C]C"",""G[G>C]G"",""G[G>C]T"",""T[G>C]A"",""T[G>C]C"",""T[G>C]G"",""T[G>C]T"",""A[G>A]A"",""A[G>A]C"",""A[G>A]G"",""A[G>A]T"",""C[G>A]A"",""C[G>A]C"",""C[G>A]G"",""C[G>A]T"",""G[G>A]A"",""G[G>A]C"",""G[G>A]G"",""G[G>A]T"",""T[G>A]A"",""T[G>A]C"",""T[G>A]G"",""T[G>A]T"",""A[A>T]A"",""A[A>T]C"",""A[A>T]G"",""A[A>T]T"",""C[A>T]A"",""C[A>T]C"",""C[A>T]G"",""C[A>T]T"",""G[A>T]A"",""G[A>T]C"",""G[A>T]G"",""G[A>T]T"",""T[A>T]A"",""T[A>T]C"",""T[A>T]G"",""T[A>T]T"",""A[A>G]A"",""A[A>G]C"",""A[A>G]G"",""A[A>G]T"",""C[A>G]A"",""C[A>G]C"",""C[A>G]G"",""C[A>G]T"",""G[A>G]A"",""G[A>G]C"",""G[A>G]G"",""G[A>G]T"",""T[A>G]A"",""T[A>G]C"",""T[A>G]G"",""T[A>G]T"",""A[A>C]A"",""A[A>C]C"",""A[A>C]G"",""A[A>C]T"",""C[A>C]A"",""C[A>C]C"",""C[A>C]G"",""C[A>C]T"",""G[A>C]A"",""G[A>C]C"",""G[A>C]G"",""G[A>C]T"",""T[A>C]A"",""T[A>C]C"",""T[A>C]G"",""T[A>C]T""] + + #Colours of the bars + colourSet = [""blue"", ""black"", ""red"", ""grey"", ""green"", ""pink"", ""royalblue"", ""dimgrey"", ""coral"", ""silver"", ""darkgreen"", ""purple""] + colours = [""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""blue"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""black"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""red"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""grey"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""green"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""pink"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""royalblue"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""dimgrey"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""coral"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""silver"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""darkgreen"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple"",""purple""] + + #x axis of 1:192 + x = list() + for i in range(1, 193): + x.append(i) + + if proportion: + tM = float(0) + for m in allM: + tM += float(spectrum[m]) + else: + tM = float(1) + + #Extract number/proportion of each mutation to plot + y = list() + for m in allM: + y.append(float(spectrum[m])/tM) + + #Used to plot the rectangles above the plot containing the mutation type + rect_lower = float(np.max(y)) + float(np.max(y) * 0.05) + rect_width = float(np.max(y)) * 0.1 + #Coordinates of the mutation type rectangles and text + mutation_types = [""C>A"", ""C>G"", ""C>T"", ""T>A"", ""T>C"", ""T>G"", ""G>T"", ""G>C"", ""G>A"", ""A>T"", ""A>G"", ""A>C""] + rect_coords = [-0.5, 15.5, 31.5, 47.5, 63.5, 79.5, 95.5, 111.5, 127.5, 143.5, 159.5, 175.5] + text_coords = [1, 17, 33, 49, 65, 81, 97, 113, 129, 145, 161, 177] + + fig = plt.figure() + ax = plt.subplot(111) + ax.bar(x, y, color = colours) + for i, rect in enumerate(rect_coords): + ax.add_patch(plt.Rectangle((rect, rect_lower), 16, rect_width, facecolor = colourSet[i])) + ax.text(text_coords[i], (rect_lower + (rect_width/3)), mutation_types[i], color = ""white"", fontweight = ""bold"") + ax.spines[""top""].set_visible(False) + ax.spines[""right""].set_visible(False) + ax.locator_params(axis = ""x"", nbins = 192) + ax.set_xticks(range(len(x))) + ax.set_xticklabels([""""] * len(x)) + plt.xlabel(""Mutation"") + if proportion: + plt.ylabel(""Proportion of mutations"") + else: + plt.ylabel(""Number of mutations"") + plt.margins(0) + + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots a SBS spectrum split into transcribed and untranscribed strands +def plotSB(spectrum, proportion, outFile): + allM = [""tACAA"",""uACAA"",""tACAC"",""uACAC"",""tACAG"",""uACAG"",""tACAT"",""uACAT"",""tCCAA"",""uCCAA"",""tCCAC"",""uCCAC"",""tCCAG"",""uCCAG"",""tCCAT"",""uCCAT"",""tGCAA"",""uGCAA"",""tGCAC"",""uGCAC"",""tGCAG"",""uGCAG"",""tGCAT"",""uGCAT"",""tTCAA"",""uTCAA"",""tTCAC"",""uTCAC"",""tTCAG"",""uTCAG"",""tTCAT"",""uTCAT"",""tACGA"",""uACGA"",""tACGC"",""uACGC"",""tACGG"",""uACGG"",""tACGT"",""uACGT"",""tCCGA"",""uCCGA"",""tCCGC"",""uCCGC"",""tCCGG"",""uCCGG"",""tCCGT"",""uCCGT"",""tGCGA"",""uGCGA"",""tGCGC"",""uGCGC"",""tGCGG"",""uGCGG"",""tGCGT"",""uGCGT"",""tTCGA"",""uTCGA"",""tTCGC"",""uTCGC"",""tTCGG"",""uTCGG"",""tTCGT"",""uTCGT"",""tACTA"",""uACTA"",""tACTC"",""uACTC"",""tACTG"",""uACTG"",""tACTT"",""uACTT"",""tCCTA"",""uCCTA"",""tCCTC"",""uCCTC"",""tCCTG"",""uCCTG"",""tCCTT"",""uCCTT"",""tGCTA"",""uGCTA"",""tGCTC"",""uGCTC"",""tGCTG"",""uGCTG"",""tGCTT"",""uGCTT"",""tTCTA"",""uTCTA"",""tTCTC"",""uTCTC"",""tTCTG"",""uTCTG"",""tTCTT"",""uTCTT"",""tATAA"",""uATAA"",""tATAC"",""uATAC"",""tATAG"",""uATAG"",""tATAT"",""uATAT"",""tCTAA"",""uCTAA"",""tCTAC"",""uCTAC"",""tCTAG"",""uCTAG"",""tCTAT"",""uCTAT"",""tGTAA"",""uGTAA"",""tGTAC"",""uGTAC"",""tGTAG"",""uGTAG"",""tGTAT"",""uGTAT"",""tTTAA"",""uTTAA"",""tTTAC"",""uTTAC"",""tTTAG"",""uTTAG"",""tTTAT"",""uTTAT"",""tATCA"",""uATCA"",""tATCC"",""uATCC"",""tATCG"",""uATCG"",""tATCT"",""uATCT"",""tCTCA"",""uCTCA"",""tCTCC"",""uCTCC"",""tCTCG"",""uCTCG"",""tCTCT"",""uCTCT"",""tGTCA"",""uGTCA"",""tGTCC"",""uGTCC"",""tGTCG"",""uGTCG"",""tGTCT"",""uGTCT"",""tTTCA"",""uTTCA"",""tTTCC"",""uTTCC"",""tTTCG"",""uTTCG"",""tTTCT"",""uTTCT"",""tATGA"",""uATGA"",""tATGC"",""uATGC"",""tATGG"",""uATGG"",""tATGT"",""uATGT"",""tCTGA"",""uCTGA"",""tCTGC"",""uCTGC"",""tCTGG"",""uCTGG"",""tCTGT"",""uCTGT"",""tGTGA"",""uGTGA"",""tGTGC"",""uGTGC"",""tGTGG"",""uGTGG"",""tGTGT"",""uGTGT"",""tTTGA"",""uTTGA"",""tTTGC"",""uTTGC"",""tTTGG"",""uTTGG"",""tTTGT"",""uTTGT""] + + #Colours of the bars + colourSet = [""blue"", ""black"", ""red"", ""grey"", ""green"", ""pink""] + colours = [""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red"",""blue"",""red""] + + #x axis of 1:192 + x = list() + for i in range(1, 193): + x.append(i) + + if proportion: + tM = float(0) + for m in allM: + tM += float(spectrum[m]) + else: + tM = float(1) + + #Extract number/proportion of each mutation to plot + y = list() + for m in allM: + y.append(float(spectrum[m])/tM) + + #Used to plot the rectangles above the plot containing the mutation type + rect_lower = float(np.max(y)) + float(np.max(y) * 0.05) + rect_width = float(np.max(y)) * 0.1 + #Coordinates of the mutation type rectangles and text + mutation_types = [""C>A"", ""C>G"", ""C>T"", ""T>A"", ""T>C"", ""T>G""] + rect_coords = [-0.5, 31.5, 63.5, 95.5, 127.5, 159.5] + text_coords = [8, 40, 72, 104, 136, 168] + + fig = plt.figure() + ax = plt.subplot(111) + ax.bar(x, y, color = colours) + for i, rect in enumerate(rect_coords): + ax.add_patch(plt.Rectangle((rect, rect_lower), 32, rect_width, facecolor = colourSet[i])) + ax.text(text_coords[i], (rect_lower + (rect_width/3)), mutation_types[i], color = ""white"", fontweight = ""bold"") + plt.xlabel(""Mutation"") + if proportion: + plt.ylabel(""Proportion of mutations"") + else: + plt.ylabel(""Number of mutations"") + plt.margins(0) + + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots the number of mutations of each type, combining all contexts from that type +def plotMutationType(mtCounts, outFile): + #Extract the mutations and counts to separate lists + mutations = list(mtCounts.keys()) + mutationCounts = list(mtCounts.values()) + + #Colours of the bars + colourSet = [""blue"", ""black"", ""red"", ""grey"", ""green"", ""pink""] + + fig = plt.figure() + ax = plt.subplot(111) + #Used to plot proportion of mutations, now changed to plotting number of mutations so not used + #ax.bar(mutations, mutationProportions, color = colourSet) + ax.bar(mutations, mutationCounts, color = colourSet) + plt.xlabel(""Mutation type"") + plt.ylabel(""Number of mutations"") + + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots the number of mutations of each type in an RNA spectrum +def plotRNAMT(mtCounts, outFile): + #Extract the mutations and counts to separate lists + mutations = list(mtCounts.keys()) + mutationCounts = list(mtCounts.values()) + + #Colours of the bars + colourSet = [""blue"", ""black"", ""red"", ""grey"", ""green"", ""pink"", ""royalblue"", ""dimgrey"", ""coral"", ""silver"", ""darkgreen"", ""purple""] + + fig = plt.figure() + ax = plt.subplot(111) + #Used to plot proportion of mutations, now changed to plotting number of mutations so not used + #ax.bar(mutations, mutationProportions, color = colourSet) + ax.bar(mutations, mutationCounts, color = colourSet) + plt.xlabel(""Mutation type"") + plt.ylabel(""Number of mutations"") + + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots a double substitution spectrum +def plotDouble(spectrum, proportion, outFile): + #Convert the spectrum to proportions if needed + if proportion: + spectrum = convertSpectrumProportions(spectrum) + #Extracts the mutations and counts to separate lists + mutations = list(spectrum.keys()) + mutationCounts = list(spectrum.values()) + + #Extract x-axis labels which are the bases mutated to + labels = list() + for m in spectrum: + labels.append(m.split("">"")[1]) + + #Colours of the bars + colours = [""red"", ""red"", ""red"", ""red"", ""red"", ""red"", ""red"", ""red"", ""red"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""cyan"", ""cyan"", ""cyan"", ""cyan"", ""cyan"", ""cyan"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darksalmon""] + colourSet = [""red"", ""limegreen"", ""gold"", ""dodgerblue"", ""orange"", ""mediumpurple"", ""cyan"", ""magenta"", ""yellowgreen"", ""darksalmon""] + + #Used to plot the rectangles above the plot containing the mutation type + rect_lower = float(np.max(mutationCounts)) + float(np.max(mutationCounts) * 0.05) + rect_width = float(np.max(mutationCounts)) * 0.1 + + #The coordinates of the mutation type rectangles and text + mutation_types = [""AA>NN"", ""AC>NN"", ""AG>NN"", ""AT>NN"", ""CA>NN"", ""CC>NN"", ""CG>NN"", ""GA>NN"", ""GC>NN"", ""TA>NN""] + rect_coords = [-0.5, 8.5, 17.5, 26.5, 32.5, 41.5, 50.5, 56.5, 65.5, 71.5] + rect_length = [9, 9, 9, 6, 9, 9, 6, 9, 6, 6] + text_coords = [1, 10, 19, 26.75, 34, 43, 50.75, 58, 65.75, 71.75] + + fig = plt.figure() + ax = plt.subplot(111) + ax.bar(mutations, mutationCounts, color = colours) + for i, rect in enumerate(rect_coords): + if proportion: + ax.add_patch(plt.Rectangle((rect, 1), rect_length[i], 0.1, facecolor = colourSet[i])) + ax.text(text_coords[i], 1.035, mutation_types[i], size = 7) + else: + ax.add_patch(plt.Rectangle((rect, rect_lower), rect_length[i], rect_width, facecolor = colourSet[i])) + ax.text(text_coords[i], (rect_lower + (rect_width/3)), mutation_types[i], size = 7) + if proportion: + plt.ylim([0, 1.1]) + plt.ylabel(""Proportion of mutations"") + else: + plt.ylabel(""Number of mutations"") + plt.xlabel(""Mutation"") + plt.tick_params(axis = ""x"", which = ""major"", labelsize = 4) + plt.xticks(ticks = mutations, rotation = 90, labels = labels) + plt.margins(0) + + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots a RNA double substitution spectrum +def plotRNADouble(spectrum, proportion, outFile): + #Convert the spectrum to proportions if needed + if proportion: + spectrum = convertSpectrumProportions(spectrum) + #Extracts the mutations and counts to separate lists + mutations = list(spectrum.keys()) + mutationCounts = list(spectrum.values()) + + #Extract x-axis labels which are the bases mutated to + labels = list() + for m in spectrum: + labels.append(m.split("">"")[1]) + + #Colours of the bars + colours = [""red"", ""red"", ""red"", ""red"", ""red"", ""red"", ""red"", ""red"", ""red"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""limegreen"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""gold"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""dodgerblue"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""orange"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""mediumpurple"", ""cyan"", ""cyan"", ""cyan"", ""cyan"", ""cyan"", ""cyan"", ""cyan"", ""cyan"", ""cyan"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""magenta"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""yellowgreen"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darksalmon"", ""darkturquoise"", ""darkturquoise"", ""darkturquoise"", ""darkturquoise"", ""darkturquoise"", ""darkturquoise"", ""darkturquoise"", ""darkturquoise"", ""darkturquoise"", ""goldenrod"", ""goldenrod"", ""goldenrod"", ""goldenrod"", ""goldenrod"", ""goldenrod"", ""goldenrod"", ""goldenrod"", ""goldenrod"", ""violet"", ""violet"", ""violet"", ""violet"", ""violet"", ""violet"", ""violet"", ""violet"", ""violet"", ""crimson"", ""crimson"", ""crimson"", ""crimson"", ""crimson"", ""crimson"", ""crimson"", ""crimson"", ""crimson"", ""deepskyblue"", ""deepskyblue"", ""deepskyblue"", ""deepskyblue"", ""deepskyblue"", ""deepskyblue"", ""deepskyblue"", ""deepskyblue"", ""deepskyblue"", ""salmon"", ""salmon"", ""salmon"", ""salmon"", ""salmon"", ""salmon"", ""salmon"", ""salmon"", ""salmon""] + colourSet = [""red"", ""limegreen"", ""gold"", ""dodgerblue"", ""orange"", ""mediumpurple"", ""cyan"", ""magenta"", ""yellowgreen"", ""darksalmon"", ""darkturquoise"", ""goldenrod"", ""violet"", ""crimson"", ""deepskyblue"", ""salmon""] + + #Used to plot the rectangles above the plot containing the mutation type + rect_lower = float(np.max(mutationCounts)) + float(np.max(mutationCounts) * 0.05) + rect_width = float(np.max(mutationCounts)) * 0.1 + + #The coordinates of the mutation type rectangles and text + mutation_types = [""AA"", ""AC"", ""AG"", ""AT"", ""CA"", ""CC"", ""CG"", ""CT"", ""GA"", ""GC"", ""GG"", ""GT"", ""TA"", ""TC"", ""TG"", ""TT""] + rect_coords = [-0.5, 8.5, 17.5, 26.5, 35.5, 44.5, 53.5, 62.5, 71.5, 80.5, 89.5, 98.5, 107.5, 116.5, 125.5, 134.5] + rect_length = [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9] + text_coords = [2, 11, 20, 29, 38, 47, 56, 65, 74, 83, 92, 101, 110, 119, 128, 137] + + fig = plt.figure() + ax = plt.subplot(111) + ax.bar(mutations, mutationCounts, color = colours) + for i, rect in enumerate(rect_coords): + if proportion: + ax.add_patch(plt.Rectangle((rect, 1), rect_length[i], 0.1, facecolor = colourSet[i])) + ax.text(text_coords[i], 1.035, mutation_types[i], size = 7) + else: + ax.add_patch(plt.Rectangle((rect, rect_lower), rect_length[i], rect_width, facecolor = colourSet[i])) + ax.text(text_coords[i], (rect_lower + (rect_width/3)), mutation_types[i], size = 7) + if proportion: + plt.ylim([0, 1.1]) + plt.ylabel(""Proportion of mutations"") + else: + plt.ylabel(""Number of mutations"") + plt.xlabel(""Mutation"") + plt.tick_params(axis = ""x"", which = ""major"", labelsize = 4) + plt.xticks(ticks = mutations, rotation = 90, labels = labels) + plt.margins(0) + + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots a comparison between 2 spectra from a dictionary with mutations as keys and difference in mutation proportions as values +def plotSpectrumComparison(spectrum, outFile): + #The 96 DNA mutations as a list, used so they are always in the same order + mutations = [""A[C>A]A"",""A[C>A]C"",""A[C>A]G"",""A[C>A]T"",""C[C>A]A"",""C[C>A]C"",""C[C>A]G"",""C[C>A]T"",""G[C>A]A"",""G[C>A]C"",""G[C>A]G"",""G[C>A]T"",""T[C>A]A"",""T[C>A]C"",""T[C>A]G"",""T[C>A]T"",""A[C>G]A"",""A[C>G]C"",""A[C>G]G"",""A[C>G]T"",""C[C>G]A"",""C[C>G]C"",""C[C>G]G"",""C[C>G]T"",""G[C>G]A"",""G[C>G]C"",""G[C>G]G"",""G[C>G]T"",""T[C>G]A"",""T[C>G]C"",""T[C>G]G"",""T[C>G]T"",""A[C>T]A"",""A[C>T]C"",""A[C>T]G"",""A[C>T]T"",""C[C>T]A"",""C[C>T]C"",""C[C>T]G"",""C[C>T]T"",""G[C>T]A"",""G[C>T]C"",""G[C>T]G"",""G[C>T]T"",""T[C>T]A"",""T[C>T]C"",""T[C>T]G"",""T[C>T]T"",""A[T>A]A"",""A[T>A]C"",""A[T>A]G"",""A[T>A]T"",""C[T>A]A"",""C[T>A]C"",""C[T>A]G"",""C[T>A]T"",""G[T>A]A"",""G[T>A]C"",""G[T>A]G"",""G[T>A]T"",""T[T>A]A"",""T[T>A]C"",""T[T>A]G"",""T[T>A]T"",""A[T>C]A"",""A[T>C]C"",""A[T>C]G"",""A[T>C]T"",""C[T>C]A"",""C[T>C]C"",""C[T>C]G"",""C[T>C]T"",""G[T>C]A"",""G[T>C]C"",""G[T>C]G"",""G[T>C]T"",""T[T>C]A"",""T[T>C]C"",""T[T>C]G"",""T[T>C]T"",""A[T>G]A"",""A[T>G]C"",""A[T>G]G"",""A[T>G]T"",""C[T>G]A"",""C[T>G]C"",""C[T>G]G"",""C[T>G]T"",""G[T>G]A"",""G[T>G]C"",""G[T>G]G"",""G[T>G]T"",""T[T>G]A"",""T[T>G]C"",""T[T>G]G"",""T[T>G]T""] + + #Will be filled with the mutation counts + mutationCounts = [] + + #Iterate through the mutations and add their count to mutationCounts + for mutation in mutations: + mutationCounts.append(spectrum[mutation]) + + #Colours of the bars + colourSet = [""blue"", ""black"", ""red"", ""grey"", ""green"", ""pink""] + colours = [i for i in colourSet for j in range(16)] + + #Labels of the mutation type rectangles + labels = [""C>A"", ""C>G"", ""C>T"", ""T>A"", ""T>C"", ""T>G""] + + #Used to plot the rectangles above the plot containing the mutation type + rect_lower = float(np.max(mutationCounts)) + float(np.max(mutationCounts) * 0.05) + rect_width = float(np.max(mutationCounts)) * 0.4 + + #The coordinates of the mutation type rectangles and text + mutation_types = [""C>A"", ""C>G"", ""C>T"", ""T>A"", ""T>C"", ""T>G""] + rect_coords = [-0.5, 15.5, 31.5, 47.5, 63.5, 79.5] + text_coords = [4, 20, 36, 52, 68, 84] + + fig = plt.figure() + ax = plt.subplot(111) + ax.bar(mutations, mutationCounts, color = colours) + #ax.add_patch(plt.Rectangle((80, rect_lower), 15, rect_width, clip_on = False)) + for i, rect in enumerate(rect_coords): + ax.add_patch(plt.Rectangle((rect, rect_lower), 16, rect_width, facecolor = colourSet[i])) + ax.text(text_coords[i], (rect_lower + (rect_width/3)), mutation_types[i], color = ""white"", fontweight = ""bold"") + ax.spines[""top""].set_visible(False) + ax.spines[""right""].set_visible(False) + ax.set_xticks(range(len(mutations))) + ax.set_xticklabels([""""] * len(mutations)) + plt.xlabel(""Mutation"") + plt.ylabel(""Difference in mutation proportion"") + plt.margins(0) + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots a comparison between 2 RNA SBS spectra +def plotRNASpectrumComparison(spectrum, outFile): + #The 192 RNA mutations as a list, used so they are always in the same order + mutations = [""A[C>A]A"",""A[C>A]C"",""A[C>A]G"",""A[C>A]T"",""C[C>A]A"",""C[C>A]C"",""C[C>A]G"",""C[C>A]T"",""G[C>A]A"",""G[C>A]C"",""G[C>A]G"",""G[C>A]T"",""T[C>A]A"",""T[C>A]C"",""T[C>A]G"",""T[C>A]T"",""A[C>G]A"",""A[C>G]C"",""A[C>G]G"",""A[C>G]T"",""C[C>G]A"",""C[C>G]C"",""C[C>G]G"",""C[C>G]T"",""G[C>G]A"",""G[C>G]C"",""G[C>G]G"",""G[C>G]T"",""T[C>G]A"",""T[C>G]C"",""T[C>G]G"",""T[C>G]T"",""A[C>T]A"",""A[C>T]C"",""A[C>T]G"",""A[C>T]T"",""C[C>T]A"",""C[C>T]C"",""C[C>T]G"",""C[C>T]T"",""G[C>T]A"",""G[C>T]C"",""G[C>T]G"",""G[C>T]T"",""T[C>T]A"",""T[C>T]C"",""T[C>T]G"",""T[C>T]T"",""A[T>A]A"",""A[T>A]C"",""A[T>A]G"",""A[T>A]T"",""C[T>A]A"",""C[T>A]C"",""C[T>A]G"",""C[T>A]T"",""G[T>A]A"",""G[T>A]C"",""G[T>A]G"",""G[T>A]T"",""T[T>A]A"",""T[T>A]C"",""T[T>A]G"",""T[T>A]T"",""A[T>C]A"",""A[T>C]C"",""A[T>C]G"",""A[T>C]T"",""C[T>C]A"",""C[T>C]C"",""C[T>C]G"",""C[T>C]T"",""G[T>C]A"",""G[T>C]C"",""G[T>C]G"",""G[T>C]T"",""T[T>C]A"",""T[T>C]C"",""T[T>C]G"",""T[T>C]T"",""A[T>G]A"",""A[T>G]C"",""A[T>G]G"",""A[T>G]T"",""C[T>G]A"",""C[T>G]C"",""C[T>G]G"",""C[T>G]T"",""G[T>G]A"",""G[T>G]C"",""G[T>G]G"",""G[T>G]T"",""T[T>G]A"",""T[T>G]C"",""T[T>G]G"",""T[T>G]T"",""A[G>T]A"",""A[G>T]C"",""A[G>T]G"",""A[G>T]T"",""C[G>T]A"",""C[G>T]C"",""C[G>T]G"",""C[G>T]T"",""G[G>T]A"",""G[G>T]C"",""G[G>T]G"",""G[G>T]T"",""T[G>T]A"",""T[G>T]C"",""T[G>T]G"",""T[G>T]T"",""A[G>C]A"",""A[G>C]C"",""A[G>C]G"",""A[G>C]T"",""C[G>C]A"",""C[G>C]C"",""C[G>C]G"",""C[G>C]T"",""G[G>C]A"",""G[G>C]C"",""G[G>C]G"",""G[G>C]T"",""T[G>C]A"",""T[G>C]C"",""T[G>C]G"",""T[G>C]T"",""A[G>A]A"",""A[G>A]C"",""A[G>A]G"",""A[G>A]T"",""C[G>A]A"",""C[G>A]C"",""C[G>A]G"",""C[G>A]T"",""G[G>A]A"",""G[G>A]C"",""G[G>A]G"",""G[G>A]T"",""T[G>A]A"",""T[G>A]C"",""T[G>A]G"",""T[G>A]T"",""A[A>T]A"",""A[A>T]C"",""A[A>T]G"",""A[A>T]T"",""C[A>T]A"",""C[A>T]C"",""C[A>T]G"",""C[A>T]T"",""G[A>T]A"",""G[A>T]C"",""G[A>T]G"",""G[A>T]T"",""T[A>T]A"",""T[A>T]C"",""T[A>T]G"",""T[A>T]T"",""A[A>G]A"",""A[A>G]C"",""A[A>G]G"",""A[A>G]T"",""C[A>G]A"",""C[A>G]C"",""C[A>G]G"",""C[A>G]T"",""G[A>G]A"",""G[A>G]C"",""G[A>G]G"",""G[A>G]T"",""T[A>G]A"",""T[A>G]C"",""T[A>G]G"",""T[A>G]T"",""A[A>C]A"",""A[A>C]C"",""A[A>C]G"",""A[A>C]T"",""C[A>C]A"",""C[A>C]C"",""C[A>C]G"",""C[A>C]T"",""G[A>C]A"",""G[A>C]C"",""G[A>C]G"",""G[A>C]T"",""T[A>C]A"",""T[A>C]C"",""T[A>C]G"",""T[A>C]T""] + + #Will be filled with the mutation counts + mutationCounts = [] + + #Iterate through the mutations and add their count to mutationCounts + for mutation in mutations: + mutationCounts.append(spectrum[mutation]) + + #Colours of the bars + colourSet = [""blue"", ""black"", ""red"", ""grey"", ""green"", ""pink"", ""royalblue"", ""dimgrey"", ""coral"", ""silver"", ""darkgreen"", ""purple""] + colours = [i for i in colourSet for j in range(16)] + + #Used to plot the rectangles above the plot containing the mutation type + rect_lower = float(np.max(mutationCounts)) + float(np.max(mutationCounts) * 0.05) + rect_width = float(np.max(mutationCounts)) * 0.4 + + #Coordinates of the mutation type rectangles and text + mutation_types = [""C>A"", ""C>G"", ""C>T"", ""T>A"", ""T>C"", ""T>G"", ""G>T"", ""G>C"", ""G>A"", ""A>T"", ""A>G"", ""A>C""] + rect_coords = [-0.5, 15.5, 31.5, 47.5, 63.5, 79.5, 95.5, 111.5, 127.5, 143.5, 159.5, 175.5] + text_coords = [1, 17, 33, 49, 65, 81, 97, 113, 129, 145, 161, 177] + + fig = plt.figure() + ax = plt.subplot(111) + ax.bar(mutations, mutationCounts, color = colours) + + for i, rect in enumerate(rect_coords): + ax.add_patch(plt.Rectangle((rect, rect_lower), 16, rect_width, facecolor = colourSet[i])) + ax.text(text_coords[i], (rect_lower + (rect_width/3)), mutation_types[i], color = ""white"", fontweight = ""bold"") + ax.spines[""top""].set_visible(False) + ax.spines[""right""].set_visible(False) + ax.set_xticks(range(len(mutations))) + ax.set_xticklabels([""""] * len(mutations)) + plt.xlabel(""Mutation"") + plt.ylabel(""Difference in mutation proportion"") + plt.margins(0) + if type(outFile) == str: + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + +#Plots a comparison of the proportions of each mutation in 2 spectra +#x-axis is the proportion of the mutation in sample 1, y-axis is the proportion of the mutation in sample 2 +#Takes 2 spectra to be compared and the output PDF to save to +#The input spectra should have already been converted to proportions +def plotSpectrumPointComparison(spectrum1, spectrum2, outFile): + #The 96 DNA mutations as a list, used so they are always in the same order + mutations = [""A[C>A]A"",""A[C>A]C"",""A[C>A]G"",""A[C>A]T"",""C[C>A]A"",""C[C>A]C"",""C[C>A]G"",""C[C>A]T"",""G[C>A]A"",""G[C>A]C"",""G[C>A]G"",""G[C>A]T"",""T[C>A]A"",""T[C>A]C"",""T[C>A]G"",""T[C>A]T"",""A[C>G]A"",""A[C>G]C"",""A[C>G]G"",""A[C>G]T"",""C[C>G]A"",""C[C>G]C"",""C[C>G]G"",""C[C>G]T"",""G[C>G]A"",""G[C>G]C"",""G[C>G]G"",""G[C>G]T"",""T[C>G]A"",""T[C>G]C"",""T[C>G]G"",""T[C>G]T"",""A[C>T]A"",""A[C>T]C"",""A[C>T]G"",""A[C>T]T"",""C[C>T]A"",""C[C>T]C"",""C[C>T]G"",""C[C>T]T"",""G[C>T]A"",""G[C>T]C"",""G[C>T]G"",""G[C>T]T"",""T[C>T]A"",""T[C>T]C"",""T[C>T]G"",""T[C>T]T"",""A[T>A]A"",""A[T>A]C"",""A[T>A]G"",""A[T>A]T"",""C[T>A]A"",""C[T>A]C"",""C[T>A]G"",""C[T>A]T"",""G[T>A]A"",""G[T>A]C"",""G[T>A]G"",""G[T>A]T"",""T[T>A]A"",""T[T>A]C"",""T[T>A]G"",""T[T>A]T"",""A[T>C]A"",""A[T>C]C"",""A[T>C]G"",""A[T>C]T"",""C[T>C]A"",""C[T>C]C"",""C[T>C]G"",""C[T>C]T"",""G[T>C]A"",""G[T>C]C"",""G[T>C]G"",""G[T>C]T"",""T[T>C]A"",""T[T>C]C"",""T[T>C]G"",""T[T>C]T"",""A[T>G]A"",""A[T>G]C"",""A[T>G]G"",""A[T>G]T"",""C[T>G]A"",""C[T>G]C"",""C[T>G]G"",""C[T>G]T"",""G[T>G]A"",""G[T>G]C"",""G[T>G]G"",""G[T>G]T"",""T[T>G]A"",""T[T>G]C"",""T[T>G]G"",""T[T>G]T""] + + #Colours of the points + colourSet = [""blue"", ""black"", ""red"", ""grey"", ""green"", ""pink""] + colours = [i for i in colourSet for j in range(16)] + + #The mutation proportions in spectrum 1 + mutation1 = [] + #The mutation proportions in spectrum 2 + mutation2 = [] + + for mutation in mutations: + mutation1.append(spectrum1[mutation]) + mutation2.append(spectrum2[mutation]) + + fig = plt.figure() + ax = plt.subplot(111) + scatter = ax.scatter(mutation1, mutation2, color = colours, s = 8) + plt.xlabel(""Mutation proportion in sample 1"") + plt.ylabel(""Mutation proportion in sample 2"") + plt.margins(0) + + #Calculate plot limits and plot x=y line across the plot + lims = [0, np.max([ax.get_xlim(), ax.get_ylim()])] + ax.plot(lims, lims, color = ""black"", alpha = 0.75, linestyle = ""--"") + ax.set_xlim(lims) + ax.set_ylim(lims) + + #Add legend + mutation_legend = [Line2D([0], [0], color = ""blue"", lw = 2), + Line2D([0], [0], color = ""black"", lw = 2), + Line2D([0], [0], color = ""red"", lw = 2), + Line2D([0], [0], color = ""grey"", lw = 2), + Line2D([0], [0], color = ""green"", lw = 2), + Line2D([0], [0], color = ""pink"", lw = 2)] + ax.legend(mutation_legend, [""C>A"", ""C>G"", ""C>T"", ""T>A"", ""T>C"", ""T>G""], bbox_to_anchor = (0.8, 1.15), ncol = 3) + + #ax.legend(, loc = ""upper right"") + + #plt.legend(bbox_to_anchor = (1.05, 1)) + + if type(outFile == str): + plt.savefig(outFile) + else: + plt.savefig(outFile.name) + + +def plot_spectrum_parser(parser): + + parser.description = ""Plot a mutational spectrum"" + + parser.add_argument(""-s"", + ""--spectrum"", + dest = ""spectrum_file"", + required = True, + help = ""csv file containing spectrum from MutTui"", + type = argparse.FileType(""r"")) + parser.add_argument(""-o"", + ""--outFile"", + dest = ""outFile"", + required = True, + help = ""Output PDF file to which spectrum will be written"") + parser.add_argument(""--proportions"", + dest = ""proportions"", + help = ""Specify if the spectrum to be plotted is proportions rather than numbers of mutations, "" + + ""e.g. if plotting SigProfilerExtractor signatures"", + action = ""store_true"", + default = False) + parser.add_argument(""--types"", + dest = ""types"", + help = ""Specify to plot mutation types spectrum. Plotting a single base substitution "" + + ""spectrum is default"", + action = ""store_true"", + default = False) + parser.add_argument(""--double"", + dest = ""double"", + help = ""Specify to plot a double substitution spectrum. Plotting a single base substitution "" + + ""spectrum is default"", + action = ""store_true"", + default = False) + parser.add_argument(""--strand_bias"", + dest = ""sb"", + help = ""Specify to plot a strand bias spectrum (SBS spectrum split into transcribed and untranscribed strands). "" + + ""Plotting a single base substitution spectrum is default"", + action = ""store_true"", + default = False) + parser.add_argument(""--rna"", + dest = ""rna"", + help = ""Specify if using an RNA pathogen, will plot an RNA mutational spectrum"", + action = ""store_true"", + default = False) + parser.add_argument(""--plot_proportion"", + dest = ""plot_proportion"", + help = ""Specify to plot the spectrum as proportion of mutations rather than number of mutations"", + action = ""store_true"", + default = False) + + parser.set_defaults(func = plot_spectrum) + + return(parser) + +def plot_spectrum(args): + + #Extract the spectrum to a dictionary with mutations as keys and counts or proportions as values + if args.sb: + spectrum = convertSB(args.spectrum_file) + else: + if args.proportions: + spectrum = convertSpectrumDictProportions(args.spectrum_file) + else: + spectrum = convertSpectrumDict(args.spectrum_file) + + if args.types and not args.rna: + plotMutationType(spectrum, args.outFile) + elif args.types and args.rna: + plotRNAMT(spectrum, args.outFile) + elif args.double and not args.rna: + plotDouble(spectrum, args.plot_proportion, args.outFile) + elif args.double and args.rna: + plotRNADouble(spectrum, args.plot_proportion, args.outFile) + elif args.sb: + plotSB(spectrum, args.plot_proportion, args.outFile) + elif args.rna: + plotRNA(spectrum, args.plot_proportion, args.outFile) + else: + plotSpectrumFromDict(spectrum, args.plot_proportion, args.outFile) + + return + + + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = plot_spectrum_parser(parser) + args = parser.parse_args() + + # run plot_spectrum + args.func(args) + + return + +if __name__ == ""__main__"": + main() +","Python" +"Viral","chrisruis/MutTui","MutTui/branch_labelling.py",".py","7477","189","#Functions for labelling branches into spectrum categories + +import operator +from Bio import Phylo + +#Converts taxon labels to a dictionary with labels as keys and taxa as values +def getLabelDict(tree, labels): + #Import the labels + taxonLabels = open(labels).readlines() + + #Labels and keys, taxa as values + labelDict = {} + + #Taxa that have a label, others will be assigned a label of OTHER + analysedTaxa = [] + + #Iterate through the taxa and add to labelDict + for taxon in taxonLabels[1:]: + if taxon.strip().split("","")[1] in labelDict: + labelDict[taxon.strip().split("","")[1]].append(taxon.strip().split("","")[0]) + else: + labelDict[taxon.strip().split("","")[1]] = [taxon.strip().split("","")[0]] + analysedTaxa.append(taxon.strip().split("","")[0]) + + #Check if OTHER has been used as a label, if it has use another OTHER label + if ""OTHER"" in labelDict: + otherLabel = ""OTHER_A"" + print(""OTHER has been used as a label, using OTHER_A as the label for taxa not included in the label file"") + else: + otherLabel = ""OTHER"" + + labelDict[otherLabel] = [] + + #Iterate through the taxa and add to labelDict if not already included + for eachTaxon in tree.get_terminals(): + if eachTaxon.name not in analysedTaxa: + labelDict[otherLabel].append(eachTaxon.name) + + return(labelDict) + +#Adds the same label to all branches, used when there are no taxon labels provided +def labelAllBranches(tree): + #Will contain the labels in the tree + treeLabels = [""A""] + + #Iterate through the branches and add the label A to them + for clade in tree.find_clades(): + clade.clade_label = ""A"" + + return(tree, treeLabels) + +#Labels branches in a given tree with names as in treetime +#Branches are labelled from NODE_0000000 onwards +def labelBranchesTreetime(tree): + #Appended with each internal node + iterator = 0 + + for clade in tree.find_clades(): + if not clade.is_terminal(): + #Check if the clade already has a name in the input tree, if it does then keep that name + #If it doesn't, name it with its node number in the tree + #Therefore if the tree is partially labelled, nodes with labels will keep their label while + #nodes without labels will be given a node label. This is how treetime deals with partially labelled + #trees so will enable matching of branch names with the branch_mutations.txt file + if not clade.name: + clade.name = ""NODE_"" + str(iterator).zfill(7) + iterator += 1 + + return(tree) + +#Writes the label dictionary to a file that can be used by treetime mugration +def writeLabels(labelDict, out_dir): + labelFile = open(out_dir + ""all_taxon_labels.csv"", ""w"") + labelFile.write(""name,group\n"") + for eachLabel in labelDict: + for sequence in labelDict[eachLabel]: + labelFile.write(sequence + "","" + eachLabel + ""\n"") + labelFile.close() + +#Identifies the root state from a treetime mugration file +def rootState(tree, confidence, gtr, root_state): + if root_state: + rState = root_state + + #Identify the root state from confidence + else: + #Identify the characters that correspond to each label + attributes = {} + for eachLine in gtr: + if eachLine == ""\n"": + break + elif eachLine.strip() != ""Character to attribute mapping:"": + attributes[eachLine.strip().split("": "")[0]] = eachLine.strip().split("": "")[1] + + #States and probabilites at the root + prob = {} + #Identify the most likely root state from confidence + for line in confidence: + if line.strip().split("","")[0] == ""NODE_0000000"": + for i in range(1, len(line.strip().split("",""))): + prob[confidence[0].strip().split("","")[i]] = float(line.strip().split("","")[i]) + + #State at the root + rState = attributes[(max(prob.items(), key = operator.itemgetter(1))[0]).strip()] + + #Add the label to the root + for clade in tree.find_clades(): + #Check if the clade is the root + if len(tree.get_path(clade)) == 0: + clade.comment = '[&group=""' + rState + '""]' + + return(tree) + +#Transfers labels from a tree labelled with label_tree.py to the treetime reconstruction tree +def getLabelledTreeLabels(tree, treeFile): + nodeTree = Phylo.read(treeFile.name, ""newick"") + + #Will be incremented with each node + nodeIterator = 1 + + #Extract nodeTree to a dictionary with nodes as keys and labels and tips as values + #Will use this to transfer labels from nodeTree to the main tree by matching the descendent tips + #Cannot use the same labels as treetime often iterates through the branches in a different order + nodeTips = {} + + #Iterate through the clades in nodeTree and add to nodeTips + for clade in nodeTree.find_clades(): + if clade.is_terminal(): + nodeTips[""Node"" + str(nodeIterator)] = [clade.name.split(""____"")[1], [clade.name.split(""____"")[0]]] + else: + nodeTips[""Node"" + str(nodeIterator)] = [clade.name, []] + #Add the tips in the clade to the empty list + for tip in clade.get_terminals(): + nodeTips[""Node"" + str(nodeIterator)][1].append(tip.name.split(""____"")[0]) + nodeIterator += 1 + + #Will be filled with the unique labels from the tree + treeLabels = [] + + #Iterate through the clades, identify the corresponding clade in nodeTree from the descendent tips + #add the label as clade_label and add unique labels to treeLabels + for clade in tree.find_clades(): + cladeTips = [] + for tip in clade.get_terminals(): + cladeTips.append(tip.name) + + #Identify the corresponding clade in nodeTree + for eachClade in nodeTips: + if sorted(nodeTips[eachClade][1]) == sorted(cladeTips): + clade.clade_label = nodeTips[eachClade][0] + if nodeTips[eachClade][0] not in treeLabels: + treeLabels.append(nodeTips[eachClade][0]) + break + + return(tree, treeLabels) + +#Label all branches in the tree with their branch name +def labelBranchesNames(tree): + #Will contain the labels in the tree + treeLabels = [] + + #Iterate through the branches and add the label A to them + for clade in tree.find_clades(): + clade.clade_label = clade.name + + return(tree, treeLabels) + +#Iterates through the tree and labels each branch with its category +#Branches with the same category will be placed in the same spectrum, there will be one spectrum per category +def labelBranchesMugration(tree, mugrationTree): + #Extract the mugration tree to a dictionary with clade names as keys and labels as values + cladeDict = {} + for clade in mugrationTree.find_clades(): + if clade.name: + cladeDict[clade.name] = clade.comment.split('=""')[1].split('""')[0] + else: + cladeDict[clade.confidence] = clade.comment.split('=""')[1].split('""')[0] + + #The labels in the tree + treeLabels = list(set(cladeDict.values())) + + #Iterate through the clades in the mutation tree and add their label + for clade in tree.find_clades(): + if clade.name: + clade.clade_label = cladeDict[clade.name] + else: + clade.clade_label = cladeDict[clade.confidence] + + return(tree, treeLabels)","Python" +"Viral","chrisruis/MutTui","MutTui/run_summary.py",".py","1848","54","#Produces summaries of a MutTui run +#Run in the same directory as the MutTui output files +#Doesn't require any arguments as the all_included_mutations.csv and SBS spectra are identified automatically + +from os.path import exists +from os import listdir + +#Summarise all_included_mutations.csv +if exists(""all_included_mutations.csv""): + nm = 0 + mutations = dict() + with open(""all_included_mutations.csv"") as f: + next(f) + for l in f: + nm += 1 + + if l.strip().split("","")[0] not in mutations: + mutations[l.strip().split("","")[0]] = [l.strip().split("","")[1], 1] + else: + mutations[l.strip().split("","")[0]][1] += 1 + + print(""Total mutations in run:"", nm) + + out = open(""all_mutation_counts.csv"", ""w"") + out.write(""Mutation_in_alignment,Mutation_in_genome,Number_of_mutations\n"") + + for m in mutations: + out.write(m + "","" + mutations[m][0] + "","" + str(mutations[m][1]) + ""\n"") + + out.close() +else: + raise RuntimeError(""all_included_mutations.csv file not present. This script should be run from the directory containing MutTui output files"") + +#Summarise SBS spectra +nf = 0 +labelM = dict() +for f in listdir("".""): + if (""mutational_spectrum_"" in f) and ("".csv"" in f) and (""_rescaled.csv"" not in f): + nf += 1 + label = f.replace(""mutational_spectrum_label_"", """").replace("".csv"", """") + labelM[label] = 0 + + with open(f) as fn: + next(fn) + for l in fn: + labelM[label] += int(l.strip().split("","")[1]) + +if nf == 0: + raise RuntimeError(""No SBS spectra found. This script should be run from the directory containing MutTui output files"") +else: + print(""Number of analysed labels:"", nf) + print(""Number of mutations per label:"") + for eL in labelM: + print(eL + "":"" + str(labelM[eL]))","Python" +"Viral","chrisruis/MutTui","MutTui/spectrum_confidence_interval.py",".py","2151","61","#Calculates confidence intervals for all mutations in a spectrum using Wilson score interval +#Can run on SBS, DBS or mutation type spectra + +import argparse +from math import sqrt +from plot_spectrum import convertSpectrumDictProportions + +#Calculates Wilson score interval for a mutation proportion +def wilsonSI(p, n): + z = 1.96 + + if (p == 0) or (n == 0): + return(0, 0) + + denominator = 1 + z**2/n + centre_adjusted_probability = p + z*z / (2*n) + adjusted_standard_deviation = sqrt((p*(1 - p) + z*z / (4*n)) / n) + lower_bound = (centre_adjusted_probability - z*adjusted_standard_deviation) / denominator + upper_bound = (centre_adjusted_probability + z*adjusted_standard_deviation) / denominator + + return(lower_bound, upper_bound) + +if __name__ == ""__main__"": + description = ""Calculates confidence intervals for all mutations in a SBS, DBS or mutation type spectrum"" + parser = argparse.ArgumentParser(description = description) + + parser.add_argument(""-s"", + ""--spectrum"", + dest = ""spectrum"", + required = True, + help = ""Mutational spectrum, can be SBS, DBS or mutation type"", + type = argparse.FileType(""r"")) + parser.add_argument(""-o"", + ""--outfile"", + dest = ""outFile"", + required = True, + help = ""Name of output csv file containing mutation proportions and confidence intervals"") + + args = parser.parse_args() + + #Import the spectrum and convert to a dictionary + spectrum = convertSpectrumDictProportions(args.spectrum) + + #Sum mutations + tm = sum(spectrum.values()) + + #Convert spectum to proportions + sP = dict() + for m in spectrum: + sP[m] = spectrum[m]/tm + + out = open(args.outFile, ""w"") + out.write(""Substitution,Proportion_of_mutations,CI_lower,CI_upper\n"") + + #Calculate CI of each mutation and write + for eM in sP: + mci = wilsonSI(sP[eM], tm) + + out.write(eM + "","" + str(sP[eM]) + "","" + str(mci[0]) + "","" + str(mci[1]) + ""\n"") + + out.close()","Python" +"Viral","chrisruis/MutTui","MutTui/post_process_branch_mutations.py",".py","13790","285","#Splits the mutations in an all_included_mutations.csv file from MutTui into branch groups +#Branch groups are defined with a branch labelling csv file with 2 columns, first column is the +#branch names as they appear in the tree, second column is the label of the branch + +import argparse +import pandas as pd +import os +from Bio import SeqIO, Phylo +import array +from isvalid import * +from reconstruct_spectrum import * +from plot_spectrum import * +from branch_labelling import labelBranchesTreetime + +#Extracts the labels to a dictionary +def getLabels(labelsFile): + labels = dict() + + with open(labelsFile.name) as f: + for l in f: + labels[l.strip().split("","")[0]] = l.strip().split("","")[1] + + return(labels) + +#Post-processes mutations into branch groups +def postProcessMutations(mutationsFile, labelsFile, rna, outdir): + #Import branch labels and extract to dictionary + labels = getLabels(labelsFile) + + #Generate an empty spectrum and mutation dictionary for each label + spectraDict = dict() + allMDict = dict() + for label in set(labels.values()): + if not rna: + spectraDict[label] = getMutationDict() + else: + spectraDict[label] = getRNADict() + allMDict[label] = list() + + #Iterate through the mutations and add to the respective spectrum + mutations = pd.read_csv(mutationsFile.name) + for i in range(mutations.shape[0]): + branch = mutations[""Branch""][i] + if branch in labels: + bL = labels[branch] + spectraDict[bL][mutations[""Substitution""][i].replace(""["", """").replace("">"", """").replace(""]"", """")] += 1 + allMDict[bL].append([mutations[""Mutation_in_alignment""][i], mutations[""Mutation_in_genome""][i], mutations[""Substitution""][i], mutations[""Branch""][i]]) + + #Write and plot the spectra + for eachLabel in spectraDict: + outFile = open(outdir + ""mutational_spectrum_label_"" + eachLabel + "".csv"", ""w"") + outFile.write(""Substitution,Number_of_mutations\n"") + for eachMutation in spectraDict[eachLabel]: + outFile.write(eachMutation[0] + ""["" + eachMutation[1] + "">"" + eachMutation[2] + ""]"" + eachMutation[3] + "","" + str(spectraDict[eachLabel][eachMutation]) + ""\n"") + outFile.close() + + #Plot the spectrum + outSpectrum = open(outdir + ""mutational_spectrum_label_"" + eachLabel + "".pdf"", ""w"") + spectrumFormat = convertSpectrumFormat(spectraDict[eachLabel]) + if not rna: + plotSpectrumFromDict(spectrumFormat, False, outSpectrum) + else: + plotRNA(spectrumFormat, False, outSpectrum) + outSpectrum.close() + + #Write the mutations in each label + outMutation = open(outdir + ""all_included_mutations_label_"" + eachLabel + "".csv"", ""w"") + outMutation.write(""Mutation_in_alignment,Mutation_in_genome,Substitution,Branch\n"") + for eM in allMDict[eachLabel]: + outMutation.write("","".join(eM) + ""\n"") + outMutation.close() + +#Filters mutations with fewer than a given number of occurrences and within a given region of the genome +def filterMutations(mutationsFile, nm, genome_pos, align_pos, rna, outdir): + #Set max and min genome and alignment positions + if not genome_pos: + g_pos = [1, 100000000] + else: + g_pos = [int(genome_pos[0]), int(genome_pos[1])] + if not align_pos: + a_pos = [1, 100000000] + else: + a_pos = [int(align_pos[0]), int(align_pos[1])] + + #Max mutations to keep + mMut = int(nm) + + #Count occurrences of each mutation + mutations = dict() + with open(mutationsFile.name) as f: + next(f) + for l in f: + #Extract genome and alignment positions + g = int(l.strip().split("","")[1][1:-1]) + a = int(l.strip().split("","")[0][1:-1]) + + #Count mutations within required genome and alignment regions + if (g >= g_pos[0]) and (g <= g_pos[1]) and (a >= a_pos[0]) and (a <= a_pos[1]): + mut = l.strip().split("","")[0] + if mut not in mutations: + mutations[mut] = 0 + mutations[mut] += 1 + + #Empty spectrum + if rna: + spectrum = getRNADict() + else: + spectrum = getMutationDict() + + #Filter mutations + with open(mutationsFile.name) as f: + next(f) + for l in f: + if l.strip().split("","")[0] in mutations: + if mutations[l.strip().split("","")[0]] <= mMut: + substitution = l.strip().split("","")[2] + spectrum[substitution[0] + substitution[2] + substitution[4] + substitution[6]] += 1 + + #Write spectrum + outFile = open(outdir + ""mutational_spectrum_filtered.csv"", ""w"") + outFile.write(""Substitution,Number_of_mutations\n"") + for eachMutation in spectrum: + outFile.write(eachMutation[0] + ""["" + eachMutation[1] + "">"" + eachMutation[2] + ""]"" + eachMutation[3] + "","" + str(spectrum[eachMutation]) + ""\n"") + outFile.close() + + #Plot spectrum + outSpectrum = open(outdir + ""mutational_spectrum_filtered.pdf"", ""w"") + spectrumFormat = convertSpectrumFormat(spectrum) + if not rna: + plotSpectrumFromDict(spectrumFormat, False, outSpectrum) + else: + plotRNA(spectrumFormat, False, outSpectrum) + outSpectrum.close() + +#Counts the number of each mutation in MutTui output and determines whether each is synonymous or nonsynonymous +def countMutations(mutationsFile, alignment, tree, outdir): + #Import to branches as keys and mutations as values + bD = dict() + with open(mutationsFile.name) as f: + next(f) + for l in f: + nN = l.strip().split("","")[-1] + if nN not in bD: + bD[nN] = list() + bD[nN].append(l.strip().split("","")[0]) + + #Import alignment and extract to dictionary with node names as keys and sequences as IDs + sDict = dict() + for r in SeqIO.parse(alignment, ""fasta""): + sDict[r.id] = array.array(""u"", r.seq) + + #Import the tree + t = Phylo.read(tree, ""newick"") + #Label the tree as in MutTui + t.ladderize() + t = labelBranchesTreetime(t) + + #Mutations as keys, counts as values + mDict = dict() + + #Iterate through the tree, add the mutations on each branch to the parental sequence, identify whether mutations are synonymous or nonsynonymous + #and add to mutation dictionary + for b in t.find_clades(): + #Check if the branch has mutations + if b.name in bD: + #Get sequence of parental node + s = sDict[getParentName(t, b)] + #Original sequence + oS = Seq("""".join(s)).translate() + + #Add mutations into sequence + for eM in bD[b.name]: + s[int(eM[1:-1]) - 1] = eM[-1] + + #Translate sequence + sT = Seq("""".join(s)).translate() + + #Iterate through mutations again, identify if they are synonymous + for eM in bD[b.name]: + #Get amino acid position of the mutation + aaPosition = (int(int(eM[1:-1])/3) + (int(eM[1:-1]) % 3 > 0)) - 1 + #Check if the amino acid position differs between the parental and mutated sequences + if oS[aaPosition] != sT[aaPosition]: + mName = eM + ""_nonsynonymous_"" + oS[aaPosition] + str(aaPosition + 1) + sT[aaPosition] + else: + mName = eM + ""_synonymous_"" + oS[aaPosition] + str(aaPosition + 1) + sT[aaPosition] + if mName not in mDict: + mDict[mName] = 0 + mDict[mName] += 1 + + #Write the mutation counts + out = open(outdir + ""mutation_counts.csv"", ""w"") + out.write(""Substitution,Substitution_position,Mutation_type,Effect,Amino_acid_position,Amino_acid_substitution,Number_of_mutations\n"") + for eM in mDict: + out.write(eM.split(""_"")[0] + "","" + eM.split(""_"")[0][1:-1] + "","" + eM[0] + "">"" + eM.split(""_"")[0][-1] + "","" + eM.split(""_"")[1] + "","" + eM.split(""_"")[2][1:-1] + "","" + eM.split(""_"")[2] + "","" + str(mDict[eM]) + ""\n"") + out.close() + +if __name__ == ""__main__"": + description = ""Post-processes output mutations from MutTui. Mutations can be filtered to keep those in particular regions of the genome or input alignment, or to keep mutations that occur a maximum number of times, using --filter. To count the number of occurrences of each mutation, use --count_mutations. If neither --filter or --count_mutations is specified, a labelling file is expected with -l to extract the spectrum of a subset of phylogenetic branches"" + parser = argparse.ArgumentParser(description = description) + + parser.add_argument(""-m"", + ""--mutations"", + dest = ""mutations"", + help = ""all_included_mutations.csv file from MutTui"", + type = argparse.FileType(""r"")) + parser.add_argument(""-f"", + ""--alignment"", + dest = ""align"", + help = ""ancestral_sequences.fasta file from MutTui, only used if --count_mutations is specified"", + type = argparse.FileType(""r"")) + parser.add_argument(""-t"", + ""--tree"", + dest = ""tree"", + help = ""Unlabelled newick tree that was used to run MutTui, only used if --count_mutations is specified"", + type = argparse.FileType(""r"")) + parser.add_argument(""-l"", + ""--labels"", + dest = ""labels"", + help = ""csv file used to split mutations into categories. This should have 2 columns: column 1 "" + + ""is the branch name as it appears in all_included_mutations.csv and column 2 is its label. This file should not "" + + ""have a header"", + type = argparse.FileType(""r"")) + parser.add_argument(""--rna"", + dest = ""rna"", + help = ""Specify if using an RNA pathogen"", + action = ""store_true"", + default = False) + parser.add_argument(""--filter"", + dest = ""filter"", + help = ""Specify to filter mutations based on their number of occurrences. If specified, use -n "" + + ""to specify the maximum number of occurrences to keep a mutation"", + action = ""store_true"", + default = False) + parser.add_argument(""--count_mutations"", + dest = ""count_mutations"", + help = ""Specify to write the number of occurrences of each mutation"", + action = ""store_true"", + default = False) + parser.add_argument(""-n"", + ""--number_mutations"", + dest = ""number_mutations"", + help = ""The maximum number of occurrences to keep a mutation. Mutation inferred to occur on more occasions than this "" + + ""will be filtered out. Default 1000000 to not exclude mutations by occurrences. Only used when --filter is specified"", + default = ""1000000"") + parser.add_argument(""-g"", + ""--genome_positions"", + dest = ""genome_positions"", + help = ""The first and last positions in the genome to be included when filtering. Mutations outside of these genome "" + + ""positions will be excluded. Defaults set 1 and 100,000,000 to include all positions. Only used when --filter is specified"", + nargs = 2, + default = None) + parser.add_argument(""-a"", + ""--align_positions"", + dest = ""align_positions"", + help = ""The first and last positions in the alignment to be included when filtering. Mutations outside of these alignment "" + + ""positions will be excluded. Defaults set 1 and 100,000,000 to include all positions. Only used when --filter is specified"", + nargs = 2, + default = None) + parser.add_argument(""-o"", + ""--out_dir"", + dest = ""output_dir"", + help = ""Location of output directory, should already be created and ideally be empty"", + type = lambda x: is_valid_folder(parser, x)) + args = parser.parse_args() + + #Make sure trailing forward slash is present in output directory + args.output_dir = os.path.join(args.output_dir, """") + + #Filter the mutations + if args.filter: + print(""Filtering mutations"") + filterMutations(args.mutations, args.number_mutations, args.genome_positions, args.align_positions, args.rna, args.output_dir) + #Count the mutations and their effects, only available for RNA spectra currently + elif args.count_mutations: + if (not args.align) or (not args.tree): + raise RuntimeError(""ancestral_sequences.fasta must be specified with -f and the original tree provided to MutTui must be specified with -t when --count_mutations is specified"") + print(""Counting mutations"") + countMutations(args.mutations, args.align, args.tree, args.output_dir) + #Post-process the spectrum into groups + else: + print(""Calculating spectrum of a subset of branches"") + if not args.labels: + raise RuntimeError(""A file containing branches to be extracted needs to be supplied when splitting the spectrum by branches"") + postProcessMutations(args.mutations, args.labels, args.rna, args.output_dir)","Python" +"Viral","chrisruis/MutTui","MutTui/reverse_spectrum.py",".py","1484","40","#Reverses an RNA spectrum +#Can be used to generate a genomic strand spectrum from sequences stored as cRNA + +import argparse +from reconstruct_spectrum import getRNADict, complement + +if __name__ == ""__main__"": + description = ""Reverses an RNA mutational spectrum"" + parser = argparse.ArgumentParser(description = description) + + parser.add_argument(""-s"", + ""--spectrum"", + dest = ""spectrum"", + required = True, + help = ""Mutational spectrum to be reversed"", + type = argparse.FileType(""r"")) + parser.add_argument(""-o"", + ""--outfile"", + dest = ""outFile"", + required = True, + help = ""Output csv to which the reversed spectrum will be written"") + + args = parser.parse_args() + + #Generate empty spectrum to be filled + s = getRNADict() + + #Iterate through the spectrum, reverse each mutation and add to s + with open(args.spectrum.name) as f: + next(f) + for l in f: + m = l.strip().split("","")[0] + s[complement(m[6]) + complement(m[2]) + complement(m[4]) + complement(m[0])] = l.strip().split("","")[1] + + #Write the spectrum + out = open(args.outFile, ""w"") + out.write(""Substitution,Number_of_mutations\n"") + for eM in s: + out.write(eM[0] + ""["" + eM[1] + "">"" + eM[2] + ""]"" + eM[3] + "","" + s[eM] + ""\n"") + out.close()","Python" +"Viral","chrisruis/MutTui","MutTui/treetime.py",".py","2268","59","#Runs treetime ancestral reconstruction on an alignment and tree + +import os +import subprocess +from Bio import AlignIO + +#Runs treetime ancestral reconstruction +def run_treetime(alignment, tree, output_dir, add_treetime_cmds): + cmd = ""treetime ancestral "" + + #Check if a model has been specified, if not use --gtr infer + if add_treetime_cmds == None: + cmd += ""--gtr infer"" + elif ""--gtr"" not in add_treetime_cmds: + cmd += ""--gtr infer "" + add_treetime_cmds + else: + cmd += add_treetime_cmds + + cmd += "" --aln "" + alignment.name + cmd += "" --tree "" + tree.name + cmd += "" --outdir "" + output_dir + + print('running cmd: ' + cmd) + + subprocess.run(cmd, shell = True, check = True) + + # Deal with old version of treetime + if os.path.isfile(output_dir + ""ancestral_sequences{}.fasta""): + os.rename(output_dir + ""ancestral_sequences{}.fasta"", output_dir + ""ancestral_sequences.fasta"") + os.rename(output_dir + ""annotated_tree{}.nexus"", output_dir + ""annotated_tree.nexus"") + + #Check if treetime completed successfully + if (os.stat(output_dir + ""ancestral_sequences.fasta"").st_size == 0) or (os.stat(output_dir + ""annotated_tree.nexus"") == 0): + raise Exception(""treetime did not complete successfully"") + +#Runs treetime mugration +def run_treetime_mugration(tree, labels, output_dir): + cmd = ""treetime mugration --tree "" + + cmd += tree + cmd += "" --states "" + labels + cmd += "" --attribute group --confidence --outdir "" + output_dir + ""/mugration_out"" + + subprocess.run(cmd, shell = True, check = True) + +#treetime reconstructs mutations at gap sites, which are later removed by MutTui +#Ns are not reconstructed by treetime. This function replaces gaps with Ns in the alignment +#so they will not be reconstructed. As gaps and Ns are both treated as missing data +#in phylogenetic methods, this will not alter any inferences but will remove large numbers +#of gaps from the infered mutations +def change_gaps_to_Ns(alignmentFile, output_dir): + alignment = AlignIO.read(alignmentFile.name, ""fasta"") + + new_a = open(output_dir + ""gaps_to_N_alignment.fasta"", ""w"") + + for seq in alignment: + new_a.write("">"" + seq.id + ""\n"" + str(seq.seq).replace(""-"", ""N"") + ""\n"") + + new_a.close()","Python" +"Viral","chrisruis/MutTui","MutTui/korimuto.py",".py","10410","233","#Calculates a mutational spectrum from variant input data +#Can take VCF input or a file containing variants +#The VCF file needs to contain a line above the variants with columns #CHROM, POS, REF and ALT +#This variant file can be in any format as long as it has columns: +#position - containing genome position of mutation +#reference - reference base at position +#variant - variant base at position +#A VCF file is the default input, to use a variant file use --variant +#A multi-fasta reference can be used by specifying option --multi_contig. In this case, all variant positions need +#to be relative to their position in the corresponding contig. Contig names need to match between the VCF file +#and the FASTA reference file + +import argparse +import pandas as pd +from Bio import SeqIO +import sys +from .reconstruct_spectrum import getMutationDict, getContext, complement, getRNADict +from .plot_spectrum import convertSpectrumFormat, plotSpectrumFromDict, plotRNA + +#Extracts variants from a VCF file, returns a list of lists with +#each list containing chromosome, position, reference, variant +def extractFromVCF(vf): + #Empty list to be filled + vL = list() + + #Will be changed to column numbers if exist + cCol = None + pCol = None + rCol = None + vCol = None + + #Iterate through the VCF, check if the format is correct and if so iterate through variants + with open(vf.name) as fileobject: + for line in fileobject: + if line[:6] == ""#CHROM"": + + #Extract columns + for i, col in enumerate(line.strip().split(""\t"")): + if col == ""#CHROM"": + cCol = i + elif col == ""POS"": + pCol = i + elif col == ""REF"": + rCol = i + elif col == ""ALT"": + vCol = i + + #Process variant lines + elif line[0] != ""#"": + #Check if all of the required columns are present, if not one or more will still be None + if None in (cCol, pCol, rCol, vCol): + print(""VCF file needs to contain CHROM, POS, REF and ALT on a line that starts with #CHROM to be processed"") + sys.exit() + + vL.append([line.strip().split(""\t"")[rCol], line.strip().split(""\t"")[vCol], int(line.strip().split(""\t"")[pCol]), line.strip().split(""\t"")[cCol]]) + + return(vL) + +#Extracts variants from a variant file, returns a list of lists with +#each list containing position, reference, variant +def extractFromVariantFile(vf): + #Import variants + variants = pd.read_csv(vf.name) + + #Check if the required columns are present + if (""position"" not in variants.columns) or (""reference"" not in variants.columns) or (""variant"" not in variants.columns): + print(""Variant file needs to contain columns position, reference and variant. Exiting"") + sys.exit() + + #Empty list to be filled + vL = list() + + #Iterate through the variants and add to vL + for i in range(variants.shape[0]): + vL.append([variants[""reference""][i], variants[""variant""][i], variants[""position""][i]]) + + return(vL) + +#Extracts multiple contigs from a FASTA file into a dictionary with contig names as keys and +#sequences as values +def extractMultiContig(fFile): + sD = dict() + + #Import each contig and add to sD + for contig in SeqIO.parse(fFile, ""fasta""): + sD[contig.id] = str(contig.seq) + + return(sD) + +#Extracts mutation context from a multi-contig reference +def getMultiContigContext(mutation, reference): + return(reference[mutation[3]][mutation[2] - 2], reference[mutation[3]][mutation[2]]) + + +def korimuto_parser(parser): + + parser.description = ""Calculates a mutational spectrum from SNP data"" + + parser.add_argument(""-v"", + ""--variant_file"", + dest = ""v_file"", + required = True, + help = ""Input file containing variants. Expects a VCF file by default "" + + ""or a variant file if --variant is used"", + type = argparse.FileType(""r"")) + parser.add_argument(""-r"", + ""--reference"", + dest = ""reference"", + required = True, + help = ""Fasta reference file. This is not updated so mutational contexts will be "" + + ""extracted from this as it is provided"", + type = argparse.FileType(""r"")) + parser.add_argument(""--variant"", + dest = ""variant"", + help = ""Use this to supply a variant file rather than a VCF. This variant file "" + + ""can be in any format as long as it has columns: position (containing the genome position "" + + ""of the variant), reference (containing the reference nucleotide at the position) and variant "" + + ""(containing the variant nucleotide at the position)"", + action = ""store_true"", + default = False) + parser.add_argument(""--multi_contig"", + dest = ""multi_contig"", + help = ""Use this option if your samples are mapped against a multi-contig reference. "" + + ""Without this option, a single continuous reference is assumed to be provided with -r. "" + + ""This option is currently only possible with a VCF input and the names in the VCF CHROM column "" + + ""must match those in the FASTA reference file exactly"", + action = ""store_true"", + default = False) + parser.add_argument(""--rna"", + dest = ""rna"", + help = ""Specify if using an RNA pathogen, will calculate an RNA mutational spectrum"", + action = ""store_true"", + default = False) + parser.add_argument(""-o"", + ""-output_prefix"", + dest = ""out"", + required = True, + help = ""Prefix for output files. By default, these will be saved in the current directory"") + + parser.set_defaults(func = korimuto) + + return(parser) + + +def korimuto(args): + + #Extract variants from input file + if args.variant: + variants = extractFromVariantFile(args.v_file) + else: + variants = extractFromVCF(args.v_file) + + #Import multi-contig reference to a dictionary + if args.multi_contig: + reference = extractMultiContig(args.reference.name) + else: + #Import reference as single contig and extract to string + reference = str(SeqIO.read(args.reference.name, ""fasta"").seq).upper() + + outMutationsNotUsed = open(args.out + ""_mutations_not_included.csv"", ""w"") + outMutationsNotUsed.write(""Mutation_in_genome,Reason_not_included\n"") + + outAllMutations = open(args.out + ""_all_included_mutations.csv"", ""w"") + outAllMutations.write(""Mutation_in_genome,Substitution\n"") + + #Empty spectrum + if args.rna: + spectrum = getRNADict() + else: + spectrum = getMutationDict() + + #Nucleotides, used to check if mutation involves 2 nucleotides + nucleotides = [""A"",""C"",""G"",""T""] + + #Iterate through the variants, get their genomic context, check if they involve all nucleotides and add to spectrum + for mutation in variants: + if (mutation[0] not in nucleotides) or (mutation[1] not in nucleotides): + outMutationsNotUsed.write(mutation[0] + str(mutation[2]) + mutation[1] + "",mutation_does_not_involve_2_nucleotides\n"") + #Remove cases where the variant matches the reference + elif mutation[0] == mutation[1]: + outMutationsNotUsed.write(mutation[0] + str(mutation[2]) + mutation[1] + "",variant_matches_reference\n"") + else: + if args.multi_contig: + mutationContext = getMultiContigContext(mutation, reference) + else: + mutationContext = getContext(mutation, reference) + + #Check if the mutation, upstream or downstream nucleotides are not A, C, G or T + if (mutationContext[0] not in nucleotides) or (mutationContext[1] not in nucleotides): + outMutationsNotUsed.write(mutation[0] + str(mutation[2]) + mutation[1] + "",surrounding_position_not_nucleotide\n"") + else: + #This will be true for all RNA mutations and half of DNA mutations + if (mutationContext[0] + mutation[0] + mutation[1] + mutationContext[1]) in spectrum: + spectrum[mutationContext[0] + mutation[0] + mutation[1] + mutationContext[1]] += 1 + outAllMutations.write(mutation[0] + str(mutation[2]) + mutation[1] + "","" + mutationContext[0] + ""["" + mutation[0] + "">"" + mutation[1] + ""]"" + mutationContext[1] + ""\n"") + #Add to the corresponding complement + else: + spectrum[complement(mutationContext[1]) + complement(mutation[0]) + complement(mutation[1]) + complement(mutationContext[0])] += 1 + outAllMutations.write(complement(mutation[0]) + str(mutation[2]) + complement(mutation[1]) + "","" + complement(mutationContext[1]) + ""["" + complement(mutation[0]) + "">"" + complement(mutation[1]) + ""]"" + complement(mutationContext[0]) + ""\n"") + + #Write the spectrum + outFile = open(args.out + ""_mutational_spectrum.csv"", ""w"") + outFile.write(""Substitution,Number_of_mutations\n"") + for eachMutation in spectrum: + outFile.write(eachMutation[0] + ""["" + eachMutation[1] + "">"" + eachMutation[2] + ""]"" + eachMutation[3] + "","" + str(spectrum[eachMutation]) + ""\n"") + outFile.close() + + #Plot the spectrum + outSpectrum = open(args.out + ""_mutational_spectrum.pdf"", ""w"") + spectrumFormat = convertSpectrumFormat(spectrum) + if args.rna: + plotRNA(spectrumFormat, False, outSpectrum) + else: + plotSpectrumFromDict(spectrumFormat, False, outSpectrum) + outSpectrum.close() + + return + + +def main(): + # set up and parse arguments + parser = argparse.ArgumentParser() + parser = korimuto_parser(parser) + args = parser.parse_args() + + # run korimuto + args.func(args) + + return + +if __name__ == ""__main__"": + main() +","Python" +"Viral","chrisruis/MutTui","docs/_coverpage.md",".md","254","14"," + + + +> A Pathogen Mutational Spectrum Pipeline. + +[GitHub](https://github.com/chrisruis/MutTui) +[Get Started](Getting_started/quick_start) + + + + +![color](#f0f0f0) +","Markdown" +"Viral","chrisruis/MutTui","docs/_sidebar.md",".md","892","28"," + +- Getting Started + + - [Quick Start](/Getting_started/quick_start.md) + - [Installation](/Getting_started/installation.md) + - [Options](/Getting_started/options.md) + - [Output](/Getting_started/output.md) + +- [Labelling the tree](/Labelling_the_tree/tree_labelling.md) + +- [Combining spectra](/Combining_spectra/combining_spectra.md) + +- Comparing spectra + + - [Spectrum subtractions](/Comparing_spectra/spectrum_subtractions.md) + - [Cosine similarity and clustering](/Comparing_spectra/cosine_similarity.md) + +- [Using variant data](/Using_variant_data/variant_data.md) + +- Post-processing + + - [Generating summaries](/Post_processing/branch_summaries.md) + - [Splitting spectra into subgroups](/Post_processing/splitting_spectra.md) + - [Filtering mutations](/Post_processing/filtering_mutations.md) + +- [MutTui algorithm](/Algorithm/algorithm.md) +","Markdown" +"Viral","chrisruis/MutTui","docs/Comparing_spectra/cosine_similarity.md",".md","1240","26","# Calculating cosine similarity between spectra + +Cosine similarity is a useful measure to compare how similar spectra are to one another at the overall level + +To calculate cosine similarity between a set of spectra run: +``` +MutTui cluster -s spectrum1.csv spectrum2.csv spectrum3.csv -l S1 S2 S3 -o . +``` + +Provide the spectra to be compared with -s. The optional labels provided with -l will be the names of the spectra in the output file; provide one label for each input spectrum. If -l is not provided, the file names (including paths) will be used as spectrum names + +The cosine similarities between all pairs of spectra are output as cosine_similarity.csv and the cosine distances (1 - cosine similarity) are output as sample_distances.csv + +Alternatively, the spectra can first be combined into a catalogue (see [Combining spectra](https://chrisruis.github.io/MutTui/#/Combining_spectra)) which can be provided with -c without -s: +``` +MutTui catalogue -c catalogue.csv -o . +``` + +In this case, the catalogue column names will be used as sample names + +# Clustering spectra + +**This is still being developed so will likely change soon** + +The cluster_spectra.py script as run above will carry out clustering on the distances between spectra +","Markdown" +"Viral","chrisruis/MutTui","docs/Comparing_spectra/spectrum_subtractions.md",".md","655","23","# Subtracting spectra + +One way to compare 2 spectra is to subtract the mutation proportions in one spectrum from those in the other spectrum + +To do this run: +``` +MutTui compare -s spectrum1.csv spectrum2.csv -o S1_S2 +``` + +The 2nd spectrum provided with -s is subtracted from the first + +2 output files are produced: + +1) A spectrum plot of the subtraction, containing the difference in mutation proportion: + + + +2) A dot plot comparing the proportions of all contextual mutations between the spectra: + + + +The dotted line in this plot is x=y +","Markdown" +"Viral","chrisruis/MutTui","docs/Post_processing/branch_summaries.md",".md","1329","26","# Generating summaries from MutTui output + +### Summarising an individual run + +To summarise the number of mutations identified in a run, both in total and for each applied label, and to calculate the number of times each mutation has been identified, run: +``` +python3 run_summary.py +``` + +This should be run from the directory containing the MutTui output files + +Several summaries are printed to the screen. This also produces an output file all_mutation_counts.csv which contains the number of times each mutation was inferred to occur within a run. This may be useful to identify potentially problematic mutations that can be filtered out (see Mutation filtering section) + +### Summarising the mutations on each branch in the tree + +A set of summaries can be generated for each branch in the tree using: +``` +python3 summarise_branch_mutations.py -m all_included_mutations.csv -t annotated_tree.nexus -o out_prefix +``` + +The all_included_mutations.csv and annotated_tree.nexus files are in the MutTui output directory + +This outputs 2 files: +1) A csv file containing one row per branch with the total mutations, number of each mutation type and proportion of each mutation type on each branch +2) A nexus tree in which each branch is labelled with the total mutations, number of each mutation type and proportion of each mutation type +","Markdown" +"Viral","chrisruis/MutTui","docs/Post_processing/filtering_mutations.md",".md","1469","17","# Filtering mutations by number of occurrences and/or genome position + +Calculated spectra can contain individual mutations more than once. In some cases, these will represent real mutations that have occurred multiple times through the history of a pathogen clade. In other cases, these might represent spurious mutations at, for example, difficult to align sites or amplicon dropouts. Depending on the use case, it may therefore be useful to apply filters to remove mutations inferred to occur on more than a specified number of occasions across the tree + +It is also possible to filter mutations by their position in the genome or the alignment file to examine the spectrum of specific parts of the genome without having to split the alignment first + +To filter mutations, run: +``` +python3 post_process_branch_mutations.py -m all_included_mutations.csv -o post_process --filter -n 10 -g 1 100000 +``` + +This takes the all_included_mutations.csv file generated by MutTui and writes new files to the directory provided with -o (post_process in this case) + +The maximum number of mutations allowed to keep a mutation is set with -n. In this example any mutation that occurs 11 or more times is filtered out + +The genome positions to keep are set with -g followed by the first and last positions to keep. In this example, mutations between positions 1 and 100000 are kept. To filter based on alignment positions instead, use -a followed by the first and last positions to keep +","Markdown" +"Viral","chrisruis/MutTui","docs/Post_processing/splitting_spectra.md",".md","605","9","# Splitting a single spectrum into multiple groups + +The output spectrum from MutTui can be split post-hoc into multiple groups using a branch labels file: +``` +python3 post_process_branch_mutations.py -m all_included_mutations.csv -l branch_labels.csv -o split_out +``` + +all_included_mutations.csv is in the MutTui output directory and contains all of the mutations included in an output spectrum and their branch. The branch_labels.csv file contains branch names and their label. MutTui outputs one spectrum per label in branch_labels.csv that contains all of the mutations on the branches with that label +","Markdown" +"Viral","chrisruis/MutTui","docs/Combining_spectra/combining_spectra.md",".md","550","9","# Combining multiple spectra into a single catalogue + +Multiple spectra can be combined into a single catalogue using: +``` +MutTui combine -s spectrum1.csv spectrum2.csv spectrum3.csv -l S1 S2 S3 -o catalogue.csv +``` + +Provide the spectra to be combined with -s. Option -l specifies the names of the spectra in the combined catalogue file. Alternatively a file can be provided with -c containing the file name of the spectrum and the name it will be given in the catalogue. If -l and -c are not provided, the spectra will be named with their file names +","Markdown" +"Viral","chrisruis/MutTui","docs/Algorithm/algorithm.md",".md","62","4","# MutTui algorithm + + +","Markdown" +"Viral","chrisruis/MutTui","docs/Getting_started/output.md",".md","3976","91","# MutTui output files + +#### mutational_spectrum_label_X.csv + +The inferred SBS spectrum from branches with label X. If your tree wasn't labelled, there will be one output file with label A. If your tree was labelled, there will be one output file per label + +Column 1 contains each contextual mutation (named with **upstream base [ancestral base > mutated base] downstream base** so A[C>T]G is the number of C>T mutations with A upstream and G downstream) + +Column 2 contains the count of the contextual mutation + +#### mutational_spectrum_label_X.pdf + +Plot of the SBS spectrum in mutational_spectrum_label_X.csv + +#### DBS_label_X.csv + +The inferred DBS spectrum from branches with label X. If your tree wasn't labelled, there will be one output file with label A. If your tree was labelled, there will be one output file per label + +Column 1 contains each double substitution (named with **ancestral_doublet > mutated_doublet** so AC>CG is the number of mutations from an AC doublet to a CG doublet) + +Column 2 contains the count of the double substitution + +#### DBS_label_X.pdf + +Plot of the DBS spectrum in DBS_label_X.csv + +#### mutation_types_label_X.csv + +The inferred spectrum of mutation counts without their context from branches with label X. If your tree wasn't labelled, there will be one output file with label A. If your tree was labelled, there will be one output file per label + +Column 1 contains the mutation type (named with ancestral base followed by mutated base so CA is the number of C>A mutations) + +Column 2 contains the count of the mutation type + +#### mutation_types_label_X.pdf + +Plot of the mutation type spectrum in mutation_types_label_X.csv + +#### strand_bias_label_X.csv + +Only included if --strand_bias is specified. Contains the inferred SBS spectrum from branches with label X split into transcribed and untranscribed strands + +#### strand_bias_label_X.pdf + +Plot of the strand-specific spectrum in strand_bias_label_X.csv + +#### all_included_mutations.csv + +All of the mutations in any of the output SBS spectra. The columns are: +* Mutation_in_alignment - the mutation and its position in the alignment +* Mutation_in_genome - the mutation and its position in the genome +* Substitution - the contextual mutation, written as ""upstream base [ancestral base > mutated base] downstream base"" +* Branch - the branch on which the mutation occurred. You can identify the branch in the tree by loading annotated_tree.nexus into FigTree + +#### all_included_double_substitutions.csv + +All of the mutations in any of the output DBS spectra. The columns are: +* Mutation_in_alignment - the mutation and its position in the alignment +* Mutation_in_genome - the mutation and its position in the genome +* Substitution - the double substitution, written as ""ancestral doublet > mutated doublet"" +* Branch - the branch on which the mutation occurred. You can identify the branch in the tree by loading annotated_tree.nexus into FigTree +* Original_mutation - specifies whether the original mutation was on the forward or reverse strand + +#### mutations_not_included.csv + +Mutations inferred by treetime that were not included in an output SBS or DBS spectrum and the reason they were excluded + +#### gaps_to_N_alignment.fasta + +The input alignment with gaps converted to Ns. This is used because gaps are treated as characters and included in reconstructions by treetime while Ns are treated as missing data + +# treetime output files + +These files are included in the MutTui output directory but are produced by treetime during ancestral reconstruction + +#### branch_mutations.txt + +Contains the mutations inferred by treetime through ancestral reconstruction + +#### ancestral_sequences.fasta + +Alignment from treetime containing observed and inferred ancestral sequences + +#### annotated_tree.nexus + +Tree from treetime containing internal node labels and inferred mutations on each branch + +#### sequence_evolution_model.txt + +Inferred model parameters from treetime ancestral reconstruction. +","Markdown" +"Viral","chrisruis/MutTui","docs/Getting_started/quick_start.md",".md","1259","43","# Quick start + +## Basic usage + +To calculate a mutational spectrum, 4 files are needed: +1) Sequence alignment in fasta format +2) Phylogenetic tree in newick format +3) Reference genome in fasta format +4) Conversion from alignment position to genome position + +Collect these files and then run: + +``` +mkdir muttui_out +MutTui run -a alignment.fasta -t tree.nwk -r reference.fasta -c conversion.txt -o muttui_out +``` + +## Creating the position conversion file + +To create the conversion.txt file from a VCF, run: + +``` +MutTui convert-vcf -v positions.vcf -o conversion.txt +``` + +## Labelling your tree + +More details in [Labelling_your_tree](https://github.com/chrisruis/MutTui/tree/main/docs/Labelling_the_tree) + +By default, MutTui will assign all branches in the given tree to the same mutational spectrum. If you want to split your tree into multiple groups, first label the tree using: + +``` +MutTui label-nodes -t unlabelled_tree.nwk -o tree_with_node_labels.nwk +MutTui label-tree -t unlabelled_tree.nwk -r root_state -s branch_state branch_state -o labelled_tree.nwk +``` + +Then run MutTui including the labelled tree with -lt: + +``` +mkdir muttui_out +MutTui run -a alignment.fasta -t tree.nwk -lt labelled_tree.nwk -r reference.fasta -c conversion.txt -o muttui_out +``` +","Markdown" +"Viral","chrisruis/MutTui","docs/Getting_started/options.md",".md","11458","187","# What's required + +MutTui requires at least 4 files to run: + +1) Sequence alignment in fasta format - provided with option -a +2) Phylogenetic tree in newick format - provided with option -t +3) Reference genome in fasta format - provided with option -r +4) Conversion from alignment position to genome position - provided with option -c + +The output directory to which the results will be written also need to be specified. The most basic MutTui command is: + +``` +python3 muttui.py -a alignment.fasta -t tree.nwk -r reference.fasta -c conversion.txt -o muttui_out +``` + +You can also provide MutTui additional [input files](#dditional-input-files) and [options](#optional-arguments), outlined in the sections below + +# Additional input files + +#### Labelled tree (-lt) + +Use this to give MutTui a labelled tree. MutTui will split each of the labels into a separate mutational spectrum. More details on how to set this up [here](https://github.com/chrisruis/MutTui/tree/main/docs/Labelling_your_tree) + +#### Tip labels (-l) + +Use this if you want to infer the labels of internal branches from labels at the tips of the tree as part of the MutTui run. MutTui will run the mugration model within treetime to infer internal node labels based on the distribution at tips. This file should contain a header and two columns: the first contains sequence names and the second their label. You don't need to include all sequence names in this file, any sequence names not included are given the label OTHER (or OTHER_A if OTHER is already used in the file) + +It's usually best to define your labels before running MutTui where possible and create a labelled tree to provide with -lt, rather than using this -l option + +#### Root state (-rs) + +Only used if labels are provided with -l and if mugration can't resolve the state at the root. In these rare cases, the root state can be provided + +#### GFF (-g) + +Use this if you are using either of the options --synonymous or --strand_bias + +This should be a GFF file containing gene coordinates in the provided reference genome and is used to identify whether each mutation is synonymous/non-synonymous (if using --synonymous) or which strand each mutation is on (if using --strand_bias) + +#### Treetime output directory (-to) + +Use this if you have already run treetime ancestral reconstruction and want to run MutTui on those results. This option is only used when --start_from_treetime is specified + +MutTui will use the branch_mutations.txt file from the provided directory + +#### Minimum branch mutations (-bm) + +Use this to set the minimum number of mutations a branch needs to exhibit to have its spectrum calculated. Default is 50 + +This is only used when --branch_specific is specified which outputs a separate spectrum for each branch with at least -bm mutations + +# Optional arguments + +#### --rna + +**This option is still being developed so doesn't currently work for all scripts** + +Use this if working with an RNA pathogen. As it is possible to determine the direction of RNA mutations, reverse mutations are not combined so the output spectrum will contain 192 bars rather than 96 + +#### --all_sites + +Use this if the alignment provided with -a contains all positions in the genome + +In this case, the context of each mutation can be identified from the alignment alone so a reference genome does not need to be provided with -r + +#### --include_all_branches + +By default, when using a labelled tree, the branches on which the label changes are excluded from the calculated spectra as we typically don't know at which point along the branch the label changed. If --include_all_branches is specified, the branches on which the label changes will be included in the spectrum of the downstream label + +Use this if specifying labels that only change on tip branches + +#### --include_root_branches + +Mutations on the two branches immediately downstream of the root are excluded by default as their direction may not be inferred reliably. Use this option to include mutations on these branches + +#### --start_from_treetime + +Use this option if you have already run treetime ancestral reconstruction and want to use those results for MutTui. The directory containing the treetime output files needs to be provided with -to + +#### --strand_bias + +Use this option to split the calculated SBS spectrum into transcribed and untranscribed strands, typically to examine strand bias. Mutations are included in the transcribed strand if the pyrimidine is on the transcribed strand and included in the nontranscribed strand if the pyrimidine is on the nontranscribed strand. Mutations that are not within a gene or are in multiple overlapping genes with different orientations are not included in these spectra. Mutations are included if they are in multiple overlapping genes that are in the same orientation + +This outputs 2 additional files per branch label - strand_bias_label_X.csv containing the mutation counts and strand_bias_label_X.pdf containing a plot of the mutation counts + +#### --synonymous + +Use this to only include synonymous mutations in the calculated spectrum. A GFF file needs to be provided with -g + +#### --branch_specific + +Use this to calculate the output a separate mutational spectrum for each branch in the tree that has at least a given number of mutations. Specify the minimum number of mutations with -bm (default 50) + +#### --add_treetime_cmds + +Use this to specify additional options that are provided to treetime for ancestral reconstruction + +# MutTui usage + +``` +usage: MutTui run [-h] -a ALIGNMENT -t TREE -o OUTPUT_DIR [-l LABELS] [-lt LABELLED_TREE] + [-r REFERENCE] [-c CONVERSION] [-g GFF] [-to TREETIME_OUT] [-bm BRANCH_MUTATIONS] + [--add_treetime_cmds ADD_TREETIME_CMDS] [--rna] [--all_sites] + [--include_all_branches] [--exclude_root_branches] [-rs ROOT_STATE] + [--start_from_treetime] [--strand_bias] [--synonymous] [--branch_specific] + [--version] + +Run the MutTui pipeline on a given alignment and tree + +options: + -h, --help show this help message and exit + --rna Specify if using an RNA pathogen, MutTui will output an RNA mutational + spectrum + --all_sites Specify that the alignment contains all sites, in which case a reference + genome does not need to be provided + --include_all_branches + Use when specifying a labelled tree with -lt. By default, the branches along + which the label changes are excluded as it is often not clear at what point + along the branch the label changed. With adding --include_all_branches, all + of the branches along which a label changes will be included in the spectrum + of the downstream label + --exclude_root_branches + Use when excluding the two branches that branch directly from the root node. + These branches will not be included in any spectrum + -rs ROOT_STATE, --root_state ROOT_STATE + Specify the root state of the given label if known. The root state is + calculated by treetime mugration and in almost all cases will be resolved. If + the root state has multiple assignments that are equally likely, it cannot be + assigned from treetime mugration output. In these rare cases, use this option + to assign the root state. This option can also be used to assign a root state + if you'd like but its recommended to use the mugration state + --start_from_treetime + Use this option to start with treetime output and so skip inference of + ancestral mutations. Use this if you have already run treetime. The directory + containing the treetime output files needs to be provided with -to + --strand_bias Split mutations into transcribed and untranscribed strands to test for + transcription strand bias. A GFF file will need to be provided with option -g + to identify genes + --synonymous Use non-coding and synonymous mutations only to calculate the mutational + spectrum. A GFF file will need to be provided with option -g which will be + used to identify genes + --branch_specific Calculate the mutational spectrum for each branch in the tree separately. + Only branches containing at least the number of mutations specified with -bm + will be included + --version show program's version number and exit + +Input/output: + -a ALIGNMENT, --alignment ALIGNMENT + Input fasta alignment + -t TREE, --tree TREE Newick tree file + -o OUTPUT_DIR, --out_dir OUTPUT_DIR + Location of output directory, should already be created and ideally be empty + -l LABELS, --labels LABELS + Comma separated file with sequences and their clade labels to divide the + spectrum. If this option is included, treetime mugration will be run to + identify changes in the label across the tree. Does not need to include all + taxa. Taxa not included will be given a label of OTHER by default, or OTHER_A + if OTHER is already taken. This file should have a header. + -lt LABELLED_TREE, --labelled_tree LABELLED_TREE + Tree with state labels, should be the same tree as that provided with -t but + with nodes labelled with their state from label_tree.py + -r REFERENCE, --reference REFERENCE + Reference genome sequence containing all sites, used to get context of + mutations, not required if using --all_sites + -c CONVERSION, --conversion CONVERSION + Conversion file for alignment position to genome position, used to get + context of mutations, not required if using --all_sites + -g GFF, --gff GFF GFF reference containing gene coordinates in reference sequence. Used to + split mutations into transcription strands and identify synonymous mutations + when --synonymous is used + -to TREETIME_OUT, --treetime_out TREETIME_OUT + The location of the directory containing treetime output files from ancestral + reconstruction. Only used if option --start_from_treetime is specified, in + which case the output files in this directory will be used to calculate the + mutational spectrum + -bm BRANCH_MUTATIONS, --branch_mutations BRANCH_MUTATIONS + The minimum number of mutations on a branch to calculate its mutational + spectrum. Only used when specifying --branch_specific which will output the + spectrum for each branch with more than this number of mutations separately. + Default = 50 + +treetime command: + --add_treetime_cmds ADD_TREETIME_CMDS + Additional options to supply to treetime (these are not checked). Supply + these together in quotes +``` +","Markdown" +"Viral","chrisruis/MutTui","docs/Getting_started/installation.md",".md","344","38","# Installation + +### Pip + +MutTui can be installed through pip using: + +``` +pip3 install git+https://github.com/chrisruis/MutTui +``` + +Or using: + +``` +pip install MutTui +``` + +### Conda + +In progress.. + +### Dependencies + +Required: + +* biopython +* numpy +* matplotlib +* phylo-treetime + +Optional: + +* gffutils +* scipy +* sklearn +* umap +* umap.plot +* pandas +","Markdown" +"Viral","chrisruis/MutTui","docs/Labelling_the_tree/tree_labelling.md",".md","3630","53","# Why label your tree? + +It's often useful to compare spectra between different groups of pathogens. If these groups are separate clades, MutTui can be run on each clade separately and the outputs compared. But it's often useful to compare multiple groups within the same tree. For example, we might want to compare the green and purple groups within this tree: + + + +In this tree, the purple sequences form a single cluster. But it might be that the groups are more interspersed: + + + +Or there might be several groups that are very interspersed across the tree: + + + +We can calculate the spectra of these groups separately in any of these cases by labelling the tree + +# How to label the tree + +We label the tree in 2 steps. First add names to all branches in the tree using: +``` +MutTui label-nodes -t tree.nwk -o tree_node_names.nwk +``` + +This outputs the same tree given with -t but each of the internal nodes now has a label ""Node"" followed by a number. We need to identify the node labels on which we want the label to change. To do this, open tree_node_names.nwk in [FigTree](http://tree.bio.ed.ac.uk/software/figtree/), switch node labels on and change display to label + +Once you've identified the branches on which the label should change, label the tree using: +``` +MutTui label-tree -t tree.nwk -r R -s Node10____S1 Node50____S2 Node75____S1 TipSequence1____S3 -o labelled_tree.nwk +``` + +This takes the same input tree as before. Option -r specifies the label at the root of the tree. With -s, we specify each of the branches on which we want the label to change and what we want the label to change to. Separate the branch from the label with four underscores. We can specify as many label changes as we want. Here, we've specified 4 label changes and, for example, has specified that the label should change to ""S1"" along the branch named Node10. To change the label on a tip branch, give the name of the tip sequence + +If there are a large number of label changes, rather than specifying them all with -s, you can provide a file with -sf that contains the branches on which the label changes and the label to change to + +You can check that the labelling has worked as expected by opening labelled_tree.nwk in FigTree and searching for four underscores followed by the label (to check the tip labels) and by switching node labels on (to check the internal node labels) + +The output of label-tree is a labelled tree which can be provided to MutTui with -lt, for example: +``` +MutTui run -a alignment.fasta -t tree.nwk -lt labelled_tree.nwk -r reference.fasta -c conversion.txt -o muttui_out +``` + +This will output one spectrum per label + +# Inferring state changes as part of the MutTui run + +It's usually best to identify where the label should change and label the tree before running MutTui as above. However, there may be cases where this isn't possible but the label of each of the tips is known. In these cases, you can infer where the label changes across the tree as part of the MutTui run using: + +``` +MutTui run -a alignment.fasta -t tree.nwk -l tip_states.csv -r reference.fasta -c conversion.txt -o muttui_out +``` + +-l contains tip sequences and their labels. Any tips not included in this file are given the label OTHER (or OTHER_A if OTHER is already used in the -l file labels). MutTui then runs the mugration model within treetime to reconstruct the label onto the tree and splits branches based on this reconstruction. Again, one spectrum is output per label +","Markdown" +"Viral","chrisruis/MutTui","docs/Using_variant_data/variant_data.md",".md","1018","18","# Calculating spectra from variant data + +MutTui can reconstruct mutational spectra from variant (SNP) data as well as from alignments and trees + +The input to calculate spectra from variant data can be either a VCF file (default) or a variant file. The variant file is a csv file with columns position (genome position of the variant), reference (containing the reference nucleotide at the position) and variant (containing the variant nucleotide at the position). This file can contain any other columns as long it contains these 3 + +MutTui identifies the mutations from the VCF or variants file. The contexts are identified from a reference genome. This would normally be the reference genome that was mapped against + +To calculate mutational spectra from variant data run: +``` +MutTui korimuto -v VCF/variant_file -r reference.fasta -o output_prefix +``` + +If a variant file is used, option --variant should be specified, for example: +``` +MutTui korimuto -v variants.csv -r reference.fasta -o output_prefix --variant +``` +","Markdown" +"Viral","chrisruis/MutTui","tests/test_muttui.py",".py","3489","74","# test add_tree_node_labels +from MutTui.muttui import main +import sys +import os +import tempfile + + +def compare_files(file1, file2): + with open(file1) as f1: + with open(file2) as f2: + assert f1.read() == f2.read() + return + + +def test_add_tree_node_labels(datafolder): + + with tempfile.TemporaryDirectory() as tmpdirname: + + # run add_tree_node_labels + sys.argv = [ + ""run"", + ""-a"", datafolder + ""orygis.filtered_polymorphic_sites.fasta"", + ""-t"", datafolder + ""orygis_rooted.nwk"", + ""-r"", datafolder + ""SRR2100577.contigs_velvet.fa"", + ""-c"", datafolder + ""conversion.txt"", + ""-o"", tmpdirname + ] + main() + + tmpdirname += '/' + + # check files are present + assert os.path.isfile(tmpdirname + ""DBS_label_A.csv"") + assert os.path.isfile(tmpdirname + ""DBS_label_A.pdf"") + assert os.path.isfile(tmpdirname + ""all_included_double_substitutions.csv"") + assert os.path.isfile(tmpdirname + ""all_included_mutations.csv"") + assert os.path.isfile(tmpdirname + ""ancestral_sequences.fasta"") + assert os.path.isfile(tmpdirname + ""annotated_tree.nexus"") + assert os.path.isfile(tmpdirname + ""branch_mutations.txt"") + assert os.path.isfile(tmpdirname + ""gaps_to_N_alignment.fasta"") + assert os.path.isfile(tmpdirname + ""mutation_types_label_A.csv"") + assert os.path.isfile(tmpdirname + ""mutation_types_label_A.pdf"") + assert os.path.isfile(tmpdirname + ""mutational_spectrum_label_A.csv"") + assert os.path.isfile(tmpdirname + ""mutational_spectrum_label_A.pdf"") + assert os.path.isfile(tmpdirname + ""mutations_not_included.csv"") + # assert os.path.isfile(tmpdirname + ""sequence_evolution_model.txt"") + + # check output + compare_files(tmpdirname + ""DBS_label_A.csv"", + datafolder + 'expected_output/' + ""DBS_label_A.csv"") + compare_files(tmpdirname + ""all_included_double_substitutions.csv"", + datafolder + 'expected_output/' + ""all_included_double_substitutions.csv"") + compare_files(tmpdirname + ""all_included_mutations.csv"", + datafolder + 'expected_output/' + ""all_included_mutations.csv"") + compare_files(tmpdirname + ""ancestral_sequences.fasta"", + datafolder + 'expected_output/' + ""ancestral_sequences.fasta"") + compare_files(tmpdirname + ""annotated_tree.nexus"", + datafolder + 'expected_output/' + ""annotated_tree.nexus"") + # compare_files(tmpdirname + ""branch_mutations.txt"", + # datafolder + 'expected_output/' + ""branch_mutations.txt"") + compare_files(tmpdirname + ""gaps_to_N_alignment.fasta"", + datafolder + 'expected_output/' + ""gaps_to_N_alignment.fasta"") + compare_files(tmpdirname + ""mutation_types_label_A.csv"", + datafolder + 'expected_output/' + ""mutation_types_label_A.csv"") + compare_files(tmpdirname + ""mutational_spectrum_label_A.csv"", + datafolder + 'expected_output/' + ""mutational_spectrum_label_A.csv"") + compare_files(tmpdirname + ""mutations_not_included.csv"", + datafolder + 'expected_output/' + ""mutations_not_included.csv"") + # compare_files(tmpdirname + ""sequence_evolution_model.txt"", + # datafolder + 'expected_output/' + ""sequence_evolution_model.txt"") + + return + +","Python" +"Viral","chrisruis/MutTui","tests/test_cluster_spectra.py",".py","189","11","# test cluster_spectra +#from MutTui.cluster_spectra import main +import sys, os +import tempfile + +def test_cluster_spectra(datafolder): + + # TODO: add tests for cluster_spectra + + return +","Python" +"Viral","chrisruis/MutTui","tests/test_convert_vcf.py",".py","225","11","# test if identical GFF3 files give the correct fasta alignment output +from MutTui.convert_vcf_position_translation import main +import sys +import glob + + +def test_convert_vcf_position_translation(datafolder): + + + + return","Python" +"Viral","chrisruis/MutTui","tests/conftest.py",".py","379","14","def pytest_addoption(parser): + parser.addoption( + ""--datafolder"", + action=""append"", + default=[], + help=""data folder to pass to test functions"", + ) + + +def pytest_generate_tests(metafunc): + if ""datafolder"" in metafunc.fixturenames: + metafunc.parametrize(""datafolder"", + metafunc.config.getoption(""datafolder"")) +","Python" +"Viral","chrisruis/MutTui","tests/test_add_tree_node_labels.py",".py","1185","32","# test add_tree_node_labels +from MutTui.add_tree_node_labels import main +import sys, os +import tempfile + +def test_add_tree_node_labels(datafolder): + + with tempfile.TemporaryDirectory() as tmpdirname: + + print(os.listdir()) + # run add_tree_node_labels + sys.argv = [ + """", ""-t"", datafolder + ""orygis_rooted.nwk"", ""-o"", + tmpdirname + ""orygis_rooted_labelled.nwk"" + ] + main() + + # check output + with open(tmpdirname + ""orygis_rooted_labelled.nwk"", 'r') as infile: + assert next(infile).strip()=='''((((((((((((SRR2100577.1:0.05954,\ +SRR5642717:0.03823)Node12:0.00000,(ERR2659156:0.04048,ERR2659\ +155:0.04448)Node13:0.00000)Node11:0.00141,SRR5642715:0.04889)\ +Node10:0.00973,SRR2101222:0.05958)Node9:0.00303,(SRR5642712:0\ +.05116,SRR5642711:0.04665)Node14:0.00147)Node8:0.00000,SRR210\ +1291:0.04564)Node7:0.00359,SRR5642716:0.05632)Node6:0.00992,S\ +RR2101161:0.06548)Node5:0.00078,ERR2659154:0.06354)Node4:0.00\ +154,((SRR5642718:0.02170,SRR5642713:0.02653)Node16:0.06462,SR\ +R5642714:0.07196)Node15:0.00000)Node3:0.00265,ERR2659153:0.09\ +780)Node2:0.03955,SRR2101329:0.13735)Node1:0.00000;''' + + + return","Python" +"Viral","refresh-bio/vclust","test.py",".py","19545","722","#!/usr/bin/env python3 + +from pathlib import Path +import shutil +import subprocess + +import vclust +import pytest + +VCLUST = Path('vclust.py') + +DATA_DIR = Path('example') +TMP_DIR = DATA_DIR / 'tmp' +FASTA_DIR = DATA_DIR / 'fna' +FASTA_FILE = DATA_DIR / 'multifasta.fna' +FASTAGZ_FILE = DATA_DIR / 'multifasta.fna.gz' +ANI_FILE = DATA_DIR / 'output'/ 'ani.tsv' +ALN_FILE = DATA_DIR / 'output' / 'ani.aln.tsv' +IDS_FILE = DATA_DIR / 'output' / 'ani.ids.tsv' +FLTR_FILE = DATA_DIR / 'output' / 'fltr.txt' +DATASET_DIR = DATA_DIR / 'datasets' +DATASET_FILES = [ + DATASET_DIR / 'refseq.fna', + DATASET_DIR / 'genbank.fna', + DATASET_DIR / 'other.fna', +] + + +@pytest.fixture +def test_dir(): + """"""Returns a testing data"""""" + #print('setup') + if TMP_DIR.exists(): + shutil.rmtree(TMP_DIR) + TMP_DIR.mkdir(parents=True) + yield TMP_DIR + #print('teardown') + shutil.rmtree(TMP_DIR) + + +@pytest.mark.parametrize('subcommand',[ + 'deduplicate', 'prefilter', 'align', 'cluster', 'info', +]) +def test_subcommands(subcommand): + cmd = [ + f'{VCLUST.resolve()}', + f'{subcommand}', + ] + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert not p.stderr + assert p.stdout + + +@pytest.mark.parametrize('input,params,error_msg',[ + (['missing_file1.fna', 'missing_file2.fna'], [], 'does not exist'), + (DATASET_FILES, ['--add-prefixes', 'refseq', 'genbank'], 'error:'), + (DATASET_FILES, ['--gzip-level', '0'], 'between 1 and 9'), +]) +def test_parser_error_deduplicate(test_dir, input, params, error_msg): + out_file = test_dir.joinpath('nr.fna') + cmd = [ + f'{VCLUST.resolve()}', + 'deduplicate', + '-i', + *[str(f) for f in input], + '-o', + f'{out_file}', + '-v', + '0', + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 2 + assert error_msg in p.stderr + assert not p.stdout + + +@pytest.mark.parametrize('input,params,error_msg',[ + (FASTA_DIR, ['--batch-size', '4'], 'error: --batch-size'), + (FASTA_DIR, ['--min-ident', '95'], 'between 0 and 1'), + (FASTA_DIR, ['--kmers-fraction', '10'], 'between 0 and 1'), + (FASTA_DIR, ['--k', '2'], 'invalid choice'), + (Path('missing_file.fna'), [], 'does not exist'), +]) +def test_parser_error_prefilter(test_dir, input, params, error_msg): + out_file = test_dir.joinpath('filter.txt') + cmd = [ + f'{VCLUST.resolve()}', + 'prefilter', + '-i', + f'{input}', + '-o', + f'{out_file}', + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 2 + assert error_msg in p.stderr + assert not p.stdout + + +@pytest.mark.parametrize('input,params,error_msg',[ + (FASTA_FILE, ['--out-tani', '40'], 'between 0 and 1'), + (Path('missing_file.fna'), [], 'does not exist'), +]) +def test_parser_error_align(test_dir, input, params, error_msg): + out_file = test_dir.joinpath('ani.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{input}', + '-o', + f'{out_file}' + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 2 + assert error_msg in p.stderr + assert not p.stdout + + +@pytest.mark.parametrize('params,error_msg',[ + (['--metric', 'tani'], 'error: tani threshold'), + (['--metric', 'ani', '--ani', '95'], 'between 0 and 1'), +]) +def test_parser_error_cluster(test_dir, params, error_msg): + out_file = test_dir.joinpath('clusters.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'cluster', + '-i', + f'{ANI_FILE}', + '-o', + f'{out_file}', + '--ids', + f'{IDS_FILE}' + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 2 + assert error_msg in p.stderr + assert not p.stdout + + +def test_deduplicate_default(test_dir): + out_file = test_dir.joinpath('nr.fna') + out_duplicates_file = test_dir.joinpath('nr.fna.duplicates.txt') + ref_ids = ['NC_002486.1', 'NC_005091.2', 'NC_010807.1', 'NC_025457.1', + 'KJ473423.1', 'MN428048.1', 'MK937595.1', 'Mushuvirus', 'Mushuvirus_copy'] + cmd = [ + f'{VCLUST.resolve()}', + 'deduplicate', + '-i', + *[str(f) for f in DATASET_FILES], + '-o', + f'{out_file}', + '-v', + '0', + ] + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert not p.stderr + assert out_file.exists() + assert out_duplicates_file.exists() + assert out_file.stat().st_size + assert out_duplicates_file.stat().st_size + seq_ids = [] + with open(out_file) as fh: + for line in fh: + if line.startswith('>'): + seq_ids.append(line.split()[0].lstrip('>')) + assert len(seq_ids) == len(ref_ids) + assert seq_ids == ref_ids + + +def test_deduplicate_default(test_dir): + out_file = test_dir.joinpath('nr.fna') + out_duplicates_file = test_dir.joinpath('nr.fna.duplicates.txt') + ref_ids = ['NC_002486.1', 'NC_005091.2', 'NC_010807.1', 'NC_025457.1', + 'MN428048.1', 'MK937595.1', 'Mushuvirus'] + ref_duplicates = { + 'Mushuvirus -Mushuvirus_copy', + 'NC_025457.1 -KJ473423.1', + 'NC_010807.1 -EU547803.1 -NC_010807.1_duplicate', + 'NC_005091.2 -AY357582.2 -AY357582.2_duplicate', + 'MN428048.1 +MN428048.1_revcomp', + 'NC_002486.1 -AB044554.1', + } + cmd = [ + f'{VCLUST.resolve()}', + 'deduplicate', + '-i', + *[str(f) for f in DATASET_FILES], + '-o', + f'{out_file}', + '-v', + '0', + ] + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert not p.stderr + assert out_file.exists() + assert out_duplicates_file.exists() + assert out_file.stat().st_size + assert out_duplicates_file.stat().st_size + seq_ids = [] + with open(out_file) as fh: + for line in fh: + if line.startswith('>'): + seq_ids.append(line.split()[0].lstrip('>')) + assert len(seq_ids) == len(ref_ids) + assert seq_ids == ref_ids + duplicates = set() + with open(out_duplicates_file) as fh: + for line in fh: + line = line.strip() + if line: + duplicates.add(line) + assert duplicates == ref_duplicates + + +@pytest.mark.parametrize('input,params',[ + (DATASET_FILES, ['--add-prefixes']), + (DATASET_FILES, ['--add-prefixes', 'refseq|', 'genbank|', 'other|']), +]) +def test_deduplicate_add_prefixes(test_dir, input, params): + out_file = test_dir.joinpath('nr.fna') + out_duplicates_file = test_dir.joinpath('nr.fna.duplicates.txt') + cmd = [ + f'{VCLUST.resolve()}', + 'deduplicate', + '-i', + *[str(f) for f in DATASET_FILES], + '-o', + f'{out_file}', + '-v', + '0', + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert not p.stderr + assert out_file.exists() + assert out_duplicates_file.exists() + assert out_file.stat().st_size + assert out_duplicates_file.stat().st_size + prefixes = [] + with open(out_file) as fh: + for line in fh: + if line.startswith('>'): + prefixes.append(line.split()[0].split('|')[0].lstrip('>')) + assert len(prefixes) == 7 + assert set(prefixes) == {'refseq', 'genbank', 'other'} + + +@pytest.mark.parametrize('input,params,out_file',[ + (DATASET_FILES, ['--gzip-output'], 'nr.fna.gz'), + (DATASET_FILES, ['--gzip-output'], 'nr.fna'), +]) +def test_deduplicate_gzip(test_dir, input, params, out_file): + out_file = test_dir.joinpath(out_file) + ref_file = test_dir.joinpath('nr.fna.gz') + ref_duplicates_file = test_dir.joinpath('nr.fna.gz.duplicates.txt') + cmd = [ + f'{VCLUST.resolve()}', + 'deduplicate', + '-i', + *[str(f) for f in DATASET_FILES], + '-o', + f'{out_file}', + '-v', + '0', + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert not p.stderr + assert ref_file.exists() + assert ref_file.stat().st_size + assert ref_duplicates_file.exists() + assert ref_duplicates_file.stat().st_size + + +def test_deduplicate_verbose(test_dir): + out_file = test_dir.joinpath('nr.fna') + out_duplicates_file = test_dir.joinpath('nr.fna.duplicates.txt') + cmd = [ + f'{VCLUST.resolve()}', + 'deduplicate', + '-i', + *[str(f) for f in DATASET_FILES], + '-o', + f'{out_file}', + ] + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert all(word in p.stderr for word in ['Running', 'Completed', 'INFO']) + assert out_file.exists() + assert out_duplicates_file.exists() + assert out_file.stat().st_size + assert out_duplicates_file.stat().st_size + + +@pytest.mark.parametrize('input,params',[ + (FASTA_DIR, []), + (FASTA_FILE, []), + (FASTA_FILE, ['--batch-size', '4']), + (FASTAGZ_FILE, []), +]) +def test_prefilter_default(test_dir, input, params): + out_file = test_dir.joinpath('filter.txt') + cmd = [ + f'{VCLUST.resolve()}', + 'prefilter', + '-i', + f'{input}', + '-o', + f'{out_file}', + '-v', + '0', + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert not p.stderr + assert out_file.exists() + assert out_file.stat().st_size + + with open(out_file) as fh: + vids = fh.readline().strip().rstrip(',').split(',')[1:] + idx2vid = {i: vid.rstrip('.fna') for i, vid in enumerate(vids, start=1)} + results = {} + for line in fh: + cols = line.rstrip().rstrip(',').split(',') + vid1 = cols[0].rstrip('.fna') + fields = cols[1:] + for field in fields: + value = field.split(':') + idx = int(value[0]) + ani = float(value[1]) + vid2 = idx2vid[idx] + results[(vid1, vid2)] = ani + results[(vid2, vid1)] = ani + assert results[('NC_010807.alt1', 'NC_010807')] == 0.99848 + assert results[('NC_010807.alt2', 'NC_010807.alt3')] == 0.992238 + assert results[('NC_025457', 'NC_025457.alt1')] == 0.990832 + assert results[('NC_010807.alt1', 'NC_010807.alt3')] == 0.996723 + assert results[('NC_025457.alt2', 'NC_025457.alt1')] == 0.94527 + assert results[('NC_002486', 'NC_002486.alt')] == 0.999979 + assert len(results) == 26 + + +@pytest.mark.parametrize('input,params',[ + (FASTA_FILE, ['--kmers-fraction', '0.2']), + (FASTA_FILE, ['--max-seqs', '2']), + (FASTA_FILE, ['-k', '20']), +]) +def test_prefilter_params(test_dir, input, params): + out_file = test_dir.joinpath('filter.txt') + cmd = [ + f'{VCLUST.resolve()}', + 'prefilter', + '-i', + f'{input}', + '-o', + f'{out_file}', + '-v', + '0', + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert not p.stderr + assert out_file.exists() + assert out_file.stat().st_size + + +def test_prefilter_verbose(test_dir): + out_file = test_dir.joinpath('filter.txt') + cmd = [ + f'{VCLUST.resolve()}', + 'prefilter', + '-i', + f'{FASTA_FILE}', + '-o', + f'{out_file}', + ] + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert all(word in p.stderr for word in ['Running', 'Completed', 'INFO']) + assert out_file.exists() + assert out_file.stat().st_size + + +@pytest.mark.parametrize('input,params',[ + (FASTA_DIR, []), + (FASTA_FILE, []), + (FASTAGZ_FILE, []), +]) +def test_align_default(test_dir, input, params): + out_file = test_dir.joinpath('ani.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{input}', + '-o', + f'{out_file}' + ] + p = subprocess.run(cmd) + assert p.returncode == 0 + assert p.stderr == None + assert out_file.exists() + assert out_file.stat().st_size + ref_pairs = { + ('NC_010807', 'NC_010807.alt1'): 0.99753, + ('NC_010807', 'NC_010807.alt2'): 0.98985, + ('NC_010807', 'NC_010807.alt3'): 0.98384, + ('NC_005091', 'NC_005091.alt1'): 0.97161, + ('NC_005091', 'NC_005091.alt2'): 0.96707, + ('NC_025457', 'NC_025457.alt1'): 0.80607, + ('NC_025457', 'NC_025457.alt2'): 0.75921, + ('NC_002486', 'NC_002486.alt'): 1.00000, + } + pairs = {} + with open(out_file) as fh: + next(fh) + for line in fh: + cols = line.split() + id1 = cols[2].rstrip('.fna') + id2 = cols[3].rstrip('.fna') + tani = float(cols[4]) + pairs[(id1, id2)] = tani + for ref_pair, ref_tani in ref_pairs.items(): + tani = pairs[ref_pair] + assert abs(tani - ref_tani) < 0.007 + + +@pytest.mark.parametrize('outfmt,ref_cols',[ + ('standard', vclust.ALIGN_OUTFMT['standard']), + ('lite', vclust.ALIGN_OUTFMT['lite']), + ('complete', vclust.ALIGN_OUTFMT['complete']), +]) +def test_align_outfmt(test_dir, outfmt, ref_cols): + out_file = test_dir.joinpath('ani.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{FASTA_FILE}', + '-o', + f'{out_file}', + '--outfmt', + f'{outfmt}' + ] + p = subprocess.run(cmd) + with open(out_file) as fh: + cols = fh.readline().split() + assert cols == ref_cols + + +@pytest.mark.parametrize('input,params',[ + (FASTA_DIR, []), + (FASTA_FILE, []), +]) +def test_align_alignments(test_dir, input, params): + out_file = test_dir.joinpath('ani.tsv') + out_aln_file = test_dir.joinpath('ani.aln.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{input}', + '-o', + f'{out_file}', + '--out-aln', + f'{out_aln_file}', + + ] + p = subprocess.run(cmd) + assert p.returncode == 0 + assert p.stderr == None + assert out_aln_file.exists() + assert out_aln_file.stat().st_size + with open(out_aln_file) as fh: + header = fh.readline().split() + assert len(header) == 10 + assert fh.readlines() + + +def test_align_verbose(test_dir): + out_file = test_dir.joinpath('ani.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{FASTA_FILE}', + '-o', + f'{out_file}', + ] + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert all(word in p.stderr for word in ['Running', 'Completed', 'INFO']) + assert out_file.exists() + + +@pytest.mark.parametrize('input,params',[ + (FASTA_DIR, []), + (FASTA_FILE, []), + (FASTA_FILE, ['--batch-size', '4']), +]) +def test_workflow_prefilter_align(test_dir, input, params): + filter_file = test_dir.joinpath('filter.txt') + ani_file = test_dir.joinpath('ani.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'prefilter', + '-i', + f'{input}', + '-o', + f'{filter_file}' + ] + cmd.extend(params) + p = subprocess.run(cmd) + assert p.returncode == 0 + assert p.stderr == None + assert filter_file.exists() + assert filter_file.stat().st_size + + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{input}', + '-o', + f'{ani_file}', + '--filter', + f'{filter_file}' + ] + p = subprocess.run(cmd) + assert p.returncode == 0 + assert p.stderr == None + assert ani_file.exists() + assert ani_file.stat().st_size + + +@pytest.mark.parametrize('algorithm',[ + 'single', + 'complete', + 'uclust', + 'cd-hit', + 'set-cover', +]) +def test_cluster_algorithm(test_dir, algorithm): + out_file = test_dir / 'clusters.tsv' + cmd = [ + f'{VCLUST.resolve()}', + 'cluster', + '-i', + f'{ANI_FILE}', + '--ids', + f'{IDS_FILE}', + '-o', + f'{out_file}', + '--algorithm', + f'{algorithm}', + '--metric', + 'tani', + '--tani', + '0.95', + '-v', + '0', + ] + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert not p.stderr + assert out_file.exists() + assert out_file.stat().st_size + + +@pytest.mark.parametrize('filtering_measure',[ + 'tani', + 'gani', + 'ani', + 'qcov', + 'rcov', +]) +def test_cluster_filtering(test_dir, filtering_measure): + out_file = test_dir / 'clusters.tsv' + cmd = [ + f'{VCLUST.resolve()}', + 'cluster', + '-i', + f'{ANI_FILE}', + '--ids', + f'{IDS_FILE}', + '-o', + f'{out_file}', + '--algorithm', + 'single', + '--metric', + 'tani', + '--tani', + '0.95', + f'--{filtering_measure}', + '0.85', + ] + p = subprocess.run(cmd, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL) + assert p.returncode == 0 + assert p.stderr == None + assert out_file.exists() + assert out_file.stat().st_size + + +def test_cluster_verbose(test_dir): + out_file = test_dir / 'clusters.tsv' + cmd = [ + f'{VCLUST.resolve()}', + 'cluster', + '-i', + f'{ANI_FILE}', + '--ids', + f'{IDS_FILE}', + '-o', + f'{out_file}', + '--algorithm', + 'single', + '--metric', + 'tani', + '--tani', + '0.95', + ] + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert all(word in p.stderr for word in ['Running', 'Completed', 'INFO']) + assert out_file.exists() + assert out_file.stat().st_size + + +@pytest.mark.parametrize('params',[ + ([]), + (['--leiden-resolution', '0.8', '--leiden-iterations', '3']), + (['--leiden-resolution', '0.8', '--leiden-beta', '0.001']), +]) +def test_cluster_algorithm_leiden(test_dir, params): + out_file = test_dir / 'clusters.tsv' + cmd = [ + f'{VCLUST.resolve()}', + 'cluster', + '-i', + f'{ANI_FILE}', + '--ids', + f'{IDS_FILE}', + '-o', + f'{out_file}', + '--algorithm', + 'leiden', + '--metric', + 'tani', + '--tani', + '0.95', + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL) + assert p.returncode == 0 + assert p.stderr == None + assert out_file.exists() + assert out_file.stat().st_size","Python" +"Viral","refresh-bio/vclust","vclust.py",".py","50491","1622","#!/usr/bin/env python3 +""""""Compute Average Nucleotide Identity (ANI) and cluster virus genome sequences. + +https://github.com/refresh-bio/vclust +"""""" + +import argparse +import logging +import multiprocessing +import os +import pathlib +import platform +import shutil +import subprocess +import sys +import tempfile +import typing + +__version__ = '1.3.1' + +CITATION = '''Zielezinski A, Gudys A et al. (2025) +Ultrafast and accurate sequence alignment and clustering of viral genomes. +Nat Methods. doi: https://doi.org/10.1038/s41592-025-02701-7''' + +DEFAULT_THREAD_COUNT = min(multiprocessing.cpu_count(), 64) + +VCLUST_SCRIPT_PATH = pathlib.Path(__file__) +VCLUST_DIR = VCLUST_SCRIPT_PATH.resolve().parent + +# Default paths to third-party binaries +BIN_DIR = VCLUST_DIR / 'bin' +BIN_KMERDB = BIN_DIR / 'kmer-db' +BIN_LZANI = BIN_DIR / 'lz-ani' +BIN_CLUSTY = BIN_DIR / 'clusty' +BIN_MFASTA = BIN_DIR / 'mfasta-tool' + +# LZ-ANI output columns +ALIGN_FIELDS = [ + 'qidx', 'ridx', 'query', 'reference', 'tani', 'gani', 'ani', 'qcov', + 'rcov', 'num_alns', 'len_ratio', 'qlen', 'rlen', 'nt_match', 'nt_mismatch', +] +# Vclust align output formats +ALIGN_OUTFMT = { + 'lite': ALIGN_FIELDS[:2] + ALIGN_FIELDS[4:11], + 'standard': ALIGN_FIELDS[:11], + 'complete': ALIGN_FIELDS[:], +} + +def get_parser() -> argparse.ArgumentParser: + """"""Return an argument parser."""""" + + # Constants and shared utilities + formatter_class = lambda prog: CustomHelpFormatter( + prog, max_help_position=32, width=100 + ) + + def input_path_type(value): + path = pathlib.Path(value) + if not path.exists(): + msg = f'input does not exist: {value}' + raise argparse.ArgumentTypeError(msg) + return path + + def ranged_float_type(value): + f = float(value) + if f < 0 or f > 1: + raise argparse.ArgumentTypeError('must be between 0 and 1') + return f + + def add_verbosity_argument(parser): + parser.add_argument( + '-v', + metavar='', + dest='verbosity_level', + type=int, + choices=[0, 1, 2], + default=1, + help='Verbosity level [%(default)s]:\n' + '0: Errors only\n1: Info\n2: Debug' + ) + + def add_help_argument(parser): + parser.add_argument( + '-h', '--help', + action='help', + help='Show this help message and exit' + ) + + def add_threads_argument(parser): + parser.add_argument( + '-t', '--threads', + metavar="""", + dest=""num_threads"", + type=int, + default=DEFAULT_THREAD_COUNT, + help='Number of threads [%(default)s]' + ) + + # Create the main parser + parser = argparse.ArgumentParser( + description=f'''%(prog)s v{__version__}: calculate ANI and cluster + virus (meta)genome sequences''', + formatter_class=formatter_class, + add_help=False, + ) + parser.add_argument( + '-v', '--version', + action='version', + version=f'v{__version__}', + help=""Display the tool's version and exit"" + ) + add_help_argument(parser) + + subparsers = parser.add_subparsers(dest='command') + + # Deduplicate parser + deduplicate_epilog = [ + 'Examples:', + 'vclust deduplicate -i refseq.fna genbank.fna -o nr.fna --add-prefixes', + 'vclust deduplicate -i refseq.fna genbank.fna -o nr.fna.gz --gzip-out ' + '--add-prefixes', + ] + deduplicate_parser = subparsers.add_parser( + 'deduplicate', + help='Deduplicate and merge genome sequences from multiple FASTA files', + formatter_class=formatter_class, + add_help=False, + epilog='\n'.join(deduplicate_epilog) + ) + deduplicate_optional = deduplicate_parser._action_groups.pop() + deduplicate_required = deduplicate_parser.add_argument_group( + 'required arguments' + ) + deduplicate_parser._action_groups.append(deduplicate_optional) + + deduplicate_required.add_argument( + '-i', '--in', + metavar='', + type=input_path_type, + dest='input_path', + nargs='+', + help='Space-separated input FASTA files (gzipped or uncompressed)', + ) + deduplicate_required.add_argument( + '-o', '--out', + metavar='', + type=pathlib.Path, + dest='output_path', + help='Output FASTA file with unique, nonredundant sequences, removing ' + 'duplicates and their reverse complements', + required=True + ) + deduplicate_parser.add_argument( + '--add-prefixes', + metavar='', + nargs='*', + default=False, + help='Add prefixes to sequence IDs. Without any values, prefixes are ' + 'set to input file names. Provide space-separated prefixes to override.' + ' Default: prefixes are disabled [%(default)s]' + ) + deduplicate_parser.add_argument( + '--gzip-output', + action=""store_true"", + help='Compress the output FASTA file with gzip [%(default)s]' + ) + deduplicate_parser.add_argument( + '--gzip-level', + metavar='', + type=int, + default=4, + help='Compression level for gzip (1-9) [%(default)s]' + ) + add_threads_argument(deduplicate_parser) + add_verbosity_argument(deduplicate_parser) + add_help_argument(deduplicate_parser) + + # Prefilter parser + prefilter_parser = subparsers.add_parser( + 'prefilter', + help='Prefilter genome pairs for alignment', + formatter_class=formatter_class, + add_help=False, + ) + + prefilter_optional = prefilter_parser._action_groups.pop() + prefilter_required = prefilter_parser.add_argument_group( + 'required arguments' + ) + prefilter_parser._action_groups.append(prefilter_optional) + + prefilter_required.add_argument( + '-i', '--in', + metavar='', + type=input_path_type, + dest='input_path', + help='Input FASTA file or directory of files (gzipped or uncompressed)', + required=True + ) + prefilter_required.add_argument( + '-o', '--out', + metavar='', + type=pathlib.Path, + dest='output_path', + help='Output filename', + required=True + ) + prefilter_parser.add_argument( + '-k', '--k', + metavar="""", + type=int, + default=25, + choices=range(15, 31), + help=""Size of k-mer for Kmer-db [%(default)s]"" + ) + prefilter_parser.add_argument( + '--min-kmers', + metavar="""", + type=int, + default=20, + help='Minimum number of shared k-mers between two genomes [%(default)s]' + ) + prefilter_parser.add_argument( + '--min-ident', + metavar="""", + type=ranged_float_type, + default=0.7, + help='Minimum sequence identity (0-1) between two genomes. Calculated ' + 'based on the shorter sequence [%(default)s]' + ) + prefilter_parser.add_argument( + '--batch-size', + metavar="""", + type=int, + default=0, + help='Process a multifasta file in smaller batches of FASTA ' + 'sequences. This option reduces memory at the expense of speed. ' + 'By default, no batch [%(default)s]' + ) + prefilter_parser.add_argument( + '--kmers-fraction', + metavar="""", + type=ranged_float_type, + default=1.0, + help='Fraction of k-mers to analyze in each genome (0-1). A lower ' + 'value reduces RAM usage and speeds up processing. By default, all ' + 'k-mers [%(default)s]' + ) + prefilter_parser.add_argument( + '--max-seqs', + metavar="""", + type=int, + default=0, + help='Maximum number of sequences allowed to pass the prefilter per ' + 'query. Only the sequences with the highest identity to the query are ' + 'reported. This option reduces RAM usage and speeds up processing ' + '(affects sensitivity). By default, all sequences that pass the ' + 'prefilter are reported [%(default)s]' + ) + add_threads_argument(prefilter_parser) + add_verbosity_argument(prefilter_parser) + add_help_argument(prefilter_parser) + + # Align parser + align_parser = subparsers.add_parser( + 'align', + help='Align genome sequence pairs and calculate ANI measures', + formatter_class=formatter_class, + add_help=False, + ) + align_optional = align_parser._action_groups.pop() + align_required = align_parser.add_argument_group('required arguments') + align_parser._action_groups.append(align_optional) + align_required.add_argument( + '-i', '--in', + metavar='', + type=input_path_type, + dest='input_path', + help='Input FASTA file or directory of files (gzipped or uncompressed)', + required=True + ) + align_required.add_argument( + '-o', '--out', + metavar='', + type=pathlib.Path, + dest='output_path', + help='Output filename', + required=True + ) + align_parser.add_argument( + '--filter', + metavar='', + type=input_path_type, + dest=""filter_path"", + help='Path to filter file (output of prefilter)' + ) + align_parser.add_argument( + '--filter-threshold', + metavar='', + dest='filter_threshold', + type=ranged_float_type, + default=0, + help='Align genome pairs above the threshold (0-1) [%(default)s]' + ) + align_parser.add_argument( + '--outfmt', + metavar='', + choices=ALIGN_OUTFMT.keys(), + dest='outfmt', + default='standard', + help='Output format [%(default)s]\n' + f'choices: {"","".join(ALIGN_OUTFMT.keys())}' + ) + align_parser.add_argument( + '--out-aln', + metavar='', + type=pathlib.Path, + dest='aln_path', + help='Write alignments to the tsv ', + ) + align_parser.add_argument( + '--out-ani', + dest='ani', + metavar='', + type=ranged_float_type, + default=0, + help='Min. ANI to output (0-1) [%(default)s]' + ) + align_parser.add_argument( + '--out-tani', + dest='tani', + metavar='', + type=ranged_float_type, + default=0, + help='Min. tANI to output (0-1) [%(default)s]' + ) + align_parser.add_argument( + '--out-gani', + dest='gani', + metavar='', + type=ranged_float_type, + default=0, + help='Min. gANI to output (0-1) [%(default)s]' + ) + align_parser.add_argument( + '--out-qcov', + dest='qcov', + metavar='', + type=ranged_float_type, + default=0, + help='Min. query coverage (aligned fraction) to output (0-1) ' + '[%(default)s]' + ) + align_parser.add_argument( + '--out-rcov', + dest='rcov', + metavar='', + type=ranged_float_type, + default=0, + help='Min. reference coverage (aligned fraction) to output (0-1) ' + '[%(default)s]' + ) + align_parser.add_argument( + '--mal', + metavar='', + type=int, + default=11, + help='Min. anchor length [%(default)s]' + ) + align_parser.add_argument( + '--msl', + metavar='', + type=int, + default=7, + help='Min. seed length [%(default)s]' + ) + align_parser.add_argument( + '--mrd', + metavar='', + type=int, + default=40, + help='Max. dist. between approx. matches in reference [%(default)s]' + ) + align_parser.add_argument( + '--mqd', + metavar='', + type=int, + default=40, + help='Max. dist. between approx. matches in query [%(default)s]' + ) + align_parser.add_argument( + '--reg', + metavar='', + type=int, + default=35, + help='Min. considered region length [%(default)s]' + ) + align_parser.add_argument( + '--aw', + metavar='', + type=int, + default=15, + help='Approx. window length [%(default)s]' + ) + align_parser.add_argument( + '--am', + metavar='', + type=int, + default=7, + help='Max. no. of mismatches in approx. window [%(default)s]' + ) + align_parser.add_argument( + '--ar', + metavar='', + type=int, + default=3, + help='Min. length of run ending approx. extension [%(default)s]' + ) + add_threads_argument(align_parser) + add_verbosity_argument(align_parser) + add_help_argument(align_parser) + + # Cluster parser + cluster_parser = subparsers.add_parser( + 'cluster', + help='Cluster genomes based on ANI thresholds', + formatter_class=formatter_class, + add_help=False, + ) + cluster_optional = cluster_parser._action_groups.pop() + cluster_required = cluster_parser.add_argument_group('required arguments') + cluster_parser._action_groups.append(cluster_optional) + + cluster_required.add_argument( + '-i', '--in', + metavar='', + type=input_path_type, + dest='input_path', + help='Input file with ANI metrics (tsv)', + required=True + ) + cluster_required.add_argument( + '-o', '--out', + metavar='', + type=pathlib.Path, + dest='output_path', + help='Output filename', + required=True + ) + cluster_required.add_argument( + '--ids', + metavar='', + type=input_path_type, + dest='ids_path', + help='Input file with sequence identifiers (tsv)', + required=True + ) + cluster_parser.add_argument( + '-r', '--out-repr', + action='store_true', + dest='representatives', + help='Output a representative genome for each cluster instead of ' + 'numerical cluster identifiers. The representative genome is selected ' + 'as the one with the longest sequence. [%(default)s]' + ) + choices = ['single', 'complete', 'uclust', 'cd-hit', 'set-cover', 'leiden'] + cluster_parser.add_argument( + '--algorithm', + metavar='', + dest=""algorithm"", + choices=choices, + default='single', + help='Clustering algorithm [%(default)s]\n' + '* single: Single-linkage (connected component)\n' + '* complete: Complete-linkage\n' + '* uclust: UCLUST\n' + '* cd-hit: Greedy incremental\n' + '* set-cover: Greedy set-cover (MMseqs2)\n' + '* leiden: Leiden algorithm' + ) + choices = ['tani','gani','ani'] + cluster_parser.add_argument( + '--metric', + metavar='', + dest='metric', + choices=choices, + default='tani', + help='Similarity metric for clustering [%(default)s]\n' + f'choices: {"","".join(choices)}' + ) + cluster_parser.add_argument( + '--tani', + metavar='', + dest='tani', + type=ranged_float_type, + default=0, + help='Min. total ANI (0-1) [%(default)s]' + ) + cluster_parser.add_argument( + '--gani', + metavar='', + dest='gani', + type=ranged_float_type, + default=0, + help='Min. global ANI (0-1) [%(default)s]' + ) + cluster_parser.add_argument( + '--ani', + metavar='', + dest='ani', + type=ranged_float_type, + default=0, + help='Min. ANI (0-1) [%(default)s]' + ) + cluster_parser.add_argument( + '--qcov', + metavar='', + dest='qcov', + type=ranged_float_type, + default=0, + help='Min. query coverage/aligned fraction (0-1) [%(default)s]' + ) + cluster_parser.add_argument( + '--rcov', + metavar='', + dest='rcov', + type=ranged_float_type, + default=0, + help='Min. reference coverage/aligned fraction (0-1) [%(default)s]' + ) + cluster_parser.add_argument( + '--len_ratio', + metavar='', + dest='len_ratio', + type=ranged_float_type, + default=0, + help='Min. length ratio between shorter and longer sequence (0-1) ' + '[%(default)s]' + ) + cluster_parser.add_argument( + '--num_alns', + metavar='', + dest='num_alns', + type=int, + default=0, + help='Max. number of local alignments between two genomes; 0 means all ' + 'genome pairs are allowed. [%(default)s]' + ) + cluster_parser.add_argument( + '--leiden-resolution', + metavar='', + type=ranged_float_type, + default=0.7, + help='Resolution parameter for the Leiden algorithm [%(default)s]' + ) + cluster_parser.add_argument( + '--leiden-beta', + metavar='', + type=ranged_float_type, + default=0.01, + help='Beta parameter for the Leiden algorithm [%(default)s]' + ) + cluster_parser.add_argument( + '--leiden-iterations', + metavar='', + type=int, + default=2, + help='Number of iterations for the Leiden algorithm [%(default)s]' + ) + add_verbosity_argument(cluster_parser) + add_help_argument(cluster_parser) + + # Info parser + info_parser = subparsers.add_parser( + 'info', + help='Show information about the tool and its dependencies', + formatter_class=formatter_class, + add_help=False, + ) + + # Show help message if the script is run without any arguments. + if len(sys.argv[1:]) == 0: + parser.print_help() + parser.exit() + + # Show subparser help message if the script is run without any arguments. + subparsers = [ + ('prefilter', prefilter_parser), + ('align', align_parser), + ('cluster', cluster_parser), + ('deduplicate', deduplicate_parser), + ] + for name, subparser in subparsers: + if sys.argv[-1] == name: + subparser.print_help() + parser.exit() + + return parser + + +def create_logger(name: str, verbosity_level: int) -> logging.Logger: + """"""Creates and configures a logger with the specified verbosity level. + + Args: + name (str): Name of the logger. + verbosity_level (int): Verbosity level: + - 0: ERROR (default) + - 1: INFO + - 2: DEBUG + + Returns: + logging.Logger: Configured logger instance. + """""" + # Map verbosity levels to logging levels + verbosity_to_log_level = { + 0: logging.ERROR, + 1: logging.INFO, + 2: logging.DEBUG + } + log_level = verbosity_to_log_level.get(verbosity_level, logging.ERROR) + + # Create logger + logger = logging.getLogger(name) + logger.setLevel(log_level) + + # Prevent duplicate handlers in case the logger is reconfigured + if not logger.handlers: + # Create a stream handler with a custom formatter + handler = logging.StreamHandler() + handler.setLevel(log_level) + handler.setFormatter(CustomLoggerFormatter()) + logger.addHandler(handler) + + return logger + + +def _validate_binary(bin_path: pathlib.Path) -> pathlib.Path: + """"""Validates the presence and executability of a binary file. + + This function checks if the provided path points to an existing binary file + and if it is executable. It also attempts to run the binary to ensure it + operates without errors. + + Args: + bin_path: + The path to the executable binary file. + + Returns: + pathlib.Path: The resolved path to the binary file. + + Raises: + RuntimeError: If the binary file does not exist, is not executable, + or if running the binary encounters an error. + """""" + bin_path = bin_path.resolve() + + if not bin_path.exists(): + raise RuntimeError(f'File not found: {bin_path}') + + if not bin_path.is_file() or not os.access(bin_path, os.X_OK): + raise RuntimeError(f'Binary file not executable: {bin_path}') + + try: + subprocess.run( + [str(bin_path)], + stdout=subprocess.DEVNULL, + stderr=subprocess.PIPE, + text=True, + check=True + ) + except subprocess.CalledProcessError as e: + raise RuntimeError(f'Running {bin_path} failed: {e.stderr}') + except OSError as e: + raise RuntimeError(f'OSError in {bin_path}: {e}') + except Exception as e: + raise RuntimeError(f'Unexpected error in {bin_path}: {e}') + return bin_path + + +def validate_binary(bin_path: pathlib.Path) -> pathlib.Path: + try: + return _validate_binary(bin_path) + except RuntimeError as e: + sys.exit(f'error: {e}') + + +def validate_args_fasta_input(args, parser) -> argparse.Namespace: + """"""Validates the arguments for FASTA input."""""" + args.is_multifasta = True + args.fasta_paths = [args.input_path] + + if args.input_path.is_dir(): + args.is_multifasta = False + args.fasta_paths = sorted( + f for f in args.input_path.iterdir() if f.is_file() + ) + + if not args.is_multifasta and len(args.fasta_paths) < 2: + parser.error(f'Too few fasta files found in {args.input_path}. ' + f'Expected at least 2, found {len(args.fasta_paths)}.') + + return args + + +def validate_args_deduplicate(args, parser) -> argparse.Namespace: + """"""Validates the arguments for the deduplicate command."""""" + # Validate dataset prefixes + if args.add_prefixes: + if len(args.add_prefixes) != len(args.input_path): + parser.error( + 'Number of prefixes must match the number of input files.') + if any(',' in prefix for prefix in args.add_prefixes): + parser.error('Prefixes cannot contain commas.') + elif args.add_prefixes == []: + args.add_prefixes = [f'{f.stem.split(""."")[0]}|' for f in args.input_path] + + if not (1 <= args.gzip_level <= 9): + parser.error('Compression level must be between 1 and 9.') + + # Ensure the output file has a .gz extension if gzip compression is enabled. + if args.gzip_output and not args.output_path.suffix == '.gz': + args.output_path = pathlib.Path(f'{args.output_path}.gz') + + # Create the output file name for storing information on duplicates. + args.output_duplicates_path = pathlib.Path( + f'{args.output_path}.duplicates.txt') + + return args + + +def validate_args_prefilter(args, parser) -> argparse.Namespace: + """"""Validates the arguments for the prefilter command."""""" + if args.batch_size and args.input_path.is_dir(): + parser.error('--batch-size only handles a multi-fasta file' + ', not a directory.') + return args + + +def validate_args_cluster(args, parser) -> argparse.Namespace: + """"""Validates the arguments for the cluster command."""""" + # Check the metric and its threshold. + args_dict = vars(args) + args.metric_threshold = args_dict.get(args.metric, 0) + if not args.metric_threshold: + parser.error(f'{args.metric} threshold must be above 0. ' + f'Specify the option: --{args.metric}') + + # Check if the input TSV file has the required columns. + with open(args.input_path) as fh: + header = fh.readline().split() + if 'qidx' not in header and 'ridx' not in header: + parser.error( + f'missing columns `qidx` and `ridx` in {args.input_path}') + cols = ['tani', 'gani', 'ani', 'qcov', 'rcov', 'len_ratio', 'num_alns'] + for name in cols: + value = args_dict[name] + if value != 0 and name not in header: + parser.error(f'missing column `{name}` in {args.input_path}') + return args + + +def run( + cmd: typing.List[str], + verbosity_level: int, + logger: logging.Logger + ) -> subprocess.CompletedProcess: + """"""Executes a given command as a subprocess and handles logging. + + This function runs the specified command, logs the execution details, + and manages errors. If verbose mode is enabled, the command's standard + error output is not suppressed. Otherwise, the standard error is piped + and logged in case of failure. + + Args: + cmd: + The command to run as a list of strings. + verbose: + Flag indicating whether to run the command in verbose mode. + logger: + The logger instance for logging information and errors. + + Returns: + subprocess.CompletedProcess: The completed process information. + + Raises: + SystemExit: If the command fails to execute or an error occurs. + """""" + logger.info(f'Running: {"" "".join(cmd)}') + try: + process = subprocess.run( + cmd, + stdout=None if verbosity_level else subprocess.DEVNULL, + stderr=None if verbosity_level else subprocess.PIPE, + text=True, + check=True + ) + except subprocess.CalledProcessError as e: + logger.error(f'Process {"" "".join(cmd)} failed with message: {e.stderr}') + sys.exit(1) + except OSError as e: + logger.error(f'OSError: {"" "".join(cmd)} failed with message: {e}') + sys.exit(1) + except Exception as e: + logger.error(f'Unexpected: {"" "".join(cmd)} failed with message: {e}') + sys.exit(1) + logger.info(f'Completed') + return process + + +def cmd_mfasta_deduplicate( + input_paths: typing.List[pathlib.Path], + output_path: pathlib.Path, + output_duplicates_path: pathlib.Path, + add_prefixes: typing.List[pathlib.Path], + gzip_output: bool, + gzip_level: int, + num_threads: int, + verbosity_level: int, + bin_path: pathlib.Path = BIN_MFASTA + ) -> typing.List[str]: + """"""Builds the command for mfasta-tool to deduplicate FASTA files. + + Args: + input_paths (List[Path]): + List of paths to the input FASTA files. + output_path (Path): + Path to the output FASTA file. + output_duplicates_path (Path): + Path to the output file listing duplicate sequences. + add_prefixes (List[Path]): + List of prefixes to add to sequence IDs. + gzip_output (bool): + Whether to compress the output FASTA file. + gzip_level (int): + Compression level for gzip (1-9). + num_threads (int): + Number of threads to use in mfasta-tool. + bin_path (Path): + Path to the mfasta-tool executable. + + Returns: + list: The constructed command as a list of strings. + + """""" + cmd = [ + f'{bin_path}', + 'mrds', + '-i', + "","".join([str(f) for f in input_paths]), + '-o', + f'{output_path}', + '--out-duplicates', + f'{output_duplicates_path}', + '--remove-duplicates', + '--mark-duplicates-orientation', + '--rev-comp-as-equivalent', + '-t', + f'{num_threads}', + ] + if verbosity_level: + cmd.extend(['--verbosity', '1']) + if add_prefixes: + cmd.extend(['--in-prefixes', "","".join(add_prefixes)]) + if gzip_output: + cmd.extend(['--gzipped-output', '--gzip-level', f'{gzip_level}']) + return cmd + + +def cmd_mfasta_split( + input_fasta: pathlib.Path, + out_dir: pathlib.Path, + n: int, + num_threads: int, + verbosity_level: int, + bin_path = BIN_MFASTA + ) -> typing.List[str]: + """"""Builds the command for mfasta-tool to split the input FASTA file. + + Args: + input_fasta (Path): + Path to the input FASTA file. + out_dir (Path): + Path to the output directory. + n (int): + Number of sequences per output FASTA file. + num_threads (int): + Number of threads + bin_path (Path): + Path to the mfasta-tool executable. + + Returns: + list: The constructed command as a list of strings. + + """""" + cmd = [ + f'{bin_path}', + 'mrds', + '-n', + f'{n}', + '--out-prefix', + f'{out_dir}/part', + '--out-suffix', + 'fna.gz', + '--gzipped-output', + '-i', + f'{input_fasta}', + '-t', + f'{num_threads}', + ] + if verbosity_level: + cmd.extend(['--verbosity', '1']) + return cmd + + +def cmd_kmerdb_build( + input_paths: pathlib.Path, + txt_path: pathlib.Path, + db_path: pathlib.Path, + is_multisample_fasta: bool, + kmer_size: int, + kmers_fraction: float, + num_threads: int, + bin_path: pathlib.Path = BIN_KMERDB + ) -> typing.List[str]: + """"""Builds the command for Kmer-db build. + + Args: + input_fasta (Path): + Path to the input FASTA file or directory with input FASTA files. + outfile_txt (Path): + Path to the output text file that will list the input FASTA files. + outfile_db (Path): + Path to the output kmer-db database file. + kmer_size (int): + k-mer size. + kmers_fraction (float): + Fraction of k-mers to analyze for each genome (0-1). + num_threads (int): + Number of threads to use in kmer-db. + bin_path (Path): + Path to the kmer-db executable. + + Returns: + list: The constructed command as a list of strings. + + """""" + # Create a text file listing input FASTA files. + with open(txt_path, 'w') as oh: + for f in input_paths: + oh.write(f'{f}\n') + + # Run kmer-db build. + cmd = [ + f""{bin_path}"", + ""build"", + ""-k"", f""{kmer_size}"", + ""-f"", f""{kmers_fraction}"", + ""-t"", f""{num_threads}"", + f'{txt_path}', + f'{db_path}', + ] + if is_multisample_fasta: + cmd.insert(2, '-multisample-fasta') + return cmd + + +def cmd_kmerdb_all2all( + db_paths: typing.List[pathlib.Path], + db_list_path: pathlib.Path, + outfile_all2all: pathlib.Path, + min_kmers: int, + min_ident: float, + max_seqs: int, + num_threads: int, + bin_path: pathlib.Path = BIN_KMERDB + ) -> typing.List[str]: + """"""Builds the command for Kmer-db all2all. + + Args: + db_paths (list[Path]): + List of paths to the input kmer-db database files. + db_list_path (Path): + Path to the output text file listing the kmer-db database files. + outfile_all2all (Path): + Path to the output all2all file. + min_kmers (int): + Minimum number of shared k-mers to report in all2all output. + min_ident (float): + Minimum sequence identity of the shorter sequence. + max_seqs (int): + Maximum number of sequences allowed to pass the prefilter per query. + num_threads (int): + Number of threads to use in kmer-db. + bin_path (Path): + Path to the kmer-db executable. + + Returns: + list: The constructed command as a list of strings. + + """""" + with open(db_list_path, 'w') as oh: + for db_path in db_paths: + oh.write(f'{db_path}\n') + + cmd = [ + f""{bin_path}"", + 'all2all-parts' if len(db_paths) > 1 else 'all2all-sp', + '-sparse', + '-min', f'num-kmers:{min_kmers}', + '-min', f'ani-shorter:{min_ident}', + ""-t"", f""{num_threads}"", + f'{db_list_path}' if len(db_paths) > 1 else f'{db_paths[0]}', + f'{outfile_all2all}', + ] + if max_seqs > 0: + cmd[5:5] = ['-sample-rows', f'ani-shorter:{max_seqs}'] + return cmd + + +def cmd_kmerdb_distance( + infile_all2all: pathlib.Path, + outfile_distance: pathlib.Path, + min_ident: float, + num_threads: int, + bin_path: pathlib.Path = BIN_KMERDB + ) -> typing.List[str]: + """"""Builds the command for Kmer-db distance. + + Args: + infile_all2all (Path): + Path to the input all2all file. + outfile_distance (Path): + Path to the output distance (file) file. + min_ident (float): + Minimum sequence identity to report in output. + num_threads (int): + Number of threads to use in kmer-db. + bin_path (Path): + Path to the kmer-db executable. + + Returns: + list: The constructed command as a list of strings. + + """""" + cmd = [ + f""{bin_path}"", + ""distance"", + ""ani-shorter"", + ""-sparse"", + '-min', f'{min_ident}', + ""-t"", f""{num_threads}"", + f'{infile_all2all}', + f'{outfile_distance}', + ] + return cmd + + +def cmd_lzani( + input_paths: typing.List[pathlib.Path], + txt_path: pathlib.Path, + output_path: pathlib.Path, + out_format: typing.List[str], + out_aln_path: pathlib.Path, + out_tani: float, + out_gani: float, + out_ani: float, + out_qcov: float, + out_rcov: float, + filter_file: pathlib.Path, + filter_threshold: float, + mal: int, + msl: int, + mrd: int, + mqd: int, + reg: int, + aw: int, + am: int, + ar: int, + num_threads: int, + verbosity_level: bool, + bin_path: pathlib.Path = BIN_LZANI + ) -> typing.List[str]: + """"""Builds the command for LZ-ANI. + + Args: + input_paths (List[Path]): + List of paths to the input FASTA files. + txt_path (Path): + Path to the output text file listing the input FASTA files. + output_path (Path): + Path to the output ANI file. + out_format (List[str]): + List of LZ-ANI column names. + out_aln_path (Path): + Path to the output alignment file. + out_tani (float): + Minimum tANI to output. + out_gani (float): + Minimum gANI to output. + out_ani (float): + Minimum ANI to output. + out_qcov (float): + Minimum query coverage (aligned fraction) to output. + out_rcov (float): + Minimum reference coverage (aligned fraction) to output. + filter_file (Path): + Path to the filter file (prefilter's output). + filter_threshold (float): + Filter threshold. + mal (int): + Minimum anchor length. + msl (int): + Minimum seed length. + mrd (int): + Maximum distance between approximate matches in reference. + mqd (int): + Maximum distance between approximate matches in query. + reg (int): + Minimum considered region length. + aw (int): + Approximate window length. + am (int): + Maximum number of mismatches in approximate window. + ar (int): + Minimum length of run ending approximate extension. + num_threads (int): + Number of threads to use in lz-ani. + verbose (bool): + Whether to display verbose output. + bin_path (Path): + Path to the lz-ani executable. + + Returns: + list: The constructed command as a list of strings. + + """""" + # Create a text file listing input FASTA files. + with open(txt_path, 'w') as oh: + for f in input_paths: + oh.write(f'{f}\n') + + cmd = [ + f'{bin_path}', + 'all2all', + '--in-txt', + f'{txt_path}', + '-o', + f'{output_path}', + '-t', + f'{num_threads}', + '--mal', f'{mal}', + '--msl', f'{msl}', + '--mrd', f'{mrd}', + '--mqd', f'{mqd}', + '--reg', f'{reg}', + '--aw', f'{aw}', + '--am', f'{am}', + '--ar', f'{ar}', + '--multisample-fasta', + 'true' if len(input_paths) == 1 else 'false', + '--out-type', 'tsv', + '--out-format', + ','.join(out_format), + ] + if filter_file: + cmd.extend(['--flt-kmerdb', f'{filter_file}', f'{filter_threshold}']) + if out_aln_path: + cmd.extend(['--out-alignment', f'{out_aln_path}']) + + cols = [ + ('tani', out_tani), ('gani', out_gani), ('ani', out_ani), + ('qcov', out_qcov), ('rcov', out_rcov) + ] + for name, value in cols: + if value > 0: + cmd.extend(['--out-filter', f'{name}', f'{value}']) + + if verbosity_level: + cmd.extend(['--verbose', f'{verbosity_level + 1}']) + + return cmd + + +def cmd_clusty( + input_path: pathlib.Path, + ids_path: pathlib.Path, + output_path: pathlib.Path, + algorithm: str, + metric: str, + tani: float, + gani: float, + ani: float, + qcov: float, + rcov: float, + num_alns: int, + len_ratio: float, + is_representatives: bool, + leiden_resolution: float, + leiden_beta: float, + leiden_iterations: int, + bin_path=BIN_CLUSTY, + ) -> typing.List[str]: + """"""Builds the command for Clusty. + + Args: + input_path (Path): + Path to the input ANI file. + ids_path (Path): + Path to the input file with sequence identifiers. + output_path (Path): + Path to the output file. + algorithm (str): + Clustering algorithm. + metric (str): + Similarity metric for clustering. + metric_threshold (float): + Similarity threshold. + tani (float): + Minimum tANI. + gani (float): + Minimum gANI. + ani (float): + Minimum ANI. + qcov (float): + Minimum query coverage (aligned fraction). + rcov (float): + Minimum reference coverage (aligned fraction). + num_alns (int): + Maximum number of local alignments between two genomes. + len_ratio (float): + Ratio between genome sequence lengths (shorter / longer) + is_representatives (bool): + Whether to output a representative genome for each cluster. + leiden_resolution (float): + Resolution parameter for the Leiden algorithm. + leiden_beta (float): + Beta parameter for the Leiden algorithm. + leiden_iterations (int): + Number of iterations for the Leiden algorithm. + bin_path (Path): + Path to the Clusty executable. + + Returns: + list: The constructed command as a list of strings. + + """""" + cmd = [ + f'{bin_path}', + '--objects-file', + f'{ids_path}', + '--algo', + f'{algorithm}', + f'--id-cols', + 'qidx', 'ridx', + '--distance-col', + f'{metric}', + '--similarity', + '--numeric-ids', + ] + cols = [('tani', tani), ('gani', gani), ('ani', ani), ('qcov', qcov), + ('rcov', rcov), ('len_ratio', len_ratio)] + for name, value in cols: + if value > 0: + cmd.extend(['--min', f'{name}', f'{value}']) + if num_alns > 0: + cmd.extend(['--max', 'num_alns', f'{num_alns}']) + if is_representatives: + cmd.append('--out-representatives') + if algorithm == 'leiden': + leiden_options = [ + '--leiden-resolution', f'{leiden_resolution}', + '--leiden-beta', f'{leiden_beta}', + '--leiden-iterations', f'{leiden_iterations}', + ] + cmd.extend(leiden_options) + + cmd.extend([f'{input_path}', f'{output_path}']) + return cmd + + +def handle_info(args, parser, logger) -> None: + """""" + Displays the Vclust version, installation paths, and binary dependencies. + Checks for the presence and executable status of required binaries. + + Exits with a non-zero status if any dependencies are missing or + not executable. + + Returns: + None + + Raises: + SystemExit: If any binary dependencies are missing or not executable. + + """""" + binaries = { + 'Kmer-db': BIN_KMERDB, + 'LZ-ANI': BIN_LZANI, + 'Clusty': BIN_CLUSTY, + 'mfasta': BIN_MFASTA, + } + + vclustpy_size_kb = f'{VCLUST_SCRIPT_PATH.stat().st_size / 1024:.1f} KB' + output_lines = [ + f'Vclust version {__version__} (Python {platform.python_version()})', + '', + 'Citation:', + CITATION, + '', + 'Installed at:', + f' {VCLUST_SCRIPT_PATH.resolve()} ({vclustpy_size_kb})', + f' {BIN_DIR.resolve()}', + '', + 'Binary dependencies:', + ] + + errors = [] # List to collect any errors encountered during binary checks. + + # Check each binary's presence and version. + for name, path in binaries.items(): + try: + _validate_binary(path) + version = subprocess.run( + [str(path), '-version' if name == 'Kmer-db' else '--version'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + check=True + ).stderr.strip() + size_mb = f'{path.stat().st_size / 1024 / 1024:.1f} MB' + output_lines.append(f' {name:<20} v{version:<7} ({size_mb})') + except Exception as e: + output_lines.append(f' {name:<20} [error]') + errors.append((name, e)) + + # Append the status summary based on any encountered errors. + output_lines.append('') + if errors: + output_lines.append(f'\033[31mStatus: error\033[0m') + output_lines.extend(f"" - {name}: {error}"" for name, error in errors) + else: + output_lines.append(f'\033[32;1mStatus: ready\033[0m') + + # Output the complete information. + print('\n'.join(output_lines)) + + if errors: + sys.exit(1) + + +def handle_deduplicate(args, parser, logger) -> None: + """""" + Deduplicates input FASTA files by validating inputs, constructing commands, + and executing the deduplication process. + + Args: + args (argparse.Namespace): + Parsed command-line arguments. + parser (argparse.ArgumentParser): + Argument parser for validation. + logger (logging.Logger): + Logger instance for logging messages. + + """""" + validate_binary(BIN_MFASTA) + args = validate_args_deduplicate(args, parser) + cmd = cmd_mfasta_deduplicate( + input_paths=args.input_path, + output_path=args.output_path, + output_duplicates_path=args.output_duplicates_path, + add_prefixes=args.add_prefixes, + gzip_output=args.gzip_output, + gzip_level=args.gzip_level, + verbosity_level=args.verbosity_level, + num_threads=args.num_threads, + ) + run(cmd, args.verbosity_level, logger) + + +def handle_prefilter(args, parser, logger) -> None: + """""" + Preprocesses FASTA inputs by building Kmer-db databases and computing + pairwise distances between sequences. + + Args: + args (argparse.Namespace): + Parsed command-line arguments. + parser (argparse.ArgumentParser): + Argument parser for validation. + logger (logging.Logger): + Logger instance for logging messages. + + """""" + validate_binary(BIN_KMERDB) + args = validate_args_prefilter(args, parser) + args = validate_args_fasta_input(args, parser) + + out_dir = args.output_path.parent + + with tempfile.TemporaryDirectory(dir=out_dir) as temp_dir: + out_dir = pathlib.Path(temp_dir) + logger.info(f'Temp directory created: {out_dir}') + batches = [] + # Input is a directory of fasta files. + if not args.is_multifasta: + batches.append(args.fasta_paths) + else: + # Split multi-fasta file. + if args.batch_size: + validate_binary(BIN_MFASTA) + cmd = cmd_mfasta_split( + input_fasta=args.input_path, + out_dir=out_dir, + n=args.batch_size, + verbosity_level=args.verbosity_level, + num_threads=args.num_threads, + ) + run(cmd, args.verbosity_level, logger) + batches.extend(sorted([f] for f in out_dir.glob('part_*'))) + # Do not split multi-fasta file. + else: + batches.append([args.input_path]) + + db_paths = [] + num_batches = len(batches) + for i, batch in enumerate(batches): + logger.info(f'Processing batch: {i+1}/{num_batches}') + batch_id = f'part_{i:05d}' if num_batches > 1 else 'whole' + txt_path = out_dir / f'{batch_id}.txt' + db_path = out_dir / f'{batch_id}.kdb' + + # kmer-db build. + cmd = cmd_kmerdb_build( + input_paths=batch, + txt_path=txt_path, + db_path=db_path, + is_multisample_fasta=args.is_multifasta, + kmer_size=args.k, + kmers_fraction=args.kmers_fraction, + num_threads=args.num_threads, + ) + run(cmd, args.verbosity_level, logger) + db_paths.append(db_path) + + # Delete the partial FASTA file after building the corresponding + # partial Kmer-db database. + if num_batches > 1: + batch[0].unlink() + + # Run kmer-db all2all. + db_list_path = out_dir / 'db_list.txt' + all2all_path = out_dir / 'all2all.txt' + cmd = cmd_kmerdb_all2all( + db_paths=db_paths, + db_list_path=db_list_path, + outfile_all2all=all2all_path, + min_kmers=args.min_kmers, + min_ident=args.min_ident, + max_seqs=args.max_seqs, + num_threads=args.num_threads, + ) + run(cmd, args.verbosity_level, logger) + + # Run kmer-db distance. + cmd = cmd_kmerdb_distance( + infile_all2all=all2all_path, + outfile_distance=args.output_path, + min_ident=args.min_ident, + num_threads=args.num_threads, + ) + run(cmd, args.verbosity_level, logger) + + +def handle_align(args, parser, logger) -> None: + """"""Aligns input sequences using LZ-ANI and outputs alignment metrics. + + Args: + args (argparse.Namespace): + Parsed command-line arguments. + parser (argparse.ArgumentParser): + Argument parser for validation. + logger (logging.Logger): + Logger instance for logging messages. + + """""" + validate_binary(BIN_LZANI) + args = validate_args_fasta_input(args, parser) + + out_dir = args.output_path.parent + + with tempfile.TemporaryDirectory(dir=out_dir) as temp_dir: + out_dir = pathlib.Path(temp_dir) + logger.info(f'Temp directory created: {out_dir}') + txt_path = out_dir / 'ids.txt' + + # Run lz-ani. + cmd = cmd_lzani( + input_paths=args.fasta_paths, + txt_path=txt_path, + output_path=args.output_path, + out_format=ALIGN_OUTFMT[args.outfmt], + out_aln_path=args.aln_path, + out_tani=args.tani, + out_gani=args.gani, + out_ani=args.ani, + out_qcov=args.qcov, + out_rcov=args.rcov, + filter_file=args.filter_path, + filter_threshold=args.filter_threshold, + mal=args.mal, + msl=args.msl, + mrd=args.mrd, + mqd=args.mqd, + reg=args.reg, + aw=args.aw, + am=args.am, + ar=args.ar, + num_threads=args.num_threads, + verbosity_level=args.verbosity_level, + ) + run(cmd, args.verbosity_level, logger) + + +def handle_cluster(args, parser, logger): + """"""Clusters sequences based on input metrics and parameters using the + specified clustering algorithm. + + Args: + args (argparse.Namespace): + Parsed command-line arguments. + parser (argparse.ArgumentParser): + Argument parser for validation. + logger (logging.Logger): + Logger instance for logging messages. + """""" + + validate_binary(BIN_CLUSTY) + args = validate_args_cluster(args, parser) + cmd = cmd_clusty( + input_path=args.input_path, + ids_path=args.ids_path, + output_path=args.output_path, + algorithm=args.algorithm, + metric=args.metric, + tani=args.tani, + gani=args.gani, + ani=args.ani, + qcov=args.qcov, + rcov=args.rcov, + num_alns=args.num_alns, + len_ratio=args.len_ratio, + is_representatives=args.representatives, + leiden_resolution=args.leiden_resolution, + leiden_beta=args.leiden_beta, + leiden_iterations=args.leiden_iterations, + ) + run(cmd, args.verbosity_level, logger) + + +class CustomLoggerFormatter(logging.Formatter): + """"""Custom logging formatter with log messages with different colors"""""" + + FMT = '{asctime} [{levelname:^7}] {message}' + FORMATS = { + logging.DEBUG: FMT, + logging.INFO: f""\33[36m{FMT}\33[0m"", + logging.WARNING: f""\33[33m{FMT}\33[0m"", + logging.ERROR: f""\33[31m{FMT}\33[0m"", + } + + def format(self, record): + log_fmt = self.FORMATS[record.levelno] + formatter = logging.Formatter(log_fmt, style=""{"") + return formatter.format(record) + + +class CustomHelpFormatter(argparse.RawDescriptionHelpFormatter): + """"""Custom help message formatter for argparse."""""" + + def _format_action_invocation(self, action): + # Allows options with arguments to be formatted as + # ""arg1, arg2 metavar"" instead of the ""arg1 metavar, arg2 metavar"". + # https://stackoverflow.com/a/31124505 + if not action.option_strings or action.nargs == 0: + return super()._format_action_invocation(action) + default = self._get_default_metavar_for_optional(action) + args_string = self._format_args(action, default) + return ', '.join(action.option_strings) + ' ' + args_string + + def _split_lines(self, text, width): + # Allows inserting new lines on argparse help text. + # https://stackoverflow.com/a/56865996 + r = [] + for t in text.splitlines(): + r.extend(argparse.HelpFormatter._split_lines(self, t, width)) + return r + + +def main(): + parser = get_parser() + args = parser.parse_args() + + # Initialize logger + logger = create_logger('Vclust', getattr(args, 'verbosity_level', 0)) + + # Command handlers + command_map = { + 'info': handle_info, + 'deduplicate': handle_deduplicate, + 'prefilter': handle_prefilter, + 'align': handle_align, + 'cluster': handle_cluster, + } + + # Dispatch the appropriate command + if args.command in command_map: + command_map[args.command](args, parser, logger) + + +if __name__ == '__main__': + main() +","Python" +"Viral","broadinstitute/viral-ngs","illumina.py",".py","47524","1047","#!/usr/bin/env python +"""""" +Utilities for demultiplexing Illumina data. +"""""" + +__author__ = ""dpark@broadinstitute.org"" +__commands__ = [] + +import argparse +import logging +import os +import os.path +import re +import gc +import csv +import shutil +import subprocess +import tempfile +import xml.etree.ElementTree +from collections import defaultdict +import concurrent.futures + +import arrow + +import util.cmd +import util.file +import util.misc +import tools.picard +from util.illumina_indices import IlluminaIndexReference, IlluminaBarcodeHelper + +log = logging.getLogger(__name__) + +# ========================= +# *** illumina_demux *** +# ========================= + + +def parser_illumina_demux(parser=argparse.ArgumentParser()): + parser.add_argument('inDir', help='Illumina BCL directory (or tar.gz of BCL directory). This is the top-level run directory.') + parser.add_argument('lane', help='Lane number.', type=int) + parser.add_argument('outDir', help='Output directory for BAM files.') + + parser.add_argument('--outMetrics', + help='Output ExtractIlluminaBarcodes metrics file. Default is to dump to a temp file.', + default=None) + parser.add_argument('--commonBarcodes', + help='''Write a TSV report of all barcode counts, in descending order. + Only applicable for read structures containing ""B""''', + default=None) + parser.add_argument('--sampleSheet', + default=None, + help='''Override SampleSheet. Input tab or CSV file w/header and four named columns: + barcode_name, library_name, barcode_sequence_1, barcode_sequence_2. + Default is to look for a SampleSheet.csv in the inDir.''') + parser.add_argument('--runInfo', + default=None, + dest=""runinfo"", + help='''Override RunInfo. Input xml file. + Default is to look for a RunInfo.xml file in the inDir.''') + parser.add_argument('--flowcell', help='Override flowcell ID (default: read from RunInfo.xml).', default=None) + parser.add_argument('--read_structure', + help='Override read structure (default: read from RunInfo.xml).', + default=None) + + for opt in tools.picard.ExtractIlluminaBarcodesTool.option_list: + if opt not in ('read_structure', 'num_processors'): + parser.add_argument('--' + opt, + help='Picard ExtractIlluminaBarcodes ' + opt.upper() + ' (default: %(default)s)', + default=tools.picard.ExtractIlluminaBarcodesTool.defaults.get(opt)) + for opt in tools.picard.IlluminaBasecallsToSamTool.option_list: + if opt == 'adapters_to_check': + parser.add_argument('--' + opt, + nargs='*', + help='Picard IlluminaBasecallsToSam ' + opt.upper() + ' (default: %(default)s)', + default=tools.picard.IlluminaBasecallsToSamTool.defaults.get(opt)) + elif opt in ('read_structure', 'num_processors'): + pass + else: + parser.add_argument('--' + opt, + help='Picard IlluminaBasecallsToSam ' + opt.upper() + ' (default: %(default)s)', + default=tools.picard.IlluminaBasecallsToSamTool.defaults.get(opt)) + + parser.add_argument('--JVMmemory', + help='JVM virtual memory size (default: %(default)s)', + default=tools.picard.IlluminaBasecallsToSamTool.jvmMemDefault) + util.cmd.common_args(parser, (('threads', tools.picard.IlluminaBasecallsToSamTool.defaults['num_processors']), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_illumina_demux) + return parser + + +def main_illumina_demux(args): + ''' Read Illumina runs & produce BAM files, demultiplexing to one bam per sample, or + for simplex runs, a single bam will be produced bearing the flowcell ID. + Wraps together Picard's ExtractBarcodes (for multiplexed samples) and IlluminaBasecallsToSam + while handling the various required input formats. Also can + read Illumina BCL directories, tar.gz BCL directories. + ''' + # TO DO: read BCL or tar.gz BCL directories from S3 / object store. + + # prepare + illumina = IlluminaDirectory(args.inDir) + illumina.load() + + if args.runinfo: + runinfo = RunInfo(args.runinfo) + else: + runinfo = illumina.get_RunInfo() + if args.flowcell: + flowcell = args.flowcell + else: + flowcell = runinfo.get_flowcell() + if args.run_start_date: + run_date = args.run_start_date + else: + run_date = runinfo.get_rundate_american() + if args.read_structure: + read_structure = args.read_structure + else: + read_structure = runinfo.get_read_structure() + if args.sampleSheet: + samples = SampleSheet(args.sampleSheet, only_lane=args.lane) + else: + samples = illumina.get_SampleSheet(only_lane=args.lane) + + + link_locs=False + # For HiSeq-4000/X runs, If Picard's CheckIlluminaDirectory is + # called with LINK_LOCS=true, symlinks with absolute paths + # may be created, pointing from tile-specific *.locs to the + # single s.locs file in the Intensities directory. + # These links may break if the run directory is moved. + # We should begin by removing broken links, if present, + # and call CheckIlluminaDirectory ourselves if a 's.locs' + # file is present, but only if the directory check fails + # since link_locs=true tries to create symlinks even if they + # (or the files) already exist + try: + tools.picard.CheckIlluminaDirectoryTool().execute( + illumina.get_BCLdir(), + args.lane, + read_structure, + link_locs=link_locs + ) + except subprocess.CalledProcessError as e: + log.warning(""CheckIlluminaDirectory failed for %s"", illumina.get_BCLdir()) + if os.path.exists(os.path.join(illumina.get_intensities_dir(), ""s.locs"")): + # recurse to remove broken links in directory + log.info(""This run has an 's.locs' file; checking for and removing broken per-tile symlinks..."") + broken_links = util.file.find_broken_symlinks(illumina.get_intensities_dir()) + if len(broken_links): + for lpath in broken_links: + log.info(""Removing broken symlink: %s"", lpath) + os.unlink(lpath) + + # call CheckIlluminaDirectory with LINK_LOCS=true + link_locs=True + + log.info(""Checking run directory with Picard..."") + tools.picard.CheckIlluminaDirectoryTool().execute( + illumina.get_BCLdir(), + args.lane, + read_structure, + link_locs=link_locs + ) + else: + log.error(""CheckIlluminaDirectory failed for %s"", illumina.get_BCLdir()) + + multiplexed_samples = True if 'B' in read_structure else False + + if multiplexed_samples: + assert samples is not None, ""This looks like a multiplexed run since 'B' is in the read_structure: a SampleSheet must be given."" + else: + assert samples==None, ""A SampleSheet may not be provided unless 'B' is present in the read_structure"" + if args.commonBarcodes: + log.warning(""--commonBarcodes was set but 'B' is not present in the read_structure; emitting an empty file."") + util.file.touch(args.commonBarcodes) + + # B in read structure indicates barcoded multiplexed samples + if multiplexed_samples: + # Picard ExtractIlluminaBarcodes + extract_input = util.file.mkstempfname('.txt', prefix='.'.join(['barcodeData', flowcell, str(args.lane)])) + barcodes_tmpdir = tempfile.mkdtemp(prefix='extracted_barcodes-') + samples.make_barcodes_file(extract_input) + out_metrics = (args.outMetrics is None) and util.file.mkstempfname('.metrics.txt') or args.outMetrics + picardOpts = dict((opt, getattr(args, opt)) for opt in tools.picard.ExtractIlluminaBarcodesTool.option_list + if hasattr(args, opt) and getattr(args, opt) != None) + picardOpts['read_structure'] = read_structure + tools.picard.ExtractIlluminaBarcodesTool().execute( + illumina.get_BCLdir(), + args.lane, + extract_input, + barcodes_tmpdir, + out_metrics, + picardOptions=picardOpts, + JVMmemory=args.JVMmemory) + + if args.commonBarcodes: + # this step can take > 2 hours on a large high-output flowcell + # so kick it to the background while we demux + #count_and_sort_barcodes(barcodes_tmpdir, args.commonBarcodes) + executor = concurrent.futures.ProcessPoolExecutor() + executor.submit(count_and_sort_barcodes, barcodes_tmpdir, args.commonBarcodes) + + # Picard IlluminaBasecallsToSam + basecalls_input = util.file.mkstempfname('.txt', prefix='.'.join(['library_params', flowcell, str(args.lane)])) + samples.make_params_file(args.outDir, basecalls_input) + + picardOpts = dict((opt, getattr(args, opt)) for opt in tools.picard.IlluminaBasecallsToSamTool.option_list + if hasattr(args, opt) and getattr(args, opt) != None) + picardOpts['run_start_date'] = run_date + picardOpts['read_structure'] = read_structure + if args.threads: + picardOpts['num_processors'] = args.threads + if not picardOpts.get('sequencing_center') and runinfo: + picardOpts['sequencing_center'] = runinfo.get_machine() + + if picardOpts.get('sequencing_center'): + picardOpts[""sequencing_center""] = util.file.string_to_file_name(picardOpts[""sequencing_center""]) + + # manually garbage collect to make sure we have as much RAM free as possible + gc.collect() + if multiplexed_samples: + tools.picard.IlluminaBasecallsToSamTool().execute( + illumina.get_BCLdir(), + barcodes_tmpdir, + flowcell, + args.lane, + basecalls_input, + picardOptions=picardOpts, + JVMmemory=args.JVMmemory) + else: + tools.picard.IlluminaBasecallsToSamTool().execute_single_sample( + illumina.get_BCLdir(), + os.path.join(args.outDir,flowcell+"".bam""), + flowcell, + args.lane, + flowcell, + picardOptions=picardOpts, + JVMmemory=args.JVMmemory) + + # clean up + if multiplexed_samples: + if args.commonBarcodes: + log.info(""waiting for commonBarcodes output to finish..."") + executor.shutdown(wait=True) + os.unlink(extract_input) + os.unlink(basecalls_input) + shutil.rmtree(barcodes_tmpdir) + illumina.close() + log.info(""illumina_demux complete"") + return 0 + + +__commands__.append(('illumina_demux', parser_illumina_demux)) + + +# ========================== +# *** lane_metrics *** +# ========================== + +def parser_lane_metrics(parser=argparse.ArgumentParser()): + parser.add_argument('inDir', help='Illumina BCL directory (or tar.gz of BCL directory). This is the top-level run directory.') + parser.add_argument('outPrefix', help='''Prefix path to the *.illumina_lane_metrics and *.illumina_phasing_metrics files.''') + parser.add_argument('--read_structure', + help='Override read structure (default: read from RunInfo.xml).', + default=None) + parser.add_argument('--JVMmemory', + help='JVM virtual memory size (default: %(default)s)', + default=tools.picard.ExtractIlluminaBarcodesTool.jvmMemDefault) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_lane_metrics) + return parser + +def main_lane_metrics(args): + ''' + Write out lane metrics to a tsv file. + ''' + # prepare + illumina = IlluminaDirectory(args.inDir) + illumina.load() + if args.read_structure: + read_structure = args.read_structure + else: + read_structure = illumina.get_RunInfo().get_read_structure() + + # Picard CollectIlluminaLaneMetrics + output_dir = os.path.dirname(os.path.realpath(args.outPrefix)) + output_prefix = os.path.basename(os.path.realpath(args.outPrefix)) + + picardOpts = dict((opt, getattr(args, opt)) for opt in tools.picard.CollectIlluminaLaneMetricsTool.option_list + if hasattr(args, opt) and getattr(args, opt) != None) + picardOpts['read_structure'] = read_structure + tools.picard.CollectIlluminaLaneMetricsTool().execute( + illumina.path, + output_dir, + output_prefix, + picardOptions=picardOpts, + JVMmemory=args.JVMmemory) + + illumina.close() + return 0 + +__commands__.append(('lane_metrics', parser_lane_metrics)) + + +# ========================== +# *** common_barcodes *** +# ========================== + +def parser_common_barcodes(parser=argparse.ArgumentParser()): + parser.add_argument('inDir', help='Illumina BCL directory (or tar.gz of BCL directory). This is the top-level run directory.') + parser.add_argument('lane', help='Lane number.', type=int) + parser.add_argument('outSummary', help='''Path to the summary file (.tsv format). It includes several columns: + (barcode1, likely_index_name1, barcode2, likely_index_name2, count), + where likely index names are either the exact match index name for the barcode + sequence, or those Hamming distance of 1 away.''') + + parser.add_argument('--truncateToLength', + help='If specified, only this number of barcodes will be returned. Useful if you only want the top N barcodes.', + type=int, + default=None) + parser.add_argument('--omitHeader', + help='If specified, a header will not be added to the outSummary tsv file.', + action='store_true') + parser.add_argument('--includeNoise', + help='If specified, barcodes with periods (""."") will be included.', + action='store_true') + parser.add_argument('--outMetrics', + help='Output ExtractIlluminaBarcodes metrics file. Default is to dump to a temp file.', + default=None) + parser.add_argument('--sampleSheet', + default=None, + help='''Override SampleSheet. Input tab or CSV file w/header and four named columns: + barcode_name, library_name, barcode_sequence_1, barcode_sequence_2. + Default is to look for a SampleSheet.csv in the inDir.''') + parser.add_argument('--flowcell', help='Override flowcell ID (default: read from RunInfo.xml).', default=None) + parser.add_argument('--read_structure', + help='Override read structure (default: read from RunInfo.xml).', + default=None) + + for opt in tools.picard.ExtractIlluminaBarcodesTool.option_list: + if opt not in ('read_structure', 'num_processors'): + parser.add_argument('--' + opt, + help='Picard ExtractIlluminaBarcodes ' + opt.upper() + ' (default: %(default)s)', + default=tools.picard.ExtractIlluminaBarcodesTool.defaults.get(opt)) + + parser.add_argument('--JVMmemory', + help='JVM virtual memory size (default: %(default)s)', + default=tools.picard.ExtractIlluminaBarcodesTool.jvmMemDefault) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_common_barcodes) + return parser + +def main_common_barcodes(args): + ''' + Extract Illumina barcodes for a run and write a TSV report + of the barcode counts in descending order + ''' + + # prepare + illumina = IlluminaDirectory(args.inDir) + illumina.load() + if args.flowcell: + flowcell = args.flowcell + else: + flowcell = illumina.get_RunInfo().get_flowcell() + if args.read_structure: + read_structure = args.read_structure + else: + read_structure = illumina.get_RunInfo().get_read_structure() + if args.sampleSheet: + samples = SampleSheet(args.sampleSheet, only_lane=args.lane) + else: + samples = illumina.get_SampleSheet(only_lane=args.lane) + + # Picard ExtractIlluminaBarcodes + barcode_file = util.file.mkstempfname('.txt', prefix='.'.join(['barcodeData', flowcell, str(args.lane)])) + barcodes_tmpdir = tempfile.mkdtemp(prefix='extracted_barcodes-') + samples.make_barcodes_file(barcode_file) + out_metrics = (args.outMetrics is None) and util.file.mkstempfname('.metrics.txt') or args.outMetrics + picardOpts = dict((opt, getattr(args, opt)) for opt in tools.picard.ExtractIlluminaBarcodesTool.option_list + if hasattr(args, opt) and getattr(args, opt) != None) + picardOpts['read_structure'] = read_structure + tools.picard.ExtractIlluminaBarcodesTool().execute( + illumina.get_BCLdir(), + args.lane, + barcode_file, + barcodes_tmpdir, + out_metrics, + picardOptions=picardOpts, + JVMmemory=args.JVMmemory) + + count_and_sort_barcodes(barcodes_tmpdir, args.outSummary, args.truncateToLength, args.includeNoise, args.omitHeader) + + # clean up + os.unlink(barcode_file) + shutil.rmtree(barcodes_tmpdir) + illumina.close() + return 0 + +__commands__.append(('common_barcodes', parser_common_barcodes)) + +def count_and_sort_barcodes(barcodes_dir, outSummary, truncateToLength=None, includeNoise=False, omitHeader=False): + # collect the barcode file paths for all tiles + tile_barcode_files = [os.path.join(barcodes_dir, filename) for filename in os.listdir(barcodes_dir)] + + # count all of the barcodes present in the tile files + log.info(""reading barcodes in all tile files"") + barcode_counts = defaultdict(lambda: 0) + + def sum_reducer(accumulator, element): + for key, value in element.items(): + accumulator[key] = accumulator.get(key, 0) + value + return accumulator + + with concurrent.futures.ProcessPoolExecutor(max_workers=len(tile_barcode_files)) as executor: + futures = [executor.submit(util.file.count_occurrences_in_tsv, filePath, include_noise=includeNoise) for filePath in tile_barcode_files] + for future in concurrent.futures.as_completed(futures): + barcode_counts = sum_reducer(barcode_counts, future.result()) + + # sort the counts, descending. Truncate the result if desired + log.info(""sorting counts"") + illumina_reference = IlluminaIndexReference() + count_to_write = truncateToLength if truncateToLength else len(barcode_counts) + barcode_pairs_sorted_by_count = sorted(barcode_counts, key=barcode_counts.get, reverse=True)[:count_to_write] + + mapped_counts = ( (k[:8], "","".join([x for x in illumina_reference.guess_index(k[:8], distance=1)] or [""Unknown""]), + k[8:], "","".join([x for x in illumina_reference.guess_index(k[8:], distance=1)] or [""Unknown""]), + barcode_counts[k]) + for k in barcode_pairs_sorted_by_count) + + # write the barcodes and their corresponding counts + log.info(""writing output"") + with open(outSummary, 'w') as tsvfile: + writer = csv.writer(tsvfile, delimiter='\t') + # write the header unless the user has specified not to do so + if not omitHeader: + writer.writerow((""Barcode1"", ""Likely_Index_Names1"", ""Barcode2"", ""Likely_Index_Names2"", ""Count"")) + writer.writerows(mapped_counts) + + log.info(""done"") + +# ====================================== +# *** guess_low-abundance_barcodes *** +# ====================================== + +def parser_guess_barcodes(parser=argparse.ArgumentParser()): + parser.add_argument('in_barcodes', help='The barcode counts file produced by common_barcodes.') + parser.add_argument('in_picard_metrics', help='The demultiplexing read metrics produced by Picard.') + parser.add_argument('out_summary_tsv', help='''Path to the summary file (.tsv format). It includes several columns: + (sample_name, expected_barcode_1, expected_barcode_2, + expected_barcode_1_name, expected_barcode_2_name, + expected_barcodes_read_count, guessed_barcode_1, + guessed_barcode_2, guessed_barcode_1_name, + guessed_barcode_2_name, guessed_barcodes_read_count, + match_type), + where the expected values are those used by Picard during demultiplexing + and the guessed values are based on the barcodes seen among the data.''') + + group = parser.add_mutually_exclusive_group() + group.add_argument('--readcount_threshold', + default=None, + type=int, + help='''If specified, guess barcodes for samples with fewer than this many reads.''') + group.add_argument('--sample_names', + nargs='*', + help='If specified, only guess barcodes for these sample names.', + type=str, + default=None) + parser.add_argument('--outlier_threshold', + help='threshold of how far from unbalanced a sample must be to be considered an outlier.', + type=float, + default=0.675) + parser.add_argument('--expected_assigned_fraction', + help='The fraction of reads expected to be assigned. An exception is raised if fewer than this fraction are assigned.', + type=float, + default=0.7) + parser.add_argument('--number_of_negative_controls', + help='The number of negative controls in the pool, for calculating expected number of reads in the rest of the pool.', + type=int, + default=1) + + parser.add_argument('--rows_limit', + default=1000, + type=int, + help='''The number of rows to use from the in_barcodes.''') + + + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_guess_barcodes, split_args=True) + return parser + +def main_guess_barcodes(in_barcodes, + in_picard_metrics, + out_summary_tsv, + sample_names, + outlier_threshold, + expected_assigned_fraction, + number_of_negative_controls, + readcount_threshold, + rows_limit): + """""" + Guess the barcode value for a sample name, + based on the following: + - a list is made of novel barcode pairs seen in the data, but not in the picard metrics + - for the sample in question, get the most abundant novel barcode pair where one of the + barcodes seen in the data matches one of the barcodes in the picard metrics (partial match) + - if there are no partial matches, get the most abundant novel barcode pair + + Limitations: + - If multiple samples share a barcode with multiple novel barcodes, disentangling them + is difficult or impossible + + The names of samples to guess are selected: + - explicitly by name, passed via argument, OR + - explicitly by read count threshold, OR + - automatically (if names or count threshold are omitted) + based on basic outlier detection of deviation from an assumed-balanced pool with + some number of negative controls + """""" + + bh = util.illumina_indices.IlluminaBarcodeHelper(in_barcodes, in_picard_metrics, rows_limit) + guessed_barcodes = bh.find_uncertain_barcodes(sample_names=sample_names, + outlier_threshold=outlier_threshold, + expected_assigned_fraction=expected_assigned_fraction, + number_of_negative_controls=number_of_negative_controls, + readcount_threshold=readcount_threshold) + bh.write_guessed_barcodes(out_summary_tsv, guessed_barcodes) + +__commands__.append(('guess_barcodes', parser_guess_barcodes)) + + +# ============================ +# *** IlluminaDirectory *** +# ============================ + + +class IlluminaDirectory(object): + ''' A class that handles Illumina data directories + ''' + + def __init__(self, uri): + self.uri = uri + self.path = None + self.tempDir = None + self.runinfo = None + self.samplesheet = None + + def __enter__(self): + self.load() + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + return 0 + + def load(self): + if self.path is None: + if '://' in self.uri: + raise NotImplementedError('boto s3 download here uri -> tarball') + # tarball = util.file.mkstempfname('.tar.gz') + # # TODO: download here, uri -> tarball + # self._extract_tarball(tarball) + # os.unlink(tarball) + else: + if os.path.isdir(self.uri): + self.path = self.uri + else: + self._extract_tarball(self.uri) + self._fix_path() + + def _fix_path(self): + assert self.path is not None + # this is not the correct root-level directory + # sometimes this points to one level up + while True: + if os.path.isdir(os.path.join(self.path, 'Data', 'Intensities', 'BaseCalls')): + # found it! self.path is correct + break + else: + subdirs = list(os.path.join(self.path, x) for x in os.listdir(self.path) + if os.path.isdir(os.path.join(self.path, x))) + if len(subdirs) == 1: + # follow the rabbit hole + self.path = subdirs[0] + else: + # don't know where to go now! + raise Exception('cannot find Data/Intensities/BaseCalls/ inside %s (%s)' % (self.uri, self.path)) + + def _extract_tarball(self, tarfile): + self.tempDir = tempfile.mkdtemp(prefix='IlluminaDirectory-') + self.path = self.tempDir + util.file.extract_tarball(tarfile, self.tempDir) + + def close(self): + if self.tempDir: + shutil.rmtree(self.tempDir) + self.tempDir = None + + def get_RunInfo(self): + if self.runinfo is None: + runinfo_file = os.path.join(self.path, 'RunInfo.xml') + util.file.check_paths(runinfo_file) + self.runinfo = RunInfo(runinfo_file) + return self.runinfo + + def get_SampleSheet(self, only_lane=None): + if self.samplesheet is None: + samplesheet_file = os.path.join(self.path, 'SampleSheet.csv') + util.file.check_paths(samplesheet_file) + self.samplesheet = SampleSheet(samplesheet_file, only_lane=only_lane) + return self.samplesheet + + def get_intensities_dir(self): + return os.path.join(self.path, 'Data', 'Intensities') + + def get_BCLdir(self): + return os.path.join(self.get_intensities_dir(), 'BaseCalls') + + +# ================== +# *** RunInfo *** +# ================== + + +class RunInfo(object): + ''' A class that reads the RunInfo.xml file emitted by Illumina + MiSeq and HiSeq machines. + ''' + + def __init__(self, xml_fname): + self.fname = xml_fname + self.root = xml.etree.ElementTree.parse(xml_fname).getroot() + + def get_fname(self): + return self.fname + + def get_flowcell(self): + fc = self.root[0].find('Flowcell').text + # slice in the case where the ID has a prefix of zeros + if re.match(r""^0+-"", fc): + if '-' in fc: + # miseq often adds a bunch of leading zeros and a dash in front + fc = ""-"".join(fc.split('-')[1:]) + # >=5 to avoid an exception here: https://github.com/broadinstitute/picard/blob/2.17.6/src/main/java/picard/illumina/IlluminaBasecallsToSam.java#L510 + # <= 15 to limit the bytes added to each bam record + assert len(fc) >= 5,""The flowcell ID must be five or more characters in length"" + if len(fc) > 15: + log.warning(""The provided flowcell ID is longer than 15 characters. Is that correct?"") + return fc + + def _get_rundate_obj(self): + """""" + Access the text of the node in the RunInfo.xml file + and returns an arrow date object. + """""" + rundate = self.root[0].find('Date').text + # possible formats found in RunInfo.xml: + # ""170712"" (YYMMDD) + # ""20170712"" (YYYYMMDD) + # ""6/27/2018 4:59:20 PM"" (M/D/YYYY h:mm:ss A) + datestring_formats = [ + ""YYMMDD"", + ""YYYYMMDD"", + ""M/D/YYYY h:mm:ss A"" + ] + for datestring_format in datestring_formats: + try: + date_parsed = arrow.get(rundate, datestring_format) + return date_parsed + except arrow.parser.ParserError: + pass + raise arrow.parser.ParserError(""The date string seen in RunInfo.xml ('%s') did not match known Illumina formats: %s"" % (rundate,datestring_formats) ) + + def get_rundate_american(self): + return str(self._get_rundate_obj().format(""MM/DD/YYYY"")) + + def get_rundate_iso(self): + return str(self._get_rundate_obj().format(""YYYY-MM-DD"")) + + def get_machine(self): + return self.root[0].find('Instrument').text + + def get_read_structure(self): + reads = [] + for x in self.root[0].find('Reads').findall('Read'): + order = int(x.attrib['Number']) + read = x.attrib['NumCycles'] + (x.attrib['IsIndexedRead'] == 'Y' and 'B' or 'T') + reads.append((order, read)) + return ''.join([r for _, r in sorted(reads)]) + + def num_reads(self): + return sum(1 for x in self.root[0].find('Reads').findall('Read') if x.attrib['IsIndexedRead'] == 'N') + +# ====================== +# *** SampleSheet *** +# ====================== + +class SampleSheetError(Exception): + def __init__(self, message, fname): + super(SampleSheetError, self).__init__( + 'Failed to read SampleSheet {}. {}'.format( + fname, message)) + +class SampleSheet(object): + ''' A class that reads an Illumina SampleSheet.csv or alternative/simplified + tab-delimited versions as well. + ''' + + def __init__(self, infile, use_sample_name=True, only_lane=None, allow_non_unique=False): + self.fname = infile + self.use_sample_name = use_sample_name + if only_lane is not None: + only_lane = str(only_lane) + self.only_lane = only_lane + self.allow_non_unique = allow_non_unique + self.rows = [] + self._detect_and_load_sheet(infile) + + def _detect_and_load_sheet(self, infile): + if infile.endswith(('.csv','.csv.gz')): + # one of a few possible CSV formats (watch out for line endings from other OSes) + with util.file.open_or_gzopen(infile, 'rU') as inf: + header = None + miseq_skip = False + row_num = 0 + for line_no, line in enumerate(inf): + if line_no==0: + # remove BOM, if present + line = line.replace('\ufeff','') + + # if this is a blank line, skip parsing and continue to the next line... + if len(line.rstrip('\r\n').strip()) == 0: + continue + csv.register_dialect('samplesheet', quoting=csv.QUOTE_MINIMAL, escapechar='\\') + row = next(csv.reader([line.strip().rstrip('\n')], dialect=""samplesheet"")) + row = [item.strip() for item in row] # remove leading/trailing whitespace from each item + if miseq_skip: + if line.startswith('[Data]'): + # start paying attention *after* this line + miseq_skip = False + # otherwise, skip all the miseq headers + elif line.startswith('['): + # miseq: ignore all lines until we see ""[Data]"" + miseq_skip = True + elif header is None: + header = row + if all(x in header for x in ['Sample_ID','Index']): + # this is a Broad Platform MiSeq-generated SampleSheet.csv + keymapper = { + 'Sample_ID': 'sample', + 'Index': 'barcode_1', + 'Index2': 'barcode_2', + 'Sample_Name': 'sample_name' + } + header = list(map(keymapper.get, header)) + elif 'Sample_ID' in header: + # this is a MiSeq-generated SampleSheet.csv + keymapper = { + 'Sample_ID': 'sample', + 'index': 'barcode_1', + 'index2': 'barcode_2', + 'Sample_Name': 'sample_name' + } + header = list(map(keymapper.get, header)) + elif 'SampleID' in header: + # this is a Broad Platform HiSeq-generated SampleSheet.csv + keymapper = { + 'SampleID': 'sample', + 'Index': 'barcode_1', + 'Index2': 'barcode_2', + 'libraryName': 'library_id_per_sample', + 'FCID': 'flowcell', + 'Lane': 'lane' + } + header = list(map(keymapper.get, header)) + elif len(row) == 3: + # hopefully this is a Broad walk-up submission sheet (_web_iww_htdocs_seq...) + header = ['sample', 'barcode_1', 'barcode_2'] + if 'sample' not in row[0].lower(): + # this is an actual data row! (no header exists in this file) + row_num += 1 + self.rows.append({ + 'sample': row[0], + 'barcode_1': row[1], + 'barcode_2': row[2], + 'row_num': str(row_num) + }) + else: + raise SampleSheetError('unrecognized filetype', infile) + for h in ('sample', 'barcode_1'): + assert h in header + else: + # data rows + row_num += 1 + + # pad the row with null strings if it is shorter than the header list + # sometimes a MiSeq produces an out-of-spec CSV file that lacks trailing commas, + # removing null values that should be present to ensure a length match with the header + while len(row) < len(header): + row.append("""") + + assert len(header) == len(row) + row = dict((k, v) for k, v in zip(header, row) if k and v) + row['row_num'] = str(row_num) + if (self.only_lane is not None and row.get('lane') and self.only_lane != row['lane']): + continue + if ('sample' in row and row['sample']) and ('barcode_1' in row and row['barcode_1']): + self.rows.append(row) + # go back and re-shuffle miseq columns if use_sample_name applies + if (self.use_sample_name and 'sample_name' in header and all(row.get('sample_name') for row in self.rows)): + for row in self.rows: + row['library_id_per_sample'] = row['sample'] + row['sample'] = row['sample_name'] + for row in self.rows: + if 'sample_name' in row: + del row['sample_name'] + elif infile.endswith(('.txt','.txt.gz')): + # our custom tab file format: sample, barcode_1, barcode_2, library_id_per_sample + self.rows = [] + row_num = 0 + for row in util.file.read_tabfile_dict(infile): + assert row.get('sample') and row.get('barcode_1') + row_num += 1 + row['row_num'] = str(row_num) + self.rows.append(row) + else: + raise SampleSheetError('unrecognized filetype', infile) + + if not self.rows: + raise SampleSheetError('empty file', infile) + + # populate library IDs, run IDs (ie BAM filenames) + for row in self.rows: + row['library'] = row['sample'] + if row.get('library_id_per_sample'): + row['library'] += '.l' + row['library_id_per_sample'] + row['run'] = row['library'] + if len(set(row['run'] for row in self.rows)) != len(self.rows): + if self.allow_non_unique: + log.warning(""non-unique library IDs in this lane"") + unique_count = {} + for row in self.rows: + unique_count.setdefault(row['library'], 0) + unique_count[row['library']] += 1 + row['run'] += '.r' + str(unique_count[row['library']]) + else: + raise SampleSheetError('non-unique library IDs in this lane', infile) + + # escape sample, run, and library IDs to be filename-compatible + for row in self.rows: + row['sample'] = util.file.string_to_file_name(row['sample']) + row['library'] = util.file.string_to_file_name(row['library']) + row['run'] = util.file.string_to_file_name(row['run']) + + # are we single or double indexed? + if all(row.get('barcode_2') for row in self.rows): + self.indexes = 2 + elif any(row.get('barcode_2') for row in self.rows): + raise SampleSheetError('inconsistent single/double barcoding in sample sheet', infile) + else: + self.indexes = 1 + + def make_barcodes_file(self, outFile): + ''' Create input file for Picard ExtractBarcodes ''' + if self.num_indexes() == 2: + header = ['barcode_name', 'library_name', 'barcode_sequence_1', 'barcode_sequence_2'] + else: + header = ['barcode_name', 'library_name', 'barcode_sequence_1'] + with open(outFile, 'wt') as outf: + outf.write('\t'.join(header) + '\n') + for row in self.rows: + out = { + 'barcode_sequence_1': row['barcode_1'], + 'barcode_sequence_2': row.get('barcode_2', ''), + 'barcode_name': row['sample'], + 'library_name': row['library'] + } + outf.write('\t'.join(out[h] for h in header) + '\n') + + def make_params_file(self, bamDir, outFile): + ''' Create input file for Picard IlluminaBasecallsToXXX ''' + if self.num_indexes() == 2: + header = ['OUTPUT', 'SAMPLE_ALIAS', 'LIBRARY_NAME', 'BARCODE_1', 'BARCODE_2'] + else: + header = ['OUTPUT', 'SAMPLE_ALIAS', 'LIBRARY_NAME', 'BARCODE_1'] + with open(outFile, 'wt') as outf: + outf.write('\t'.join(header) + '\n') + # add one catchall entry at the end called Unmatched + rows = self.rows + [{ + 'barcode_1': 'N', + 'barcode_2': 'N', + 'sample': 'Unmatched', + 'library': 'Unmatched', + 'run': 'Unmatched' + }] + for row in rows: + out = { + 'BARCODE_1': row['barcode_1'], + 'BARCODE_2': row.get('barcode_2', ''), + 'SAMPLE_ALIAS': row['sample'], + 'LIBRARY_NAME': row['library'] + } + out['OUTPUT'] = os.path.join(bamDir, row['run'] + "".bam"") + outf.write('\t'.join(out[h] for h in header) + '\n') + + def get_fname(self): + return self.fname + + def get_rows(self): + return self.rows + + def num_indexes(self): + ''' Return 1 or 2 depending on whether pools are single or double indexed ''' + return self.indexes + + def fetch_by_index(self, idx): + idx = str(idx) + for row in self.rows: + if idx == row['row_num']: + return row + return None + +# ============================= +# *** miseq_fastq_to_bam *** +# ============================= + + +def miseq_fastq_to_bam(outBam, sampleSheet, inFastq1, inFastq2=None, runInfo=None, + sequencing_center=None, + JVMmemory=tools.picard.FastqToSamTool.jvmMemDefault): + ''' Convert fastq read files to a single bam file. Fastq file names must conform + to patterns emitted by Miseq machines. Sample metadata must be provided + in a SampleSheet.csv that corresponds to the fastq filename. Specifically, + the _S##_ index in the fastq file name will be used to find the corresponding + row in the SampleSheet + ''' + + # match miseq based on fastq filenames + mo = re.match(r""^\S+_S(\d+)_L001_R(\d)_001.fastq(?:.gz|)$"", inFastq1) + assert mo, ""fastq filename %s does not match the patterns used by an Illumina Miseq machine"" % inFastq1 + assert mo.group(2) == '1', ""fastq1 must correspond to read 1, not read %s"" % mo.group(2) + sample_num = mo.group(1) + if inFastq2: + mo = re.match(r""^\S+_S(\d+)_L001_R(\d)_001.fastq(?:.gz|)$"", inFastq2) + assert mo, ""fastq filename %s does not match the patterns used by an Illumina Miseq machine"" % inFastq2 + assert mo.group(2) == '2', ""fastq2 must correspond to read 2, not read %s"" % mo.group(2) + assert mo.group(1) == sample_num, ""fastq1 (%s) and fastq2 (%s) must have the same sample number"" % ( + sample_num, mo.group(1)) + + # load metadata + samples = SampleSheet(sampleSheet, allow_non_unique=True) + sample_info = samples.fetch_by_index(sample_num) + assert sample_info, ""sample %s not found in %s"" % (sample_num, sampleSheet) + sampleName = sample_info['sample'] + log.info(""Using sample name: %s"", sampleName) + if sample_info.get('barcode_2'): + barcode = '-'.join((sample_info['barcode_1'], sample_info['barcode_2'])) + else: + barcode = sample_info['barcode_1'] + picardOpts = { + 'LIBRARY_NAME': sample_info['library'], + 'PLATFORM': 'illumina', + 'VERBOSITY': 'WARNING', + 'QUIET': 'TRUE', + } + if runInfo: + runInfo = RunInfo(runInfo) + flowcell = runInfo.get_flowcell() + picardOpts['RUN_DATE'] = runInfo.get_rundate_iso() + if inFastq2: + assert runInfo.num_reads() == 2, ""paired fastqs given for a single-end RunInfo.xml"" + else: + assert runInfo.num_reads() == 1, ""second fastq missing for a paired-end RunInfo.xml"" + else: + flowcell = 'A' + if sequencing_center is None and runInfo: + sequencing_center = runInfo.get_machine() + if sequencing_center: + picardOpts['SEQUENCING_CENTER'] = util.file.string_to_file_name(sequencing_center) + picardOpts['PLATFORM_UNIT'] = '.'.join((flowcell, '1', barcode)) + if len(flowcell) > 5: + flowcell = flowcell[:5] + picardOpts['READ_GROUP_NAME'] = flowcell + + # run Picard + picard = tools.picard.FastqToSamTool() + picard.execute(inFastq1, + inFastq2, + sampleName, + outBam, + picardOptions=picard.dict_to_picard_opts(picardOpts), + JVMmemory=JVMmemory) + return 0 + + +def parser_miseq_fastq_to_bam(parser=argparse.ArgumentParser()): + parser.add_argument('outBam', help='Output BAM file.') + parser.add_argument('sampleSheet', help='Input SampleSheet.csv file.') + parser.add_argument('inFastq1', help='Input fastq file; 1st end of paired-end reads if paired.') + parser.add_argument('--inFastq2', help='Input fastq file; 2nd end of paired-end reads.', default=None) + parser.add_argument('--runInfo', help='Input RunInfo.xml file.', default=None) + parser.add_argument( + '--sequencing_center', + default=None, + help='Name of your sequencing center (default is the sequencing machine ID from the RunInfo.xml)') + parser.add_argument('--JVMmemory', + default=tools.picard.FastqToSamTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, miseq_fastq_to_bam, split_args=True) + return parser + + +__commands__.append(('miseq_fastq_to_bam', parser_miseq_fastq_to_bam)) + + + +# ============================== +# *** extract_fc_metadata *** +# ============================== +def extract_fc_metadata(flowcell, outRunInfo, outSampleSheet): + ''' Extract RunInfo.xml and SampleSheet.csv from the provided Illumina directory + ''' + illumina = IlluminaDirectory(flowcell) + illumina.load() + shutil.copy(illumina.get_RunInfo().get_fname(), outRunInfo) + shutil.copy(illumina.get_SampleSheet().get_fname(), outSampleSheet) + return 0 +def parser_extract_fc_metadata(parser=argparse.ArgumentParser()): + parser.add_argument('flowcell', help='Illumina directory (possibly tarball)') + parser.add_argument('outRunInfo', help='Output RunInfo.xml file.') + parser.add_argument('outSampleSheet', help='Output SampleSheet.csv file.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, extract_fc_metadata, split_args=True) + return parser +__commands__.append(('extract_fc_metadata', parser_extract_fc_metadata)) + + +# ======================= +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","errors.py",".py","178","7","#!/usr/bin/env python + +class QCError(RuntimeError): + '''Indicates a failure at a QC step.''' + + def __init__(self, reason): + super(QCError, self).__init__(reason)","Python" +"Viral","broadinstitute/viral-ngs","intrahost.py",".py","58403","1204","#!/usr/bin/env python +'''This script contains a number of utilities for intrahost variant calling +and annotation for viral genomes. +''' + +__author__ = ""dpark@broadinstitute.org, rsealfon@broadinstitute.org, ""\ + ""swohl@broadinstitute.org, irwin@broadinstitute.org"" +__commands__ = [] + +# built-ins +import argparse +import logging +import itertools +import re +import os +import collections + +# third-party +import Bio.AlignIO +import Bio.SeqIO +import Bio.Data.IUPACData +import pysam + +# module-specific +import util.genbank +import util.cmd +import util.file +import util.vcf +import util.misc +from util.stats import median, fisher_exact, chi2_contingency +from interhost import CoordMapper +from tools.vphaser2 import Vphaser2Tool +from tools.samtools import SamtoolsTool + +log = logging.getLogger(__name__) + +# ============= class AlleleFieldParser ================= + + +class AlleleFieldParser(object): + """""" + Class for converting between the string and list representation + of the fields in the allele columns of vphaser_one_sample output + (corresponding to the SNP_or_LP_Profile columns in the V-Phaser 2 output). + """""" + __slots__ = ('_allele', '_strandCounts', '_libBiasPval', '_libCounts') + + def __init__(self, field=None, allele=None, fcount=None, rcount=None, libBiasPval=None, libCounts=None): + """""" Input is either the string stored in one of the allele columns. + or set field values. + """""" + if field is None: + self._allele = allele + self._strandCounts = [fcount, rcount] + self._libBiasPval = libBiasPval + self._libCounts = libCounts # libCounts is a list of 2-element lists + else: + words = field.split(':') + self._allele = words[0] + self._strandCounts = [int(words[1]), int(words[2])] + self._libCounts = [[int(words[ii]), int(words[ii + 1])] for ii in range(3, len(words) - 1, 2)] + self._libBiasPval = float(words[-1]) + + def __repr__(self): + """"""Convert to string representation."""""" + return ':'.join([self._allele] + list(map(str, self._strandCounts)) + sum((list(map( + str, libCount)) for libCount in self._libCounts), []) + ['%.4g' % self._libBiasPval]) + + def allele(self): + """""" Return allele: + A, C, G, or T for SNVs, + Dn with n > 0 for deletions, + Ibases where bases is a string of two or more bases for inserts + """""" + return self._allele + + def total(self): + return sum(self._strandCounts) + + def strand_counts(self): + ""Return [# forward reads (all libs), # reverse reads (all libs)]"" + return self._strandCounts + + def allele_and_strand_counts(self): + return [self.allele()] + self.strand_counts() + + def lib_counts(self): + """"""Yield [# forward reads, # reverse reads] for each library, in order + of read groups in BAM file. + """""" + for counts in self._libCounts: + yield counts + + def lib_bias_pval(self): + ""Return a p-value on whether there is a library bias for this allele."" + return self._libBiasPval + +# ========== vphaser_one_sample ================= + +defaultMinReads = 5 +defaultMaxBias = 10 + + +def vphaser_one_sample(inBam, inConsFasta, outTab, vphaserNumThreads=None, + minReadsEach=None, maxBias=None, removeDoublyMappedReads=False): + ''' Input: a single BAM file, representing reads from one sample, mapped to + its own consensus assembly. It may contain multiple read groups and + libraries. + Output: a tab-separated file with no header containing filtered + V Phaser-2 output variants with additional column for + sequence/chrom name, and library counts and p-values appended to + the counts for each allele. + ''' + samtoolsTool = SamtoolsTool() + + if minReadsEach is not None and minReadsEach < 0: + raise Exception('minReadsEach must be at least 0.') + + sorted_bam_file = inBam + if not util.file.bam_is_sorted(inBam): + sorted_bam_file = util.file.mkstempfname('.mapped-sorted.bam') + sorted_bam_file_tmp = util.file.mkstempfname('.mapped-sorted.bam') + samtoolsTool.sort(args=['-T', sorted_bam_file_tmp], inFile=inBam, outFile=sorted_bam_file) + + bam_to_process = sorted_bam_file + if removeDoublyMappedReads: + leading_or_trailing_indels_removed = util.file.mkstempfname('.mapped-leading_or_trailing_indels_removed.bam') + # vphaser crashes when cigar strings have leading or trailing indels + # so we will use filterByCigarString() with its default regex to remove such reads + samtoolsTool.filterByCigarString(sorted_bam_file, leading_or_trailing_indels_removed) + + bam_to_process = util.file.mkstempfname('.mapped-withdoublymappedremoved.bam') + samtoolsTool.removeDoublyMappedReads(leading_or_trailing_indels_removed, bam_to_process) + samtoolsTool.index(bam_to_process) + os.unlink(leading_or_trailing_indels_removed) + + # For low-quality data, the process of removing doubly-mapped reads + # can remove all reads. In such cases, stub out an empty vphaser output + # file to allow the pipeline to continue + if samtoolsTool.count(bam_to_process) == 0: + log.warning(""The bam file %s has 0 reads after removing doubly-mapped reads. Writing blank V-Phaser output."", bam_to_process) + util.file.touch(outTab) + return None + + variantIter = Vphaser2Tool().iterate(bam_to_process, vphaserNumThreads) + filteredIter = filter_strand_bias(variantIter, minReadsEach, maxBias) + + libraryFilteredIter = compute_library_bias(filteredIter, bam_to_process, inConsFasta) + with util.file.open_or_gzopen(outTab, 'wt') as outf: + for row in libraryFilteredIter: + outf.write('\t'.join(row) + '\n') + + +def filter_strand_bias(isnvs, minReadsEach=None, maxBias=None): + ''' Take an iterator of V-Phaser output (plus chromosome name prepended) + and perform hard filtering for strand bias + ''' + alleleCol = 7 # First column of output with allele counts + if minReadsEach is None: + minReadsEach = defaultMinReads + if maxBias is None: + maxBias = defaultMaxBias + for row in isnvs: + #front = row[:alleleCol] + for fieldInd in range(len(row) - 1, alleleCol - 1, -1): + f, r = AlleleFieldParser(row[fieldInd]).strand_counts() + if (int(f) < minReadsEach or int(r) < minReadsEach or + (minReadsEach > 0 and not (maxBias >= (float(f) / float(r)) >= 1.0 / maxBias))): + del row[fieldInd] + if len(row) > alleleCol + 1: + row[alleleCol:] = sorted(row[alleleCol:], key=lambda field: AlleleFieldParser(field).total(), reverse=True) + mac = sum(AlleleFieldParser(field).total() for field in row[alleleCol + 1:]) + tot = sum(AlleleFieldParser(field).total() for field in row[alleleCol:]) + row[2] = AlleleFieldParser(row[alleleCol + 1]).allele() + row[3] = AlleleFieldParser(row[alleleCol]).allele() + row[6] = '%.6g' % (100.0 * mac / tot) + yield row + + +def compute_library_bias(isnvs, inBam, inConsFasta): + ''' For each variant, compute read counts in each library and p-value for + library bias; append them to string for each variant. + Format is allele:totalF:totalR:1stLibFCount:1stLibRCount:2ndLibFCount:...:p-val. + Library counts are in alphabetical order of library IDs. + Note: Total was computed by vphaser, library counts by samtools mpileup, + so total might not be sum of library counts. + ''' + alleleCol = 7 # First column of output with allele counts + samtoolsTool = SamtoolsTool() + rgs_by_lib = sorted((rg['LB'], rg['ID']) for rg in samtoolsTool.getReadGroups(inBam).values()) + rgs_by_lib = itertools.groupby(rgs_by_lib, lambda x: x[0]) + libBams = [] + header_sam = util.file.mkstempfname('.sam') + samtoolsTool.dumpHeader(inBam, header_sam) + for lib, rgs in rgs_by_lib: + rgs = list(idVal for lb, idVal in rgs) + + # Create libBam containing all the readgroups in rgs. + # In samtools 1.1, this can be done by including -r multiple times on + # a single command line, but that doesn't work in 0.1.19, so instead + # extract readgroups one by one and then concatenate. + rgBams = [] + for idVal in rgs: + rgBam = util.file.mkstempfname('.bam') + samtoolsTool.view(['-b', '-r', idVal], inBam, rgBam) + samtoolsTool.index(rgBam) + if samtoolsTool.count(rgBam) > 0: + rgBams.append(rgBam) + else: + # most samtools functions don't like empty input bams, so skip them + os.unlink(rgBam) + if rgBams: + if len(rgBams) > 1: + libBam = util.file.mkstempfname('.bam') + samtoolsTool.merge(rgBams, libBam, ['-f', '-1', '-h', header_sam]) + for bam in rgBams: + os.unlink(bam) + else: + # samtools merge cannot deal with only one (or zero) input bams + libBam = rgBams[0] + samtoolsTool.index(libBam) + n_reads = samtoolsTool.count(libBam) + log.debug(""LB:%s has %s reads in %s read group(s) (%s)"", lib, n_reads, len(rgs), ', '.join(rgs)) + libBams.append(libBam) + + for row in isnvs: + consensusAllele = row[3] + pos = int(row[1]) if consensusAllele != 'i' else int(row[1]) - 1 + chrom = row[0] + libCounts = [get_mpileup_allele_counts(libBamItem, chrom, pos, inConsFasta, samtools=samtoolsTool) for libBamItem in libBams] + numAlleles = len(row) - alleleCol + countsMatrix = [[0] * numAlleles for lib in libBams] + libCountsByAllele = [] + for alleleInd in range(numAlleles): + allele = row[alleleCol + alleleInd].split(':')[0] + libCountsByAllele.append([]) + for libAlleleCounts, countsRow in zip(libCounts, countsMatrix): + f, r = libAlleleCounts.get(allele, [0, 0]) + libCountsByAllele[-1].append([f, r]) + countsRow[alleleInd] += f + r + for alleleInd in range(numAlleles): + contingencyTable = [ + [countsRow[alleleInd] for countsRow in countsMatrix], [sum(countsRow) - countsRow[alleleInd] + for countsRow in countsMatrix] + ] + rowSums = map(sum, contingencyTable) + dofs = len(libCounts) - 1 + if dofs < 1: + pval = 1.0 + elif min(rowSums) ** dofs / dofs < 10000: + # At this cutoff, fisher_exact should take <~ 0.1 sec + pval = fisher_exact(contingencyTable) + else: + pval = chi2_contingency(contingencyTable) + row[alleleCol + alleleInd] = str(AlleleFieldParser(None, *(row[alleleCol + alleleInd].split(':') + + [pval, libCountsByAllele[alleleInd]]))) + yield row + for bam in libBams: + os.unlink(bam) + os.unlink(header_sam) + + +def parse_alleles_string(allelesStr): + # Return {allele : [forwardCount, reverseCount]} + # For reference, allele is '.' rather than real allele + alleleCounts = {} # allele : [forwardCount, reverseCount] + pos = -1 + digits = re.compile('[0-9]+') + while pos < len(allelesStr) - 1: + pos += 1 + c = allelesStr[pos] + if c in '.,': + allele = '.' + isRev = c == ',' + elif c in '<>$*': # Reference skip, end of read, placeholder + continue # Not interested in these + elif c == '^': # Start of read + pos += 1 # Skip quality character + continue + elif c in 'ACGTNacgtn': + allele = c.upper() + isRev = c == c.lower() + elif c in '+-': # e.g., +3aaa + mat = digits.match(allelesStr, pos + 1) + indelLen = int(allelesStr[mat.start():mat.end()]) + indelStr = allelesStr[mat.end():mat.end() + indelLen] + allele = 'I' + indelStr.upper() if c == '+' else 'D' + str(indelLen) + isRev = indelStr == indelStr.lower() + pos += mat.end() - mat.start() + indelLen + else: + raise Exception('Unknown allele type %s' % c) + alleleCounts.setdefault(allele, [0, 0]) + alleleCounts[allele][isRev] += 1 + return alleleCounts + + +def get_mpileup_allele_counts(inBam, chrom, pos, inConsFasta, samtools=None): + """""" Return {allele : [forwardCount, reverseCount], ...} + allele is: + Iins for insertions where ins represents the inserted bases + Dlen for deletions where len is the length of the deletion + base itself for non-indels + 'i' or 'd', in which case report count for consensus. + """""" + samtools = samtools or SamtoolsTool() + pileupFileName = util.file.mkstempfname('.txt') + samtools.mpileup(inBam, pileupFileName, ['-A', '-r', '%s:%d-%d' % (chrom, pos, pos), '-B', '-d', '50000', + '-L', '50000', '-Q', '0', '-f', inConsFasta]) + with open(pileupFileName) as pileupFile: + words = pileupFile.readline().split('\t') + if len(words) < 5: + # empty output files means no reads pile up on this position + return {} + alleleCounts = parse_alleles_string(words[4]) + + # '.' is whatever mpileup thinks is the reference base (which might be + # different from vphaser's consensus base). This is the count we want to + # report for this base, but we also want to report this count for what + # vphaser calls 'i' or 'd'. + # This will probably be wrong in the unlikely case that there are both + # an indel and a snp at the same position, and vphaser's consensus base + # is different from mpileup's at that position. + refAllele = words[2] + alleleCounts['i'] = alleleCounts['d'] = alleleCounts[refAllele] = \ + alleleCounts.get('.', [0, 0]) + + return alleleCounts + + +def parser_vphaser_one_sample(parser=argparse.ArgumentParser()): + parser.add_argument(""inBam"", help=""Input Bam file."") + parser.add_argument(""inConsFasta"", help=""Consensus assembly fasta."") + parser.add_argument(""outTab"", help=""Tab-separated headerless output file."") + parser.add_argument(""--vphaserNumThreads"", type=int, default=None, help=""Number of threads in call to V-Phaser 2."") + parser.add_argument(""--minReadsEach"", + type=int, + default=defaultMinReads, + help=""Minimum number of reads on each strand (default: %(default)s)."") + parser.add_argument(""--maxBias"", + type=int, + default=defaultMaxBias, + help=""""""Maximum allowable ratio of number of reads on the two strands + (default: %(default)s). Ignored if minReadsEach = 0."""""") + parser.add_argument(""--removeDoublyMappedReads"", + default=False, + action=""store_true"", + help=""""""When calling V-Phaser, remove reads mapping to more than one contig. Default is to keep the reads."""""") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, vphaser_one_sample, split_args=True) + return parser + + +__commands__.append(('vphaser_one_sample', parser_vphaser_one_sample)) + +# ========== vphaser ================= + + +def parser_vphaser(parser=argparse.ArgumentParser()): + parser.add_argument(""inBam"", help=""Input Bam file."") + parser.add_argument(""outTab"", help=""Tab-separated headerless output file."") + parser.add_argument(""--numThreads"", type=int, default=None, help=""Number of threads in call to V-Phaser 2."") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, vphaser_main, split_args=True) + return parser + + +def vphaser_main(inBam, outTab, numThreads=None): + """""" Run V-Phaser 2 on the input file without any additional filtering. + Combine the non-header lines of the CHROM.var.raw.txt files it produces, + adding CHROM as the first field on each line. + """""" + with open(outTab, 'wt') as outf: + for row in Vphaser2Tool().iterate(inBam, numThreads): + outf.write('\t'.join(row) + '\n') + + +__commands__.append(('vphaser', parser_vphaser)) + +# ========== tabfile_values_rename ================= + + +def tabfile_values_rename(inFile, mapFile, outFile, col=0): + ''' Take input tab file and copy to an output file while changing + the values in a specific column based on a mapping file. + The first line will pass through untouched (it is assumed to be + a header). + ''' + # read map + with open(mapFile, 'rt') as inf: + name_map = dict(line.strip().split('\t') for line in inf) + # convert file + with open(outFile, 'wt') as outf: + with open(inFile, 'rt') as inf: + # copy header row verbatim + outf.write(inf.readline()) + # all other rows: remap the specified column's values + for line in inf: + row = line.rstrip('\n').split('\t') + row[col] = name_map[row[col]] + outf.write('\t'.join(row) + '\n') + + +def parser_tabfile_rename(parser=argparse.ArgumentParser()): + parser.add_argument(""inFile"", help=""Input flat file"") + parser.add_argument(""mapFile"", + help=""""""Map file. Two-column headerless file that maps input values to + output values. This script will error if there are values in inFile that do + not exist in mapFile."""""") + parser.add_argument(""outFile"", help=""Output flat file"") + parser.add_argument(""--col_idx"", + dest=""col"", + type=int, + help=""""""Which column number to replace (0-based index). [default: %(default)s]"""""", + default=0) + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, tabfile_values_rename, split_args=True) + return parser + + +__commands__.append(('tabfile_rename', parser_tabfile_rename)) + +# ========== merge_to_vcf =========================== + + +def count_iter_items(iterable): + """""" + Consume an iterable not reading it into memory; return the number of items. + """""" + + counter = itertools.count() + collections.deque(zip(iterable, counter), maxlen=0) # (consume at C speed) + return next(counter) + + +def strip_accession_version(acc): + ''' If this is a Genbank accession with a version number, + remove the version number. + ''' + m = re.match(r""^(\S+)\.\d+$"", acc) + if m: + acc = m.group(1) + return acc + + + +# def merge_to_vcf(refFasta, outVcf, samples, isnvs, assemblies, strip_chr_version=False, naive_filter=False): + + +def merge_to_vcf( + refFasta, + outVcf, + samples, + isnvs, + alignments, + strip_chr_version=False, + naive_filter=False, + parse_accession=False): + ''' Combine and convert vPhaser2 parsed filtered output text files into VCF format. + Assumption: consensus assemblies used in creating alignments do not extend beyond ends of reference. + the number of alignment files equals the number of chromosomes / segments + ''' + + guessed_samples = [] + if not samples: + samplenames_from_isnvs = [] + for isnvs_file in isnvs: + for row in util.file.read_tabfile(isnvs_file): + guessed_sample_ID = sampleIDMatch(row[0]) + if guessed_sample_ID not in samplenames_from_isnvs: + samplenames_from_isnvs.append(guessed_sample_ID) + + samplenames_from_alignments = set() + for alignmentFile in alignments: + with util.file.open_or_gzopen(alignmentFile, 'r') as inf: + for seq in Bio.SeqIO.parse(inf, 'fasta'): + samplenames_from_alignments.add(sampleIDMatch(seq.id)) + + refnames = set() + with util.file.open_or_gzopen(refFasta, 'r') as inf: + for seq in Bio.SeqIO.parse(inf, 'fasta'): + refnames.add(sampleIDMatch(seq.id)) + + # sample names from the isnv files, in that order, + # followed by sample names seen in the alignments, minus the former and the reference IDs + guessed_samples = samplenames_from_isnvs + list(samplenames_from_alignments-(refnames|set(samplenames_from_isnvs))) + log.info(""guessed sample names %s"" % guessed_samples) + + samples = samples if samples is not None and len(samples)>0 else guessed_samples + + samp_to_isnv = {} + # if we had to guess sample names, match them up to isnv files + if len(guessed_samples)>0: + matched_samples = [] + matched_isnv_files = [] + for sample in samples: + sample_found=False + for isnvs_file in isnvs: + for row in util.file.read_tabfile(isnvs_file): + if sample==sampleIDMatch(row[0]): + samp_to_isnv[sample] = isnvs_file + sample_found=True + matched_samples.append(sample) + matched_isnv_files.append(isnvs_file) + break + if sample_found: + break + samples = matched_samples + isnvs = matched_isnv_files + else: + samp_to_isnv = dict(zip(samples, isnvs)) + + log.info(samp_to_isnv) + + # get IDs and sequence lengths for reference sequence + with util.file.open_or_gzopen(refFasta, 'r') as inf: + ref_chrlens = list((seq.id, len(seq)) for seq in Bio.SeqIO.parse(inf, 'fasta')) + + # use the output filepath specified if it is a .vcf, otherwise if it is gzipped we need + # to write to a temp VCF and then compress to vcf.gz later + if outVcf.endswith('.vcf.gz'): + tmpVcf = util.file.mkstempfname('.vcf') + elif outVcf.endswith('.vcf'): + tmpVcf = outVcf + else: + raise ValueError(""outVcf must end in .vcf or .vcf.gz"") + + log.info(""loaded CoordMapper for all genomes, starting VCF merge..."") + + # write header + with open(tmpVcf, 'w') as outf: + # write header + outf.write('##fileformat=VCFv4.1\n') + outf.write('##FORMAT=\n') + outf.write('##FORMAT=\n') + outf.write('##FORMAT=\n') + outf.write('##FORMAT=\n') + outf.write( + '##FORMAT=\n') + # write out the contig lengths present in the reference genome + for c, clen in ref_chrlens: + if parse_accession: + c = util.genbank.parse_accession_str(c) + if strip_chr_version: + c = strip_accession_version(c) + outf.write('##contig=\n' % (c, clen)) + # write out the name of the reference file used to generate the VCF + outf.write('##reference=file://%s\n' % refFasta) + header = ['CHROM', 'POS', 'ID', 'REF', 'ALT', 'QUAL', 'FILTER', 'INFO', 'FORMAT'] + samples + outf.write('#' + '\t'.join(header) + '\n') + + # compress output if requested + if outVcf.endswith('.vcf.gz'): + pysam.tabix_compress(tmpVcf, outVcf, force=True) + pysam.tabix_index(outVcf, force=True, preset='vcf') + + with open(tmpVcf, 'a') as outf: + if not len(ref_chrlens) == len(alignments): + raise LookupError(""there must be an alignment file for each chromosome/segment present in the reference"") + + # we are assuming that the reference sequences have the same IDs in the alignments and in the + # reference fasta, but we need to relate each reference sequence (chromosome/segment) to a specific + # alignment file and index within the alignment + ref_seq_id_to_alignment_file = dict() + ref_seq_in_alignment_file = dict() + + # copy the list of alignment files + alignmentFiles = list(alignments) + + with util.file.open_or_gzopen(refFasta, 'r') as inf: + for refSeq in Bio.SeqIO.parse(inf, 'fasta'): + for alignmentFile in alignmentFiles: + with util.file.open_or_gzopen(alignmentFile, 'r') as inf2: + for seq in Bio.SeqIO.parse(inf2, 'fasta'): + if refSeq.id == seq.id: + ref_seq_id_to_alignment_file[seq.id] = alignmentFile + ref_seq_in_alignment_file[seq.id] = seq.seq.ungap('-') + + if len(ref_seq_id_to_alignment_file) < len(ref_chrlens): + raise LookupError(""Not all reference sequences found in alignments."") + + if len(guessed_samples)==0 and not (len(samples) == len(isnvs)): + raise LookupError( + ""There must be an isnv file for each sample. %s samples, %s isnv files"" % (len(samples), len(isnvs))) + + for fileName in alignments: + with util.file.open_or_gzopen(fileName, 'r') as inf: + # get two independent iterators into the alignment file + number_of_aligned_sequences = count_iter_items(Bio.SeqIO.parse(inf, 'fasta')) + num_isnv_files = len(isnvs) + # -1 is to account for inclusion of reference in the alignement in addition + # to the assemblies + + # if we had to guess samples only check that the number of isnv files == number of alignments + if len(guessed_samples)==0: + if not (number_of_aligned_sequences - 1) == num_isnv_files == len(samples): + raise LookupError( + """"""The number of isnv files provided (%s) and must equal the number of sequences + seen in the alignment (%s) (plus an extra reference record in the alignment), + as well as the number of sample names provided (%s) + %s does not have the right number of sequences"""""" % (num_isnv_files,number_of_aligned_sequences - 1,len(samples),fileName)) + + # one reference chrom at a time + with open(refFasta, 'r') as inf: + for ref_sequence in Bio.SeqIO.parse(inf, 'fasta'): + samp_to_seqIndex = dict() + + #ref_sequence = ref_seq_in_alignment_file[refSequence.id] + # make a coordmapper to map all alignments to this reference sequence + cm = CoordMapper() + cm.load_alignments([ref_seq_id_to_alignment_file[ref_sequence.id]]) + + # ======================== + # to map from ref->sample + # cm[ref_sequence.id][s] + # to map sample->ref + # cm[s][ref_sequence.id] + + # read in all iSNVs for this chrom and map to reference coords + data = [] + + # use conditional matching to only include the sequences that match the sample basename provided + samplesToUse = [x for x in cm.chrMaps.keys() if sampleIDMatch(x) in samples] + + alignmentFile = ref_seq_id_to_alignment_file[ref_sequence.id] + with util.file.open_or_gzopen(alignmentFile, 'r') as alignFileIn: + for seq in Bio.SeqIO.parse(alignFileIn, 'fasta'): + for sampleName in samplesToUse: + if seq.id == sampleName: + samp_to_seqIndex[sampleName] = seq.seq.ungap('-') + break + + if not len(samp_to_seqIndex) == len(samplesToUse): + raise LookupError( + ""Sequence info not found in file %s for all sample names provided. Check alignment files."" % + alignmentFile) + + for s in samplesToUse: + isnv_filepath = samp_to_isnv[sampleIDMatch(s)] + + for row in util.file.read_tabfile(isnv_filepath): + # map ref->sample + s_chrom = cm.mapChr(ref_sequence.id, s) + if row[0] == s_chrom: + allele_fields = list(AlleleFieldParser(x) for x in row[7:] if x) + row = { + 'sample': s, + 'CHROM': ref_sequence.id, + 's_chrom': s_chrom, + 's_pos': int(row[1]), + 's_alt': row[2], + 's_ref': row[3], + 'alleles': list(x.allele_and_strand_counts() for x in allele_fields), + 'n_libs': dict( + (x.allele(), sum(1 for f, r in x.lib_counts() + if f + r > 0)) for x in allele_fields), + 'lib_bias': dict( + (x.allele(), x.lib_bias_pval()) for x in allele_fields), + } + # make a sorted allele list + row['allele_counts'] = list(sorted( + [(a, int(f) + int(r)) for a, f, r in row['alleles']], + key=(lambda x: x[1]), + reverse=True)) + # naive filter (quick and dirty) + if naive_filter: + # require 2 libraries for every allele call + row['allele_counts'] = list((a, n) for a, n in row['allele_counts'] + if row['n_libs'][a] >= 2) + # recompute total read counts for remaining + tot_n = sum(n for a, n in row['allele_counts']) + # require allele frequency >= 0.5% + row['allele_counts'] = list((a, n) for a, n in row['allele_counts'] + if tot_n > 0 and float(n) / tot_n >= 0.005) + # drop this position:sample if no variation left + if len(row['allele_counts']) < 2: + log.info( + """"""dropping iSNV at %s:%s (%s) + because no variation remains after simple filtering"""""", row['s_chrom'], + row['s_pos'], row['sample']) + continue + # reposition vphaser deletions minus one to be consistent with + # VCF conventions + if row['s_alt'].startswith('D'): + for a, n in row['allele_counts']: + if a[0] not in ('D', 'i'): + log.error(""allele_counts: "" + str(row['allele_counts'])) + raise Exception(""deletion alleles must always start with D or i"") + row['s_pos'] = row['s_pos'] - 1 + # map position back to reference coordinates + row['POS'] = cm.mapChr(s, ref_sequence.id, row['s_pos'], side=-1)[1] + row['END'] = cm.mapChr(s, ref_sequence.id, row['s_pos'], side=1)[1] + if row['POS'] == None or row['END'] == None: + raise Exception('consensus extends beyond start or end of reference.') + data.append(row) + + # sort all iSNVs (across all samples) and group by position + data = sorted(data, key=(lambda row: row['POS'])) + data = itertools.groupby(data, lambda row: row['POS']) + + # process one reference position at a time from + for pos, rows in data: + # each of the sample-specific variants for a given ref pos + rows = list(rows) + + # define the length of this variation based on the largest deletion + end = pos + for row in rows: + end = max(end, row['END']) + for a, n in row['allele_counts']: + if a.startswith('D'): + # end of deletion in sample's coord space + local_end = row['s_pos'] + int(a[1:]) + + # end of deletion in reference coord space + ref_end = cm.mapChr(row['s_chrom'], ref_sequence.id, local_end, side=1)[1] + if ref_end is None: + raise Exception('consensus extends ' 'beyond start or end of reference.') + end = max(end, ref_end) + + # find reference allele and consensus alleles + refAllele = str(ref_sequence[pos - 1:end].seq) + consAlleles = {} # the full pos-to-end consensus assembly sequence for each sample + samp_offsets = {} # {sample : isnv's index in its consAllele string} + for row in rows: + s_pos = row['s_pos'] + sample = row['sample'] + if samp_offsets.get(sample, s_pos) != s_pos: + raise NotImplementedError('Sample %s has variants at 2 ' + 'positions %s mapped to same reference position (%s:%s)' % + (sample, (s_pos, samp_offsets[sample]), ref_sequence.id, pos)) + samp_offsets[sample] = s_pos + for s in samplesToUse: + # map ref to s + cons_start = cm.mapChr(ref_sequence.id, s, pos, side=-1)[1] + cons_stop = cm.mapChr(ref_sequence.id, s, end, side=1)[1] + if cons_start is None or cons_stop is None: + log.info(""variant is outside consensus assembly "" + ""for %s at %s:%s-%s."", s, ref_sequence.id, pos, end) + continue + + cons = samp_to_seqIndex[s] # .seq.ungap('-')#[ cm.mapChr(ref_sequence.id, s) ] + + allele = str(cons[cons_start - 1:cons_stop]).upper() + if s in samp_offsets: + samp_offsets[s] -= cons_start + if all(a in set(('A', 'C', 'T', 'G')) for a in allele): + consAlleles[s] = allele + else: + log.warning(""dropping ambiguous consensus for %s at %s:%s-%s: %s"", s, ref_sequence.id, pos, + end, allele) + + # define genotypes and fractions + iSNVs = {} # {sample : {allele : fraction, ...}, ...} + iSNVs_read_depth = {} # {sample: read depth} + iSNVs_n_libs = {} # {sample : {allele : n libraries > 0, ...}, ...} + iSNVs_lib_bias = {} # {sample : {allele : pval, ...}, ...} + for s in samplesToUse: + # get all rows for this sample and merge allele counts together + acounts = dict(itertools.chain.from_iterable(row['allele_counts'] for row in rows if + row['sample'] == s)) + nlibs = dict(itertools.chain.from_iterable(row['n_libs'].items() for row in rows if + row['sample'] == s)) + libbias = dict(itertools.chain.from_iterable(row['lib_bias'].items() for row in rows if + row['sample'] == s)) + if 'i' in acounts and 'd' in acounts: + # This sample has both an insertion line and a deletion line at the same spot! + # To keep the reference allele from be counted twice, once as an i and once + # as a d, average the counts and get rid of one of them. + acounts['i'] = int(round((acounts['i'] + acounts['d']) / 2.0, 0)) + del acounts['d'] + nlibs['i'] = max(nlibs['i'], nlibs['d']) + libbias['i'] = max(libbias['i'], libbias['d']) + + if acounts and s in consAlleles: + # we have iSNV data on this sample + consAllele = consAlleles[s] + tot_n = sum(acounts.values()) + iSNVs[s] = {} # {allele : fraction, ...} + iSNVs_read_depth[s] = tot_n + iSNVs_n_libs[s] = {} + iSNVs_lib_bias[s] = {} + for orig_a, n in acounts.items(): + f = float(n) / tot_n + a = orig_a + if a.startswith('I'): + # insertion point is relative to each sample + insert_point = samp_offsets[s] + 1 + a = consAllele[:insert_point] + a[1:] + consAllele[insert_point:] + elif a.startswith('D'): + # deletion is the first consensus base, plus remaining + # consensus seq with the first few positions dropped off + cut_left = samp_offsets[s] + 1 + cut_right = samp_offsets[s] + 1 + int(a[1:]) + a = consAllele[:cut_left] + consAllele[cut_right:] + elif a in ('i', 'd'): + # this is vphaser's way of saying the ""reference"" (majority/consensus) + # allele, in the face of other indel variants + a = consAllele + else: + # this is a SNP + if a not in set(('A', 'C', 'T', 'G')): + raise Exception() + if f > 0.5 and a != consAllele[samp_offsets[s]]: + log.warning(""vPhaser and assembly pipelines mismatch at "" + ""%s:%d (%s) - consensus %s, vPhaser %s, f %.3f"", ref_sequence.id, + pos, s, consAllele[samp_offsets[s]], a, f) + new_allele = list(consAllele) + new_allele[samp_offsets[s]] = a + a = ''.join(new_allele) + if not (a and a == a.upper()): + raise Exception() + iSNVs[s][a] = f + iSNVs_n_libs[s][a] = nlibs[orig_a] + iSNVs_lib_bias[s][a] = libbias[orig_a] + if all(len(a) == 1 for a in iSNVs[s].keys()): + if consAllele not in iSNVs[s]: + raise Exception( + """"""at %s:%s (%s), consensus allele %s + not among iSNV alleles %s -- other cons alleles: %s"""""" % ( + ref_sequence.id, pos, s, consAllele, ', '.join( + iSNVs[s].keys()), ', '.join( + consAlleles[s]))) + elif s in consAlleles: + # there is no iSNV data for this sample, so substitute the consensus allele + iSNVs[s] = {consAlleles[s]: 1.0} + + # get unique alleles list for this position, in this order: + # first: reference allele, + # next: consensus allele for each sample, in descending order of + # number of samples with that consensus, + # finally: all other alleles, sorted first by number of containing samples, + # then by intrahost read frequency summed over the population, + # then by the allele string itself. + alleles_cons = [alleleItem for alleleItem, n in sorted(util.misc.histogram(consAlleles.values()).items(), + key=lambda x: x[1], + reverse=True) if alleleItem != refAllele] + alleles_isnv = list(itertools.chain.from_iterable( + [iSNVs[s].items() for s in samplesToUse if s in iSNVs])) + alleles_isnv2 = [] + for a in set(a for a, n in alleles_isnv): + counts = list(x[1] for x in alleles_isnv if x[0] == a) + if len(counts) > 0 and sum(counts) > 0: + # if we filtered any alleles above, make sure to omit absent alleles + alleles_isnv2.append((len(counts), sum(counts), a)) + else: + log.info(""dropped allele %s at position %s:%s"", a, ref_sequence.id, pos) + alleles_isnv = list(allele for n_samples, n_reads, allele in reversed(sorted(alleles_isnv2))) + alleles = list(util.misc.unique([refAllele] + alleles_cons + alleles_isnv)) + + # map alleles from strings to numeric indexes + if not alleles: + raise Exception() + elif len(alleles) == 1: + # if we filtered any alleles above, skip this position if there is no variation left here + log.info(""dropped position %s:%s due to lack of variation"", ref_sequence.id, pos) + continue + alleleMap = dict((a, i) for i, a in enumerate(alleles)) + # GT col emitted below + genos = [str(alleleMap.get(consAlleles.get(s), '.')) for s in samplesToUse] + # AF col emitted below, everything excluding the ref allele (one float per non-ref allele) + freqs = [(s in iSNVs) and ','.join(map(str, [iSNVs[s].get(a, 0.0) for a in alleles[1:]])) or '.' + for s in samplesToUse] + # DP col emitted below + depths = [str(iSNVs_read_depth.get(s, '.')) for s in samplesToUse] + # NL col, everything including the ref allele (one int per allele) + nlibs = [(s in iSNVs_n_libs) and ','.join([str(iSNVs_n_libs[s].get(a, 0)) for a in alleles]) or '.' + for s in samplesToUse] + # LB col, everything including the ref allele (one float per allele) + pvals = [(s in iSNVs_lib_bias) and ','.join([str(iSNVs_lib_bias[s].get(a, '.')) for a in alleles]) + or '.' for s in samplesToUse] + + # prepare output row and write to file + c = ref_sequence.id + if parse_accession: + c = util.genbank.parse_accession_str(c) + if strip_chr_version: + c = strip_accession_version(c) + out = [c, pos, '.', alleles[0], ','.join(alleles[1:]), '.', '.', '.', 'GT:AF:DP:NL:LB'] + out = out + list(map(':'.join, zip(genos, freqs, depths, nlibs, pvals))) + outf.write('\t'.join(map(str, out)) + '\n') + # compress output if requested + if outVcf.endswith('.vcf.gz'): + pysam.tabix_compress(tmpVcf, outVcf, force=True) + pysam.tabix_index(outVcf, force=True, preset='vcf') + os.unlink(tmpVcf) + + +def parser_merge_to_vcf(parser=argparse.ArgumentParser()): + parser.add_argument(""refFasta"", + help=""""""The target reference genome. outVcf will use these + chromosome names, coordinate spaces, and reference alleles"""""") + parser.add_argument(""outVcf"", help=""Output VCF file containing all variants"") + parser.add_argument(""--samples"", nargs='*', help=""A list of sample names"") + parser.add_argument(""--isnvs"", + nargs='+', + required=True, + help=""""""A list of file names from the output of vphaser_one_sample + These must be in the SAME ORDER as samples."""""") + parser.add_argument(""--alignments"", + nargs='+', + required=True, + help=""""""a list of fasta files containing multialignment of input + assemblies, with one file per chromosome/segment. Each alignment + file will contain a line for each sample, as well as the + reference genome to which they were aligned."""""") + parser.add_argument(""--strip_chr_version"", + default=False, + action=""store_true"", + dest=""strip_chr_version"", + help=""""""If set, strip any trailing version numbers from the + chromosome names. If the chromosome name ends with a period + followed by integers, this is interepreted as a version number + to be removed. This is because Genbank accession numbers are + often used by SnpEff databases downstream, but without the + corresponding version number. Default is false (leave + chromosome names untouched)."""""") + parser.add_argument(""--naive_filter"", + default=False, + action=""store_true"", + dest=""naive_filter"", + help=""""""If set, keep only the alleles that have at least + two independent libraries of support and allele freq > 0.005. + Default is false (do not filter at this stage)."""""") + parser.add_argument(""--parse_accession"", + default=False, + action=""store_true"", + dest=""parse_accession"", + help=""""""If set, parse only the accession for the chromosome name. + Helpful if snpEff has to create its own database"""""") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, merge_to_vcf, split_args=True) + return parser + + +__commands__.append(('merge_to_vcf', parser_merge_to_vcf)) + +# =================================================== + + +def compute_Fws(vcfrow): + format_col = vcfrow[8].split(':') + if 'AF' not in format_col: + return None + af_idx = format_col.index('AF') + + freqs = [dat.split(':') for dat in vcfrow[9:]] + freqs = [float(dat[af_idx].split(',')[0]) for dat in freqs + if len(dat) > af_idx and dat[af_idx] != '.' and dat[0] != '.' and int(dat[0]) <= 1] + + if len(freqs) < 2: + return None + + p_s = sum(freqs) / len(freqs) + H_s = 2 * p_s * (1.0 - p_s) + + if H_s == 0.0: + return None + + H_w = [2 * p * (1.0 - p) for p in freqs] + H_w = sum(H_w) / len(H_w) + return (H_s, 1.0 - H_w / H_s) + + +def add_Fws_vcf(inVcf, outVcf): + '''Compute the Fws statistic on iSNV data. See Manske, 2012 (Nature)''' + with open(outVcf, 'wt') as outf: + with util.file.open_or_gzopen(inVcf, 'rt') as inf: + for line in inf: + if line.startswith('##'): + outf.write(line) + elif line.startswith('#'): + outf.write( + '##INFO=\n') + outf.write( + '##INFO=\n') + outf.write(line) + else: + row = line.strip('\n').split('\t') + Fws = compute_Fws(row) + if Fws is not None: + row[7] = row[7] + "";PI=%s;FWS=%s"" % Fws + outf.write('\t'.join(row) + '\n') + + +def parser_Fws(parser=argparse.ArgumentParser()): + parser.add_argument(""inVcf"", help=""Input VCF file"") + parser.add_argument(""outVcf"", help=""Output VCF file"") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, add_Fws_vcf, split_args=True) + return parser + + +__commands__.append(('Fws', parser_Fws)) + +# =================== iSNV_table ================================ + + +def parse_eff(eff_field): + ''' parse the old snpEff ""EFF"" INFO field ''' + out = {} + effs = [eff.rstrip(')').replace('(', '|').split('|') for eff in eff_field.split(',')] + effs = [[eff[i] for i in (0, 3, 4, 5, 6, 9, 11)] for eff in effs] + effs = [eff for eff in effs if eff[5] not in ('sGP', 'ssGP') and int(eff[6]) < 2] + if not len(effs) == 1: + raise Exception() + eff = effs[0] + if eff[2]: + aa = eff[2].split('/')[0] + assert aa.startswith('p.') + aa = aa[2:] + m = re.search(r""(\d+)"", aa) + out['eff_aa_pos'] = int(m.group(1)) + (out['eff_type'], out['eff_codon_dna'], out['eff_aa'], out[ + 'eff_prot_len' + ], out['eff_gene'], out['eff_protein'], _) = eff # _ is placeholder for rank + return out + + +class SnpEffException(Exception): + pass + + +def parse_ann(ann_field, alleles, transcript_blacklist=None): + ''' parse the new snpEff ""ANN"" INFO field ''' + + transcript_blacklist = transcript_blacklist or set(('GP.2', 'GP.3')) + + # only work on alt alleles + alleles = alleles[1:] + + effs = [eff.split('|') for eff in ann_field.split(',')] + effs = [(eff[0]+""-""+eff[6], dict((k, eff[i]) for k, i in (('eff_type', 1), ('eff_gene', 3), ('eff_protein', 6), ( + 'eff_codon_dna', 9), ('eff_aa', 10), ('eff_aa_pos', 13), ('eff_prot_len', 13)))) for eff in effs + if eff[6] not in transcript_blacklist] + effs_dict = dict(effs) # effs_dict contains key,val pairs where key is BOTH the alt allele plus each transcript being annotated + effs_alleles = [ k[:k.index(""-"")] for k in effs_dict ] # effs_alleles is a non-unique list of all alt alleles to keep track of how many ANNs were processed + if not effs: + return {} + + if len(effs) != len(effs_alleles): # raises an exception iff an alt allele has more than one annotation for the same transcript; does not error with overlapping transcripts being annotated + raise SnpEffException(""ANN field has non-unique alleles"") + for a in alleles: + if a not in effs_alleles: # raises an exception iff an alt allele is not found in the ANN field + raise SnpEffException(""ANN field is missing ALT allele: "" + a) + if len(set(effs_alleles)) != len(set(alleles)): # raises an exception if ANN field has different number of unique alleles than alt alleles + raise SnpEffException(""ANN field has %s entries, but ALT field has %s unique alleles: %s"" % ( + len(effs), len(set(alleles)), ','.join(alleles))) + + out = {} + for k in ('eff_type', 'eff_codon_dna', 'eff_aa', 'eff_aa_pos', 'eff_prot_len', 'eff_gene', 'eff_protein'): + a_out = [] + for a in effs_dict: + v = effs_dict[a][k] + if k == 'eff_codon_dna' and v.startswith('c.'): + v = v[2:] + elif k == 'eff_aa' and v.startswith('p.'): + v = v[2:] + elif k == 'eff_aa_pos' and '/' in v: + v = v.split('/')[0] + elif k == 'eff_prot_len' and '/' in v: + v = v.split('/')[1] + elif k == 'eff_protein' and v == 'GP.1': + v = 'Glycoprotein' + if v: + a_out.append(v) + out[k] = ','.join(util.misc.unique(a_out)) + return out + + +def iSNV_table(vcf_iter): + for row in vcf_iter: + info = dict(kv.split('=') for kv in row['INFO'].split(';') if kv and kv != '.') + samples = [ + k for k in row.keys() if k not in set( + ('CHROM', 'POS', 'ID', 'REF', 'ALT', 'QUAL', 'FILTER', 'INFO', 'FORMAT')) + ] + # compute Hs: heterozygosity in population based on consensus genotypes alone + genos = [row[s].split(':')[0] for s in samples] + genos = util.misc.histogram(int(gt) for gt in genos if gt != '.') + n = sum(genos.values()) + Hs = 1.0 - sum(k * k / float(n * n) for k in genos.values()) + try: + for s in samples: + f = row[s].split(':')[1] + if f and f != '.': + freqs = list(map(float, f.split(','))) + f = sum(freqs) + Hw = 1.0 - sum(p * p for p in [1.0 - f] + freqs) + out = { + 'chr': row['CHROM'], + 'pos': row['POS'], + 'alleles': ""%s,%s"" % (row['REF'], row['ALT']), + 'sample': s, + 'iSNV_freq': f, + 'Hw': Hw, + 'Hs': Hs + } + if 'EFF' in info: + for k, v in parse_eff(info['EFF']).items(): + out[k] = v + if 'ANN' in info: + for k, v in parse_ann(info['ANN'], alleles=out['alleles'].split(',')).items(): + out[k] = v + if 'PI' in info: + out['Hs_snp'] = info['PI'] + if 'FWS' in info: + out['Fws_snp'] = info['FWS'] + yield out + except: + log.error(""VCF parsing error at %s:%s"", row['CHROM'], row['POS']) + raise + + +def parser_iSNV_table(parser=argparse.ArgumentParser()): + parser.add_argument(""inVcf"", help=""Input VCF file"") + parser.add_argument(""outFile"", help=""Output text file"") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, main_iSNV_table) + return parser + + +def main_iSNV_table(args): + '''Convert VCF iSNV data to tabular text''' + header = ['chr', 'pos', 'sample', 'patient', 'time', 'alleles', 'iSNV_freq', 'Hw', 'Hs', 'eff_type', + 'eff_codon_dna', 'eff_aa', 'eff_aa_pos', 'eff_prot_len', 'eff_gene', 'eff_protein'] + with util.file.open_or_gzopen(args.outFile, 'wt') as outf: + outf.write('\t'.join(header) + '\n') + for row in iSNV_table(util.file.read_tabfile_dict(args.inVcf)): + sample_parts = row['sample'].split('.') + row['patient'] = sample_parts[0] + if len(sample_parts) > 1: + row['time'] = sample_parts[1] + outf.write('\t'.join(map(str, [row.get(h, '') for h in header])) + '\n') + return 0 + + +__commands__.append(('iSNV_table', parser_iSNV_table)) + +# =================================================== + + +def iSNP_per_patient(table, agg_fun=median): + data = sorted(table, key=lambda row: (int(row['pos']), row['patient'])) + data = itertools.groupby(data, lambda row: (int(row['pos']), row['patient'])) + for _, rows in data: + rows = list(rows) + row = rows[0] + if set(r['time'] for r in rows if r.get('time')): + f = agg_fun(list(float(r['iSNV_freq']) for r in rows)) + row['iSNV_freq'] = f + row['Hw'] = 2 * f * (1.0 - f) + row['sample'] = row['patient'] + else: + assert len(rows) == 1, ""error, found multiple rows for %s:%s"" % (row['pos'], row['patient']) + yield row + + +def parser_iSNP_per_patient(parser=argparse.ArgumentParser()): + parser.add_argument(""inFile"", help=""Input text file"") + parser.add_argument(""outFile"", help=""Output text file"") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, main_iSNP_per_patient) + return parser + + +def main_iSNP_per_patient(args): + '''Aggregate tabular iSNP data per patient x position (all time points averaged)''' + header = ['pos', 'patient', 'alleles', 'iSNV_freq', 'Hw', 'eff_type', 'eff_codon_dna', 'eff_aa', 'eff_aa_pos', + 'eff_prot_len', 'eff_gene', 'eff_protein'] + with open(args.outFile, 'wt') as outf: + outf.write('\t'.join(header) + '\n') + for row in iSNP_per_patient(util.file.read_tabfile_dict(args.inFile)): + outf.write('\t'.join(map(str, [row.get(h, '') for h in header])) + '\n') + return 0 + + +__commands__.append(('iSNP_per_patient', parser_iSNP_per_patient)) + +# =================================================== + +# ===============[ Utility functions ]================ + + +def sampleIDMatch(inputString): + """""" + Given a sample name in the form of [sample] or [sample]-#, + return only [sample] + """""" + idRegex = re.compile(r""(.*?)(?:-\d+)?$"") + m = idRegex.match(inputString) + + if m: + return m.group(1) + else: + raise LookupError(r""The ID was not of the form (.*?)(?:-\d+|$)+, ex. 5985-0"") + + +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","metagenomics.py",".py","61534","1447","#!/usr/bin/env python +''' This script contains a number of utilities for metagenomic analyses. +''' +from __future__ import print_function +from __future__ import division + +__author__ = ""yesimon@broadinstitute.org"" + +import argparse +import collections +import csv +import gzip +import io +import itertools +import logging +import os.path +from os.path import join +import operator +import queue +import re +import shutil +import sys +import tempfile +import json + +from Bio import SeqIO +from Bio.Seq import Seq +from Bio.SeqRecord import SeqRecord +import pysam + +import util.cmd +import util.file +import util.misc +import tools.kaiju +import tools.kraken +import tools.krona +import tools.picard +import tools.samtools +from util.file import open_or_gzopen + +__commands__ = [] + +log = logging.getLogger(__name__) + + +class TaxIdError(ValueError): + '''Taxonomy ID couldn't be determined.''' + + +def maybe_compressed(fn): + fn_gz = fn + '.gz' + if os.path.exists(fn): + return fn + elif os.path.exists(fn_gz): + return fn_gz + else: + raise FileNotFoundError(fn) + + +class TaxonomyDb(object): + """""" + This class loads NCBI taxonomy information from: + ftp://ftp.ncbi.nlm.nih.gov/pub/taxonomy/ + """""" + + def __init__( + self, + tax_dir=None, + gis=None, + nodes=None, + names=None, + gis_paths=None, + nodes_path=None, + names_path=None, + load_gis=False, + load_nodes=False, + load_names=False + ): + if tax_dir: + gis_paths = [maybe_compressed(join(tax_dir, 'gi_taxid_nucl.dmp')), + maybe_compressed(join(tax_dir, 'gi_taxid_prot.dmp'))] + nodes_path = maybe_compressed(join(tax_dir, 'nodes.dmp')) + names_path = maybe_compressed(join(tax_dir, 'names.dmp')) + self.tax_dir = tax_dir + self.gis_paths = gis_paths + self.nodes_path = nodes_path + self.names_path = names_path + if load_gis: + if gis: + self.gis = gis + elif gis_paths: + self.gis = {} + for gi_path in gis_paths: + log.info('Loading taxonomy gis: %s', gi_path) + self.gis.update(self.load_gi_single_dmp(gi_path)) + if load_nodes: + if nodes: + self.ranks, self.parents = nodes + elif nodes_path: + log.info('Loading taxonomy nodes: %s', nodes_path) + self.ranks, self.parents = self.load_nodes(nodes_path) + if load_names: + if names: + self.names = names + elif names_path: + log.info('Loading taxonomy names: %s', names_path) + self.names = self.load_names(names_path) + + def load_gi_single_dmp(self, dmp_path): + '''Load a gi->taxid dmp file from NCBI taxonomy.''' + gi_array = {} + with open_or_gzopen(dmp_path) as f: + for i, line in enumerate(f): + gi, taxid = line.strip().split('\t') + gi = int(gi) + taxid = int(taxid) + gi_array[gi] = taxid + if (i + 1) % 1000000 == 0: + log.info('Loaded %s gis', i) + return gi_array + + def load_names(self, names_db, scientific_only=True): + '''Load the names.dmp file from NCBI taxonomy.''' + if scientific_only: + names = {} + else: + names = collections.defaultdict(list) + for line in open_or_gzopen(names_db): + parts = line.strip().split('|') + taxid = int(parts[0]) + name = parts[1].strip() + #unique_name = parts[2].strip() + class_ = parts[3].strip() + if scientific_only: + if class_ == 'scientific name': + names[taxid] = name + else: + names[taxid].append(name) + return names + + def load_nodes(self, nodes_db): + '''Load ranks and parents arrays from NCBI taxonomy.''' + ranks = {} + parents = {} + with open_or_gzopen(nodes_db) as f: + for line in f: + parts = line.strip().split('|') + taxid = int(parts[0]) + parent_taxid = int(parts[1]) + rank = parts[2].strip() + #embl_code = parts[3].strip() + #division_id = parts[4].strip() + parents[taxid] = parent_taxid + ranks[taxid] = rank + return ranks, parents + + +BlastRecord = collections.namedtuple( + 'BlastRecord', [ + 'query_id', 'subject_id', 'percent_identity', 'aln_length', 'mismatch_count', 'gap_open_count', 'query_start', + 'query_end', 'subject_start', 'subject_end', 'e_val', 'bit_score', 'extra' + ] +) + + +def blast_records(f): + '''Yield blast m8 records line by line''' + for line in f: + if line.startswith('#'): + continue + parts = line.strip().split() + for field in range(3, 10): + parts[field] = int(parts[field]) + for field in (2, 10, 11): + parts[field] = float(parts[field]) + args = parts[:12] + extra = parts[12:] + args.append(extra) + + yield BlastRecord(*args) + + +def paired_query_id(record): + '''Replace paired suffixes in query ids.''' + suffixes = ('/1', '/2') + for suffix in suffixes: + if record.query_id.endswith(suffix): + rec_list = list(record) + rec_list[0] = record.query_id[:-len(suffix)] + return BlastRecord(*rec_list) + return record + + +def translate_gi_to_tax_id(db, record): + '''Replace gi headers in subject ids to int taxonomy ids.''' + gi = int(record.subject_id.split('|')[1]) + tax_id = db.gis[gi] + rec_list = list(record) + rec_list[1] = tax_id + return BlastRecord(*rec_list) + + +def blast_m8_taxids(record): + return [int(record.subject_id)] + + +def extract_tax_id(sam1): + '''Replace gi headers in subject ids to int taxonomy ids.''' + parts = sam1.reference_name.split('|') + if parts[0] == 'taxid': + return int(parts[1]) + else: + raise TaxIdError(parts) + + +def sam_lca(db, sam_file, output=None, top_percent=10, unique_only=True): + ''' Calculate the LCA taxonomy id for multi-mapped reads in a samfile. + + Assumes the sam is sorted by query name. Writes tsv output: query_id \t tax_id. + + Args: + db: (TaxonomyDb) Taxonomy db. + sam_file: (path) Sam file. + output: (io) Output file. + top_percent: (float) Only this percent within top hit are used. + unique_only: (bool) If true, only output assignments for unique, mapped reads. If False, set unmapped or duplicate reads as unclassified. + + Return: + (collections.Counter) Counter of taxid hits + ''' + + c = collections.Counter() + with pysam.AlignmentFile(sam_file, 'rb') as sam: + seg_groups = (v for k, v in itertools.groupby(sam, operator.attrgetter('query_name'))) + for seg_group in seg_groups: + segs = list(seg_group) + query_name = segs[0].query_name + # 0x4 is unmapped, 0x400 is duplicate + mapped_segs = [seg for seg in segs if seg.flag & 0x4 == 0 and seg.flag & 0x400 == 0] + if unique_only and not mapped_segs: + continue + + if mapped_segs: + tax_id = process_sam_hits(db, mapped_segs, top_percent) + if tax_id is None: + log.warning('Query: {} has no valid taxonomy paths.'.format(query_name)) + if unique_only: + continue + else: + tax_id = 0 + else: + tax_id = 0 + + if output: + classified = 'C' if tax_id else 'U' + output.write('{}\t{}\t{}\n'.format(classified, query_name, tax_id)) + c[tax_id] += 1 + return c + + +def blast_lca(db, + m8_file, + output, + paired=False, + min_bit_score=50, + max_expected_value=0.01, + top_percent=10,): + '''Calculate the LCA taxonomy id for groups of blast hits. + + Writes tsv output: query_id \t tax_id + + Args: + db: (TaxonomyDb) Taxonomy db. + m8_file: (io) Blast m8 file to read. + output: (io) Output file. + paired: (bool) Whether to count paired suffixes /1,/2 as one group. + min_bit_score: (float) Minimum bit score or discard. + max_expected_value: (float) Maximum e-val or discard. + top_percent: (float) Only this percent within top hit are used. + ''' + records = blast_records(m8_file) + records = (r for r in records if r.e_val <= max_expected_value) + records = (r for r in records if r.bit_score >= min_bit_score) + if paired: + records = (paired_query_id(rec) for rec in records) + blast_groups = (v for k, v in itertools.groupby(records, operator.attrgetter('query_id'))) + for blast_group in blast_groups: + blast_group = list(blast_group) + tax_id = process_blast_hits(db, blast_group, top_percent) + query_id = blast_group[0].query_id + if not tax_id: + log.debug('Query: {} has no valid taxonomy paths.'.format(query_id)) + classified = 'C' if tax_id else 'U' + output.write('{}\t{}\t{}\n'.format(classified, query_id, tax_id)) + + +def process_sam_hits(db, sam_hits, top_percent): + '''Filter groups of blast hits and perform lca. + + Args: + db: (TaxonomyDb) Taxonomy db. + sam_hits: []Sam groups of hits. + top_percent: (float) Only consider hits within this percent of top bit score. + + Return: + (int) Tax id of LCA. + ''' + best_score = max(hit.get_tag('AS') for hit in sam_hits) + cutoff_alignment_score = (100 - top_percent) / 100 * best_score + valid_hits = (hit for hit in sam_hits if hit.get_tag('AS') >= cutoff_alignment_score) + valid_hits = list(valid_hits) + # Sort requires realized list + valid_hits.sort(key=lambda sam1: sam1.get_tag('AS'), reverse=True) + + tax_ids = [extract_tax_id(hit) for hit in valid_hits] + return coverage_lca(tax_ids, db.parents) + + +def process_blast_hits(db, hits, top_percent): + '''Filter groups of blast hits and perform lca. + + Args: + db: (TaxonomyDb) Taxonomy db. + hits: []BlastRecord groups of hits. + top_percent: (float) Only consider hits within this percent of top bit score. + + Return: + (int) Tax id of LCA. + ''' + hits = (translate_gi_to_tax_id(db, hit) for hit in hits) + + hits = [hit for hit in hits if hit.subject_id != 0] + if len(hits) == 0: + return + + best_score = max(hit.bit_score for hit in hits) + cutoff_bit_score = (100 - top_percent) / 100 * best_score + valid_hits = (hit for hit in hits if hit.bit_score >= cutoff_bit_score) + valid_hits = list(valid_hits) + # Sort requires realized list + valid_hits.sort(key=operator.attrgetter('bit_score'), reverse=True) + if valid_hits: + tax_ids = tuple(itertools.chain(*(blast_m8_taxids(hit) for hit in valid_hits))) + return coverage_lca(tax_ids, db.parents) + + +def coverage_lca(query_ids, parents, lca_percent=100): + '''Calculate the lca that will cover at least this percent of queries. + + Args: + query_ids: []int list of nodes. + parents: []int array of parents. + lca_percent: (float) Cover at least this percent of queries. + + Return: + (int) LCA + ''' + lca_needed = lca_percent / 100 * len(query_ids) + paths = [] + for query_id in query_ids: + path = [] + while query_id != 1: + path.append(query_id) + if parents.get(query_id, 0) == 0: + log.warning('Parent for query id: {} missing'.format(query_id)) + break + query_id = parents[query_id] + if query_id == 1: + path.append(1) + path = list(reversed(path)) + paths.append(path) + if not paths: + return + + last_common = 1 + max_path_length = max(len(path) for path in paths) + for level in range(max_path_length): + valid_paths = (path for path in paths if len(path) > level) + max_query_id, hits_covered = collections.Counter(path[level] for path in valid_paths).most_common(1)[0] + if hits_covered >= lca_needed: + last_common = max_query_id + else: + break + return last_common + + +def tree_level_lookup(parents, node, level_cache): + '''Get the node level/depth. + + Args: + parents: Array of node parents. + node: Node to get level (root == 1). + level_cache: Cache of previously found levels. + + Returns: + (int) level of node + ''' + path = [] + while True: + level = level_cache.get(node) + if level: + for i, node in enumerate(reversed(path)): + level_cache[node] = level + i + 1 + return level + len(path) + path.append(node) + node = parents[node] + + +def push_up_tree_hits(parents, hits, min_support_percent=None, min_support=None, update_assignments=False): + '''Push up hits on nodes until min support is reached. + + Args: + parents: Array of node parents. + hits: Counter of hits on each node. + min_support_percent: Push up hits until each node has + this percent of the sum of all hits. + min_support: Push up hits until each node has this number of hits. + + Returns: + (counter) Hits mutated pushed up the tree. + ''' + assert min_support_percent or min_support + + if update_assignments: + pass + + total_hits = sum(hits.values()) + if not min_support: + min_support = round(min_support_percent * 0.01 * total_hits) + pq_level = queue.PriorityQueue() + level_cache = {1: 1} + for hit_id, num_hits in hits.items(): + if num_hits < min_support: + pq_level.put((-tree_level_lookup(parents, hit_id, level_cache), hit_id)) + + while not pq_level.empty() > 0: + level, hit_id = pq_level.get() + level = -level + + if hits[hit_id] >= min_support: + continue + if hit_id == 1: + del hits[1] + break + + parent_hit_id = parents[hit_id] + num_hits = hits[hit_id] + hits[parent_hit_id] += num_hits + # Can't pop directly from hits because hit_id might not be stored in counter + if hit_id in hits: + del hits[hit_id] + if hits[parent_hit_id] < min_support: + pq_level.put((-tree_level_lookup(parents, parent_hit_id, level_cache), parent_hit_id)) + return hits + + +def parents_to_children(parents): + '''Convert an array of parents to lists of children for each parent. + + Returns: + (dict[list]) Lists of children + ''' + children = collections.defaultdict(list) + for node, parent in parents.items(): + if node == 1: + continue + if parent != 0: + children[parent].append(node) + return children + + + +def file_lines(filename): + if filename is not None: + with open(filename) as f: + for line in f: + yield line + + +def collect_children(children, original_taxids): + '''Collect nodes with all children recursively.''' + taxids = original_taxids + while taxids: + taxid = taxids.pop() + yield taxid + for child_taxid in children[taxid]: + taxids.add(child_taxid) + + +def collect_parents(parents, taxids): + '''Collect nodes with all parents recursively.''' + # The root taxid node is 1 + yield 1 + taxids_with_parents = set([1]) + for taxid in taxids: + while taxid not in taxids_with_parents: + yield taxid + taxids_with_parents.add(taxid) + taxid = parents[taxid] + + +def parser_subset_taxonomy(parser=argparse.ArgumentParser()): + parser.add_argument( + ""taxDb"", + help=""Taxonomy database directory (containing nodes.dmp, parents.dmp etc.)"", + ) + parser.add_argument( + ""outputDb"", + help=""Output taxonomy database directory"", + ) + parser.add_argument( + ""--whitelistTaxids"", + help=""List of taxids to add to taxonomy (with parents)"", + nargs='+', type=int + ) + parser.add_argument( + ""--whitelistTaxidFile"", + help=""File containing taxids - one per line - to add to taxonomy with parents."", + ) + parser.add_argument( + ""--whitelistTreeTaxids"", + help=""List of taxids to add to taxonomy (with parents and children)"", + nargs='+', type=int + ) + parser.add_argument( + ""--whitelistTreeTaxidFile"", + help=""File containing taxids - one per line - to add to taxonomy with parents and children."", + ) + parser.add_argument( + ""--whitelistGiFile"", + help=""File containing GIs - one per line - to add to taxonomy with nodes."", + ) + parser.add_argument( + ""--whitelistAccessionFile"", + help=""File containing accessions - one per line - to add to taxonomy with nodes."", + ) + parser.add_argument( + ""--skipGi"", action='store_true', + help=""Skip GI to taxid mapping files"" + ) + parser.add_argument( + ""--skipAccession"", action='store_true', + help=""Skip accession to taxid mapping files"" + ) + parser.add_argument( + ""--skipDeadAccession"", action='store_true', + help=""Skip dead accession to taxid mapping files"" + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, subset_taxonomy, split_args=True) + return parser +def subset_taxonomy(taxDb, outputDb, whitelistTaxids=None, whitelistTaxidFile=None, + whitelistTreeTaxids=None, whitelistTreeTaxidFile=None, + whitelistGiFile=None, whitelistAccessionFile=None, + skipGi=None, skipAccession=None, skipDeadAccession=None, + stripVersion=True): + ''' + Generate a subset of the taxonomy db files filtered by the whitelist. The + whitelist taxids indicate specific taxids plus their parents to add to + taxonomy while whitelistTreeTaxids indicate specific taxids plus both + parents and all children taxa. Whitelist GI and accessions can only be + provided in file form and the resulting gi/accession2taxid files will be + filtered to only include those in the whitelist files. Finally, taxids + + parents for the gis/accessions will also be included. + ''' + util.file.mkdir_p(os.path.join(outputDb, 'accession2taxid')) + db = TaxonomyDb(tax_dir=taxDb, load_nodes=True) + + taxids = set() + if whitelistTaxids is not None: + taxids.update(set(whitelistTaxids)) + taxids.update((int(x) for x in file_lines(whitelistTaxidFile))) + + tree_taxids = set() + if whitelistTreeTaxids is not None: + tree_taxids.update(set(whitelistTreeTaxids)) + taxids.update((int(x) for x in file_lines(whitelistTreeTaxidFile))) + keep_taxids = set(collect_parents(db.parents, taxids)) + + if tree_taxids: + db.children = parents_to_children(db.parents) + children_taxids = collect_children(db.children, tree_taxids) + keep_taxids.update(children_taxids) + + # Taxids kept based on GI or Accession. Get parents afterwards to not pull in all GIs/accessions. + keep_seq_taxids = set() + def filter_file(path, sep='\t', taxid_column=0, gi_column=None, a2t=False, header=False): + input_path = os.path.join(db.tax_dir, path) + output_path = os.path.join(outputDb, path) + + input_path = maybe_compressed(input_path) + with open_or_gzopen(input_path, 'rt') as f, \ + open_or_gzopen(output_path, 'wt') as out_f: + if header: + out_f.write(next(f)) + for line in f: + parts = line.split(sep) + taxid = int(parts[taxid_column]) + if gi_column is not None: + gi = int(parts[gi_column]) + if gi in gis: + keep_seq_taxids.add(taxid) + out_f.write(line) + continue + if a2t: + accession = parts[accession_column_i] + if stripVersion: + accession = accession.split('.', 1)[0] + if accession in accessions: + keep_seq_taxids.add(taxid) + out_f.write(line) + continue + if taxid in keep_taxids: + out_f.write(line) + + if not skipGi: + gis = set(int(x) for x in file_lines(whitelistGiFile)) + + filter_file('gi_taxid_nucl.dmp', taxid_column=1, gi_column=0) + filter_file('gi_taxid_prot.dmp', taxid_column=1, gi_column=0) + + if not skipAccession: + if stripVersion: + accessions = set(x.strip().split('.', 1)[0] for x in file_lines(whitelistAccessionFile)) + accession_column_i = 0 + else: + accessions = set(file_lines(whitelistAccessionFile)) + accession_column_i = 1 + + acc_dir = os.path.join(db.tax_dir, 'accession2taxid') + acc_paths = [] + for fn in os.listdir(acc_dir): + if fn.endswith('.accession2taxid') or fn.endswith('.accession2taxid.gz'): + if skipDeadAccession and fn.startswith('dead_'): + continue + acc_paths.append(os.path.join(acc_dir, fn)) + for acc_path in acc_paths: + filter_file(os.path.relpath(acc_path, db.tax_dir), taxid_column=2, header=True, a2t=True) + + + # Add in taxids found from processing GI/accession + keep_seq_taxids = collect_parents(db.parents, keep_seq_taxids) + keep_taxids.update(keep_seq_taxids) + + filter_file('nodes.dmp', sep='|') + filter_file('names.dmp', sep='|') + filter_file('merged.dmp') + filter_file('delnodes.dmp') +__commands__.append(('subset_taxonomy', parser_subset_taxonomy)) + + +def rank_code(rank): + '''Get the short 1 letter rank code for named ranks.''' + if rank == ""species"": + return ""S"" + elif rank == ""genus"": + return ""G"" + elif rank == ""family"": + return ""F"" + elif rank == ""order"": + return ""O"" + elif rank == ""class"": + return ""C"" + elif rank == ""phylum"": + return ""P"" + elif rank == ""kingdom"": + return ""K"" + elif rank == ""superkingdom"": + return ""D"" + elif rank == ""unclassified"": + return ""U"" + else: + return ""-"" + + +def taxa_hits_from_tsv(f, taxid_column=2): + '''Return a counter of hits from tsv.''' + c = collections.Counter() + for row in csv.reader(f, delimiter='\t'): + tax_id = int(row[taxid_column - 1]) + c[tax_id] += 1 + return c + + +def kraken_dfs_report(db, taxa_hits): + '''Return a kraken compatible DFS report of taxa hits. + + Args: + db: (TaxonomyDb) Taxonomy db. + taxa_hits: (collections.Counter) # of hits per tax id. + + Return: + []str lines of the report + ''' + + db.children = parents_to_children(db.parents) + total_hits = sum(taxa_hits.values()) + if total_hits == 0: + return ['\t'.join(['100.00', '0', '0', 'U', '0', 'unclassified'])] + + lines = [] + kraken_dfs(db, lines, taxa_hits, total_hits, 1, 0) + unclassified_hits = taxa_hits.get(0, 0) + unclassified_hits += taxa_hits.get(-1, 0) + + if unclassified_hits > 0: + percent_covered = '%.2f' % (unclassified_hits / total_hits * 100) + lines.append( + '\t'.join([ + str(percent_covered), str(unclassified_hits), str(unclassified_hits), 'U', '0', 'unclassified' + ]) + ) + return reversed(lines) + + +def kraken_dfs(db, lines, taxa_hits, total_hits, taxid, level): + '''Recursively do DFS for number of hits per taxa.''' + cum_hits = num_hits = taxa_hits.get(taxid, 0) + for child_taxid in db.children[taxid]: + cum_hits += kraken_dfs(db, lines, taxa_hits, total_hits, child_taxid, level + 1) + percent_covered = '%.2f' % (cum_hits / total_hits * 100) + rank = rank_code(db.ranks[taxid]) + name = db.names[taxid] + if cum_hits > 0: + lines.append('\t'.join([percent_covered, str(cum_hits), str(num_hits), rank, str(taxid), ' ' * level + name])) + return cum_hits + + +def parser_krakenuniq(parser=argparse.ArgumentParser()): + parser.add_argument('db', help='Kraken database directory.') + parser.add_argument('inBams', nargs='+', help='Input unaligned reads, BAM format.') + parser.add_argument('--outReports', nargs='+', help='Kraken summary report output file. Multiple filenames space separated.') + parser.add_argument('--outReads', nargs='+', help='Kraken per read classification output file. Multiple filenames space separated.') + parser.add_argument( + '--filterThreshold', default=0.05, type=float, help='Kraken filter threshold (default %(default)s)' + ) + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, krakenuniq, split_args=True) + return parser +def krakenuniq(db, inBams, outReports=None, outReads=None, lockMemory=False, filterThreshold=None, threads=None): + ''' + Classify reads by taxon using KrakenUniq + ''' + + assert outReads or outReports, ('Either --outReads or --outReport must be specified.') + kuniq_tool = tools.kraken.KrakenUniq() + kuniq_tool.pipeline(db, inBams, out_reports=outReports, out_reads=outReads, + filter_threshold=filterThreshold, num_threads=threads) +__commands__.append(('krakenuniq', parser_krakenuniq)) + + +def parser_krona(parser=argparse.ArgumentParser()): + parser.add_argument('inReport', help='Input report file (default: tsv)') + parser.add_argument('db', help='Krona taxonomy database directory.') + parser.add_argument('outHtml', help='Output html report.') + parser.add_argument('--queryColumn', help='Column of query id. (default %(default)s)', type=int, default=2) + parser.add_argument('--taxidColumn', help='Column of taxonomy id. (default %(default)s)', type=int, default=3) + parser.add_argument('--scoreColumn', help='Column of score. (default %(default)s)', type=int, default=None) + parser.add_argument('--magnitudeColumn', help='Column of magnitude. (default %(default)s)', type=int, default=None) + parser.add_argument('--noHits', help='Include wedge for no hits.', action='store_true') + parser.add_argument('--noRank', help='Include no rank assignments.', action='store_true') + parser.add_argument('--inputType', help='Handling for specialized report types.', default='tsv', choices=['tsv', 'krakenuniq', 'kaiju']) + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, krona, split_args=True) + return parser +def krona(inReport, db, outHtml, queryColumn=None, taxidColumn=None, scoreColumn=None, magnitudeColumn=None, noHits=None, noRank=None, + inputType=None): + ''' + Create an interactive HTML report from a tabular metagenomic report + ''' + + krona_tool = tools.krona.Krona() + + if inputType == 'tsv': + root_name = os.path.basename(inReport) + if inReport.endswith('.gz'): + tmp_tsv = util.file.mkstempfname('.tsv') + with gzip.open(inReport, 'rb') as f_in: + with open(tmp_tsv, 'wb') as f_out: + shutil.copyfileobj(f_in, f_out) + to_import = [tmp_tsv] + else: + to_import = [inReport] + + krona_tool.import_taxonomy( + db, + to_import, + outHtml, + query_column=queryColumn, + taxid_column=taxidColumn, + score_column=scoreColumn, + magnitude_column=magnitudeColumn, + root_name=root_name, + no_hits=noHits, + no_rank=noRank + ) + + if inReport.endswith('.gz'): + # Cleanup tmp .tsv files + for tmp_tsv in to_import: + os.unlink(tmp_tsv) + + elif inputType == 'krakenuniq': + krakenuniq = tools.kraken.KrakenUniq() + report = krakenuniq.read_report(inReport) + with util.file.tempfname() as fn: + with open(fn, 'w') as to_import: + for taxid, (tax_reads, tax_kmers) in report.items(): + print('{}\t{}\t{}'.format(taxid, tax_reads, tax_kmers), file=to_import) + krona_tool.import_taxonomy( + db, [fn], outHtml, + taxid_column=1, magnitude_column=2, + score_column=3, + no_hits=True, no_rank=True + ) + # Rename ""Avg. score"" to ""Est. genome coverage"" + html_lines = util.file.slurp_file(outHtml).split('\n') + with util.file.tempfname() as fn: + with open(fn, 'w') as new_report: + for line in html_lines: + if 'score' in line: + line = line.replace('Avg. score', 'Est. unique kmers') + print(line, file=new_report) + shutil.copyfile(fn, outHtml) + return + elif inputType == 'kaiju': + kaiju = tools.kaiju.Kaiju() + report = kaiju.read_report(inReport) + with util.file.tempfname() as fn: + print(fn) + with open(fn, 'w') as to_import: + for taxid, reads in report.items(): + print('{}\t{}'.format(taxid, reads), file=to_import) + krona_tool.import_taxonomy( + db, [fn], outHtml, + taxid_column=1, magnitude_column=2, + no_hits=True, no_rank=True + ) + return + else: + raise NotImplementedError +__commands__.append(('krona', parser_krona)) + + +def parser_kaiju(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input unaligned reads, BAM format.') + parser.add_argument('db', help='Kaiju database .fmi file.') + parser.add_argument('taxDb', help='Taxonomy database directory.') + parser.add_argument('outReport', help='Output taxonomy report.') + parser.add_argument('--outReads', help='Output LCA assignments for each read.') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, kaiju, split_args=True) + return parser +def kaiju(inBam, db, taxDb, outReport, outReads=None, threads=None): + ''' + Classify reads by the taxon of the Lowest Common Ancestor (LCA) + ''' + + kaiju_tool = tools.kaiju.Kaiju() + kaiju_tool.classify(db, taxDb, inBam, output_report=outReport, output_reads=outReads, num_threads=threads) +__commands__.append(('kaiju', parser_kaiju)) + + +def sam_lca_report(tax_db, bam_aligned, outReport, outReads=None, unique_only=None): + + if outReads: + lca_tsv = outReads + else: + lca_tsv = util.file.mkstempfname('.tsv') + + with util.file.open_or_gzopen(lca_tsv, 'wt') as lca: + hits = sam_lca(tax_db, bam_aligned, lca, top_percent=10, unique_only=unique_only) + + with open(outReport, 'w') as f: + + for line in kraken_dfs_report(tax_db, hits): + print(line, file=f) + + +def parser_metagenomic_report_merge(parser=argparse.ArgumentParser()): + parser.add_argument( + ""metagenomic_reports"", + help=""Input metagenomic reports with the query ID and taxon ID in the 2nd and 3rd columns (Kraken format)"", + nargs='+', + type=argparse.FileType('r') + ) + parser.add_argument( + ""--outSummaryReport"", + dest=""out_kraken_summary"", + help=""Path of human-readable metagenomic summary report, created by kraken-report"" + ) + parser.add_argument( + ""--krakenDB"", + dest=""kraken_db"", + help=""Kraken database (needed for outSummaryReport)"", + type=argparse.FileType('r') + ) + parser.add_argument( + ""--outByQueryToTaxonID"", dest=""out_krona_input"", help=""Output metagenomic report suitable for Krona input. "" + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, metagenomic_report_merge, split_args=True) + return parser +def metagenomic_report_merge(metagenomic_reports, out_kraken_summary, kraken_db, out_krona_input): + ''' + Merge multiple metegenomic reports into a single metagenomic report. + Any Krona input files created by this + ''' + assert out_kraken_summary or out_krona_input, ( + ""Either --outSummaryReport or --outByQueryToTaxonID must be specified"" + ) + assert kraken_db if out_kraken_summary else True, ( + 'A Kraken db must be provided via --krakenDB if outSummaryReport is specified' + ) + + # column numbers containing the query (sequence) ID and taxonomic ID + # these are one-indexed + # See: http://ccb.jhu.edu/software/kraken/MANUAL.html#output-format + # tool_data_columns = { + # ""kraken"": (2, 3) + # } + + # if we're creating a Krona input file + if out_krona_input: + # open the output file (as gz if necessary) + with util.file.open_or_gzopen(out_krona_input, ""wt"") as outf: + # create a TSV writer for the output file + output_writer = csv.writer(outf, delimiter='\t', lineterminator='\n') + + if metagenomic_reports: + # for each Kraken-format metag file specified, pull out the appropriate columns + # and write them to the TSV output + for metag_file in metagenomic_reports: + with util.file.open_or_gzopen(metag_file.name, ""rt"") as inf: + file_reader = csv.reader(inf, delimiter='\t') + for row in file_reader: + # for only the two relevant columns + output_writer.writerow([f for f in row]) + + # create a human-readable summary of the Kraken reports + # kraken-report can only be used on kraken reports since it depends on queries being in its database + if out_kraken_summary: + # create temporary file to hold combined kraken report + tmp_metag_combined_txt = util.file.mkstempfname('.txt') + + util.file.cat(tmp_metag_combined_txt, [metag_file.name for metag_file in metagenomic_reports]) + + kraken_tool = tools.kraken.Kraken() + kraken_tool.report(tmp_metag_combined_txt, kraken_db.name, out_kraken_summary) +__commands__.append(('report_merge', parser_metagenomic_report_merge)) + + + +def fasta_library_accessions(library): + '''Parse accession from ids of fasta files in library directory. ''' + library_accessions = set() + for dirpath, dirnames, filenames in os.walk(library, followlinks=True): + for filename in filenames: + if not filename.endswith('.fna') and not filename.endswith('.fa') and not filename.endswith('.ffn'): + continue + filepath = os.path.join(dirpath, filename) + for seqr in SeqIO.parse(filepath, 'fasta'): + name = seqr.name + # Search for accession + mo = re.search('([A-Z]+_?\d+\.\d+)', name) + if mo: + accession = mo.group(1) + library_accessions.add(accession) + return library_accessions + + +class KrakenUniqBuildError(Exception): + '''Error while building KrakenUniq database.''' + +def parser_filter_bam_to_taxa(parser=argparse.ArgumentParser()): + parser.add_argument('in_bam', help='Input bam file.') + parser.add_argument('read_IDs_to_tax_IDs', help='TSV file mapping read IDs to taxIDs, Kraken-format by default. Assumes bijective mapping of read ID to tax ID.') + parser.add_argument('out_bam', help='Output bam file, filtered to the taxa specified') + parser.add_argument('nodes_dmp', help='nodes.dmp file from ftp://ftp.ncbi.nlm.nih.gov/pub/taxonomy/') + parser.add_argument('names_dmp', help='names.dmp file from ftp://ftp.ncbi.nlm.nih.gov/pub/taxonomy/') + parser.add_argument('--taxNames', nargs=""+"", dest=""tax_names"", help='The taxonomic names to include. More than one can be specified. Mapped to Tax IDs by lowercase exact match only. Ex. ""Viruses"" This is in addition to any taxonomic IDs provided.') + parser.add_argument('--taxIDs', nargs=""+"", type=int, dest=""tax_ids"", help='The NCBI taxonomy IDs to include. More than one can be specified. This is in addition to any taxonomic names provided.') + parser.add_argument('--without-children', action='store_true', dest=""omit_children"", help='Omit reads classified more specifically than each taxon specified (without this a taxon and its children are included).') + parser.add_argument('--read_id_col', type=int, dest=""read_id_col"", help='The (zero-indexed) number of the column in read_IDs_to_tax_IDs containing read IDs. (default: %(default)s)', default=1) + parser.add_argument('--tax_id_col', type=int, dest=""tax_id_col"", help='The (zero-indexed) number of the column in read_IDs_to_tax_IDs containing Taxonomy IDs. (default: %(default)s)', default=2) + parser.add_argument( + '--JVMmemory', + default=tools.picard.FilterSamReadsTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, filter_bam_to_taxa, split_args=True) + return parser + +def filter_bam_to_taxa(in_bam, read_IDs_to_tax_IDs, out_bam, + nodes_dmp, names_dmp, + tax_names=None, tax_ids=None, + omit_children=False, + read_id_col=1, tax_id_col=2, + JVMmemory=None): + """""" + Filter an (already classified) input bam file to only include reads that have been mapped to specified + taxonomic IDs or scientific names. This requires a classification file, as produced + by tools such as Kraken, as well as the NCBI taxonomy database. + """""" + tax_ids = set(tax_ids) if tax_ids else set() + tax_names = tax_names or [] + # use TaxonomyDb() class above and tree traversal/collection functions above + db = TaxonomyDb(nodes_path=nodes_dmp, names_path=names_dmp, load_nodes=True, load_names=True) + db.children = parents_to_children(db.parents) + + paired_read_base_pattern = re.compile(r'^(.*?)(/[1-2])?$') + + # get taxIDs for each of the heading values specifed (exact matches only) + tax_ids_from_headings = set() + for heading in tax_names: + # map heading to taxID + name_pattern = re.compile(heading, flags=re.IGNORECASE) + for row_tax_id, names in db.names.items(): + found_heading = False + if type(names) != list: + # if taxID->str, create list (of names) with cardinality=1 + names = [names] + for name in names: + if name_pattern.match(name): + tax_ids_from_headings.add(row_tax_id) + log.debug(""Found taxName match: %s -> %s"" % (row_tax_id,name)) + found_heading = True + break + if found_heading: + break + + tax_ids |= tax_ids_from_headings + + log.debug(""tax_ids %s"", tax_ids) + log.debug(""tax_names %s"", tax_names) + + # extend tax_ids to include IDs of children + tax_ids_to_include = set() + for tax_id in tax_ids: + tax_ids_to_include.add(tax_id) + if not omit_children: + child_ids = collect_children(db.children, set([tax_id])) + tax_ids_to_include |= set(child_ids) + + tax_ids_to_include = frozenset(tax_ids_to_include) # frozenset membership check slightly faster + + # perform the actual filtering to return a list of read IDs, writeen to a temp file + with util.file.tempfname("".txt.gz"") as temp_read_list: + with open_or_gzopen(temp_read_list, ""wt"") as read_IDs_file: + read_ids_written = 0 + for row in util.file.read_tabfile(read_IDs_to_tax_IDs): + assert tax_id_col 0: + # filter the input bam to include only these + tools.picard.FilterSamReadsTool().execute(in_bam, + False, + temp_read_list, + out_bam, + JVMmemory=JVMmemory) + else: + # otherwise, ""touch"" the output bam to contain the + # header of the input bam (no matching reads) + tools.samtools.SamtoolsTool().dumpHeader(in_bam,out_bam) +__commands__.append(('filter_bam_to_taxa', parser_filter_bam_to_taxa)) + + + +def parser_kraken_taxlevel_summary(parser=argparse.ArgumentParser()): + parser.add_argument('summary_files_in', nargs=""+"", help='Kraken-format summary text file with tab-delimited taxonomic levels.') + parser.add_argument('--jsonOut', dest=""json_out"", type=argparse.FileType('w'), help='The path to a json file containing the relevant parsed summary data in json format.') + parser.add_argument('--csvOut', dest=""csv_out"", type=argparse.FileType('w'), help='The path to a csv file containing sample-specific counts.') + parser.add_argument('--taxHeading', nargs=""+"", dest=""tax_headings"", help='The taxonomic heading to analyze (default: %(default)s). More than one can be specified.', default=""Viruses"") + parser.add_argument('--taxlevelFocus', dest=""taxlevel_focus"", help='The taxonomic heading to summarize (totals by Genus, etc.) (default: %(default)s).', default=""species"")#, + #choices=[""species"", ""genus"", ""family"", ""order"", ""class"", ""phylum"", ""kingdom"", ""superkingdom""]) + parser.add_argument('--topN', type=int, dest=""top_n_entries"", help='Only include the top N most abundant taxa by read count (default: %(default)s)', default=100) + parser.add_argument('--countThreshold', type=int, dest=""count_threshold"", help='Minimum number of reads to be included (default: %(default)s)', default=1) + parser.add_argument('--zeroFill', action='store_true', dest=""zero_fill"", help='When absent from a sample, write zeroes (rather than leaving blank).') + parser.add_argument('--noHist', action='store_true', dest=""no_hist"", help='Write out a report by-sample rather than a histogram.') + parser.add_argument('--includeRoot', action='store_true', dest=""include_root"", help='Include the count of reads at the root level and the unclassified bin.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, taxlevel_summary, split_args=True) + return parser + +def taxlevel_summary(summary_files_in, json_out, csv_out, tax_headings, taxlevel_focus, top_n_entries, count_threshold, no_hist, zero_fill, include_root): + """""" + Aggregates taxonomic abundance data from multiple Kraken-format summary files. + It is intended to report information on a particular taxonomic level (--taxlevelFocus; ex. 'species'), + within a higher-level grouping (--taxHeading; ex. 'Viruses'). By default, when --taxHeading + is at the same level as --taxlevelFocus a summary with lines for each sample is emitted. + Otherwise, a histogram is returned. If per-sample information is desired, --noHist can be specified. + In per-sample data, the suffix ""-pt"" indicates percentage, so a value of 0.02 is 0.0002 of the total number of reads for the sample. + If --topN is specified, only the top N most abundant taxa are included in the histogram count or per-sample output. + If a number is specified for --countThreshold, only taxa with that number of reads (or greater) are included. + Full data returned via --jsonOut (filtered by --topN and --countThreshold), whereas -csvOut returns a summary. + """""" + + samples = {} + same_level = False + + Abundance = collections.namedtuple(""Abundance"", ""percent,count,kmers,dup,cov"") + + def indent_len(in_string): + return len(in_string)-len(in_string.lstrip()) + + for f in list(summary_files_in): + sample_name, extension = os.path.splitext(f) + sample_summary = {} + sample_root_summary = {} + tax_headings_copy = [s.lower() for s in tax_headings] + + # ----------------------------------------------------------------- + # KrakenUniq has two lines prefixed by '#', a blank line, + # and then a TSV header beginning with ""%"". The column fields are: + # (NB:field names accurate, but space-separated in this comment + # for readability here) + # % reads taxReads kmers dup cov taxID rank taxName + # 0.05591 2 0 13 1.85 NA 10239 superkingdom Viruses + # + # Where the fields are: + # %: + # reads: + # taxReads: + # kmers: number of unique k-mers + # dup: average number of times each unique k-mer has been seen + # cov: coverage of the k-mers of the clade in the database + # taxID: + # rank: row[""rank""]; A rank code (see list below) + # taxName: row[""sci_name""]; indented scientific name + # + # Taxonomic ranks used by KrakenUniq include: + # unknown, no rank, sequence, assembly, subspecies, + # species, species subgroup, species group, subgenus, + # genus, tribe, subfamily, family, superfamily, parvorder, + # infraorder, suborder, order, superorder, parvclass, + # infraclass, subclass, class, superclass, subphylum, + # phylum, kingdom, superkingdom, root + # + # via: https://github.com/fbreitwieser/krakenuniq/blob/a8b4a2dbf50553e02d3cab3c32f93f91958aa575/src/taxdb.hpp#L96-L131 + # ----------------------------------------------------------------- + # Kraken (standard) reports lack header lines. + # (NB:field names below are only for reference. Space-separated for + # readability here) + # % reads taxReads rank taxID taxName + # 0.00 16 0 D 10239 Viruses + # + # Where the fields are: + # %: row[""pct_of_reads""]; Percentage of reads covered by the clade rooted at this taxon + # reads: row[""num_reads""]; Number of reads covered by the clade rooted at this taxon + # taxReads: row[""reads_exc_children""]; Number of reads assigned directly to this taxon + # rank: row[""rank""]; A rank code, indicating (U)nclassified, (D)omain, (K)ingdom, (P)hylum, (C)lass, (O)rder, (F)amily, (G)enus, or (S)pecies. All other ranks are simply '-'. + # taxID: row[""NCBI_tax_ID""]; NCBI taxonomy ID + # taxName: row[""sci_name""]; indented scientific name + # ----------------------------------------------------------------- + + + with util.file.open_or_gzopen(f, 'rU') as inf: + report_type=None + should_process = False + indent_of_selection = -1 + currently_being_processed = """" + for lineno, line in enumerate(inf): + if len(line.rstrip('\r\n').strip()) == 0 or ( report_type != None and line.startswith(""#"") or line.startswith(""%"")): + continue + + # KrakenUniq is mentioned on the first line of + # summary reports created by KrakenUniq + if not report_type and ""KrakenUniq"" in line: + report_type=""krakenuniq"" + continue + elif not report_type: + report_type=""kraken"" + + csv.register_dialect('kraken_report', quoting=csv.QUOTE_MINIMAL, delimiter=""\t"") + if report_type == ""kraken"": + fieldnames = [ ""pct_of_reads"", + ""num_reads"", + ""reads_exc_children"", + ""rank"", + ""NCBI_tax_ID"", + ""sci_name"" + ] + elif report_type == ""krakenuniq"": + fieldnames = [ + ""pct_of_reads"", + ""num_reads"", + ""reads_exc_children"", + ""uniq_kmers"", + ""kmer_dups"", + ""cov_of_clade_kmers"", + ""NCBI_tax_ID"", + ""rank"", + ""sci_name"" + ] + else: + continue #never reached since we fall back to kraken above + + row = next(csv.DictReader([line.strip().rstrip('\n')], fieldnames=fieldnames, dialect=""kraken_report"")) + + try: + indent_of_line = indent_len(row[""sci_name""]) + except AttributeError as e: + log.warning(""Report type: '{}'"".format(report_type)) + log.warning(""Issue with line {}: '{}'"".format(lineno,line.strip().rstrip('\n'))) + log.warning(""From file: {}"".format(f)) + # remove leading/trailing whitespace from each item + row = { k:v.strip() for k, v in row.items()} + + # rows are formatted as described above. + # Kraken: + # 0.00 16 0 D 10239 Viruses + # KrakenUniq: + # 0.05591 2 0 13 1.85 NA 10239 superkingdom Viruses + + # if the root-level bins (root, unclassified) should be included, do so, but bypass normal + # stateful parsing logic since root does not have a distinct rank level + if row[""sci_name""].lower() in [""root"",""unclassified""] and include_root: + sample_root_summary[row[""sci_name""]] = collections.OrderedDict() + sample_root_summary[row[""sci_name""]][row[""sci_name""]] = Abundance(float(row[""pct_of_reads""]), int(row[""num_reads""]),row.get(""kmers"",None),row.get(""dup"",None),row.get(""cov"",None)) + continue + + if indent_of_line <= indent_of_selection: + should_process = False + indent_of_selection=-1 + + if indent_of_selection == -1: + if row[""sci_name""].lower() in tax_headings_copy: + tax_headings_copy.remove(row[""sci_name""].lower()) + + should_process = True + indent_of_selection = indent_of_line + currently_being_processed = row[""sci_name""] + sample_summary[currently_being_processed] = collections.OrderedDict() + if row[""rank""] == rank_code(taxlevel_focus) or row[""rank""].lower().replace("" "","""") == taxlevel_focus.lower().replace("" "",""""): + same_level = True + if row[""rank""] in (""-"",""no rank""): + log.warning(""Non-taxonomic parent level selected"") + + if should_process: + # skip ""-"" rank levels since they do not occur at the sample level + # otherwise include the taxon row if the rank matches the desired level of focus + if (row[""rank""] not in (""-"",""no rank"") and (rank_code(taxlevel_focus) == row[""rank""] or row[""rank""].lower().replace("" "","""") == taxlevel_focus.lower().replace("" "","""")) ): + if int(row[""num_reads""])>=count_threshold: + sample_summary[currently_being_processed][row[""sci_name""]] = Abundance(float(row[""pct_of_reads""]), int(row[""num_reads""]),row.get(""kmers"",None),row.get(""dup"",None),row.get(""cov"",None)) + + + for k,taxa in sample_summary.items(): + sample_summary[k] = collections.OrderedDict(sorted(taxa.items(), key=lambda item: (item[1][1]) , reverse=True)[:top_n_entries]) + + if len(list(sample_summary[k].items()))>0: + log.info(""{f}: most abundant among {heading} at the {level} level: "" + ""\""{name}\"" with {reads} reads ({percent:.2%} of total); "" + ""included since >{threshold} read{plural}"".format( + f=f, + heading=k, + level=taxlevel_focus, + name=list(sample_summary[k].items())[0][0], + reads=list(sample_summary[k].items())[0][1].count, + percent=list(sample_summary[k].items())[0][1].percent/100.0, + threshold=count_threshold, + plural=""s"" if count_threshold>1 else """" ) + ) + + if include_root: + # include root-level bins (root, unclassified) in the returned data + for k,taxa in sample_root_summary.items(): + assert (k not in sample_summary), ""{k} already in sample summary"".format(k=k) + sample_summary[k] = taxa + samples[sample_name] = sample_summary + + if json_out != None: + json_summary = json.dumps(samples, sort_keys=True, indent=4, separators=(',', ': ')) + json_out.write(json_summary) + json_out.close() + + + if csv_out != None: + + # if we're writing out at the same level as the query header + # write out the fractions and counts + if same_level or no_hist: + + fieldnames = set() + for sample, taxa in samples.items(): + for heading,taxon in taxa.items(): + if len(taxon): + for k in taxon.keys(): + fieldnames |= set([k+""-pt"",k+""-ct""]) + + heading_columns = [""sample""] + if include_root: + root_fields = [""root-pt"",""root-ct"",""unclassified-pt"",""unclassified-ct""] + fieldnames -= set(root_fields) + heading_columns += root_fields + + writer = csv.DictWriter(csv_out, restval=0 if zero_fill else '', fieldnames=heading_columns+sorted(list(fieldnames))) + writer.writeheader() + + for sample, taxa in samples.items(): + sample_dict = {} + sample_dict[""sample""] = sample + for heading,taxon in taxa.items(): + for entry in taxon.keys(): + sample_dict[entry+""-pt""] = taxon[entry].percent + sample_dict[entry+""-ct""] = taxon[entry].count + writer.writerow(sample_dict) + + + csv_out.close() + + # otherwise write out a histogram + else: + count = 0 + summary_counts = collections.defaultdict(dict) + for sample, totals in samples.items(): + for heading,taxa in totals.items(): + for taxon in taxa.keys(): + if taxon not in summary_counts[heading].keys(): + summary_counts[heading][taxon] = 1 + else: + summary_counts[heading][taxon] += 1 + + for k,taxa in summary_counts.items(): + summary_counts[k] = collections.OrderedDict(sorted(taxa.items(), key=lambda item: (item[1]) , reverse=True)) + + + fieldnames = [""heading"",""taxon"",""num_samples""] + writer = csv.DictWriter(csv_out, restval=0 if zero_fill else '', fieldnames=fieldnames) + writer.writeheader() + + for heading,taxa_counts in summary_counts.items(): + writer.writerows([{""heading"":heading,""taxon"":taxon,""num_samples"":count} for taxon,count in taxa_counts.items()]) + + csv_out.close() + + +__commands__.append(('taxlevel_summary', parser_kraken_taxlevel_summary)) + + +def parser_krakenuniq_build(parser=argparse.ArgumentParser()): + parser.add_argument('db', help='Krakenuniq database output directory.') + parser.add_argument('--library', help='Input library directory of fasta files. If not specified, it will be read from the ""library"" subdirectory of ""db"".') + parser.add_argument('--taxonomy', help='Taxonomy db directory. If not specified, it will be read from the ""taxonomy"" subdirectory of ""db"".') + parser.add_argument('--subsetTaxonomy', action='store_true', help='Subset taxonomy based on library fastas.') + parser.add_argument('--minimizerLen', type=int, help='Minimizer length (krakenuniq default: 15)') + parser.add_argument('--kmerLen', type=int, help='k-mer length (krakenuniq default: 31)') + parser.add_argument('--maxDbSize', type=int, help='Maximum db size in GB (will shrink if too big)') + parser.add_argument('--clean', action='store_true', help='Clean by deleting other database files after build') + parser.add_argument('--workOnDisk', action='store_true', help='Work on disk instead of RAM. This is generally much slower unless the ""db"" directory lives on a RAM disk.') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, krakenuniq_build, split_args=True) + return parser +def krakenuniq_build(db, library, taxonomy=None, subsetTaxonomy=None, + threads=None, workOnDisk=False, + minimizerLen=None, kmerLen=None, maxDbSize=None, clean=False): + ''' + Builds a krakenuniq database from library directory of fastas and taxonomy + db directory. The --subsetTaxonomy option allows shrinking the taxonomy to + only include taxids associated with the library folders. For this to work, + the library fastas must have the standard accession id names such as + `>NC1234.1` or `>NC_01234.1`. + + Setting the --minimizerLen (default: 16) small, such as 10, will drastically + shrink the db size for small inputs, which is useful for testing. + + The built db may include symlinks to the original --library / --taxonomy + directories. If you want to build a static archiveable version of the + library, simply use the --clean option, which will also remove any + unnecessary files. + ''' + util.file.mkdir_p(db) + library_dir = os.path.join(db, 'library') + library_exists = os.path.exists(library_dir) + if library: + try: + os.symlink(os.path.abspath(library), os.path.join(db, 'library')) + except FileExistsError: + pass + else: + if not library_exists: + raise FileNotFoundError('Library directory {} not found'.format(library_dir)) + + taxonomy_dir = os.path.join(db, 'taxonomy') + taxonomy_exists = os.path.exists(taxonomy_dir) + if taxonomy: + if taxonomy_exists: + raise KrakenUniqBuildError('Output db directory already contains taxonomy directory {}'.format(taxonomy_dir)) + if subsetTaxonomy: + accessions = fasta_library_accessions(library) + + whitelist_accession_f = util.file.mkstempfname() + with open(whitelist_accession_f, 'wt') as f: + for accession in accessions: + print(accession, file=f) + + # Context-managerize eventually + taxonomy_tmp = tempfile.mkdtemp() + subset_taxonomy(taxonomy, taxonomy_tmp, whitelistAccessionFile=whitelist_accession_f) + shutil.move(taxonomy_tmp, taxonomy_dir) + else: + os.symlink(os.path.abspath(taxonomy), taxonomy_dir) + else: + if not taxonomy_exists: + raise FileNotFoundError('Taxonomy directory {} not found'.format(taxonomy_dir)) + if subsetTaxonomy: + raise KrakenUniqBuildError('Cannot subset taxonomy if already in db folder') + + krakenuniq_tool = tools.kraken.KrakenUniq() + options = {'--build': None} + if threads: + options['--threads'] = threads + if minimizerLen: + options['--minimizer-len'] = minimizerLen + if kmerLen: + options['--kmer-len'] = kmerLen + if maxDbSize: + options['--max-db-size'] = maxDbSize + if workOnDisk: + options['--work-on-disk'] = None + krakenuniq_tool.build(db, options=options) + + if clean: + krakenuniq_tool.execute('krakenuniq-build', db, '', options={'--clean': None}) +__commands__.append(('krakenuniq_build', parser_krakenuniq_build)) + + + +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","assembly.py",".py","71501","1686","#!/usr/bin/env python +''' This script contains a number of utilities for viral sequence assembly + from NGS reads. Primarily used for Lassa and Ebola virus analysis in + the Sabeti Lab / Broad Institute Viral Genomics. +''' + +__author__ = ""dpark@broadinstitute.org, rsealfon@broadinstitute.org"" +__commands__ = [] + +# built-ins +import argparse +import logging +import random +import numpy +import os +import os.path +import shutil +import subprocess +import functools +import operator +import concurrent.futures +import csv + +from itertools import zip_longest # pylint: disable=E0611 + +# intra-module +import util.cmd +import util.file +import util.misc +import util.vcf +import read_utils +import tools +import tools.picard +import tools.samtools +import tools.gatk +import tools.novoalign +import tools.spades +import tools.trimmomatic +import tools.trinity +import tools.mafft +import tools.mummer +import tools.muscle +import tools.gap2seq + +# third-party +import Bio.AlignIO +import Bio.SeqIO +import Bio.Data.IUPACData + +log = logging.getLogger(__name__) + + +class DenovoAssemblyError(RuntimeError): + + '''Indicates a failure of the de novo assembly step. Can indicate an internal error in the assembler, but also + insufficient input data (for assemblers which cannot report that condition separately).''' + + def __init__(self, reason): + super(DenovoAssemblyError, self).__init__(reason) + + +def trim_rmdup_subsamp_reads(inBam, clipDb, outBam, n_reads=100000, trim_opts=None): + ''' Take reads through Trimmomatic, Prinseq, and subsampling. + This should probably move over to read_utils. + ''' + + downsamplesam = tools.picard.DownsampleSamTool() + samtools = tools.samtools.SamtoolsTool() + + if n_reads < 1: + raise Exception() + + # BAM -> fastq + infq = list(map(util.file.mkstempfname, ['.in.1.fastq', '.in.2.fastq'])) + tools.picard.SamToFastqTool().execute(inBam, infq[0], infq[1]) + n_input = util.file.count_fastq_reads(infq[0]) + + # --- Trimmomatic --- + trimfq = list(map(util.file.mkstempfname, ['.trim.1.fastq', '.trim.2.fastq'])) + trimfq_unpaired = list(map(util.file.mkstempfname, ['.trim.unpaired.1.fastq', '.trim.unpaired.2.fastq'])) + if n_input == 0: + for i in range(2): + shutil.copyfile(infq[i], trimfq[i]) + else: + tools.trimmomatic.TrimmomaticTool().execute( + infq[0], + infq[1], + trimfq[0], + trimfq[1], + clipDb, + unpairedOutFastq1=trimfq_unpaired[0], + unpairedOutFastq2=trimfq_unpaired[1], + **(trim_opts or {}) + ) + + n_trim = max(map(util.file.count_fastq_reads, trimfq)) # count is pairs + n_trim_unpaired = sum(map(util.file.count_fastq_reads, trimfq_unpaired)) # count is individual reads + + # --- Prinseq duplicate removal --- + # the paired reads from trim, de-duplicated + rmdupfq = list(map(util.file.mkstempfname, ['.rmdup.1.fastq', '.rmdup.2.fastq'])) + + # the unpaired reads from rmdup, de-duplicated with the other singleton files later on + rmdupfq_unpaired_from_paired_rmdup = list( + map(util.file.mkstempfname, ['.rmdup.unpaired.1.fastq', '.rmdup.unpaired.2.fastq']) + ) + + prinseq = tools.prinseq.PrinseqTool() + prinseq.rmdup_fastq_paired( + trimfq[0], + trimfq[1], + rmdupfq[0], + rmdupfq[1], + includeUnmated=False, + unpairedOutFastq1=rmdupfq_unpaired_from_paired_rmdup[0], + unpairedOutFastq2=rmdupfq_unpaired_from_paired_rmdup[1] + ) + + n_rmdup_paired = max(map(util.file.count_fastq_reads, rmdupfq)) # count is pairs + n_rmdup = n_rmdup_paired # count is pairs + + tmp_header = util.file.mkstempfname('.header.sam') + tools.samtools.SamtoolsTool().dumpHeader(inBam, tmp_header) + + # convert paired reads to bam + # stub out an empty file if the input fastqs are empty + tmp_bam_paired = util.file.mkstempfname('.paired.bam') + if all(os.path.getsize(x) > 0 for x in rmdupfq): + tools.picard.FastqToSamTool().execute(rmdupfq[0], rmdupfq[1], 'Dummy', tmp_bam_paired) + else: + opts = ['INPUT=' + tmp_header, 'OUTPUT=' + tmp_bam_paired, 'VERBOSITY=ERROR'] + tools.picard.PicardTools().execute('SamFormatConverter', opts, JVMmemory='50m') + + n_paired_subsamp = 0 + n_unpaired_subsamp = 0 + n_rmdup_unpaired = 0 + + # --- subsampling --- + + # if we have too few paired reads after trimming and de-duplication, we can incorporate unpaired reads to reach the desired count + if n_rmdup_paired * 2 < n_reads: + # the unpaired reads from the trim operation, and the singletons from Prinseq + unpaired_concat = util.file.mkstempfname('.unpaired.fastq') + + # merge unpaired reads from trimmomatic and singletons left over from paired-mode prinseq + util.file.cat(unpaired_concat, trimfq_unpaired + rmdupfq_unpaired_from_paired_rmdup) + + # remove the earlier singleton files + for f in trimfq_unpaired + rmdupfq_unpaired_from_paired_rmdup: + os.unlink(f) + + # the de-duplicated singletons + unpaired_concat_rmdup = util.file.mkstempfname('.unpaired.rumdup.fastq') + prinseq.rmdup_fastq_single(unpaired_concat, unpaired_concat_rmdup) + os.unlink(unpaired_concat) + + n_rmdup_unpaired = util.file.count_fastq_reads(unpaired_concat_rmdup) + + did_include_subsampled_unpaired_reads = True + # if there are no unpaired reads, simply output the paired reads + if n_rmdup_unpaired == 0: + shutil.copyfile(tmp_bam_paired, outBam) + n_output = samtools.count(outBam) + else: + # take pooled unpaired reads and convert to bam + tmp_bam_unpaired = util.file.mkstempfname('.unpaired.bam') + tools.picard.FastqToSamTool().execute(unpaired_concat_rmdup, None, 'Dummy', tmp_bam_unpaired) + + tmp_bam_unpaired_subsamp = util.file.mkstempfname('.unpaired.subsamp.bam') + reads_to_add = (n_reads - (n_rmdup_paired * 2)) + + downsamplesam.downsample_to_approx_count(tmp_bam_unpaired, tmp_bam_unpaired_subsamp, reads_to_add) + n_unpaired_subsamp = samtools.count(tmp_bam_unpaired_subsamp) + os.unlink(tmp_bam_unpaired) + + # merge the subsampled unpaired reads into the bam to be used as + tmp_bam_merged = util.file.mkstempfname('.merged.bam') + tools.picard.MergeSamFilesTool().execute([tmp_bam_paired, tmp_bam_unpaired_subsamp], tmp_bam_merged) + os.unlink(tmp_bam_unpaired_subsamp) + + tools.samtools.SamtoolsTool().reheader(tmp_bam_merged, tmp_header, outBam) + os.unlink(tmp_bam_merged) + + n_paired_subsamp = n_rmdup_paired # count is pairs + n_output = n_rmdup_paired * 2 + n_unpaired_subsamp # count is individual reads + + else: + did_include_subsampled_unpaired_reads = False + log.info(""PRE-SUBSAMPLE COUNT: %s read pairs"", n_rmdup_paired) + + tmp_bam_paired_subsamp = util.file.mkstempfname('.unpaired.subsamp.bam') + downsamplesam.downsample_to_approx_count(tmp_bam_paired, tmp_bam_paired_subsamp, n_reads) + n_paired_subsamp = samtools.count(tmp_bam_paired_subsamp) // 2 # count is pairs + n_output = n_paired_subsamp * 2 # count is individual reads + + tools.samtools.SamtoolsTool().reheader(tmp_bam_paired_subsamp, tmp_header, outBam) + os.unlink(tmp_bam_paired_subsamp) + + os.unlink(tmp_bam_paired) + os.unlink(tmp_header) + + n_final_individual_reads = samtools.count(outBam) + + log.info(""Pre-DeNovoAssembly read filters: "") + log.info("" {} read pairs at start "".format(n_input)) + log.info( + "" {} read pairs after Trimmomatic {}"".format( + n_trim, ""(and {} unpaired)"".format(n_trim_unpaired) if n_trim_unpaired > 0 else """" + ) + ) + log.info( + "" {} read pairs after Prinseq rmdup {} "".format( + n_rmdup, ""(and {} unpaired from Trimmomatic+Prinseq)"".format(n_rmdup_unpaired) + if n_rmdup_unpaired > 0 else """" + ) + ) + if did_include_subsampled_unpaired_reads: + log.info( + "" Too few individual reads ({}*2={}) from paired reads to reach desired threshold ({}), so including subsampled unpaired reads"".format( + n_rmdup_paired, n_rmdup_paired * 2, n_reads + ) + ) + else: + log.info("" Paired read count sufficient to reach threshold ({})"".format(n_reads)) + log.info( + "" {} individual reads for de novo assembly ({}{})"".format( + n_output, ""paired subsampled {} -> {}"".format(n_rmdup_paired, n_paired_subsamp) + if not did_include_subsampled_unpaired_reads else ""{} read pairs"".format(n_rmdup_paired), + "" + unpaired subsampled {} -> {}"".format(n_rmdup_unpaired, n_unpaired_subsamp) + if did_include_subsampled_unpaired_reads else """" + ) + ) + log.info("" {} individual reads"".format(n_final_individual_reads)) + + if did_include_subsampled_unpaired_reads: + if n_final_individual_reads < n_reads: + log.warning( + ""NOTE: Even with unpaired reads included, there are fewer unique trimmed reads than requested for de novo assembly input."" + ) + + # clean up temp files + for i in range(2): + for f in infq, trimfq, rmdupfq: + if os.path.exists(f[i]): + os.unlink(f[i]) + + # multiply counts so all reflect individual reads + return (n_input * 2, n_trim * 2, n_rmdup * 2, n_output, n_paired_subsamp * 2, n_unpaired_subsamp) + + +def parser_trim_rmdup_subsamp(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input reads, unaligned BAM format.') + parser.add_argument('clipDb', help='Trimmomatic clip DB.') + parser.add_argument( + 'outBam', + help=""""""Output reads, unaligned BAM format (currently, read groups and other + header information are destroyed in this process)."""""" + ) + parser.add_argument( + '--n_reads', + default=100000, + type=int, + help='Subsample reads to no more than this many individual reads. Note that paired reads are given priority, and unpaired reads are included to reach the count if there are too few paired reads to reach n_reads. (default %(default)s)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, trim_rmdup_subsamp_reads, split_args=True) + return parser + + +__commands__.append(('trim_rmdup_subsamp', parser_trim_rmdup_subsamp)) + + +def assemble_trinity( + inBam, clipDb, + outFasta, n_reads=100000, + outReads=None, + always_succeed=False, + JVMmemory=None, + threads=None +): + ''' This step runs the Trinity assembler. + First trim reads with trimmomatic, rmdup with prinseq, + and random subsample to no more than 100k reads. + ''' + if outReads: + subsamp_bam = outReads + else: + subsamp_bam = util.file.mkstempfname('.subsamp.bam') + + picard_opts = { + 'CLIPPING_ATTRIBUTE': tools.picard.SamToFastqTool.illumina_clipping_attribute, + 'CLIPPING_ACTION': 'X' + } + + read_stats = trim_rmdup_subsamp_reads(inBam, clipDb, subsamp_bam, n_reads=n_reads) + subsampfq = list(map(util.file.mkstempfname, ['.subsamp.1.fastq', '.subsamp.2.fastq'])) + tools.picard.SamToFastqTool().execute(subsamp_bam, subsampfq[0], subsampfq[1], picardOptions=tools.picard.PicardTools.dict_to_picard_opts(picard_opts)) + try: + tools.trinity.TrinityTool().execute(subsampfq[0], subsampfq[1], outFasta, JVMmemory=JVMmemory, threads=threads) + except subprocess.CalledProcessError as e: + if always_succeed: + log.warning(""denovo assembly (Trinity) failed to assemble input, emitting empty output instead."") + util.file.make_empty(outFasta) + else: + raise DenovoAssemblyError('denovo assembly (Trinity) failed. {} reads at start. {} read pairs after Trimmomatic. ' + '{} read pairs after Prinseq rmdup. {} reads for trinity ({} pairs + {} unpaired).'.format(*read_stats)) + os.unlink(subsampfq[0]) + os.unlink(subsampfq[1]) + + if not outReads: + os.unlink(subsamp_bam) + + +def parser_assemble_trinity(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input unaligned reads, BAM format.') + parser.add_argument('clipDb', help='Trimmomatic clip DB.') + parser.add_argument('outFasta', help='Output assembly.') + parser.add_argument( + '--n_reads', + default=100000, + type=int, + help='Subsample reads to no more than this many pairs. (default %(default)s)' + ) + parser.add_argument('--outReads', default=None, help='Save the trimmomatic/prinseq/subsamp reads to a BAM file') + parser.add_argument( + ""--always_succeed"", + help=""""""If Trinity fails (usually because insufficient reads to assemble), + emit an empty fasta file as output. Default is to throw a DenovoAssemblyError."""""", + default=False, + action=""store_true"", + dest=""always_succeed"" + ) + parser.add_argument( + '--JVMmemory', + default=tools.trinity.TrinityTool.jvm_mem_default, + help='JVM virtual memory size (default: %(default)s)' + ) + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, assemble_trinity, split_args=True) + return parser + + +__commands__.append(('assemble_trinity', parser_assemble_trinity)) + +def assemble_spades( + in_bam, + clip_db, + out_fasta, + spades_opts='', + contigs_trusted=None, contigs_untrusted=None, + filter_contigs=False, + min_contig_len=0, + kmer_sizes=(55,65), + n_reads=10000000, + outReads=None, + always_succeed=False, + max_kmer_sizes=1, + mem_limit_gb=8, + threads=None, +): + '''De novo RNA-seq assembly with the SPAdes assembler. + ''' + + if outReads: + trim_rmdup_bam = outReads + else: + trim_rmdup_bam = util.file.mkstempfname('.subsamp.bam') + + trim_rmdup_subsamp_reads(in_bam, clip_db, trim_rmdup_bam, n_reads=n_reads, + trim_opts=dict(maxinfo_target_length=35, maxinfo_strictness=.2)) + + with tools.picard.SamToFastqTool().execute_tmp(trim_rmdup_bam, includeUnpaired=True, illuminaClipping=True + ) as (reads_fwd, reads_bwd, reads_unpaired): + try: + tools.spades.SpadesTool().assemble(reads_fwd=reads_fwd, reads_bwd=reads_bwd, reads_unpaired=reads_unpaired, + contigs_untrusted=contigs_untrusted, contigs_trusted=contigs_trusted, + contigs_out=out_fasta, filter_contigs=filter_contigs, + min_contig_len=min_contig_len, + kmer_sizes=kmer_sizes, always_succeed=always_succeed, max_kmer_sizes=max_kmer_sizes, + spades_opts=spades_opts, mem_limit_gb=mem_limit_gb, + threads=threads) + except subprocess.CalledProcessError as e: + raise DenovoAssemblyError('SPAdes assembler failed: ' + str(e)) + + if not outReads: + os.unlink(trim_rmdup_bam) + + + +def parser_assemble_spades(parser=argparse.ArgumentParser()): + parser.add_argument('in_bam', help='Input unaligned reads, BAM format. May include both paired and unpaired reads.') + parser.add_argument('clip_db', help='Trimmomatic clip db') + parser.add_argument('out_fasta', help='Output assembled contigs. Note that, since this is RNA-seq assembly, for each assembled genomic region there may be several contigs representing different variants of that region.') + parser.add_argument('--contigsTrusted', dest='contigs_trusted', + help='Optional input contigs of high quality, previously assembled from the same sample') + parser.add_argument('--contigsUntrusted', dest='contigs_untrusted', + help='Optional input contigs of high medium quality, previously assembled from the same sample') + parser.add_argument('--nReads', dest='n_reads', type=int, default=10000000, + help='Before assembly, subsample the reads to at most this many') + parser.add_argument('--outReads', default=None, help='Save the trimmomatic/prinseq/subsamp reads to a BAM file') + parser.add_argument('--filterContigs', dest='filter_contigs', default=False, action='store_true', + help='only output contigs SPAdes is sure of (drop lesser-quality contigs from output)') + parser.add_argument('--alwaysSucceed', dest='always_succeed', default=False, action='store_true', + help='if assembly fails for any reason, output an empty contigs file, rather than failing with ' + 'an error code') + parser.add_argument('--minContigLen', dest='min_contig_len', type=int, default=0, + help='only output contigs longer than this many bp') + parser.add_argument('--spadesOpts', dest='spades_opts', default='', help='(advanced) Extra flags to pass to the SPAdes assembler') + parser.add_argument('--memLimitGb', dest='mem_limit_gb', default=4, type=int, help='Max memory to use, in GB (default: %(default)s)') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, assemble_spades, split_args=True) + return parser + + +__commands__.append(('assemble_spades', parser_assemble_spades)) + +def gapfill_gap2seq(in_scaffold, in_bam, out_scaffold, threads=None, mem_limit_gb=4, time_soft_limit_minutes=60.0, + random_seed=0, gap2seq_opts='', always_succeed=False): + ''' This step runs the Gap2Seq tool to close gaps between contigs in a scaffold. + ''' + try: + tools.gap2seq.Gap2SeqTool().gapfill(in_scaffold, in_bam, out_scaffold, gap2seq_opts=gap2seq_opts, threads=threads, + mem_limit_gb=mem_limit_gb, time_soft_limit_minutes=time_soft_limit_minutes, + random_seed=random_seed) + except Exception as e: + if not always_succeed: + raise + log.warning('Gap-filling failed (%s); ignoring error, emulating successful run where simply no gaps were filled.') + shutil.copyfile(in_scaffold, out_scaffold) + +def parser_gapfill_gap2seq(parser=argparse.ArgumentParser(description='Close gaps between contigs in a scaffold')): + parser.add_argument('in_scaffold', help='FASTA file containing the scaffold. Each FASTA record corresponds to one ' + 'segment (for multi-segment genomes). Contigs within each segment are separated by Ns.') + parser.add_argument('in_bam', help='Input unaligned reads, BAM format.') + parser.add_argument('out_scaffold', help='Output assembly.') + parser.add_argument('--memLimitGb', dest='mem_limit_gb', default=4.0, help='Max memory to use, in gigabytes %(default)s') + parser.add_argument('--timeSoftLimitMinutes', dest='time_soft_limit_minutes', default=60.0, + help='Stop trying to close more gaps after this many minutes (default: %(default)s); this is a soft/advisory limit') + parser.add_argument('--maskErrors', dest='always_succeed', default=False, action='store_true', + help='In case of any error, just copy in_scaffold to out_scaffold, emulating a successful run that simply could not ' + 'fill any gaps.') + parser.add_argument('--gap2seqOpts', dest='gap2seq_opts', default='', help='(advanced) Extra command-line options to pass to Gap2Seq') + parser.add_argument('--randomSeed', dest='random_seed', default=0, help='Random seed; 0 means use current time') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, gapfill_gap2seq, split_args=True) + return parser + + +__commands__.append(('gapfill_gap2seq', parser_gapfill_gap2seq)) + + +def _order_and_orient_orig(inFasta, inReference, outFasta, + outAlternateContigs=None, + breaklen=None, # aligner='nucmer', circular=False, trimmed_contigs=None, + maxgap=200, minmatch=10, mincluster=None, + min_pct_id=0.6, min_contig_len=200, min_pct_contig_aligned=0.3): + ''' This step cleans up the de novo assembly with a known reference genome. + Uses MUMmer (nucmer or promer) to create a reference-based consensus + sequence of aligned contigs (with runs of N's in between the de novo + contigs). + ''' + mummer = tools.mummer.MummerTool() + #if trimmed_contigs: + # trimmed = trimmed_contigs + #else: + # trimmed = util.file.mkstempfname('.trimmed.contigs.fasta') + #mummer.trim_contigs(inReference, inFasta, trimmed, + # aligner=aligner, circular=circular, extend=False, breaklen=breaklen, + # min_pct_id=min_pct_id, min_contig_len=min_contig_len, + # min_pct_contig_aligned=min_pct_contig_aligned) + #mummer.scaffold_contigs(inReference, trimmed, outFasta, + # aligner=aligner, circular=circular, extend=True, breaklen=breaklen, + # min_pct_id=min_pct_id, min_contig_len=min_contig_len, + # min_pct_contig_aligned=min_pct_contig_aligned) + mummer.scaffold_contigs_custom( + inReference, + inFasta, + outFasta, + outAlternateContigs=outAlternateContigs, + extend=True, + breaklen=breaklen, + min_pct_id=min_pct_id, + min_contig_len=min_contig_len, + maxgap=maxgap, + minmatch=minmatch, + mincluster=mincluster, + min_pct_contig_aligned=min_pct_contig_aligned + ) + #if not trimmed_contigs: + # os.unlink(trimmed) + return 0 + +def _call_order_and_orient_orig(inReference, outFasta, outAlternateContigs, **kwargs): + return _order_and_orient_orig(inReference=inReference, outFasta=outFasta, outAlternateContigs=outAlternateContigs, **kwargs) + +def order_and_orient(inFasta, inReference, outFasta, + outAlternateContigs=None, outReference=None, + breaklen=None, # aligner='nucmer', circular=False, trimmed_contigs=None, + maxgap=200, minmatch=10, mincluster=None, + min_pct_id=0.6, min_contig_len=200, min_pct_contig_aligned=0.3, n_genome_segments=0, + outStats=None, threads=None): + ''' This step cleans up the de novo assembly with a known reference genome. + Uses MUMmer (nucmer or promer) to create a reference-based consensus + sequence of aligned contigs (with runs of N's in between the de novo + contigs). + ''' + + chk = util.cmd.check_input + + ref_segments_all = [tuple(Bio.SeqIO.parse(inRef, 'fasta')) for inRef in util.misc.make_seq(inReference)] + chk(ref_segments_all, 'No references given') + chk(len(set(map(len, ref_segments_all))) == 1, 'All references must have the same number of segments') + if n_genome_segments: + if len(ref_segments_all) == 1: + chk((len(ref_segments_all[0]) % n_genome_segments) == 0, + 'Number of reference sequences in must be a multiple of the number of genome segments') + else: + chk(len(ref_segments_all[0]) == n_genome_segments, + 'Number of reference segments must match the n_genome_segments parameter') + else: + n_genome_segments = len(ref_segments_all[0]) + ref_segments_all = functools.reduce(operator.concat, ref_segments_all, ()) + + n_refs = len(ref_segments_all) // n_genome_segments + log.info('n_genome_segments={} n_refs={}'.format(n_genome_segments, n_refs)) + ref_ids = [] + + with util.file.tempfnames(suffixes=[ '.{}.ref.fasta'.format(ref_num) for ref_num in range(n_refs)]) as refs_fasta, \ + util.file.tempfnames(suffixes=[ '.{}.scaffold.fasta'.format(ref_num) for ref_num in range(n_refs)]) as scaffolds_fasta, \ + util.file.tempfnames(suffixes=[ '.{}.altcontig.fasta'.format(ref_num) for ref_num in range(n_refs)]) as alt_contigs_fasta: + + for ref_num in range(n_refs): + this_ref_segs = ref_segments_all[ref_num*n_genome_segments : (ref_num+1)*n_genome_segments] + ref_ids.append(this_ref_segs[0].id) + Bio.SeqIO.write(this_ref_segs, refs_fasta[ref_num], 'fasta') + + with concurrent.futures.ProcessPoolExecutor(max_workers=util.misc.sanitize_thread_count(threads)) as executor: + retvals = executor.map(functools.partial(_call_order_and_orient_orig, inFasta=inFasta, + breaklen=breaklen, maxgap=maxgap, minmatch=minmatch, mincluster=mincluster, min_pct_id=min_pct_id, + min_contig_len=min_contig_len, min_pct_contig_aligned=min_pct_contig_aligned), + refs_fasta, scaffolds_fasta, alt_contigs_fasta) + for r in retvals: + # if an exception is raised by _call_order_and_orient_contig, the + # concurrent.futures.Executor.map function documentations states + # that the same exception will be raised when retrieving that entry + # of the retval iterator. This for loop is intended to reveal any + # CalledProcessErrors from mummer itself. + assert r==0 + + scaffolds = [tuple(Bio.SeqIO.parse(scaffolds_fasta[ref_num], 'fasta')) for ref_num in range(n_refs)] + base_counts = [sum([len(seg.seq.ungap('N')) for seg in scaffold]) \ + if len(scaffold)==n_genome_segments else 0 for scaffold in scaffolds] + best_ref_num = numpy.argmax(base_counts) + if len(scaffolds[best_ref_num]) != n_genome_segments: + raise IncompleteAssemblyError(len(scaffolds[best_ref_num]), n_genome_segments) + log.info('base_counts={} best_ref_num={}'.format(base_counts, best_ref_num)) + shutil.copyfile(scaffolds_fasta[best_ref_num], outFasta) + if outAlternateContigs: + shutil.copyfile(alt_contigs_fasta[best_ref_num], outAlternateContigs) + if outReference: + shutil.copyfile(refs_fasta[best_ref_num], outReference) + if outStats: + ref_ranks = (-numpy.array(base_counts)).argsort().argsort() + with open(outStats, 'w') as stats_f: + stats_w = csv.DictWriter(stats_f, fieldnames='ref_num ref_name base_count rank'.split(), delimiter='\t') + stats_w.writeheader() + for ref_num, (ref_id, base_count, rank) in enumerate(zip(ref_ids, base_counts, ref_ranks)): + stats_w.writerow({'ref_num': ref_num, 'ref_name': ref_id, 'base_count': base_count, 'rank': rank}) + + +def parser_order_and_orient(parser=argparse.ArgumentParser()): + parser.add_argument('inFasta', help='Input de novo assembly/contigs, FASTA format.') + parser.add_argument( + 'inReference', nargs='+', + help=('Reference genome for ordering, orienting, and merging contigs, FASTA format. Multiple filenames may be listed, each ' + 'containing one reference genome. Alternatively, multiple references may be given by specifying a single filename, ' + 'and giving the number of reference segments with the nGenomeSegments parameter. If multiple references are given, ' + 'they must all contain the same number of segments listed in the same order.') + ) + parser.add_argument( + 'outFasta', + help=""""""Output assembly, FASTA format, with the same number of + chromosomes as inReference, and in the same order."""""" + ) + parser.add_argument( + '--outAlternateContigs', + help=""""""Output sequences (FASTA format) from alternative contigs that mapped, + but were not chosen for the final output."""""", + default=None + ) + + parser.add_argument('--nGenomeSegments', dest='n_genome_segments', type=int, default=0, + help=""""""Number of genome segments. If 0 (the default), the `inReference` parameter is treated as one genome. + If positive, the `inReference` parameter is treated as a list of genomes of nGenomeSegments each."""""") + + parser.add_argument('--outReference', help='Output the reference chosen for scaffolding to this file') + parser.add_argument('--outStats', help='Output stats used in reference selection') + #parser.add_argument('--aligner', + # help='nucmer (nucleotide) or promer (six-frame translations) [default: %(default)s]', + # choices=['nucmer', 'promer'], + # default='nucmer') + #parser.add_argument(""--circular"", + # help=""""""Allow contigs to wrap around the ends of the chromosome."""""", + # default=False, + # action=""store_true"", + # dest=""circular"") + parser.add_argument( + ""--breaklen"", + ""-b"", + help=""""""Amount to extend alignment clusters by (if --extend). + nucmer default 200, promer default 60."""""", + type=int, + default=None, + dest=""breaklen"" + ) + parser.add_argument( + ""--maxgap"", + ""-g"", + help=""""""Maximum gap between two adjacent matches in a cluster. + Our default is %(default)s. + nucmer default 90, promer default 30. Manual suggests going to 1000."""""", + type=int, + default=200, + dest=""maxgap"" + ) + parser.add_argument( + ""--minmatch"", + ""-l"", + help=""""""Minimum length of an maximal exact match. + Our default is %(default)s. + nucmer default 20, promer default 6."""""", + type=int, + default=10, + dest=""minmatch"" + ) + parser.add_argument( + ""--mincluster"", + ""-c"", + help=""""""Minimum cluster length. + nucmer default 65, promer default 20."""""", + type=int, + default=None, + dest=""mincluster"" + ) + parser.add_argument( + ""--min_pct_id"", + ""-i"", + type=float, + default=0.6, + help=""show-tiling: minimum percent identity for contig alignment (0.0 - 1.0, default: %(default)s)"" + ) + parser.add_argument( + ""--min_contig_len"", + type=int, + default=200, + help=""show-tiling: reject contigs smaller than this (default: %(default)s)"" + ) + parser.add_argument( + ""--min_pct_contig_aligned"", + ""-v"", + type=float, + default=0.3, + help=""show-tiling: minimum percent of contig length in alignment (0.0 - 1.0, default: %(default)s)"" + ) + #parser.add_argument(""--trimmed_contigs"", + # default=None, + # help=""optional output file for trimmed contigs"") + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, order_and_orient, split_args=True) + return parser + + +__commands__.append(('order_and_orient', parser_order_and_orient)) + + +class IncompleteAssemblyError(Exception): + def __init__(self, actual_n, expected_n): + super(IncompleteAssemblyError, self).__init__( + 'All computed scaffolds are incomplete. Best assembly has {} contigs, expected {}'.format( + actual_n, expected_n) + ) + +class PoorAssemblyError(Exception): + def __init__(self, chr_idx, seq_len, non_n_count, min_length, segment_length): + super(PoorAssemblyError, self).__init__( + 'Error: poor assembly quality, chr {}: contig length {}, unambiguous bases {}; bases required of reference segment length: {}/{} ({:.0%})'.format( + chr_idx, seq_len, non_n_count, min_length, int(segment_length), float(min_length)/float(segment_length) + ) + ) + + +def impute_from_reference( + inFasta, + inReference, + outFasta, + minLengthFraction, + minUnambig, + replaceLength, + newName=None, + aligner='muscle', + index=False +): + ''' + This takes a de novo assembly, aligns against a reference genome, and + imputes all missing positions (plus some of the chromosome ends) + with the reference genome. This provides an assembly with the proper + structure (but potentially wrong sequences in areas) from which + we can perform further read-based refinement. + Two steps: + filter_short_seqs: We then toss out all assemblies that come out to + < 15kb or < 95% unambiguous and fail otherwise. + modify_contig: Finally, we trim off anything at the end that exceeds + the length of the known reference assembly. We also replace all + Ns and everything within 55bp of the chromosome ends with the + reference sequence. This is clearly incorrect consensus sequence, + but it allows downstream steps to map reads in parts of the genome + that would otherwise be Ns, and we will correct all of the inferred + positions with two steps of read-based refinement (below), and + revert positions back to Ns where read support is lacking. + FASTA indexing: output assembly is indexed for Picard, Samtools, Novoalign. + ''' + tempFastas = [] + + pmc = parser_modify_contig(argparse.ArgumentParser()) + assert aligner in ('muscle', 'mafft', 'mummer') + + with open(inFasta, 'r') as asmFastaFile: + with open(inReference, 'r') as refFastaFile: + asmFasta = Bio.SeqIO.parse(asmFastaFile, 'fasta') + refFasta = Bio.SeqIO.parse(refFastaFile, 'fasta') + for idx, (refSeqObj, asmSeqObj) in enumerate(zip_longest(refFasta, asmFasta)): + # our zip fails if one file has more seqs than the other + if not refSeqObj or not asmSeqObj: + raise KeyError(""inFasta and inReference do not have the same number of sequences. This could be because the de novo assembly process was unable to create contigs for all segments."") + + # error if PoorAssembly + minLength = len(refSeqObj) * minLengthFraction + non_n_count = unambig_count(asmSeqObj.seq) + seq_len = len(asmSeqObj) + log.info( + ""Assembly Quality - segment {idx} - name {segname} - contig len {len_actual} / {len_desired} ({min_frac}) - unambiguous bases {unamb_actual} / {unamb_desired} ({min_unamb})"".format( + idx=idx + 1, + segname=refSeqObj.id, + len_actual=seq_len, + len_desired=len(refSeqObj), + min_frac=minLengthFraction, + unamb_actual=non_n_count, + unamb_desired=seq_len, + min_unamb=minUnambig + ) + ) + if seq_len < minLength or non_n_count < seq_len * minUnambig: + raise PoorAssemblyError(idx + 1, seq_len, non_n_count, minLength, len(refSeqObj)) + + # prepare temp input and output files + tmpOutputFile = util.file.mkstempfname(prefix='seq-out-{idx}-'.format(idx=idx), suffix="".fasta"") + concat_file = util.file.mkstempfname('.ref_and_actual.fasta') + ref_file = util.file.mkstempfname('.ref.fasta') + actual_file = util.file.mkstempfname('.actual.fasta') + aligned_file = util.file.mkstempfname('.'+aligner+'.fasta') + refName = refSeqObj.id + with open(concat_file, 'wt') as outf: + Bio.SeqIO.write([refSeqObj, asmSeqObj], outf, ""fasta"") + with open(ref_file, 'wt') as outf: + Bio.SeqIO.write([refSeqObj], outf, ""fasta"") + with open(actual_file, 'wt') as outf: + Bio.SeqIO.write([asmSeqObj], outf, ""fasta"") + + # align scaffolded genome to reference (choose one of three aligners) + if aligner == 'mafft': + tools.mafft.MafftTool().execute( + [ref_file, actual_file], aligned_file, False, True, True, False, False, None + ) + elif aligner == 'muscle': + if len(refSeqObj) > 40000: + tools.muscle.MuscleTool().execute( + concat_file, aligned_file, quiet=False, + maxiters=2, diags=True + ) + else: + tools.muscle.MuscleTool().execute(concat_file, aligned_file, quiet=False) + elif aligner == 'mummer': + tools.mummer.MummerTool().align_one_to_one(ref_file, actual_file, aligned_file) + + # run modify_contig + args = [ + aligned_file, tmpOutputFile, refName, '--call-reference-ns', '--trim-ends', '--replace-5ends', + '--replace-3ends', '--replace-length', str(replaceLength), '--replace-end-gaps' + ] + if newName: + # renames the segment name ""sampleName-idx"" where idx is the segment number + args.extend(['--name', newName + ""-"" + str(idx + 1)]) + args = pmc.parse_args(args) + args.func_main(args) + + # clean up + os.unlink(concat_file) + os.unlink(ref_file) + os.unlink(actual_file) + os.unlink(aligned_file) + tempFastas.append(tmpOutputFile) + + # merge outputs + util.file.concat(tempFastas, outFasta) + for tmpFile in tempFastas: + os.unlink(tmpFile) + + # Index final output FASTA for Picard/GATK, Samtools, and Novoalign + if index: + tools.samtools.SamtoolsTool().faidx(outFasta, overwrite=True) + tools.picard.CreateSequenceDictionaryTool().execute(outFasta, overwrite=True) + tools.novoalign.NovoalignTool().index_fasta(outFasta) + + return 0 + + +def parser_impute_from_reference(parser=argparse.ArgumentParser()): + parser.add_argument( + 'inFasta', + help='Input assembly/contigs, FASTA format, already ordered, oriented and merged with inReference.' + ) + parser.add_argument('inReference', help='Reference genome to impute with, FASTA format.') + parser.add_argument('outFasta', help='Output assembly, FASTA format.') + parser.add_argument(""--newName"", default=None, help=""rename output chromosome (default: do not rename)"") + parser.add_argument( + ""--minLengthFraction"", + type=float, + default=0.5, + help=""minimum length for contig, as fraction of reference (default: %(default)s)"" + ) + parser.add_argument( + ""--minUnambig"", + type=float, + default=0.5, + help=""minimum percentage unambiguous bases for contig (default: %(default)s)"" + ) + parser.add_argument( + ""--replaceLength"", + type=int, + default=0, + help=""length of ends to be replaced with reference (default: %(default)s)"" + ) + parser.add_argument( + '--aligner', + help=""""""which method to use to align inFasta to + inReference. ""muscle"" = MUSCLE, ""mafft"" = MAFFT, + ""mummer"" = nucmer. [default: %(default)s]"""""", + choices=['muscle', 'mafft', 'mummer'], + default='muscle' + ) + parser.add_argument( + ""--index"", + help=""""""Index outFasta for Picard/GATK, Samtools, and Novoalign."""""", + default=False, + action=""store_true"", + dest=""index"" + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, impute_from_reference, split_args=True) + return parser + + +__commands__.append(('impute_from_reference', parser_impute_from_reference)) + + +def refine_assembly( + inFasta, + inBam, + outFasta, + outVcf=None, + outBam=None, + novo_params='', + min_coverage=2, + major_cutoff=0.5, + chr_names=None, + keep_all_reads=False, + already_realigned_bam=None, + JVMmemory=None, + threads=None, + gatk_path=None, + novoalign_license_path=None +): + ''' This a refinement step where we take a crude assembly, align + all reads back to it, and modify the assembly to the majority + allele at each position based on read pileups. + This step considers both SNPs as well as indels called by GATK + and will correct the consensus based on GATK calls. + Reads are aligned with Novoalign, then PCR duplicates are removed + with Picard (in order to debias the allele counts in the pileups), + and realigned with GATK's IndelRealigner (in order to call indels). + Output FASTA file is indexed for Picard, Samtools, and Novoalign. + ''' + chr_names = chr_names or [] + + # if the input fasta is empty, create an empty output fasta and return + if (os.path.getsize(inFasta) == 0): + util.file.touch(outFasta) + return 0 + + # Get tools + picard_index = tools.picard.CreateSequenceDictionaryTool() + picard_mkdup = tools.picard.MarkDuplicatesTool() + samtools = tools.samtools.SamtoolsTool() + novoalign = tools.novoalign.NovoalignTool(license_path=novoalign_license_path) + gatk = tools.gatk.GATKTool(path=gatk_path) + + # Create deambiguated genome for GATK + deambigFasta = util.file.mkstempfname('.deambig.fasta') + deambig_fasta(inFasta, deambigFasta) + picard_index.execute(deambigFasta, overwrite=True) + samtools.faidx(deambigFasta, overwrite=True) + + if already_realigned_bam: + realignBam = already_realigned_bam + else: + # Novoalign reads to self + novoBam = util.file.mkstempfname('.novoalign.bam') + min_qual = 0 if keep_all_reads else 1 + novoalign.execute(inBam, inFasta, novoBam, options=novo_params.split(), min_qual=min_qual, JVMmemory=JVMmemory) + rmdupBam = util.file.mkstempfname('.rmdup.bam') + opts = ['CREATE_INDEX=true'] + if not keep_all_reads: + opts.append('REMOVE_DUPLICATES=true') + picard_mkdup.execute([novoBam], rmdupBam, picardOptions=opts, JVMmemory=JVMmemory) + os.unlink(novoBam) + realignBam = util.file.mkstempfname('.realign.bam') + gatk.local_realign(rmdupBam, deambigFasta, realignBam, JVMmemory=JVMmemory, threads=threads) + os.unlink(rmdupBam) + if outBam: + shutil.copyfile(realignBam, outBam) + + # Modify original assembly with VCF calls from GATK + tmpVcf = util.file.mkstempfname('.vcf.gz') + tmpFasta = util.file.mkstempfname('.fasta') + gatk.ug(realignBam, deambigFasta, tmpVcf, JVMmemory=JVMmemory, threads=threads) + if already_realigned_bam is None: + os.unlink(realignBam) + os.unlink(deambigFasta) + name_opts = [] + if chr_names: + name_opts = ['--name'] + chr_names + main_vcf_to_fasta( + parser_vcf_to_fasta(argparse.ArgumentParser( + )).parse_args([ + tmpVcf, + tmpFasta, + '--trim_ends', + '--min_coverage', + str(min_coverage), + '--major_cutoff', + str(major_cutoff) + ] + name_opts) + ) + if outVcf: + shutil.copyfile(tmpVcf, outVcf) + if outVcf.endswith('.gz'): + shutil.copyfile(tmpVcf + '.tbi', outVcf + '.tbi') + os.unlink(tmpVcf) + shutil.copyfile(tmpFasta, outFasta) + os.unlink(tmpFasta) + + # Index final output FASTA for Picard/GATK, Samtools, and Novoalign + picard_index.execute(outFasta, overwrite=True) + # if the input bam is empty, an empty fasta will be created, however + # faidx cannot index an empty fasta file, so only index if the fasta + # has a non-zero size + if (os.path.getsize(outFasta) > 0): + samtools.faidx(outFasta, overwrite=True) + novoalign.index_fasta(outFasta) + + return 0 + + +def parser_refine_assembly(parser=argparse.ArgumentParser()): + parser.add_argument( + 'inFasta', help='Input assembly, FASTA format, pre-indexed for Picard, Samtools, and Novoalign.' + ) + parser.add_argument('inBam', help='Input reads, unaligned BAM format.') + parser.add_argument( + 'outFasta', + help='Output refined assembly, FASTA format, indexed for Picard, Samtools, and Novoalign.' + ) + parser.add_argument( + '--already_realigned_bam', + default=None, + help=""""""BAM with reads that are already aligned to inFasta. + This bypasses the alignment process by novoalign and instead uses the given + BAM to make an assembly. When set, outBam is ignored."""""" + ) + parser.add_argument( + '--outBam', + default=None, + help='Reads aligned to inFasta. Unaligned and duplicate reads have been removed. GATK indel realigned.' + ) + parser.add_argument('--outVcf', default=None, help='GATK genotype calls for genome in inFasta coordinate space.') + parser.add_argument( + '--min_coverage', + default=3, + type=int, + help='Minimum read coverage required to call a position unambiguous.' + ) + parser.add_argument( + '--major_cutoff', + default=0.5, + type=float, + help=""""""If the major allele is present at a frequency higher than this cutoff, + we will call an unambiguous base at that position. If it is equal to or below + this cutoff, we will call an ambiguous base representing all possible alleles at + that position. [default: %(default)s]"""""" + ) + parser.add_argument( + '--novo_params', + default='-r Random -l 40 -g 40 -x 20 -t 100', + help='Alignment parameters for Novoalign.' + ) + parser.add_argument( + ""--chr_names"", + dest=""chr_names"", + nargs=""*"", + help=""Rename all output chromosomes (default: retain original chromosome names)"", + default=[] + ) + parser.add_argument( + ""--keep_all_reads"", + help=""""""Retain all reads in BAM file? Default is to remove unaligned and duplicate reads."""""", + default=False, + action=""store_true"", + dest=""keep_all_reads"" + ) + parser.add_argument( + '--JVMmemory', + default=tools.gatk.GATKTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--GATK_PATH', + default=None, + dest=""gatk_path"", + help='A path containing the GATK jar file. This overrides the GATK_ENV environment variable or the GATK conda package. (default: %(default)s)' + ) + parser.add_argument( + '--NOVOALIGN_LICENSE_PATH', + default=None, + dest=""novoalign_license_path"", + help='A path to the novoalign.lic file. This overrides the NOVOALIGN_LICENSE_PATH environment variable. (default: %(default)s)' + ) + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, refine_assembly, split_args=True) + return parser + + +__commands__.append(('refine_assembly', parser_refine_assembly)) + + +def unambig_count(seq): + unambig = set(('A', 'T', 'C', 'G')) + return sum(1 for s in seq if s.upper() in unambig) + + +def parser_filter_short_seqs(parser=argparse.ArgumentParser()): + parser.add_argument(""inFile"", help=""input sequence file"") + parser.add_argument(""minLength"", help=""minimum length for contig"", type=int) + parser.add_argument(""minUnambig"", help=""minimum percentage unambiguous bases for contig"", type=float) + parser.add_argument(""outFile"", help=""output file"") + parser.add_argument(""-f"", ""--format"", help=""Format for input sequence (default: %(default)s)"", default=""fasta"") + parser.add_argument( + ""-of"", ""--output-format"", + help=""Format for output sequence (default: %(default)s)"", + default=""fasta"" + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, main_filter_short_seqs) + return parser + + +def main_filter_short_seqs(args): + '''Check sequences in inFile, retaining only those that are at least minLength''' + # orig by rsealfon, edited by dpark + # TO DO: make this more generalized to accept multiple minLengths (for multiple chromosomes/segments) + with util.file.open_or_gzopen(args.inFile) as inf: + with util.file.open_or_gzopen(args.outFile, 'w') as outf: + Bio.SeqIO.write( + [ + s for s in Bio.SeqIO.parse(inf, args.format) + if len(s) >= args.minLength and unambig_count(s.seq) >= len(s) * args.minUnambig + ], outf, args.output_format + ) + return 0 + + +__commands__.append(('filter_short_seqs', parser_filter_short_seqs)) + + +def parser_modify_contig(parser=argparse.ArgumentParser()): + parser.add_argument(""input"", help=""input alignment of reference and contig (should contain exactly 2 sequences)"") + parser.add_argument(""output"", help=""Destination file for modified contigs"") + parser.add_argument(""ref"", help=""reference sequence name (exact match required)"") + parser.add_argument( + ""-n"", ""--name"", + type=str, help=""fasta header output name (default: existing header)"", + default=None + ) + parser.add_argument( + ""-cn"", + ""--call-reference-ns"", + help=""""""should the reference sequence be called if there is an + N in the contig and a more specific base in the reference (default: %(default)s)"""""", + default=False, + action=""store_true"", + dest=""call_reference_ns"" + ) + parser.add_argument( + ""-t"", + ""--trim-ends"", + help=""should ends of contig.fasta be trimmed to length of reference (default: %(default)s)"", + default=False, + action=""store_true"", + dest=""trim_ends"" + ) + parser.add_argument( + ""-r5"", + ""--replace-5ends"", + help=""should the 5'-end of contig.fasta be replaced by reference (default: %(default)s)"", + default=False, + action=""store_true"", + dest=""replace_5ends"" + ) + parser.add_argument( + ""-r3"", + ""--replace-3ends"", + help=""should the 3'-end of contig.fasta be replaced by reference (default: %(default)s)"", + default=False, + action=""store_true"", + dest=""replace_3ends"" + ) + parser.add_argument( + ""-l"", + ""--replace-length"", + help=""length of ends to be replaced (if replace-ends is yes) (default: %(default)s)"", + default=10, + type=int + ) + parser.add_argument(""-f"", ""--format"", help=""Format for input alignment (default: %(default)s)"", default=""fasta"") + parser.add_argument( + ""-r"", + ""--replace-end-gaps"", + help=""Replace gaps at the beginning and end of the sequence with reference sequence (default: %(default)s)"", + default=False, + action=""store_true"", + dest=""replace_end_gaps"" + ) + parser.add_argument( + ""-rn"", + ""--remove-end-ns"", + help=""Remove leading and trailing N's in the contig (default: %(default)s)"", + default=False, + action=""store_true"", + dest=""remove_end_ns"" + ) + parser.add_argument( + ""-ca"", + ""--call-reference-ambiguous"", + help=""""""should the reference sequence be called if the contig seq is ambiguous and + the reference sequence is more informative & consistant with the ambiguous base + (ie Y->C) (default: %(default)s)"""""", + default=False, + action=""store_true"", + dest=""call_reference_ambiguous"" + ) + util.cmd.common_args(parser, (('tmp_dir', None), ('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, main_modify_contig) + return parser + + +def main_modify_contig(args): + ''' Modifies an input contig. Depending on the options + selected, can replace N calls with reference calls, replace ambiguous + calls with reference calls, trim to the length of the reference, replace + contig ends with reference calls, and trim leading and trailing Ns. + Author: rsealfon. + ''' + aln = Bio.AlignIO.read(args.input, args.format) + + # TODO?: take list of alignments in, one per chromosome, rather than + # single alignment + + if len(aln) != 2: + raise Exception(""alignment does not contain exactly 2 sequences, %s found"" % len(aln)) + elif aln[0].name == args.ref: + ref_idx = 0 + consensus_idx = 1 + elif aln[1].name == args.ref: + ref_idx = 1 + consensus_idx = 0 + else: + raise NameError(""reference name '%s' not in alignment"" % args.ref) + + mc = ContigModifier(str(aln[ref_idx].seq), str(aln[consensus_idx].seq)) + if args.remove_end_ns: + mc.remove_end_ns() + if args.call_reference_ns: + mc.call_reference_ns() + if args.call_reference_ambiguous: + mc.call_reference_ambiguous() + if args.trim_ends: + mc.trim_ends() + if args.replace_end_gaps: + mc.replace_end_gaps() + if args.replace_5ends: + mc.replace_5ends(args.replace_length) + if args.replace_3ends: + mc.replace_3ends(args.replace_length) + + with open(args.output, ""wt"") as f: + if hasattr(args, ""name""): + name = args.name + else: + name = aln[consensus_idx].name + for line in util.file.fastaMaker([(name, mc.get_stripped_consensus())]): + f.write(line) + return 0 + + +__commands__.append(('modify_contig', parser_modify_contig)) + + +class ContigModifier(object): + ''' Initial modifications to Trinity+MUMmer assembly output based on + MUSCLE alignment to known reference genome + author: rsealfon + ''' + + def __init__(self, ref, consensus): + if len(ref) != len(consensus): + raise Exception(""improper alignment"") + self.ref = list(ref) + self.consensus = list(consensus) + self.len = len(ref) + + def get_stripped_consensus(self): + return ''.join(self.consensus).replace('-', '') + + def call_reference_ns(self): + log.debug(""populating N's from reference..."") + for i in range(self.len): + if self.consensus[i].upper() == ""N"": + self.consensus[i] = self.ref[i] + + def call_reference_ambiguous(self): + ''' This is not normally used by default in our pipeline ''' + log.debug(""populating ambiguous bases from reference..."") + for i in range(self.len): + if self.ref[i].upper() in Bio.Data.IUPACData.ambiguous_dna_values.get(self.consensus[i].upper(), []): + self.consensus[i] = self.ref[i] + + def trim_ends(self): + ''' This trims down the consensus so it cannot go beyond the given reference genome ''' + log.debug(""trimming ends..."") + for end_iterator in (range(self.len), reversed(range(self.len))): + for i in end_iterator: + if self.ref[i] != ""-"": + break + else: + self.consensus[i] = ""-"" + + def replace_end_gaps(self): + ''' This fills out the ends of the consensus with reference sequence ''' + log.debug(""populating leading and trailing gaps from reference..."") + for end_iterator in (range(self.len), reversed(range(self.len))): + for i in end_iterator: + if self.consensus[i] != ""-"": + break + self.consensus[i] = self.ref[i] + + def replace_5ends(self, replace_length): + ''' This replaces everything within of the ends of the + reference genome with the reference genome. + ''' + log.debug(""replacing 5' ends..."") + ct = 0 + for i in range(self.len): + if self.ref[i] != ""-"": + ct = ct + 1 + if ct == replace_length: + for j in range(i + 1): + self.consensus[j] = self.ref[j] + break + + def replace_3ends(self, replace_length): + log.debug(""replacing 3' ends..."") + ct = 0 + for i in reversed(range(self.len)): + if self.ref[i] != ""-"": + ct = ct + 1 + if ct == replace_length: + for j in range(i, self.len): + self.consensus[j] = self.ref[j] + break + + def remove_end_ns(self): + ''' This clips off any N's that begin or end the consensus. + Not normally used in our pipeline + ''' + log.debug(""removing leading and trailing N's..."") + for end_iterator in (range(self.len), reversed(range(self.len))): + for i in end_iterator: + if (self.consensus[i].upper() == ""N"" or self.consensus[i] == ""-""): + self.consensus[i] = ""-"" + else: + break + + +class MutableSequence(object): + + def __init__(self, name, start, stop, init_seq=None): + if not (stop >= start >= 1): + raise IndexError(""coords out of bounds"") + if init_seq is None: + self.seq = list('N' * (stop - start + 1)) + else: + self.seq = list(init_seq) + if stop - start + 1 != len(self.seq): + raise Exception(""wrong length"") + self.start = start + self.stop = stop + self.name = name + self.deletions = [] + + def modify(self, p, new_base): + if not (self.start <= p <= self.stop): + raise IndexError(""position out of bounds"") + i = p - self.start + self.seq[i] = new_base + + def replace(self, start, stop, new_seq): + if stop > start: + self.deletions.append((start, stop, new_seq)) + self.__change__(start, stop, new_seq) + + def __change__(self, start, stop, new_seq): + if not (self.start <= start <= stop <= self.stop): + raise IndexError(""positions out of bounds"") + start -= self.start + stop -= self.start + if start == stop: + self.seq[start] = new_seq + for i in range(max(stop - start + 1, len(new_seq))): + if start + i <= stop: + if i < len(new_seq): + if start + i == stop: + # new allele is >= ref length, fill out the rest of the bases + self.seq[start + i] = new_seq[i:] + else: + self.seq[start + i] = new_seq[i] + else: + # new allele is shorter than ref, so delete extra bases + self.seq[start + i] = '' + + def replay_deletions(self): + for start, stop, new_seq in self.deletions: + self.__change__(start, stop, new_seq) + + def emit(self): + return (self.name, ''.join(self.seq)) + + +def alleles_to_ambiguity(allelelist): + ''' Convert a list of DNA bases to a single ambiguity base. + All alleles must be one base long. ''' + for a in allelelist: + if len(a) != 1: + raise Exception(""all alleles must be one base long"") + if len(allelelist) == 1: + return allelelist[0] + else: + convert = dict([(tuple(sorted(v)), k) for k, v in Bio.Data.IUPACData.ambiguous_dna_values.items() if k != 'X']) + key = tuple(sorted(set(a.upper() for a in allelelist))) + return convert[key] + + +def vcfrow_parse_and_call_snps(vcfrow, samples, min_dp=0, major_cutoff=0.5, min_dp_ratio=0.0): + ''' Parse a single row of a VCF file, emit an iterator over each sample, + call SNP genotypes using custom viral method based on read counts. + ''' + # process this row + c = vcfrow[0] + alleles = [vcfrow[3]] + [a for a in vcfrow[4].split(',') if a not in '.'] + start = int(vcfrow[1]) + stop = start + len(vcfrow[3]) - 1 + format_col = vcfrow[8].split(':') + format_col = dict((format_col[i], i) for i in range(len(format_col))) + assert 'GT' in format_col and format_col['GT'] == 0 # required by VCF spec + assert len(vcfrow) == 9 + len(samples) + info = [x.split('=') for x in vcfrow[7].split(';') if x != '.'] + info = dict(x for x in info if len(x) == 2) + info_dp = int(info.get('DP', 0)) + + # process each sample + for i in range(len(samples)): + sample = samples[i] + rec = vcfrow[i + 9].split(':') + + # require a minimum read coverage + if len(alleles) == 1: + # simple invariant case + dp = ('DP' in format_col and len(rec) > format_col['DP']) and int(rec[format_col['DP']]) or 0 + if dp < min_dp: + continue + geno = alleles + if info_dp and float(dp) / info_dp < min_dp_ratio: + log.warning( + ""dropping invariant call at %s:%s-%s %s (%s) due to low DP ratio (%s / %s = %s < %s)"", c, start, + stop, sample, geno, dp, info_dp, float(dp) / info_dp, min_dp_ratio + ) + continue + else: + # variant: manually call the highest read count allele if it exceeds a threshold + assert ('AD' in format_col and len(rec) > format_col['AD']) + allele_depths = list(map(int, rec[format_col['AD']].split(','))) + assert len(allele_depths) == len(alleles) + allele_depths = [(allele_depths[i], alleles[i]) for i in range(len(alleles)) if allele_depths[i] > 0] + allele_depths = list(reversed(sorted((n, a) for n, a in allele_depths if n >= min_dp))) + if not allele_depths: + continue + dp = sum(n for n, a in allele_depths) + + if allele_depths[0][0] > (dp * major_cutoff): + # call a single allele at this position if it is a clear winner + geno = [allele_depths[0][1]] + else: + # call multiple alleles at this position if there is no clear winner + geno = [a for _, a in allele_depths] + if geno: + yield (c, start, stop, sample, geno) + + +def vcf_to_seqs(vcfIter, chrlens, samples, min_dp=0, major_cutoff=0.5, min_dp_ratio=0.0): + ''' Take a VCF iterator and produce an iterator of chromosome x sample full sequences.''' + seqs = {} + cur_c = None + for vcfrow in vcfIter: + try: + for c, start, stop, s, alleles in vcfrow_parse_and_call_snps( + vcfrow, samples, min_dp=min_dp, + major_cutoff=major_cutoff, + min_dp_ratio=min_dp_ratio + ): + # changing chromosome? + if c != cur_c: + if cur_c is not None: + # dump the previous chromosome before starting a new one + for s in samples: + seqs[s].replay_deletions() # because of the order of VCF rows with indels + yield seqs[s].emit() + + # prepare base sequences for this chromosome + cur_c = c + for s in samples: + name = len(samples) > 1 and (""%s-%s"" % (c, s)) or c + seqs[s] = MutableSequence(name, 1, chrlens[c]) + + # modify sequence for this chromosome/sample/position + if len(alleles) == 1: + # call a single allele + seqs[s].replace(start, stop, alleles[0]) + elif all(len(a) == 1 for a in alleles): + # call an ambiguous SNP + seqs[s].replace(start, stop, alleles_to_ambiguity(alleles)) + else: + # mix of indels with no clear winner... force the most popular one + seqs[s].replace(start, stop, alleles[0]) + except: + log.exception(""Exception occurred while parsing VCF file. Row: '%s'"", vcfrow) + raise + + # at the end, dump the last chromosome + if cur_c is not None: + for s in samples: + seqs[s].replay_deletions() # because of the order of VCF rows with indels + yield seqs[s].emit() + + +def parser_vcf_to_fasta(parser=argparse.ArgumentParser()): + parser.add_argument(""inVcf"", help=""Input VCF file"") + parser.add_argument(""outFasta"", help=""Output FASTA file"") + parser.add_argument( + ""--trim_ends"", + action=""store_true"", + dest=""trim_ends"", + default=False, + help=""""""If specified, we will strip off continuous runs of N's from the beginning + and end of the sequences before writing to output. Interior N's will not be + changed."""""" + ) + parser.add_argument( + ""--min_coverage"", + dest=""min_dp"", + type=int, + help=""""""Specify minimum read coverage (with full agreement) to make a call. + [default: %(default)s]"""""", + default=3 + ) + parser.add_argument( + ""--major_cutoff"", + dest=""major_cutoff"", + type=float, + help=""""""If the major allele is present at a frequency higher than this cutoff, + we will call an unambiguous base at that position. If it is equal to or below + this cutoff, we will call an ambiguous base representing all possible alleles at + that position. [default: %(default)s]"""""", + default=0.5 + ) + parser.add_argument( + ""--min_dp_ratio"", + dest=""min_dp_ratio"", + type=float, + help=""""""The input VCF file often reports two read depth values (DP)--one for + the position as a whole, and one for the sample in question. We can optionally + reject calls in which the sample read count is below a specified fraction of the + total read count. This filter will not apply to any sites unless both DP values + are reported. [default: %(default)s]"""""", + default=0.0 + ) + parser.add_argument( + ""--name"", + dest=""name"", + nargs=""*"", + help=""output sequence names (default: reference names in VCF file)"", + default=[] + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, main_vcf_to_fasta) + return parser + + +def main_vcf_to_fasta(args): + ''' Take input genotypes (VCF) and construct a consensus sequence + (fasta) by using majority-read-count alleles in the VCF. + Genotypes in the VCF will be ignored--we will use the allele + with majority read support (or an ambiguity base if there is no clear majority). + Uncalled positions will be emitted as N's. + Author: dpark. + ''' + assert args.min_dp >= 0 + assert 0.0 <= args.major_cutoff < 1.0 + + with util.vcf.VcfReader(args.inVcf) as vcf: + chrlens = dict(vcf.chrlens()) + samples = vcf.samples() + + assert len( + samples + ) == 1, """"""Multiple sample columns were found in the intermediary VCF file + of the refine_assembly step, suggesting multiple sample names are present + upstream in the BAM file. Please correct this so there is only one sample in the BAM file."""""" + + with open(args.outFasta, 'wt') as outf: + chr_idx = 0 + for chr_idx, (header, seq) in enumerate( + vcf_to_seqs( + util.file.read_tabfile(args.inVcf), + chrlens, + samples, + min_dp=args.min_dp, + major_cutoff=args.major_cutoff, + min_dp_ratio=args.min_dp_ratio + ) + ): + if args.trim_ends: + seq = seq.strip('Nn') + if args.name: + header = args.name[chr_idx % len(args.name)] + for line in util.file.fastaMaker([(header, seq)]): + outf.write(line) + + # done + log.info(""done"") + return 0 + + +__commands__.append(('vcf_to_fasta', parser_vcf_to_fasta)) + + +def parser_trim_fasta(parser=argparse.ArgumentParser()): + parser.add_argument(""inFasta"", help=""Input fasta file"") + parser.add_argument(""outFasta"", help=""Output (trimmed) fasta file"") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, trim_fasta, split_args=True) + return parser + + +def trim_fasta(inFasta, outFasta): + ''' Take input sequences (fasta) and trim any continuous sections of + N's from the ends of them. Write trimmed sequences to an output fasta file. + ''' + with open(outFasta, 'wt') as outf: + with open(inFasta, 'rt') as inf: + for record in Bio.SeqIO.parse(inf, 'fasta'): + for line in util.file.fastaMaker([(record.id, str(record.seq).strip('Nn'))]): + outf.write(line) + log.info(""done"") + return 0 + + +__commands__.append(('trim_fasta', parser_trim_fasta)) + + +def deambig_base(base): + ''' Take a single base (possibly a IUPAC ambiguity code) and return a random + non-ambiguous base from among the possibilities ''' + return random.choice(Bio.Data.IUPACData.ambiguous_dna_values[base.upper()]) + + +def deambig_fasta(inFasta, outFasta): + ''' Take input sequences (fasta) and replace any ambiguity bases with a + random unambiguous base from among the possibilities described by the ambiguity + code. Write output to fasta file. + ''' + with util.file.open_or_gzopen(outFasta, 'wt') as outf: + with util.file.open_or_gzopen(inFasta, 'rt') as inf: + for record in Bio.SeqIO.parse(inf, 'fasta'): + for line in util.file.fastaMaker([(record.id, ''.join(map(deambig_base, str(record.seq))))]): + outf.write(line) + return 0 + + +def parser_deambig_fasta(parser=argparse.ArgumentParser()): + parser.add_argument(""inFasta"", help=""Input fasta file"") + parser.add_argument(""outFasta"", help=""Output fasta file"") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, deambig_fasta, split_args=True) + return parser + + +__commands__.append(('deambig_fasta', parser_deambig_fasta)) + + +def vcf_dpdiff(vcfs): + for vcf in vcfs: + with util.vcf.VcfReader(vcf) as v: + samples = v.samples() + assert len(samples) == 1 + for row in util.file.read_tabfile(vcf): + dp1 = int(dict(x.split('=') for x in row[7].split(';') if x != '.').get('DP', 0)) + dp2 = 0 + if 'DP' in row[8].split(':'): + dpidx = row[8].split(':').index('DP') + if len(row[9].split(':')) > dpidx: + dp2 = int(row[9].split(':')[dpidx]) + ratio = '' + if dp1: + ratio = float(dp2) / dp1 + yield (row[0], row[1], samples[0], dp1, dp2, dp1 - dp2, ratio) + + +def parser_dpdiff(parser=argparse.ArgumentParser()): + parser.add_argument(""inVcfs"", help=""Input VCF file"", nargs='+') + parser.add_argument(""outFile"", help=""Output flat file"") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, dpdiff, split_args=True) + return parser + + +def dpdiff(inVcfs, outFile): + ''' Take input VCF files (all with only one sample each) and report + on the discrepancies between the two DP fields (one in INFO and one in the + sample's genotype column). + ''' + header = ['chr', 'pos', 'sample', 'dp_info', 'dp_sample', 'diff', 'ratio'] + with open(outFile, 'wt') as outf: + outf.write('#' + '\t'.join(header) + '\n') + for row in vcf_dpdiff(inVcfs): + outf.write('\t'.join(map(str, row)) + '\n') + return 0 + + +#__commands__.append(('dpdiff', parser_dpdiff)) + + +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","DEVELOPMENT_NOTES.md",".md","9677","59","## Developer Documentation +This page lists information for developers working on viral-ngs. + +### Installation, dependencies, and manual deployment requirements + +#### Dependency install destinations +When Python and binary dependencies for viral-ngs are installed by conda, they can end up in several locations. The default and preferred method of installation assumes a conda environment is active in the current shell, complete with [environment variables we can access to specify the path of the active environment](https://github.com/broadinstitute/viral-ngs/blob/master/tools/__init__.py#L240). In this case, conda packages are installed in the active conda environment. If conda is installed and available on the path but no environment is currently active, viral-ngs dependencies are installed in isolation within `viral-ngs/tools/build/conda-tools/{default}` (unless this location is overridden in the CondaPackage() constructor). For tools without a conda recipe (as may be the case on certain platforms, like Mac OSX), or where conda install fails, custom install methods are used to download and build some tools. + +#### Adding a new tool or dependency +When adding a new tool or dependency to viral-ngs, check to see if a conda package is already available either on the default channel (`conda search `), or on the bioconda channel (`conda search -c bioconda `). If so, it will needed to be added to the conda recipe template for viral-ngs. If a recipe is unavailable, it will first need to be added to a particular conda channel. [Bioconda](https://github.com/bioconda/bioconda-recipes) is used by default. + +#### Changing dependency versions +The viral-ngs package installed by `conda install viral-ngs` from the [broad-viral channel](https://anaconda.org/broad-viral/viral-ngs) depends on a conda build recipe distributed in this repository. The recipe files source the various Python and binary depedencies of viral-ngs as conda packages, including version numbers, from the `requirements-*.txt` files within this repository. When updating a package version in requirements-conda.txt, update it also in requirements-minimal.txt if it appears there as well. + +#### Upgrading GATK +When upgrading the GATK to a new version: +- in requirements-conda.txt change the gatk version +- in pipes/config.yaml change the GATK_PATH to point to the correct GATK directory containing GenomeAnalysisTK.jar. + May need to untar a .tar.bz2 from /humgen/gsa-hpprojects/GATK/bin/ into /idi/sabeti-scratch/shared-resources/software/gatk/ . +- in tools/gatk.py change TOOL_VERSION_TUPLE at the top +- in travis/install-gatk.sh change GATK_VERSION at the top +- in easy-deploy-script/easy-deploy-viral-ngs.sh +- in docker/rundocker.sh + +### (Automated) testing +[Travis CI](https://travis-ci.com/broadinstitute/viral-ngs) performs automated unit and integration tests for viral-ngs on each branch and pull request. Unit tests are run on each new branch commit, and longer integration tests are performed on pull requests to help ensure the stability of the `master` branch. Pull requests are gated to ensure merging to `master` is allowed only if all tests pass. The Travis configuration is specified in `.travis.yml`, and relies on files stored within `viral-ngs/travis/`. + +A few notes on testing: +- Travis Linux with Py3 is the authoritative test server +- Tox is present for convenience (local use only, not currently in use on Travis) +- `py.test` is used in place of `nose` or the built-in `unittest` framework for its generative testing, fixtures, and parallelized execution of tests. +- `.flake8`, `.pylintrc`, and `.style.yapf` are available in the repository root, and should be used when running the associated tools +- During Travis tests an encrypted tarball of third-party resources is downloaded into the build environment to provide a licensed copy of GATK and Novoalign. For security, forks of viral-ngs [will not have](https://docs.travis-ci.com/user/pull-requests#Security-Restrictions-when-testing-Pull-Requests) the encrypted resources available for testing on Travis, nor will pull requests from forks. +- Many tests for viral-ngs depend on static input files distributed with the repository. The test input files reside in `viral-ngs/test/input/`. Within specific unit tests, class-specific test input files may be accessed via the function `util.file.get_test_input_path(self)`. The parent directory for all static test files can be accessed via `util.file.get_test_path()` + +#### The Travis build matrix +Each commit on any branch, and any pull request, will trigger a build on Travis CI. Branch commits will test code from a specific commit hash. Pull requests will test the simulated result of merging a branch HEAD onto the target branch HEAD. For each build, the following Travis jobs are launched: +1. Docker & WDL + 1. A docker image is built and deployed to the Docker registry at quay.io. Master branch images are pushed to `quay.io/broadinstitute/viral-ngs:latest` and are also given a versioned tag. Non-master branch images and pull requests are pushed to `quay.io/broadinstitute/viral-ngs-dev` with versioned tags. The docker build is preceded by a docker pull of the docker image associated with the previous Travis build parental to this commit in order to utilize layer caching. Note that our tool dependencies result in a very large docker image (2GB compressed, this is about 10x the typical size for a docker image). The Dockerfile builds the tool dependencies before incorporating the full viral-ngs source code. This means that most docker image builds will be extremely fast: usually 10-20 seconds. The docker push/deploy is similarly fast, since the Docker registry already has most of the layers, and only the new source code layer needs to upload. The docker pull of the 2GB image takes about 5 minutes, so altogether this step takes about 6 minutes on Travis. However, if your code commit alters anything in `requirements-*.txt` or the easy deploy script, it will rebuild the heavy conda install layer, adding another 10 minutes or so to this build. The docker push requires login credentials for a docker registry (e.g. DockerHub, Quay.io, GCP, AWS), stored as an encrypted Travis variable. + 2. After the docker image is deployed, WDL pipeline files are edited to reflect the version tag of the recently pushed docker image. A WDL validator is then run (using wdltool.jar) to ensure that all WDL files are still valid. This completes in seconds. + 3. WDL pipelines are compiled to DNAnexus workflows using dxWDL.jar. These are deployed to a DNAnexus CI project using an API token stored as an encrypted Travis variable. This completes in under a minute. + 4. A couple DNAnexus workflows are test executed in the CI project. + 4. WDL pipelines are executed with test data using Cromwell on the local Travis instance. This is a bit slow (roughly 5 mins for a simple test). +1. Documentation is built automatically. It is not deployed to Read the Docs--this test only exists on Travis in order to bring the developer's attention to any auto build problems. Read the Docs has its own auto build process separate from Travis (see section below) but it does not notify anyone of its build failures. This usually completes in less than 1 minute. +1. The `viral-ngs` conda package is built and deployed to the `broad-viral` channel. This requires anaconda.org credentials stored as an encrypted Travis variable. This takes about 10 minutes. +1. `py.test` is run on Python 3.6. Tool dependencies are installed prior to unit tests via conda. Integration and unit tests are run with every branch commit--note that this is the reverse order of the Py27 tests (unit then integration) so that errors are likely to be detected earlier in the overall build process, if they exist. The Travis cache is cleared for each tagged release, invoking a full re-install of dependencies. Normally, this job completes in 15+ minutes, about half of which is the loading of conda tool dependencies from the cache. Coverage reports are sent to coveralls.io from this Travis job only. + +Some TO DO improvements for the future: + - DNAnexus workflow testing should check output for correctness. + - Cromwell workflow testing should check output for correctness. + - Utilize Travis build stages. + - All of the sub-steps of the first Docker & WDL Travis job should be broken out as separate jobs that wait for the Docker build and deploy. + - Unit tests for Python 3.6, and possibly the conda package build, should occur within the Docker container. + - Second-stage jobs that pull the docker image should utilize quay.io's torrent squashed image pull to reduce the time spent pulling our Docker image (currently about 5 minutes to pull from DockerHub). + - Alternatively, we can explore creating a minimal docker image that installs only the conda pip packages (and perhaps extremely common conda tools like samtools and Picard) and leaves the rest of the conda tools out, letting them dynamically install themselves as needed using our dynamic tool install code. + +### Building documentation +Documentation is built automatically for certain branches of viral-ngs by [Read the Docs](http://viral-ngs.readthedocs.io/en/latest/). The documentation template files reside within `viral-ngs/docs`, and are formatted in standard docutils [reStructuredText format](http://docutils.sourceforge.net/rst.html). [Pandoc](http://pandoc.org/) may be used for converting from other formats (such as Markdown) to reStructuredText. The `sphinx-argparse` module is used to automatically generate documentation for the argparse parsers used in viral-ngs. +","Markdown" +"Viral","broadinstitute/viral-ngs","run_all_tests.sh",".sh","70","6","#!/bin/bash + +set -e -x -o pipefail + +pytest test/unit test/integration +","Shell" +"Viral","broadinstitute/viral-ngs","broad_utils.py",".py","4077","130","#!/usr/bin/env python +"""""" +Utilities for getting sequences out of the Broad walk-up sequencing pipeline. +These utilities are probably not of much use outside the Broad. +"""""" + +__author__ = ""dpark@broadinstitute.org"" +__commands__ = [] + +import argparse +import logging +import os +import os.path +import json +import glob +import util.cmd +import util.file + +log = logging.getLogger(__name__) + +# ========================================== +# *** get stuff from Picard json file *** +# ========================================== + + +def get_json_from_picard(picardDir): + ''' for example, /seq/walkup/picard/{flowcell_minus_first_char} ''' + analysisDir = max( + (os.path.getmtime(os.path.join(picardDir, d)), d) for d in os.listdir(picardDir) + if os.path.isdir(os.path.join(picardDir, d)))[1] + jsonfile = list(glob.glob(os.path.join(picardDir, analysisDir, 'info', 'logs', '*.json'))) + if len(jsonfile) != 1: + raise Exception(""error"") + return jsonfile[0] + +def get_run_date(jsonfile): + with open(jsonfile, 'rt') as inf: + runDate = json.load(inf)['workflow']['runDate'] + return runDate + +def get_bustard_dir(jsonfile): + with open(jsonfile, 'rt') as inf: + bustard = json.load(inf)['workflow']['runFolder'] + return bustard + + +def parser_get_bustard_dir(parser=argparse.ArgumentParser()): + parser.add_argument('inDir', help='Picard directory') + util.cmd.common_args(parser, (('loglevel', 'ERROR'),)) + util.cmd.attach_main(parser, main_get_bustard_dir) + return parser +def main_get_bustard_dir(args): + 'Find the basecalls directory from a Picard directory' + print(get_bustard_dir(get_json_from_picard(args.inDir))) + return 0 +__commands__.append(('get_bustard_dir', parser_get_bustard_dir)) + + +def parser_get_run_date(parser=argparse.ArgumentParser()): + parser.add_argument('inDir', help='Picard directory') + util.cmd.common_args(parser, (('loglevel', 'ERROR'),)) + util.cmd.attach_main(parser, main_get_run_date) + return parser +def main_get_run_date(args): + 'Find the sequencing run date from a Picard directory' + print(get_run_date(get_json_from_picard(args.inDir))) + return 0 +__commands__.append(('get_run_date', parser_get_run_date)) + + +# =============== +# *** misc *** +# =============== + +def iterate_wells(runfile): + for lane in util.file.read_tabfile_dict(runfile): + for well in util.file.read_tabfile_dict(lane['barcode_file']): + yield (lane, well) + + +def get_all_samples(runfile): + return list(sorted(set(well['sample'] for lane, well in iterate_wells(runfile)))) + + +def get_all_libraries(runfile): + return list(sorted(set(well['sample'] + '.l' + well['library_id_per_sample'] for lane, well in iterate_wells( + runfile)))) + + +def get_run_id(well): + run_id = well['sample'] + if well.get('library_id_per_sample'): + run_id += '.l' + well['library_id_per_sample'] + if well.get('run_id_per_library'): + run_id += '.r' + well['run_id_per_library'] + return run_id + + +def get_all_runs(runfile): + return list(sorted(get_run_id(well) + '.' + lane['flowcell'] + '.' + lane['lane'] for lane, well in iterate_wells( + runfile))) + + +def parser_get_all_names(parser=argparse.ArgumentParser()): + parser.add_argument('type', help='Type of name', choices=['samples', 'libraries', 'runs']) + parser.add_argument('runfile', help='File with seq run information') + util.cmd.common_args(parser, (('loglevel', 'ERROR'),)) + util.cmd.attach_main(parser, main_get_all_names) + return parser +def main_get_all_names(args): + 'Get all samples' + if args.type == 'samples': + method = get_all_samples + elif args.type == 'libraries': + method = get_all_libraries + elif args.type == 'runs': + method = get_all_runs + for s in method(args.runfile): + print(s) + return 0 +__commands__.append(('get_all_names', parser_get_all_names)) + + +# ======================= +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","interhost.py",".py","25498","602","#!/usr/bin/env python +''' This script contains a number of utilities for SNP calling, multi-alignment, + phylogenetics, etc. +''' + +__author__ = ""PLACEHOLDER"" +__commands__ = [] + +# built-ins +import argparse +import logging +import os +import array +import bisect +import json +from itertools import permutations +from collections import OrderedDict, Sequence + +from itertools import zip_longest # pylint: disable=E0611 + +from collections import MutableMapping as DictMixin + +# third-party libraries +import Bio.AlignIO +from Bio import SeqIO + +# module-specific +import tools.muscle +import tools.snpeff +import tools.mafft +import util.cmd +import util.file +import util.vcf + +log = logging.getLogger(__name__) + +# =========== CoordMapper ================= + +# CoordMapper extends DictMixin so that after the basic dict dict() interface methods are defined, +# we get higher level dictionary intervace methods for free + + +class CoordMapperError(Exception): + def __init___(self, *args, **kwargs): + super(CoordMapperError, self).__init__(self, *args, **kwargs) + + +class CoordMapper(DictMixin): + """""" Map (chrom, coordinate) between genome A and genome B. + Coordinates are 1-based. + Indels are handled as follows after corresponding sequences are aligned: + Return (chrom, None) if base is past either end of other sequence. + If a base maps to a gap in the other species, return the index + of the closest upstream non-gap base. + If a base is followed by a gap then instead of returning an integer, + return a two-element list representing the interval in the + other species that aligns to this base and the subsequent gap. + Assumption: the aligner tool will never align two gaps, and will never + put gaps in opposite species adjacent to each other without aligning + a pair of real bases in between. + """""" + + def __init__(self, alignerTool=tools.muscle.MuscleTool): + """""" The two genomes are described by fasta files with the same number of + chromosomes, and corresponding chromosomes must be in same order. + """""" + + # { + # chrA : {chrB: mapperAB, chrC: mapperAC}, + # chrB : {chrA: mapperBA, chrC: mapperBC}, + # chrC : {chrA: mapperCA, chrB: mapperCB} + # } + self.chrMaps = OrderedDict() + self.chrMapsUngapped = OrderedDict() + self.alignerTool = alignerTool() + + def __getitem__(self, key): + return self.chrMaps[key] + + def __setitem__(self, key, value): + raise TypeError(""'%s' object does not support item assignment"" % self.__class__.__name__) + + def __delitem__(self, key): + raise TypeError(""'%s' object does not support item deletion"" % self.__class__.__name__) + + def __len__(self): + return len(self.chrMaps) + + def __iter__(self): + for i in self.chrMaps: + yield i + + def __contains__(self, key): + if key in self.chrMaps: + return True + else: + return False + + def keys(self): + return self.chrMaps.keys() + + def mapAtoB(self, fromChrom, fromPos=None, side=0): + """""" Map (chrom, coordinate) from genome A to genome B. + If fromPos is None, map only the chromosome name + If side is: + < 0, return the left-most position on B + ==0, return either the unique position on B or a [left,right] list + > 0, return the right-most position on B + """""" + if len(self.chrMaps.keys()) != 4: + raise LookupError( + ""CoordMapper.mapAtoB expects two input sequences and is provided only as a legacy function"") + + return self.mapChr(fromChrom, list(self.chrMaps[fromChrom].keys())[0], fromPos, side) + + def mapBtoA(self, fromChrom, fromPos=None, side=0): + """""" Map (chrom, coordinate) from genome B to genome A. + If fromPos is None, map only the chromosome name + If side is: + < 0, return the left-most position on A + ==0, return either the unique position on A or a [left,right] list + > 0, return the right-most position on A + """""" + if len(self.chrMaps.keys()) != 4: + raise LookupError( + ""CoordMapper.mapBtoA expects two input sequences and is provided only as a legacy function"") + + return self.mapChr(fromChrom, list(self.chrMaps[fromChrom].keys())[0], fromPos, side) + + def mapChr(self, fromChrom, toChrom, fromPos=None, side=0): + """""" Map (chrom, coordinate) from seq ""fromChrom"" to seq ""toChrom"". + If fromPos is None, map only the chromosome name + If side is: + < 0, return the left-most position on A + ==0, return either the unique position on A or a [left,right] list + > 0, return the right-most position on A + """""" + + if fromChrom not in self.chrMaps: + raise KeyError(""chr '%s' not found in CoordMapper relation map"" % fromChrom) + if toChrom not in self.chrMaps[fromChrom].keys(): + raise KeyError(""chr '%s' not found in CoordMapper relation map"" % toChrom) + + mapper = self.chrMaps[fromChrom][toChrom] + + if fromPos is None: + return toChrom + toPos = mapper(fromPos, 0) + if isinstance(toPos, Sequence) and side != 0: + toPos = toPos[0] if side < 0 else toPos[1] + return (toChrom, toPos) + + def load_alignments(self, aligned_files, a_idx=None, b_idx=None): + """""" Loads aligned sequences into a CoordMapper instance. + Any number of sequences >1 may be read in. + Mappers may be accessed via CoordMapper.chrMaps where chrMaps may look like: + ``` + { + chrA : {chrB: mapperAB, chrC: mapperAC}, + chrB : {chrA: mapperBA, chrC: mapperBC}, + chrC : {chrA: mapperCA, chrB: mapperCB} + } + ``` + """""" + for alignOutFileName in aligned_files: + with open(alignOutFileName, 'rt') as alignOutFile: + seqs = list(SeqIO.parse(alignOutFile, 'fasta')) + + # if len(list(seqs)) <2: + # raise Exception(""Each aligned input file must contain >1 sequence."") + + # if mapping between specific sequences is specified + if a_idx is not None and b_idx is not None: + assert a_idx >= 0 and b_idx >= 0 + assert a_idx < len(seqs) and b_idx < len(seqs) + + mapper = CoordMapper2Seqs(seqs[a_idx].seq, seqs[b_idx].seq) + self.chrMaps.setdefault(seqs[a_idx].id, OrderedDict()) + mapDict = OrderedDict() + mapDict[seqs[b_idx].id] = mapper + self.chrMaps[seqs[a_idx].id] = mapDict + + mapper = CoordMapper2Seqs(seqs[b_idx].seq, seqs[a_idx].seq) + self.chrMaps.setdefault(seqs[b_idx].id, OrderedDict()) + mapDict = OrderedDict() + mapDict[seqs[a_idx].id] = mapper + self.chrMaps[seqs[b_idx].id] = mapDict + # otherwise, map all possible pairwise permutations + else: + for (seq1, seq2) in permutations(seqs, 2): + if (seq1.id == seq2.id): + raise KeyError(""duplicate sequence names '%s', '%s'"" % (seq1.id, seq2.id)) + + self.chrMaps.setdefault(seq1.id, OrderedDict()) + self.chrMapsUngapped.setdefault(seq1.id, OrderedDict()) + # if the sequence we are mapping onto is already in the map + # raise an error + # (could occur if same sequence is read in from multiple files) + if (seq2.id in self.chrMaps[seq1.id]): + raise KeyError( + ""duplicate sequence name '%s' already in chrMap for %s"" % (seq2.id, seq1.id)) + + mapper = CoordMapper2Seqs(seq1.seq, seq2.seq) + mapDict = self.chrMaps[seq1.id] + mapDict[seq2.id] = mapper + self.chrMaps[seq1.id] = mapDict + + # ungapped strings + #longerSeqLen = max( len(seq1.seq.ungap(""-"")), len(seq2.seq.ungap(""-"")) ) + #seq1UngappedPadded = str(seq1.seq.ungap(""-"")).ljust(longerSeqLen, ""N"") + #seq2UngappedPadded = str(seq2.seq.ungap(""-"")).ljust(longerSeqLen, ""N"") + #mapper = CoordMapper2Seqs(seq1UngappedPadded, seq2UngappedPadded) + #mapDict = self.chrMapsUngapped[seq1.id] + #mapDict[seq2.id] = mapper + #self.chrMapsUngapped[seq1.id] = mapDict + + def align_and_load_sequences(self, unaligned_fasta_files, aligner=None): + aligner = self.alignerTool if aligner is None else aligner + + # transpose + per_chr_fastas = transposeChromosomeFiles(unaligned_fasta_files) + if not per_chr_fastas: + raise Exception('no input sequences') + # align + alignOutFileNames = [] + for alignInFileName in per_chr_fastas: + alignOutFileName = util.file.mkstempfname('.fasta') + aligner.execute(alignInFileName, alignOutFileName) + alignOutFileNames.append(alignOutFileName) + os.unlink(alignInFileName) + # read in + self.load_alignments(alignOutFileNames) + # clean up + for f in alignOutFileNames: + os.unlink(f) + + +class CoordMapper2Seqs(object): + """""" Map 1-based coordinates between two aligned sequences. + Result is a coordinate or an interval, as described in CoordMapper main + comment string. + Return None if beyond end. + Input sequences must be already-aligned iterators through bases with + gaps represented by dashes and all other characters assumed to be + real bases. + Assumptions: + - Sequences (including gaps) are same length. + - Each sequence has at least one real base. + - A gap is never aligned to a gap. + - A gap in one sequence is never adjacent to a gap in the other; + there must always be an intervening real base between two gaps. + """""" + # + # Implementation: + # mapArrays is a pair of arrays of equal length such that + # (mapArrays[0][n], mapArrays[1][n]) are the coordinates of a pair of + # aligned real bases on the two sequences. The only pairs that are + # included are the first, the last, and the pair immediately following + # any gap. Pairs are in increasing order. Coordinate mapping + # requires binary search in one of the arrays. + # Total space required, in bytes, is const + 8 * (number of indels). + # Time for a map in either direction is O(log(number of indels)). + # + + def __init__(self, seq0, seq1): + self.mapArrays = [array.array('I'), array.array('I')] + baseCount0 = 0 # Number of real bases in seq0 up to and including cur pos + baseCount1 = 0 # Number of real bases in seq1 up to and including cur pos + beforeStart = True # Haven't yet reached first pair of aligned real bases + gapSinceLast = False # Have encounted a gap since last pair in mapArrays + for b0, b1 in zip_longest(seq0, seq1): + if b0 is None or b1 is None: + raise Exception('CoordMapper2Seqs: sequences must be same length.') + realBase0 = b0 != '-' + realBase1 = b1 != '-' + baseCount0 += realBase0 + baseCount1 += realBase1 + if realBase0 and realBase1: + if beforeStart or gapSinceLast: + self.mapArrays[0].append(baseCount0) + self.mapArrays[1].append(baseCount1) + gapSinceLast = False + beforeStart = False + finalPos0 = baseCount0 # Last pair of aligned real bases so far + finalPos1 = baseCount1 # Last pair of aligned real bases so far + else: + gapSinceLast = True + if len(self.mapArrays[0]) > 0: + if self.mapArrays[0][-1] != finalPos0: + self.mapArrays[0].append(finalPos0) + self.mapArrays[1].append(finalPos1) + + def __call__(self, fromPos, fromWhich): + """""" fromPos: 1-based coordinate + fromWhich: if 0, map from 1st sequence to 2nd, o.w. 2nd to 1st."""""" + if len(self.mapArrays[0]) == 0: + raise Exception('CoordMapper2Seqs: no aligned bases.') + if fromPos != int(fromPos): + raise TypeError('CoordMapper2Seqs: pos %s is not an integer' % fromPos) + fromArray = self.mapArrays[fromWhich] + toArray = self.mapArrays[1 - fromWhich] + if fromPos < fromArray[0] or fromPos > fromArray[-1]: + result = None + elif fromPos == fromArray[-1]: + result = toArray[-1] + else: + insertInd = bisect.bisect(fromArray, fromPos) + prevFromPos = fromArray[insertInd - 1] + nextFromPos = fromArray[insertInd] + prevToPos = toArray[insertInd - 1] + nextToPos = toArray[insertInd] + assert (prevFromPos <= fromPos < nextFromPos) + prevPlusOffset = prevToPos + (fromPos - prevFromPos) + if fromPos == nextFromPos - 1 and prevPlusOffset < nextToPos - 1: + result = [prevPlusOffset, nextToPos - 1] + else: + result = min(prevPlusOffset, nextToPos - 1) + return result + +# ========== snpEff annotation of VCF files ================== + + +def parser_snpEff(parser=argparse.ArgumentParser()): + parser.add_argument(""inVcf"", help=""Input VCF file"") + parser.add_argument(""genomes"", nargs='+', help=""genome name (snpEff db name, or NCBI accessions)"") + parser.add_argument(""outVcf"", help=""Output VCF file"") + parser.add_argument(""--emailAddress"", + help=""""""Your email address. To access the Genbank CoreNucleotide database, + NCBI requires you to specify your email address with each request. + In case of excessive usage of the E-utilities, NCBI will attempt to contact + a user at the email address provided before blocking access."""""") + util.cmd.common_args(parser, (('tmp_dir', None), ('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, tools.snpeff.SnpEff().annotate_vcf, split_args=True) + return parser + + +__commands__.append(('snpEff', parser_snpEff)) + +# ======================= +# *** align_mafft *** +# ======================= + + +def parser_general_mafft(parser=argparse.ArgumentParser()): + parser.add_argument('inFastas', nargs='+', help='Input FASTA files.') + + group = parser.add_mutually_exclusive_group() + group.add_argument('--localpair', + default=None, + action='store_true', + help='All pairwise alignments are computed with the Smith-Waterman algorithm.') + group.add_argument('--globalpair', + default=None, + action='store_true', + help='All pairwise alignments are computed with the Needleman-Wunsch algorithm.') + + parser.add_argument('--preservecase', + default=None, + action='store_true', + help='Preserve base or aa case, as well as symbols.') + parser.add_argument('--reorder', + default=None, + action='store_true', + help='Output is ordered aligned rather than in the order of the input (default: %(default)s).') + parser.add_argument('--gapOpeningPenalty', + default=1.53, + type=float, + help='Gap opening penalty (default: %(default)s).') + parser.add_argument('--ep', type=float, help='Offset (works like gap extension penalty).') + parser.add_argument('--verbose', default=False, action='store_true', help='Full output (default: %(default)s).') + parser.add_argument('--outputAsClustal', + default=None, + action='store_true', + help='Write output file in Clustal format rather than FASTA') + parser.add_argument( + '--maxiters', + default=0, + type=int, + help=""""""Maximum number of refinement iterations (default: %(default)s). + Note: if ""--localpair"" or ""--globalpair"" is specified this defaults to 1000."""""") + return parser + + +def parser_align_mafft(parser): + parser = parser_general_mafft(parser) + + parser.add_argument('outFile', help='Output file containing alignment result (default format: FASTA)') + + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_align_mafft) + return parser + + +def main_align_mafft(args): + ''' Run the mafft alignment on the input FASTA file.''' + + tools.mafft.MafftTool().execute( + inFastas=args.inFastas, + outFile=args.outFile, + localpair=args.localpair, + globalpair=args.globalpair, + preservecase=args.preservecase, + reorder=args.reorder, + gapOpeningPenalty=args.gapOpeningPenalty, + offset=args.ep, + verbose=args.verbose, + outputAsClustal=args.outputAsClustal, + maxiters=args.maxiters, + threads=args.threads) + + return 0 + + +__commands__.append(('align_mafft', parser_align_mafft)) + +# ======================= +# *** multichr_mafft *** +# ======================= + + +def parser_multichr_mafft(parser): + parser = parser_general_mafft(parser) + + parser.add_argument('outDirectory', help='Location for the output files (default is cwd: %(default)s)') + parser.add_argument('--outFilePrefix', + default=""aligned"", + help='Prefix for the output file name (default: %(default)s)') + parser.add_argument('--sampleRelationFile', + default=None, + help=""""""If the parameter sampleRelationFile is specified + (as a file path), a JSON file will be written mapping + sample name to sequence position in the output."""""") + parser.add_argument('--sampleNameListFile', + default=None, + help=""""""If the parameter sampleRelationFile is specified + (as a file path), a file will be written mapping + sample names in the order of their sequence + positions in the output."""""") + + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, multichr_mafft) + return parser + + +def multichr_mafft(args): + ''' Run the mafft alignment on a series of chromosomes provided in sample-partitioned FASTA files. Output as FASTA. + (i.e. file1.fasta would contain chr1, chr2, chr3; file2.fasta would also contain chr1, chr2, chr3)''' + + # get the absolute path to the output directory in case it has been specified as a relative path, + # since MAFFT relies on its CWD for path resolution + absoluteOutDirectory = os.path.abspath(args.outDirectory) + + # make the output directory if it does not exist + if not os.path.isdir(absoluteOutDirectory): + os.makedirs(absoluteOutDirectory) + + # prefix for output files + prefix = """" if args.outFilePrefix is None else args.outFilePrefix + + # reorder the data into new FASTA files, where each FASTA file has only variants of its respective chromosome + transposedFiles = transposeChromosomeFiles(args.inFastas, args.sampleRelationFile, args.sampleNameListFile) + + # since the FASTA files are + for idx, filePath in enumerate(transposedFiles): + + # execute MAFFT alignment. The input file is passed within a list, since argparse ordinarily + # passes input files in this way, and the MAFFT tool expects lists, + # but in this case we are creating the input file ourselves + tools.mafft.MafftTool().execute( + inFastas=[os.path.abspath(filePath)], + outFile=os.path.join(absoluteOutDirectory, ""{}_{}.fasta"".format(prefix, idx + 1)), + localpair=args.localpair, + globalpair=args.globalpair, + preservecase=args.preservecase, + reorder=args.reorder, + gapOpeningPenalty=args.gapOpeningPenalty, + offset=args.ep, + verbose=args.verbose, + outputAsClustal=args.outputAsClustal, + maxiters=args.maxiters, + threads=args.threads) + + return 0 + + +__commands__.append(('multichr_mafft', parser_multichr_mafft)) + +# ============================ + +# modified version of rachel's call_snps_3.py follows + + +def call_snps_3(inFasta, outVcf, REF=""KJ660346.2""): + a = Bio.AlignIO.read(inFasta, ""fasta"") + ref_idx = find_ref(a, REF) + with open(outVcf, 'wt') as outf: + outf.write(vcf_header(a)) + for row in make_vcf(a, ref_idx, REF): + outf.write('\t'.join(map(str, row)) + '\n') + + +def find_ref(a, ref): + for i in range(len(a)): + if a[i].id == ref: + return i + return -1 + + +def vcf_header(a): + header = ""##fileformat=VCFv4.1\n"" + header += ""##FORMAT=\n"" + header += ""##contig=\n"" + header += '#' + '\t'.join(['CHROM', 'POS', 'ID', 'REF', 'ALT', + 'QUAL', 'FILTER', 'INFO', 'FORMAT'] + [x.id for x in a]) + '\n' # pylint: disable=E1101 + + return header + + +def make_vcf(a, ref_idx, chrom): + bases = set([""A"", ""C"", ""G"", ""T""]) + for i in range(len(a[0])): + alt = [] + for j in range(len(a)): + if (a[j][i] != a[ref_idx][i]) and ((a[ref_idx][i] in bases) and (a[j][i] in bases)) and a[j][i] not in alt: + alt.append(a[j][i]) + if len(alt) > 0: + row = [chrom, i + 1, '.', a[ref_idx][i], ','.join(alt), '.', '.', '.', 'GT'] + genos = [] + for k in range(len(a)): + if a[k][i] == a[ref_idx][i]: + genos.append(0) + elif a[k][i] not in bases: + genos.append(""."") + else: + for m in range(0, len(alt)): + if a[k][i] == alt[m]: + genos.append(m + 1) + yield row + genos + +class TranspositionError(Exception): + def __init___(self, *args, **kwargs): + super(TranspositionError, self).__init__(self, *args, **kwargs) + +def transposeChromosomeFiles(inputFilenamesList, sampleRelationFile=None, sampleNameListFile=None): + ''' Input: a list of FASTA files representing a genome for each sample. + Each file contains the same number of sequences (chromosomes, segments, + etc) in the same order. + If the parameter sampleRelationFile is specified (as a file path), + a JSON file will be written mapping sample name to sequence position + in the output. + Output: a list of FASTA files representing all samples for each + chromosome/segment for input to a multiple sequence aligner. + The number of FASTA files corresponds to the number of chromosomes + in the genome. Each file contains the same number of samples + in the same order. Each output file is a tempfile. + ''' + outputFilenames = [] + + # open all files + inputFilesList = [util.file.open_or_gzopen(x, 'r') for x in inputFilenamesList] + # get BioPython iterators for each of the FASTA files specified in the input + fastaFiles = [SeqIO.parse(x, 'fasta') for x in inputFilesList] + + # write out json file containing relation of + # sample name to position in output + if sampleRelationFile: + with open(os.path.realpath(sampleRelationFile), ""w"") as outFile: + # dict mapping sample->index, zero indexed + sampleIdxMap = dict((os.path.basename(v).replace("".fasta"", """"), k) + for k, v in enumerate(inputFilenamesList)) + json.dump(sampleIdxMap, outFile, sort_keys=True, indent=4, separators=(',', ': ')) + + if sampleNameListFile: + with open(os.path.realpath(sampleNameListFile), ""w"") as outFile: + sampleNameList = [os.path.basename(v).replace("".fasta"", ""\n"") for v in inputFilenamesList] + outFile.writelines(sampleNameList) + + # for each interleaved record + for chrRecordList in zip_longest(*fastaFiles): + if any(rec is None for rec in chrRecordList): + raise TranspositionError(""input fasta files must all have the same number of sequences"") + + outputFilename = util.file.mkstempfname('.fasta') + outputFilenames.append(outputFilename) + with open(outputFilename, ""w"") as outf: + # write the corresonding records to a new FASTA file + SeqIO.write(chrRecordList, outf, 'fasta') + + # close all input files + for x in inputFilesList: + x.close() + + return outputFilenames + + +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","file_utils.py",".py","2408","64","#!/usr/bin/env python +"""""" +Utilities for dealing with files. +"""""" + +__author__ = ""tomkinsc@broadinstitute.org"" +__commands__ = [] + +import argparse +import logging + +import util.cmd +import util.file + +log = logging.getLogger(__name__) + + +# ============================== +# *** merge_tarballs *** +# ============================== + +def merge_tarballs(out_tarball, in_tarballs, threads=None, extract_to_disk_path=None, pipe_hint_in=None, pipe_hint_out=None): + ''' Merges separate tarballs into one tarball + data can be piped in and/or out + ''' + util.file.repack_tarballs(out_tarball, in_tarballs, threads=threads, extract_to_disk_path=extract_to_disk_path, pipe_hint_in=pipe_hint_in, pipe_hint_out=pipe_hint_out) + return 0 +def parser_merge_tarballs(parser=argparse.ArgumentParser()): + parser.add_argument( + 'out_tarball', + help='''output tarball (*.tar.gz|*.tar.lz4|*.tar.bz2|-); + compression is inferred by the file extension. + Note: if ""-"" is used, output will be written to stdout and + --pipeOutHint must be provided to indicate compression type + when compression type is not gzip (gzip is used by default). + ''') + parser.add_argument( + 'in_tarballs', nargs='+', + help=('input tarballs (*.tar.gz|*.tar.lz4|*.tar.bz2)') + ) + parser.add_argument('--extractToDiskPath', + dest=""extract_to_disk_path"", + help='If specified, the tar contents will also be extracted to a local directory.') + parser.add_argument('--pipeInHint', + dest=""pipe_hint_in"", + default=""gz"", + help='If specified, the compression type used is used for piped input.') + parser.add_argument('--pipeOutHint', + dest=""pipe_hint_out"", + default=""gz"", + help='If specified, the compression type used is used for piped output.') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, merge_tarballs, split_args=True) + return parser +__commands__.append(('merge_tarballs', parser_merge_tarballs)) + + +# ======================= +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__)","Python" +"Viral","broadinstitute/viral-ngs","kmer_utils.py",".py","10548","201","#!/usr/bin/env python + +""""""Commands for working with sets of kmers"""""" + + +from __future__ import print_function +__author__ = ""ilya@broadinstitute.org"" + +__commands__ = [] + +import argparse +import logging +import functools + +import util.cmd +import util.file +import util.misc +import tools +import tools.picard +import tools.samtools +import tools.kmc + +log = logging.getLogger(__name__) # pylint: disable=invalid-name + +# ================================= + +def build_kmer_db(seq_files, kmer_db, kmer_size=tools.kmc.DEFAULT_KMER_SIZE, min_occs=1, max_occs=util.misc.MAX_INT32, + counter_cap=tools.kmc.DEFAULT_COUNTER_CAP, single_strand=False, mem_limit_gb=8, mem_limit_laxness=0, + threads=None): + """"""Build a database of kmers occurring in given sequences."""""" + tools.kmc.KmcTool().build_kmer_db(**locals()) + +def parser_build_kmer_db(parser=argparse.ArgumentParser()): + """"""Create parser for build_kmer_db"""""" + parser.add_argument('seq_files', nargs='+', + help='Files from which to extract kmers (fasta/fastq/bam, fasta/fastq may be .gz or .bz2)') + parser.add_argument('kmer_db', help='kmer database (with or without .kmc_pre/.kmc_suf suffix)') + parser.add_argument('--kmerSize', '-k', dest='kmer_size', type=int, default=tools.kmc.DEFAULT_KMER_SIZE, + help='kmer size') + parser.add_argument('--minOccs', '-ci', dest='min_occs', type=int, default=1, + help='drop kmers with fewer than this many occurrences') + parser.add_argument('--maxOccs', '-cx', dest='max_occs', type=int, default=util.misc.MAX_INT32, + help='drop kmers with more than this many occurrences') + parser.add_argument('--counterCap', '-cs', dest='counter_cap', type=int, + default=tools.kmc.DEFAULT_COUNTER_CAP, help='cap kmer counts at this value') + parser.add_argument('--singleStrand', '-b', dest='single_strand', default=False, action='store_true', + help='do not add kmers from reverse complements of input sequences') + parser.add_argument('--memLimitGb', dest='mem_limit_gb', default=8, type=int, help='Max memory to use, in GB') + parser.add_argument('--memLimitLaxness', dest='mem_limit_laxness', default=0, type=int, choices=(0, 1, 2), + help='How strict is --memLimitGb? 0=strict, 1=lax, 2=even more lax') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, build_kmer_db, split_args=True) + return parser + +__commands__.append(('build_kmer_db', parser_build_kmer_db)) + +# ========================= + +def dump_kmer_counts(kmer_db, out_kmers, min_occs=1, max_occs=util.misc.MAX_INT32, threads=None): + """"""Dump kmers and their counts from kmer database to a text file"""""" + tools.kmc.KmcTool().dump_kmer_counts(**locals()) + +def parser_dump_kmer_counts(parser=argparse.ArgumentParser()): + """"""Create parser for dump_kmer_counts"""""" + parser.add_argument('kmer_db', help='kmer database (with or without .kmc_pre/.kmc_suf suffix)') + parser.add_argument('out_kmers', help='text file to which to write the kmers') + parser.add_argument('--minOccs', '-ci', dest='min_occs', type=int, default=1, + help='drop kmers with fewer than this many occurrences') + parser.add_argument('--maxOccs', '-cx', dest='max_occs', type=int, default=util.misc.MAX_INT32, + help='drop kmers with more than this many occurrences') + + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, dump_kmer_counts, split_args=True) + return parser + +__commands__.append(('dump_kmer_counts', parser_dump_kmer_counts)) + +# ========================= + +def filter_reads(kmer_db, in_reads, out_reads, db_min_occs=1, db_max_occs=util.misc.MAX_INT32, + read_min_occs=0, read_max_occs=util.misc.MAX_INT32, + read_min_occs_frac=0.0, read_max_occs_frac=1.0, hard_mask=False, threads=None): + """"""Filter reads based on their kmer contents. + + Can also be used to filter contigs or reference sequences, but we'll refer to filtering of reads + in the documentation. + + Note that ""occurrence of a kmer"" means ""occurrence of the kmer or its reverse complement"" if kmer_db was built + with single_strand==False. + + Inputs: + kmer_db: the kmc kmer database + in_reads: the reads to filter. can be a .fasta or .fastq or .bam; fasta or fastq can be compressed + with gzip or bzip2. If a .bam, a read pair is kept if either mate passes the filter. + + Outputs: + out_reads: file to which filtered reads are written. type is determined from extension, + same types as above are supported. + + Params: + db_min_occs: only consider database kmers with at least this count + db_max_occs: only consider database kmers with at most this count + + read_min_occs: only keep reads with at least this many occurrences of kmers from database. + read_max_occs: only keep reads with no more than this many occurrence of kmers from the database. + read_min_occs_frac: only keep reads with at least this many occurrences of kmers from database, + interpreted as a fraction of read length in kmers + read_max_occs_frac: only keep reads with no more than this many occurrence of kmers from the database. + interpreted as a fraction of read length in kmers. + + (Note: minimal read kmer content can be given as absolute counts or fraction of read length, but not both). + + hard_mask: if True, in the output reads, kmers not passing the filter are replaced by Ns + threads: use this many threads + """""" + tools.kmc.KmcTool().filter_reads(**locals()) + +def parser_filter_reads(parser=argparse.ArgumentParser()): + """"""Create parser for filter_reads"""""" + parser.add_argument('kmer_db', help='kmer database (with or without .kmc_pre/.kmc_suf suffix)') + parser.add_argument('in_reads', help='input reads, as fasta/fastq/bam') + parser.add_argument('out_reads', help='output reads') + parser.add_argument('--dbMinOccs', dest='db_min_occs', type=int, default=1, + help='ignore datatbase kmers with count below this') + parser.add_argument('--dbMaxOccs', dest='db_max_occs', type=int, default=util.misc.MAX_INT32, + help='ignore datatbase kmers with count above this') + parser.add_argument('--readMinOccs', dest='read_min_occs', type=int, default=0, + help='filter out reads with fewer than this many db kmers') + parser.add_argument('--readMaxOccs', dest='read_max_occs', type=int, default=util.misc.MAX_INT32, + help='filter out reads with more than this many db kmers') + parser.add_argument('--readMinOccsFrac', dest='read_min_occs_frac', type=float, default=0.0, + help='filter out reads with fewer than this many db kmers, ' + 'interpreted as fraction of read length') + parser.add_argument('--readMaxOccsFrac', dest='read_max_occs_frac', type=float, default=1.0, + help='filter out reads with more than this many db kmers, ' + 'interpreted as fraction of read length') + parser.add_argument('--hardMask', dest='hard_mask', default=False, + action='store_true', + help='In the output reads, mask the invalid kmers') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, filter_reads, split_args=True) + return parser + +__commands__.append(('filter_reads', parser_filter_reads)) + +# ========================= + +def kmers_binary_op(op, kmer_db1, kmer_db2, kmer_db_out, + result_min_occs=1, result_max_occs=util.misc.MAX_INT32, + result_counter_cap=tools.kmc.DEFAULT_COUNTER_CAP, threads=None): # pylint: disable=invalid-name + """"""Perform a simple binary operation on kmer sets."""""" + + tools.kmc.KmcTool().kmers_binary_op(**locals()) + +def parser_kmers_binary_op(parser=argparse.ArgumentParser()): + """"""Create parser forkmers_binary_op"""""" + parser.add_argument('op', choices=('intersect', 'union', 'kmers_subtract', 'counters_subtract'), + help='binary operation to perform') + parser.add_argument('kmer_db1', help='first kmer set') + parser.add_argument('kmer_db2', help='second kmer set') + parser.add_argument('kmer_db_out', help='output kmer db') + parser.add_argument('--resultMinOccs', dest='result_min_occs', type=int, default=1, + help='from the result drop kmers with counts below this') + parser.add_argument('--resultMaxOccs', dest='result_max_occs', type=int, default=util.misc.MAX_INT32, + help='from the result drop kmers with counts above this') + parser.add_argument('--resultCounterCap', dest='result_counter_cap', type=int, default=tools.kmc.DEFAULT_COUNTER_CAP, + help='cap output counters at this value') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, kmers_binary_op, split_args=True) + return parser + +__commands__.append(('kmers_binary_op', parser_kmers_binary_op)) + +# ========================= + +def kmers_set_counts(kmer_db_in, value, kmer_db_out, threads=None): + """"""Copy the kmer database, setting all kmer counts in the output to the given value."""""" + + tools.kmc.KmcTool().set_kmer_counts(**locals()) + +def parser_kmers_set_counts(parser=argparse.ArgumentParser()): + """"""Create parser for kmers_set_counts"""""" + parser.add_argument('kmer_db_in', help='input kmer db') + parser.add_argument('value', type=int, help='all kmer counts in the output will be set to this value') + parser.add_argument('kmer_db_out', help='output kmer db') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, kmers_set_counts, split_args=True) + return parser + +__commands__.append(('kmers_set_counts', parser_kmers_set_counts)) + +# ======================== + +def full_parser(): + """"""Create parser for all commands in kmers.py"""""" + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","reports.py",".py","41980","1048","#!/usr/bin/env python +''' Functions to create reports from genomics pipeline data. +''' + +__author__ = ""dpark@broadinstitute.org"" +__commands__ = [] + +import argparse +import logging +import glob +import os +import time +from collections import OrderedDict, defaultdict +import csv +import math +import shutil + +import pysam +from pybedtools import BedTool +import Bio.SeqIO +import Bio.AlignIO +from Bio.Alphabet.IUPAC import IUPACUnambiguousDNA +import matplotlib +matplotlib.use('Agg') +import matplotlib.pyplot as plt + +import util.cmd +import util.file +import util.misc +import tools.samtools +import tools.bwa +import tools.fastqc +import assembly +import interhost +from util.stats import mean, median + +log = logging.getLogger(__name__) + + +def get_assembly_stats(sample, + cov_thresholds=(1, 5, 20, 100), + assembly_dir='data/02_assembly', assembly_tmp='tmp/02_assembly', + align_dir='data/02_align_to_self', reads_dir='data/01_per_sample', + raw_reads_dir='data/00_raw'): + ''' Fetch assembly-level statistics for a given sample ''' + out = {'sample': sample} + samtools = tools.samtools.SamtoolsTool() + header = ['sample', + 'reads_raw', + 'reads_cleaned', + 'reads_taxfilt', + 'assembled_trinity', + 'trinity_in_reads', + 'n_contigs', + 'contig_len', + 'unambig_bases', + 'pct_unambig', + 'aln2self_reads_tot', + 'aln2self_reads_aln', + 'aln2self_reads_rmdup', + 'aln2self_pct_nondup', + 'aln2self_cov_median', + 'aln2self_cov_mean', + 'aln2self_cov_mean_non0',] + ['aln2self_cov_%dX' % t for t in cov_thresholds] + + # per-sample unaligned read stats + for adj in ('cleaned', 'taxfilt'): + reads_bam = os.path.join(reads_dir, '.'.join((sample, adj, 'bam'))) + if os.path.isfile(reads_bam): + out['reads_' + adj] = samtools.count(reads_bam) + if os.path.isdir(raw_reads_dir): + out['reads_raw'] = sum(samtools.count(bam) + # correct issue where sample names containing other sample names as substrings leads + # to extra files being included in the count + # + # add a dot before the wildcard, and assume the sample name is found before the dot. + # this works for now since dots are the filename field separators + # and leading/trailing dots are stripped from sample names in util.file.string_to_file_name() + # TODO: replace this with better filtering? + for bam in glob.glob(os.path.join(raw_reads_dir, sample + "".*.bam""))) + sample_raw_fname = os.path.join(raw_reads_dir, sample + "".bam"") + if os.path.isfile(sample_raw_fname): + # if ""00_raw/sample.bam"" exists, these were not demuxed by snakemake + if out['reads_raw']: + # if sample.bam AND sample.library.flowcell.lane.bam exist, we have a problem! + out['reads_raw'] = 'ambiguous filenames in raw reads directory!' + else: + # just count the sample.bam reads + out['reads_raw'] = samtools.count(sample_raw_fname) + + # pre-assembly stats + out['assembled_trinity'] = os.path.isfile(os.path.join(assembly_tmp, sample + + '.assembly1-trinity.fasta')) and 1 or 0 + sub_bam = os.path.join(assembly_tmp, sample + '.subsamp.bam') + if os.path.isfile(sub_bam): + out['trinity_in_reads'] = samtools.count(sub_bam) + + # assembly stats + assembly_fname = os.path.join(assembly_dir, sample + '.fasta') + if not os.path.isfile(assembly_fname): + assembly_fname = os.path.join(assembly_tmp, sample + '.assembly2-scaffolded.fasta') + if not os.path.isfile(assembly_fname): + out['n_contigs'] = 0 + if os.path.isfile(assembly_fname): + with open(assembly_fname, 'rt') as inf: + counts = [(len(s), assembly.unambig_count(s.seq)) for s in Bio.SeqIO.parse(inf, 'fasta') if len(s) > 0] + out['n_contigs'] = len(counts) + out['contig_len'] = ','.join(str(x) for x, y in counts) + out['unambig_bases'] = ','.join(str(y) for x, y in counts) + out['pct_unambig'] = ','.join(str(float(y) / x) for x, y in counts) + + # read counts from align-to-self + bam_fname = os.path.join(align_dir, sample + '.bam') + if os.path.isfile(bam_fname): + out['aln2self_reads_tot'] = samtools.count(bam_fname) + out['aln2self_reads_aln'] = samtools.count(bam_fname, opts=['-F', '4']) + out['aln2self_reads_rmdup'] = samtools.count(bam_fname, opts=['-F', '1028']) + if out['aln2self_reads_aln']: + out['aln2self_pct_nondup'] = float(out['aln2self_reads_rmdup']) / out['aln2self_reads_aln'] + + # genome coverage stats + bam_fname = os.path.join(align_dir, sample + '.mapped.bam') + if os.path.isfile(bam_fname): + with pysam.AlignmentFile(bam_fname, 'rb') as bam: + coverages = list([pcol.nsegments for pcol in bam.pileup()]) + if coverages: + out['aln2self_cov_median'] = median(coverages) + out['aln2self_cov_mean'] = ""%0.3f"" % mean(coverages) + out['aln2self_cov_mean_non0'] = ""%0.3f"" % mean([n for n in coverages if n > 0]) + for thresh in cov_thresholds: + out['aln2self_cov_%dX' % thresh] = sum(1 for n in coverages if n >= thresh) + + return (header, out) + + +def genome_coverage_stats_only(mapped_bam, chr_name=None, cov_thresholds=(1, 5, 20, 100)): + out = {} + with pysam.AlignmentFile(mapped_bam, 'rb') as bam: + coverages = list([pcol.nsegments for pcol in bam.pileup(chr_name)]) + if coverages: + out['aln2self_cov_median'] = median(coverages) + out['aln2self_cov_mean'] = ""%0.3f"" % mean(coverages) + out['aln2self_cov_mean_non0'] = ""%0.3f"" % mean([n for n in coverages if n > 0]) + for thresh in cov_thresholds: + out['aln2self_cov_%dX' % thresh] = sum(1 for n in coverages if n >= thresh) + return out + + +def assembly_stats(samples, outFile, cov_thresholds, assembly_dir, assembly_tmp, align_dir, reads_dir, raw_reads_dir): + ''' Fetch assembly-level statistics for a given sample ''' + header_written = False + with open(outFile, 'wt') as outf: + for sample in samples: + log.info(""fetching stats on "" + sample) + header, out = get_assembly_stats(sample, + cov_thresholds=cov_thresholds, + assembly_dir=assembly_dir, + assembly_tmp=assembly_tmp, + align_dir=align_dir, + reads_dir=reads_dir, + raw_reads_dir=raw_reads_dir) + if not header_written: + outf.write('\t'.join(map(str, header)) + '\n') + header_written = True + outf.write('\t'.join([str(out.get(h, '')) for h in header]) + '\n') + outf.flush() + + +def parser_assembly_stats(parser=argparse.ArgumentParser()): + parser.add_argument('samples', nargs='+', help='Sample names.') + parser.add_argument('outFile', help='Output report file.') + parser.add_argument('--cov_thresholds', + nargs='+', + type=int, + default=(1, 5, 20, 100), + help='Genome coverage thresholds to report on. (default: %(default)s)') + parser.add_argument('--assembly_dir', + default='data/02_assembly', + help='Directory with assembly outputs. (default: %(default)s)') + parser.add_argument('--assembly_tmp', + default='tmp/02_assembly', + help='Directory with assembly temp files. (default: %(default)s)') + parser.add_argument('--align_dir', + default='data/02_align_to_self', + help='Directory with reads aligned to own assembly. (default: %(default)s)') + parser.add_argument('--reads_dir', + default='data/01_per_sample', + help='Directory with unaligned filtered read BAMs. (default: %(default)s)') + parser.add_argument('--raw_reads_dir', + default='data/00_raw', + help='Directory with unaligned raw read BAMs. (default: %(default)s)') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, assembly_stats, split_args=True) + return parser + + +__commands__.append(('assembly_stats', parser_assembly_stats)) + + +def _get_samples_from_bam(bam): + with pysam.AlignmentFile(bam) as af: + return set(rg['SM'] for rg in af.header['RG']) +def _get_chrs_from_bam(bam): + with pysam.AlignmentFile(bam) as af: + return list(sq['SN'] for sq in af.header['SQ']) + +def parser_coverage_only(parser=argparse.ArgumentParser()): + parser.add_argument('mapped_bams', nargs='+', help='Aligned-to-self mapped bam files.') + parser.add_argument('out_report', help='Output report file.') + parser.add_argument('--cov_thresholds', + nargs='+', + type=int, + default=(1, 5, 20, 100), + help='Genome coverage thresholds to report on. (default: %(default)s)') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, coverage_only, split_args=True) + return parser +def coverage_only(mapped_bams, out_report, cov_thresholds=(1, 5, 20, 100)): + header = ['sample','aln2self_cov_median', 'aln2self_cov_mean', 'aln2self_cov_mean_non0'] + header += ['aln2self_cov_%dX' % thresh for thresh in cov_thresholds] + with open(out_report, 'wt') as outf: + outf.write('\t'.join(header)+'\n') + for bam in mapped_bams: + # check for index and auto-create if needed + with pysam.AlignmentFile(bam) as af: + is_indexed = af.has_index() + if not is_indexed: + pysam.index(bam) + # get unique sample name + samples = _get_samples_from_bam(bam) + if len(samples) != 1: + raise Exception(""input bam file {} has {} unique samples: {} (require one unique sample)"".format(bam, len(samples), str(samples))) + sample_name = samples.pop() + # get and write coverage stats + row = genome_coverage_stats_only(bam, cov_thresholds=cov_thresholds) + row['sample'] = sample_name + outf.write('\t'.join([str(row.get(h,'')) for h in header])+'\n') + # for multi-seg genomes, also do per-chr stats + chrs = _get_chrs_from_bam(bam) + if len(chrs) > 1: + for i in range(len(chrs)): + row = genome_coverage_stats_only(bam, chr_name=chrs[i], cov_thresholds=cov_thresholds) + row['sample'] = ""{}-{}"".format(sample_name, i+1) + outf.write('\t'.join([str(row.get(h,'')) for h in header])+'\n') +__commands__.append(('coverage_only', parser_coverage_only)) + + +def alignment_summary(inFastaFileOne, inFastaFileTwo, outfileName=None, printCounts=False): + """""" Write or print pairwise alignment summary information for sequences in two FASTA + files, including SNPs, ambiguous bases, and indels. + """""" + gap = '-' + ambiguous = 'N' + aligner = tools.muscle.MuscleTool() + + per_chr_fastas = interhost.transposeChromosomeFiles([inFastaFileOne, inFastaFileTwo]) + + results = OrderedDict() + results[""same_unambig""] = 0 + results[""snp_unambig""] = 0 + results[""indel_unambig""] = 0 + results[""indel_ambig""] = 0 + results[""ambig_one""] = 0 + results[""ambig_two""] = 0 + results[""ambig_both""] = 0 + results[""unambig_both""] = 0 + + for chr_fasta in per_chr_fastas: + same_unambig = 0 + snp_unambig = 0 + indel_unambig = 0 + indel_ambig = 0 + ambig_one = 0 + ambig_two = 0 + ambig_both = 0 + unambig_both = 0 + + alignOutFileName = util.file.mkstempfname('.fasta') + aligner.execute(chr_fasta, alignOutFileName, fmt=""clw"") + + with open(alignOutFileName, ""r"") as f: + alignment = Bio.AlignIO.read(f, ""clustal"") + + for col_idx in range(0, alignment.get_alignment_length()): + col = alignment[:, col_idx] + c1 = col[0] + c2 = col[1] + + if (c1 in ambiguous + and c2 in ambiguous): + ambig_both +=1 + elif c1 in ambiguous: + ambig_one += 1 + elif c2 in ambiguous: + ambig_two += 1 + + if (c1 in IUPACUnambiguousDNA().letters + and c2 in IUPACUnambiguousDNA().letters): + unambig_both += 1 + if c1 == c2: + same_unambig += 1 + else: + snp_unambig += 1 + + if ((c1 == gap and + c2 in IUPACUnambiguousDNA().letters) or + (c2 == gap and + c1 in IUPACUnambiguousDNA().letters)): + indel_unambig += 1 + + if ((c1 == gap and + c2 in ambiguous) or + (c2 == gap and + c1 in ambiguous)): + indel_ambig += 1 + + if printCounts: + print(""Counts for this segment/chromosome:"") + print(""same_unambig "", same_unambig) + print(""snp_unambig "", snp_unambig) + print(""indel_unambig"", indel_unambig) + print(""indel_ambig "", indel_ambig) + print(""ambig_one "", ambig_one) + print(""ambig_two "", ambig_two) + print(""ambig_both "", ambig_both) + print(""unambig_both "", unambig_both) + + results[""same_unambig""] += same_unambig + results[""snp_unambig""] += snp_unambig + results[""indel_unambig""] += indel_unambig + results[""indel_ambig""] += indel_ambig + results[""ambig_one""] += ambig_one + results[""ambig_two""] += ambig_two + results[""ambig_both""] += ambig_both + results[""unambig_both""] += unambig_both + + if printCounts: + print(""\nCounts for this sample:"") + print(""same_unambig "", results[""same_unambig""]) + print(""snp_unambig "", results[""snp_unambig""]) + print(""indel_unambig"", results[""indel_unambig""]) + print(""indel_ambig "", results[""indel_ambig""]) + print(""ambig_one "", results[""ambig_one""]) + print(""ambig_two "", results[""ambig_two""]) + print(""ambig_both "", results[""ambig_both""]) + print(""unambig_both "", results[""unambig_both""]) + + if outfileName: + with open(outfileName, ""wt"") as of: + csvout = csv.writer(of, delimiter='\t') + csvout.writerow(list(results.keys())) + csvout.writerow(list(results.values())) + +def parser_alignment_summary(parser=argparse.ArgumentParser()): + parser.add_argument('inFastaFileOne', help='First fasta file for an alignment') + parser.add_argument('inFastaFileTwo', help='First fasta file for an alignment') + parser.add_argument('--outfileName', help='Output file for counts in TSV format') + parser.add_argument('--printCounts', help='', action='store_true') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, alignment_summary, split_args=True) + return parser +__commands__.append(('alignment_summary', parser_alignment_summary)) + + +def consolidate_fastqc(inDirs, outFile): + '''Consolidate multiple FASTQC reports into one.''' + with util.file.open_or_gzopen(outFile, 'wt') as outf: + header = ['Sample'] + out_n = 0 + for sdir in inDirs: + out = {} + with open(os.path.join(sdir, 'summary.txt'), 'rt') as inf: + for line in inf: + v, k, fn = line.strip().split('\t') + out[k] = v + if out_n == 0: + header.append(k) + if not fn.endswith('.bam'): + raise TypeError(""%s not a bam file"" % fn) + out['Sample'] = fn[:-len('.bam')] + if out_n == 0: + outf.write('\t'.join(header) + '\n') + outf.write('\t'.join([out.get(h, '') for h in header]) + '\n') + out_n += 1 + + +def parser_consolidate_fastqc(parser=argparse.ArgumentParser()): + parser.add_argument('inDirs', help='Input FASTQC directories.', nargs='+') + parser.add_argument('outFile', help='Output report file.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, consolidate_fastqc, split_args=True) + return parser + + +__commands__.append(('consolidate_fastqc', parser_consolidate_fastqc)) + + +def get_bam_info(bamstats_dir): + libs = {} + for fn in glob.glob(os.path.join(bamstats_dir, ""*.txt"")): + with util.file.open_or_gzopen(fn, 'rt') as inf: + bam = {} + for line in inf: + k, v = line.rstrip('\n').split('\t') + bam[k] = v + libs.setdefault(bam['Sample'], {}) + libs[bam['Sample']][bam['BAM']] = bam['Total reads'] + return libs + + +def get_lib_info(runfile): + libs = {} + for lane in util.file.read_tabfile_dict(runfile): + for well in util.file.read_tabfile_dict(lane['barcode_file']): + libname = well['sample'] + '.l' + well['library_id_per_sample'] + libs.setdefault(libname, []) + plate = well['Plate'] + if plate.lower().startswith('plate'): + plate = plate[5:] + well_id = well['Well'][0].upper() + ""%02d"" % int(well['Well'][1:]) + dat = [well['sample'], lane['flowcell'] + '.' + lane['lane'], well['barcode_1'] + '-' + well['barcode_2'], + plate.strip() + ':' + well_id, get_earliest_date(lane['bustard_dir']), well.get('Tube_ID', '')] + libs[libname].append(dat) + return libs + + +def get_earliest_date(inDir): + fnames = [inDir] + [os.path.join(inDir, x) for x in os.listdir(inDir)] + earliest = min(os.path.getmtime(fn) for fn in fnames) + return time.strftime(""%Y-%m-%d"", time.localtime(earliest)) + + +def consolidate_spike_count(in_dir, out_file): + '''Consolidate multiple spike count reports into one.''' + with open(out_file, 'wt') as outf: + for fn in os.listdir(in_dir): + fn = os.path.join(in_dir, fn) + s = os.path.basename(fn) + if not s.endswith('.spike_count.txt'): + raise Exception() + s = s[:-len('.spike_count.txt')] + with open(fn, 'rt') as inf: + for line in inf: + if not line.startswith('Input bam') and not line.startswith('*'): + spike, count = [line.strip().split('\t')[i] for i in [0,2]] + outf.write('\t'.join([s, spike, count]) + '\n') + + +def parser_consolidate_spike_count(parser=argparse.ArgumentParser()): + parser.add_argument('in_dir', metavar=""inDir"", help='Input spike count directory.') + parser.add_argument('out_file', metavar=""outFile"", help='Output report file.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, consolidate_spike_count, split_args=True) + return parser + + +__commands__.append(('consolidate_spike_count', parser_consolidate_spike_count)) + + +def aggregate_spike_count(in_dir, out_file): + '''aggregate multiple spike count reports into one.''' + spike_in_sample_counts = defaultdict(dict) # For a given spikein ID, map to sample name and corresponding count + samples_seen = [] + with open(out_file, 'wt') as outf: + for fn in glob.glob(os.path.realpath(in_dir)+""/*.spike_count.txt""):# os.listdir(): + #fn = os.path.join(in_dir, fn) + s = os.path.basename(fn) + if not s.endswith('.spike_count.txt'): + raise Exception() + if s.find('.spike_count.txt'): + s = s[:-len('.spike_count.txt')] + if s not in samples_seen: + samples_seen.append(s) + with open(fn, 'rt') as inf: + for line in inf: + if not line.startswith('Input bam') and not line.startswith('*'): + spike, count = [line.strip().split('\t')[i] for i in [0,2]] + spike_in_sample_counts[spike][s] = count + #outf.write('\t'.join([s, spike, count]) + '\n') + outf.write(""\t"".join([""spike-in""]+samples_seen)+""\n"") + for spike in sorted(spike_in_sample_counts.keys()): + row = [] + row.append(spike) + for s in samples_seen: + if s in spike_in_sample_counts[spike]: + row.append(spike_in_sample_counts[spike][s]) + else: + row.append(""0"") + outf.write(""\t"".join(row)+""\n"") + + +def parser_aggregate_spike_count(parser=argparse.ArgumentParser()): + parser.add_argument('in_dir', metavar=""inDir"", help='Input spike count directory.') + parser.add_argument('out_file', metavar=""outFile"", help='Output report file.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, aggregate_spike_count, split_args=True) + return parser + + +__commands__.append(('aggregate_spike_count', parser_aggregate_spike_count)) + + +# ========================= + + +def parser_plot_coverage_common(parser=argparse.ArgumentParser()): # parser needs add_help=False? + parser.add_argument('in_bam', help='Input reads, BAM format.') + parser.add_argument('out_plot_file', help='The generated chart file') + parser.add_argument( + '--plotFormat', + dest=""plot_format"", + default=None, + type=str, + choices=list(plt.gcf().canvas.get_supported_filetypes().keys()), + metavar='', + help=""File format of the coverage plot. By default it is inferred from the file extension of out_plot_file, but it can be set explicitly via --plotFormat. Valid formats include: "" + + "", "".join(list(plt.gcf().canvas.get_supported_filetypes().keys())) + ) + parser.add_argument( + '--plotDataStyle', + dest=""plot_data_style"", + default=""filled"", + type=str, + choices=[""filled"", ""line"", ""dots""], + metavar='', + help=""The plot data display style. Valid options: "" + "", "".join([""filled"", ""line"", ""dots""]) + + "" (default: %(default)s)"" + ) + parser.add_argument( + '--plotStyle', + dest=""plot_style"", + default=""ggplot"", + type=str, + choices=plt.style.available, + metavar='', + help=""The plot visual style. Valid options: "" + "", "".join(plt.style.available) + "" (default: %(default)s)"" + ) + parser.add_argument( + '--plotWidth', + dest=""plot_width"", + default=880, + type=int, + help=""Width of the plot in pixels (default: %(default)s)"" + ) + parser.add_argument( + '--plotHeight', + dest=""plot_height"", + default=680, + type=int, + help=""Width of the plot in pixels (default: %(default)s)"" + ) + parser.add_argument( + '--plotDPI', + dest=""plot_dpi"", + default=plt.gcf().get_dpi(), + type=int, + help=""dots per inch for rendered output, more useful for vector modes (default: %(default)s)"" + ) + parser.add_argument( + '--plotTitle', + dest=""plot_title"", + default=""Coverage Plot"", + type=str, + help=""The title displayed on the coverage plot (default: '%(default)s')"" + ) + parser.add_argument( + '--plotXLimits', + dest=""plot_x_limits"", + nargs=2, + default=None, + type=int, + help=""Limits on the x-axis of the coverage plot; args are ' '"" + ) + parser.add_argument( + '--plotYLimits', + dest=""plot_y_limits"", + nargs=2, + default=None, + type=int, + help=""Limits on the y-axis of the coverage plot; args are ' '"" + ) + parser.add_argument( + '-q', dest=""base_q_threshold"", + default=None, type=int, + help=""The minimum base quality threshold"" + ) + parser.add_argument( + '-Q', dest=""mapping_q_threshold"", + default=None, + type=int, help=""The minimum mapping quality threshold"" + ) + parser.add_argument( + '-m', + dest=""max_coverage_depth"", + default=None, + type=int, + help=""The max coverage depth (default: %(default)s)"" + ) + parser.add_argument('-l', + dest=""read_length_threshold"", + default=None, + type=int, + help=""Read length threshold"" + ) + parser.add_argument( + '--binLargePlots', + dest=""bin_large_plots"", + action=""store_true"", + help=""Plot summary read depth in one-pixel-width bins for large plots."" + ) + parser.add_argument( + '--binningSummaryStatistic', + dest=""binning_summary_statistic"", + choices=[""max"", ""min""], + type=str, + default=""max"", + help=""Statistic used to summarize each bin (max or min)."" + ) + parser.add_argument( + '--outSummary', + dest=""out_summary"", + default=None, + type=str, + help=""Coverage summary TSV file. Default is to write to temp."" + ) + return parser + + +def plot_coverage( + in_bam, + out_plot_file, + plot_format, + plot_data_style, + plot_style, + plot_width, + plot_height, + plot_dpi, + plot_title, + plot_x_limits, + plot_y_limits, + base_q_threshold, + mapping_q_threshold, + max_coverage_depth, + read_length_threshold, + plot_only_non_duplicates=False, + bin_large_plots=False, + binning_summary_statistic=""max"", + out_summary=None + ): + ''' + Generate a coverage plot from an aligned bam file + ''' + samtools = tools.samtools.SamtoolsTool() + + # check if in_bam is aligned, if not raise an error + num_mapped_reads = samtools.count(in_bam, opts=[""-F"", ""4""]) + if num_mapped_reads == 0: + raise Exception( + """"""The bam file specified appears to have zero mapped reads. 'plot_coverage' requires an aligned bam file. You can try 'align_and_plot_coverage' if the plot input bam file contains reads and you don't mind a simple bwa alignment. \n File: %s"""""" + % in_bam + ) + + if out_summary is None: + coverage_tsv_file = util.file.mkstempfname('.summary.tsv') + else: + coverage_tsv_file = out_summary + + bam_dupe_processed = util.file.mkstempfname('.dupe_processed.bam') + if plot_only_non_duplicates: + # TODO: this is probably not necessary since ""samtools depth"" does not count marked duplicates + # write a new bam file; exclude reads with the 1024 flag set (PCR or optical duplicates) + samtools.view([""-F"", ""1024"", '-@', '3'], in_bam, bam_dupe_processed) + else: + bam_dupe_processed = in_bam + + # only sort if not sorted + bam_sorted = util.file.mkstempfname('.sorted.bam') + should_remove_sorted = True + if not util.file.bam_is_sorted(bam_dupe_processed): + samtools.sort(bam_dupe_processed, bam_sorted, args=[""-O"", ""bam""]) + if plot_only_non_duplicates: + os.unlink(bam_dupe_processed) + else: + bam_sorted = bam_dupe_processed + if not plot_only_non_duplicates: + # in this case we are passing through the original in_bam directly + should_remove_sorted = False + + # call samtools index + samtools.index(bam_sorted) + + # call samtools depth + opts = [] + opts += ['-aa'] # report coverate at ""absolutely all"" positions + if base_q_threshold: + if not plot_only_non_duplicates: + # Note: ""bedtools genomecov"" will count depth including duplicates, but does + # not expose options for filtering by quality. When duplicates + # are excluded, ""samtools depth"" is used which does support quality filtering + # We use either samtools or bedtools, because the former ignores marked duplicates + # from its depth count while bedtools includes them. + log.warning(""'-q' ignored since --plotOnlyNonDuplicates is absent"") + opts += [""-q"", str(base_q_threshold)] + if mapping_q_threshold: + if not plot_only_non_duplicates: + log.warning(""'-Q' ignored since --plotOnlyNonDuplicates is absent"") + opts += [""-Q"", str(mapping_q_threshold)] + if max_coverage_depth: + if not plot_only_non_duplicates: + log.warning(""'-m' ignored since --plotOnlyNonDuplicates is absent"") + opts += [""-m"", str(max_coverage_depth)] + if read_length_threshold: + if not plot_only_non_duplicates: + log.warning(""'-l' ignored since --plotOnlyNonDuplicates is absent"") + opts += [""-l"", str(read_length_threshold)] + + # add option here for bedtools to report coverage w/ duplicates + # (and then samtools for no-dups) + # + # Ex. + # samtools depth -aa mapped-to-ref.with-dups.tmp.bam + # bedtools genomecov -ibam mapped-to-ref.with-dups.tmp.bam -d + if not plot_only_non_duplicates: + bt = BedTool(bam_sorted) + # ""d=True"" is the equivalent of passing ""-d"" to the bedtools CLI + bt.genome_coverage(d=True).saveas(coverage_tsv_file) + else: + samtools.depth(bam_sorted, coverage_tsv_file, opts) + + # only remove the sorted bam if it is not the original input bam + # which we use directly in some casess + if should_remove_sorted: + os.unlink(bam_sorted) + + # ---- create plot based on coverage_tsv_file ---- + + segment_depths = OrderedDict() + domain_max = 0 + with open(coverage_tsv_file, ""r"") as tabfile: + for row in csv.reader(tabfile, delimiter='\t'): + segment_depths.setdefault(row[0], []).append(float(row[2])) + domain_max += 1 + + with plt.style.context(plot_style): + fig = plt.gcf() + DPI = plot_dpi or fig.get_dpi() + fig.set_size_inches(float(plot_width) / float(DPI), float(plot_height) / float(DPI)) + + font_size = (2.5 * plot_height) / float(DPI) + + ax = plt.subplot() # Defines ax variable by creating an empty plot + + # Set the tick labels font + for label in (ax.get_xticklabels() + ax.get_yticklabels()): + label.set_fontsize(font_size) + + # Binning + bin_size = 1 + if bin_large_plots: + # Bin locations and take summary value (maximum or minimum) in each bin + binning_action = eval(binning_summary_statistic) + + inner_plot_width_inches = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted()).width + inner_plot_width_px = inner_plot_width_inches * fig.dpi # width of actual plot (sans whitespace and y axis text) + bins_per_pixel = 1 # increase to make smaller (but less visible) bins + bin_size = 1 + int(domain_max/(inner_plot_width_px * bins_per_pixel)) + + binned_segment_depths = OrderedDict() + for segment_num, (segment_name, position_depths) in enumerate(segment_depths.items()): + summary_depths_in_bins = [binning_action(position_depths[i:i + bin_size]) for i in range(0, len(position_depths), bin_size)] + binned_segment_depths[segment_name] = summary_depths_in_bins + segment_depths = binned_segment_depths + + # Plotting + domain_max = 0 + for segment_num, (segment_name, position_depths) in enumerate(segment_depths.items()): + prior_domain_max = domain_max + domain_max += len(position_depths) + + colors = list(plt.rcParams['axes.prop_cycle'].by_key()['color']) # get the colors for this style + segment_color = colors[segment_num % len(colors)] # pick a color, offset by the segment index + + x_values = range(prior_domain_max, domain_max) + x_values = [x * bin_size for x in x_values] + + if plot_data_style == ""filled"": + plt.fill_between( + x_values, + position_depths, [0] * len(position_depths), + linewidth=0, + antialiased=True, + color=segment_color + ) + elif plot_data_style == ""line"": + plt.plot( + x_values, + position_depths, + antialiased=True, + color=segment_color + ) + elif plot_data_style == ""dots"": + plt.plot( + x_values, + position_depths, + 'ro', + antialiased=True, + color=segment_color + ) + + plt.title(plot_title, fontsize=font_size * 1.2) + plt.xlabel(""bp"", fontsize=font_size * 1.1) + + ylabel = ""read depth"" + if(bin_size > 1): + ylabel = ""read depth ({summary} in {size}-bp bin)"".format(size=bin_size, summary=binning_summary_statistic) + plt.ylabel(ylabel, fontsize=font_size * 1.1) + + if plot_x_limits is not None: + x_min, x_max = plot_x_limits + plt.xlim(x_min, x_max) + if plot_y_limits is not None: + y_min, y_max = plot_y_limits + plt.ylim(y_min, y_max) + + # to squash a backend renderer error on OSX related to tight layout + if plt.get_backend().lower() in ['agg', 'macosx']: + fig.set_tight_layout(True) + else: + fig.tight_layout() + + plt.savefig(out_plot_file, format=plot_format, dpi=DPI) #, bbox_inches='tight') + log.info(""Coverage plot saved to: "" + out_plot_file) + + if not out_summary: + os.unlink(coverage_tsv_file) + + +def parser_plot_coverage(parser=argparse.ArgumentParser()): + parser = parser_plot_coverage_common(parser) + parser.add_argument( + '--plotOnlyNonDuplicates', + dest=""plot_only_non_duplicates"", + action=""store_true"", + help=""Plot only non-duplicates (samtools -F 1024), coverage counted by bedtools rather than samtools."" + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, plot_coverage, split_args=True) + return parser + + +__commands__.append(('plot_coverage', parser_plot_coverage)) + + +def align_and_plot_coverage( + out_plot_file, + plot_format, + plot_data_style, + plot_style, + plot_width, + plot_height, + plot_dpi, + plot_title, + plot_x_limits, + plot_y_limits, + base_q_threshold, + mapping_q_threshold, + max_coverage_depth, + read_length_threshold, + out_summary, + in_bam, + ref_fasta, + out_bam=None, + sensitive=False, + excludeDuplicates=False, + bin_large_plots=False, + binning_summary_statistic=""max"", + JVMmemory=None, + picardOptions=None, + min_score_to_filter=None, + aligner=""bwa"", + aligner_options='', + novoalign_license_path=None +): + ''' + Take reads, align to reference with BWA-MEM, and generate a coverage plot + ''' + + # TODO: use read_utils.py::align_and_fix in place of the duplicated alignment code here + # The main difference is the presence/absence of GATK's local_realign + + if out_bam is None: + bam_aligned = util.file.mkstempfname('.aligned.bam') + else: + bam_aligned = out_bam + + assert aligner in [""bwa"", ""novoalign""] + if aligner_options is None: + if aligner==""novoalign"": + aligner_options = '-r Random -l 40 -g 40 -x 20 -t 100 -k' + elif aligner=='bwa': + aligner_options = '-1' # hidden option to work around kernel/cpu bug; disables multithreaded file read: https://github.com/lh3/bwa/issues/102 + + samtools = tools.samtools.SamtoolsTool() + + ref_indexed = util.file.mkstempfname('.reference.fasta') + shutil.copyfile(ref_fasta, ref_indexed) + + aln_bam = util.file.mkstempfname('.bam') + if aligner==""bwa"": + bwa = tools.bwa.Bwa() + + + bwa.index(ref_indexed) + + bwa_opts = aligner_options.split() + if sensitive: + bwa_opts += ""-k 12 -A 1 -B 1 -O 1 -E 1"".split() + + bwa.align_mem_bam(in_bam, ref_indexed, aln_bam, options=bwa_opts, + min_score_to_filter=min_score_to_filter) + elif aligner==""novoalign"": + + tools.novoalign.NovoalignTool(license_path=novoalign_license_path).index_fasta(ref_indexed) + + tools.novoalign.NovoalignTool(license_path=novoalign_license_path).execute( + in_bam, ref_indexed, aln_bam, + options=aligner_options.split(), + JVMmemory=JVMmemory + ) + + aln_bam_dupe_processed = util.file.mkstempfname('.filtered_dupe_processed.bam') + if excludeDuplicates: + opts = list(picardOptions) + dupe_removal_out_metrics = util.file.mkstempfname('.metrics') + tools.picard.MarkDuplicatesTool().execute( + [aln_bam], aln_bam_dupe_processed, + dupe_removal_out_metrics, picardOptions=opts, + JVMmemory=JVMmemory + ) + else: + aln_bam_dupe_processed = aln_bam + + samtools.sort(aln_bam_dupe_processed, bam_aligned) + os.unlink(aln_bam) + + if excludeDuplicates: + os.unlink(aln_bam_dupe_processed) + + samtools.index(bam_aligned) + + # -- call plot function -- + plot_coverage( + bam_aligned, out_plot_file, plot_format, plot_data_style, plot_style, plot_width, plot_height, plot_dpi, plot_title, + plot_x_limits, plot_y_limits, base_q_threshold, mapping_q_threshold, max_coverage_depth, read_length_threshold, + excludeDuplicates, bin_large_plots, binning_summary_statistic, out_summary + ) + + # remove the output bam, unless it is needed + if out_bam is None: + os.unlink(bam_aligned) + + # remove the files created by bwa index. + # The empty extension causes the original fasta file to be removed + for ext in ["".amb"", "".ann"", "".bwt"", "".bwa"", "".pac"", "".sa"", """"]: + file_to_remove = ref_indexed + ext + if os.path.isfile(file_to_remove): + os.unlink(file_to_remove) + + +def parser_align_and_plot_coverage(parser=argparse.ArgumentParser()): + parser = parser_plot_coverage_common(parser) + parser.add_argument('ref_fasta', default=None, help='Reference genome, FASTA format.') + parser.add_argument( + '--outBam', + dest=""out_bam"", + default=None, + help='Output aligned, indexed BAM file. Default is to write to temp.' + ) + parser.add_argument( + '--sensitive', action=""store_true"", + help=""Equivalent to giving bwa: '-k 12 -A 1 -B 1 -O 1 -E 1'. Only relevant if the bwa aligner is selected (the default). "" + ) + parser.add_argument( + '--excludeDuplicates', action=""store_true"", + help=""MarkDuplicates with Picard and only plot non-duplicates"" + ) + parser.add_argument( + '--JVMmemory', + default=tools.picard.MarkDuplicatesTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], + nargs='*', + help='Optional arguments to Picard\'s MarkDuplicates, OPTIONNAME=value ...' + ) + parser.add_argument( + '--minScoreToFilter', + dest=""min_score_to_filter"", + type=int, + help=(""Filter bwa alignments using this value as the minimum allowed "" + ""alignment score. Specifically, sum the alignment scores across "" + ""all alignments for each query (including reads in a pair, "" + ""supplementary and secondary alignments) and then only include, "" + ""in the output, queries whose summed alignment score is at least "" + ""this value. This is only applied when the aligner is 'bwa'. "" + ""The filtering on a summed alignment score is sensible for reads "" + ""in a pair and supplementary alignments, but may not be "" + ""reasonable if bwa outputs secondary alignments (i.e., if '-a' "" + ""is in the aligner options). (default: not set - i.e., do not "" + ""filter bwa's output)"") + ) + parser.add_argument('--aligner', choices=['novoalign', 'bwa'], default='bwa', help='aligner (default: %(default)s)') + parser.add_argument('--aligner_options', default=None, help='aligner options (default for novoalign: ""-r Random -l 40 -g 40 -x 20 -t 100 -k"", bwa: bwa defaults') + parser.add_argument( + '--NOVOALIGN_LICENSE_PATH', + default=None, + dest=""novoalign_license_path"", + help='A path to the novoalign.lic file. This overrides the NOVOALIGN_LICENSE_PATH environment variable. (default: %(default)s)' + ) + + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, align_and_plot_coverage, split_args=True) + return parser + + +__commands__.append(('align_and_plot_coverage', parser_align_and_plot_coverage)) + + + +def parser_fastqc(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input reads, BAM format.') + parser.add_argument('outHtml', help='Output report, HTML format.') + util.cmd.attach_main(parser, tools.fastqc.FastQC().execute, split_args=True) + return parser +__commands__.append(('fastqc', parser_fastqc)) + +# ======================= + + +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","read_utils.py",".py","58587","1456","#!/usr/bin/env python +"""""" +Utilities for working with sequence reads, such as converting formats and +fixing mate pairs. +"""""" +from __future__ import division + +__author__ = ""irwin@broadinstitute.org, dpark@broadinstitute.org"" +__commands__ = [] + +import argparse +import logging +import math +import os +import tempfile +import shutil +import sys +import concurrent.futures +from contextlib import contextmanager +import functools + +from Bio import SeqIO +import pysam + +import util.cmd +import util.file +import util.misc +from util.file import mkstempfname +import tools.bwa +import tools.cdhit +import tools.picard +import tools.samtools +import tools.mvicuna +import tools.prinseq +import tools.novoalign +import tools.gatk + +log = logging.getLogger(__name__) + +# ======================= +# *** purge_unmated *** +# ======================= + + +def purge_unmated(inFastq1, inFastq2, outFastq1, outFastq2, regex=r'^@(\S+)/[1|2]$'): + '''Use mergeShuffledFastqSeqs to purge unmated reads, and + put corresponding reads in the same order. + Corresponding sequences must have sequence identifiers + of the form SEQID/1 and SEQID/2. + ''' + tempOutput = mkstempfname() + mergeShuffledFastqSeqsPath = os.path.join(util.file.get_scripts_path(), 'mergeShuffledFastqSeqs.pl') + cmdline = [mergeShuffledFastqSeqsPath, '-t', '-r', regex, '-f1', inFastq1, '-f2', inFastq2, '-o', tempOutput] + log.debug(' '.join(cmdline)) + util.misc.run_and_print(cmdline, check=True) + shutil.move(tempOutput + '.1.fastq', outFastq1) + shutil.move(tempOutput + '.2.fastq', outFastq2) + return 0 + + +def parser_purge_unmated(parser=argparse.ArgumentParser()): + parser.add_argument('inFastq1', help='Input fastq file; 1st end of paired-end reads.') + parser.add_argument('inFastq2', help='Input fastq file; 2nd end of paired-end reads.') + parser.add_argument('outFastq1', help='Output fastq file; 1st end of paired-end reads.') + parser.add_argument('outFastq2', help='Output fastq file; 2nd end of paired-end reads.') + parser.add_argument( + ""--regex"", + help=""Perl regular expression to parse paired read IDs (default: %(default)s)"", + default=r'^@(\S+)/[1|2]$' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, purge_unmated, split_args=True) + return parser + + +__commands__.append(('purge_unmated', parser_purge_unmated)) + + +# =============================== +# *** index_fasta_samtools *** +# =============================== + + +def parser_index_fasta_samtools(parser=argparse.ArgumentParser()): + parser.add_argument('inFasta', help='Reference genome, FASTA format.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, main_index_fasta_samtools) + return parser + + +def main_index_fasta_samtools(args): + '''Index a reference genome for Samtools.''' + tools.samtools.SamtoolsTool().faidx(args.inFasta, overwrite=True) + return 0 + + +__commands__.append(('index_fasta_samtools', parser_index_fasta_samtools)) + +# ============================= +# *** index_fasta_picard *** +# ============================= + + +def parser_index_fasta_picard(parser=argparse.ArgumentParser()): + parser.add_argument('inFasta', help='Input reference genome, FASTA format.') + parser.add_argument( + '--JVMmemory', + default=tools.picard.CreateSequenceDictionaryTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], + nargs='*', + help='Optional arguments to Picard\'s CreateSequenceDictionary, OPTIONNAME=value ...' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_index_fasta_picard) + return parser + + +def main_index_fasta_picard(args): + '''Create an index file for a reference genome suitable for Picard/GATK.''' + tools.picard.CreateSequenceDictionaryTool().execute( + args.inFasta, overwrite=True, + picardOptions=args.picardOptions, + JVMmemory=args.JVMmemory + ) + return 0 + + +__commands__.append(('index_fasta_picard', parser_index_fasta_picard)) + +# ============================= +# *** mkdup_picard *** +# ============================= + + +def parser_mkdup_picard(parser=argparse.ArgumentParser()): + parser.add_argument('inBams', help='Input reads, BAM format.', nargs='+') + parser.add_argument('outBam', help='Output reads, BAM format.') + parser.add_argument('--outMetrics', help='Output metrics file. Default is to dump to a temp file.', default=None) + parser.add_argument( + ""--remove"", + help=""Instead of marking duplicates, remove them entirely (default: %(default)s)"", + default=False, + action=""store_true"", + dest=""remove"" + ) + parser.add_argument( + '--JVMmemory', + default=tools.picard.MarkDuplicatesTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], + nargs='*', + help='Optional arguments to Picard\'s MarkDuplicates, OPTIONNAME=value ...' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_mkdup_picard) + return parser + + +def main_mkdup_picard(args): + '''Mark or remove duplicate reads from BAM file.''' + opts = list(args.picardOptions) + if args.remove: + opts = ['REMOVE_DUPLICATES=true'] + opts + tools.picard.MarkDuplicatesTool().execute( + args.inBams, args.outBam, + args.outMetrics, picardOptions=opts, + JVMmemory=args.JVMmemory + ) + return 0 + + +__commands__.append(('mkdup_picard', parser_mkdup_picard)) + +# ============================= +# *** revert_bam_picard *** +# ============================= + +def parser_revert_sam_common(parser=argparse.ArgumentParser()): + parser.add_argument('--clearTags', dest='clear_tags', default=False, action='store_true', + help='When supplying an aligned input file, clear the per-read attribute tags') + parser.add_argument(""--tagsToClear"", type=str, nargs='+', dest=""tags_to_clear"", default=[""XT"", ""X0"", ""X1"", ""XA"", + ""AM"", ""SM"", ""BQ"", ""CT"", ""XN"", ""OC"", ""OP""], + help='A space-separated list of tags to remove from all reads in the input bam file (default: %(default)s)') + parser.add_argument( + '--doNotSanitize', + dest=""do_not_sanitize"", + action='store_true', + help=""""""When being reverted, picard's SANITIZE=true + is set unless --doNotSanitize is given. + Sanitization is a destructive operation that removes reads so the bam file is consistent. + From the picard documentation: + 'Reads discarded include (but are not limited to) paired reads with missing mates, duplicated records, + records with mismatches in length of bases and qualities.' + For more information see: + https://broadinstitute.github.io/picard/command-line-overview.html#RevertSam + """""" + ) + try: + parser.add_argument( + '--JVMmemory', + default=tools.picard.RevertSamTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + except argparse.ArgumentError: + # if --JVMmemory is already present in the parser, continue on... + pass + return parser + +def parser_revert_bam_picard(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input reads, BAM format.') + parser.add_argument('outBam', help='Output reads, BAM format.') + parser.add_argument( + '--JVMmemory', + default=tools.picard.RevertSamTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], + nargs='*', + help='Optional arguments to Picard\'s RevertSam, OPTIONNAME=value ...' + ) + parser = parser_revert_sam_common(parser) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_revert_bam_picard, split_args=True) + return parser + + +def main_revert_bam_picard(inBam, outBam, clear_tags=False, tags_to_clear=None, picardOptions=None, do_not_sanitize=False, JVMmemory=None): + '''Revert BAM to raw reads''' + picardOptions = picardOptions or [] + tags_to_clear = tags_to_clear or [] + + if clear_tags: + for tag in tags_to_clear: + picardOptions.append(""ATTRIBUTE_TO_CLEAR={}"".format(tag)) + + if not do_not_sanitize and not any(opt.startswith(""SANITIZE"") for opt in picardOptions): + picardOptions.append('SANITIZE=true') + + tools.picard.RevertSamTool().execute(inBam, outBam, picardOptions=picardOptions, JVMmemory=JVMmemory) + return 0 +__commands__.append(('revert_bam_picard', parser_revert_bam_picard)) + +@contextmanager +def revert_bam_if_aligned(inBam, revert_bam=None, clear_tags=True, tags_to_clear=None, picardOptions=None, JVMmemory=""4g"", sanitize=False): + ''' + revert the bam file if aligned. + If a revertBam file path is specified, it is used, otherwise a temp file is created. + ''' + + revertBamOut = revert_bam if revert_bam else util.file.mkstempfname('.bam') + picardOptions = picardOptions or [] + tags_to_clear = tags_to_clear or [] + + outBam = inBam + with pysam.AlignmentFile(inBam, 'rb', check_sq=False) as bam: + # if it looks like the bam is aligned, revert it + if 'SQ' in bam.header and len(bam.header['SQ'])>0: + if clear_tags: + for tag in tags_to_clear: + picardOptions.append(""ATTRIBUTE_TO_CLEAR={}"".format(tag)) + + if not any(opt.startswith(""SORT_ORDER"") for opt in picardOptions): + picardOptions.append('SORT_ORDER=queryname') + + if sanitize and not any(opt.startswith(""SANITIZE"") for opt in picardOptions): + picardOptions.append('SANITIZE=true') + + tools.picard.RevertSamTool().execute( + inBam, revertBamOut, picardOptions=picardOptions + ) + outBam = revertBamOut + else: + # if we don't need to produce a revertBam file + # but the user has specified one anyway + # simply touch the output + if revert_bam: + log.warning(""An output was specified for 'revertBam', but the input is unaligned, so RevertSam was not needed. Touching the output."") + util.file.touch(revertBamOut) + # TODO: error out? run RevertSam anyway? + + yield outBam + + if revert_bam == None: + os.unlink(revertBamOut) + +# ========================= +# *** generic picard *** +# ========================= + + +def parser_picard(parser=argparse.ArgumentParser()): + parser.add_argument('command', help='picard command') + parser.add_argument( + '--JVMmemory', + default=tools.picard.PicardTools.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], nargs='*', + help='Optional arguments to Picard, OPTIONNAME=value ...' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_picard) + return parser + + +def main_picard(args): + '''Generic Picard runner.''' + tools.picard.PicardTools().execute(args.command, picardOptions=args.picardOptions, JVMmemory=args.JVMmemory) + return 0 + + +__commands__.append(('picard', parser_picard)) + +# =================== +# *** sort_bam *** +# =================== + + +def parser_sort_bam(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input bam file.') + parser.add_argument('outBam', help='Output bam file, sorted.') + parser.add_argument( + 'sortOrder', + help='How to sort the reads. [default: %(default)s]', + choices=tools.picard.SortSamTool.valid_sort_orders, + default=tools.picard.SortSamTool.default_sort_order + ) + parser.add_argument( + ""--index"", + help=""Index outBam (default: %(default)s)"", + default=False, + action=""store_true"", + dest=""index"" + ) + parser.add_argument( + ""--md5"", + help=""MD5 checksum outBam (default: %(default)s)"", + default=False, + action=""store_true"", + dest=""md5"" + ) + parser.add_argument( + '--JVMmemory', + default=tools.picard.SortSamTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], + nargs='*', + help='Optional arguments to Picard\'s SortSam, OPTIONNAME=value ...' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_sort_bam) + return parser + + +def main_sort_bam(args): + '''Sort BAM file''' + opts = list(args.picardOptions) + if args.index: + opts = ['CREATE_INDEX=true'] + opts + if args.md5: + opts = ['CREATE_MD5_FILE=true'] + opts + tools.picard.SortSamTool().execute( + args.inBam, args.outBam, args.sortOrder, + picardOptions=opts, JVMmemory=args.JVMmemory + ) + return 0 + + +__commands__.append(('sort_bam', parser_sort_bam)) + +# ==================== +# *** downsample_bams *** +# ==================== + +def parser_downsample_bams(parser=argparse.ArgumentParser()): + parser.add_argument('in_bams', help='Input bam files.', nargs='+') + parser.add_argument('--outPath', dest=""out_path"", type=str, help=""""""Output path. If not provided, + downsampled bam files will be written to the same paths as each + source bam file"""""") + parser.add_argument('--readCount', dest=""specified_read_count"", type=int, help='The number of reads to downsample to.') + group = parser.add_mutually_exclusive_group() + group.add_argument('--deduplicateBefore', action='store_true', dest=""deduplicate_before"", help='de-duplicate reads before downsampling.') + group.add_argument('--deduplicateAfter', action='store_true', dest=""deduplicate_after"", help='de-duplicate reads after downsampling.') + parser.add_argument( + '--JVMmemory', + default=tools.picard.DownsampleSamTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], + nargs='*', + help='Optional arguments to Picard\'s DownsampleSam, OPTIONNAME=value ...' + ) + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_downsample_bams, split_args=True) + return parser + + +def main_downsample_bams(in_bams, out_path, specified_read_count=None, deduplicate_before=False, deduplicate_after=False, picardOptions=None, threads=None, JVMmemory=None): + '''Downsample multiple bam files to the smallest read count in common, or to the specified count.''' + if picardOptions is None: + picardOptions = [] + + opts = list(picardOptions) + [] + + def get_read_counts(bams): + samtools = tools.samtools.SamtoolsTool() + # get read counts for bam files provided + read_counts = {} + with concurrent.futures.ThreadPoolExecutor(max_workers=util.misc.sanitize_thread_count(threads)) as executor: + for x, result in zip(bams, executor.map(samtools.count, bams)): + read_counts[x] = int(result) + + return read_counts + + def get_downsample_target_count(bams, readcount_requested): + read_counts = get_read_counts(bams) + downsample_target = 0 + if readcount_requested is not None: + downsample_target = readcount_requested + if downsample_target > min(read_counts.values()): + raise ValueError(""The smallest file has %s reads, which is less than the downsample target specified, %s. Please reduce the target count or omit it to use the read count of the smallest input file."" % (min(read_counts.values()), downsample_target)) + else: + downsample_target = min(read_counts.values()) + return downsample_target + + def downsample_bams(data_pairs, downsample_target, threads=None, JVMmemory=None): + downsamplesam = tools.picard.DownsampleSamTool() + workers = util.misc.sanitize_thread_count(threads) + JVMmemory = JVMmemory if JVMmemory else tools.picard.DownsampleSamTool.jvmMemDefault + jvm_worker_memory = str(max(1,int(JVMmemory.rstrip(""g""))/workers))+'g' + with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor: + future_to_file = {executor.submit(downsamplesam.downsample_to_approx_count, *(list(fp)+[downsample_target]), JVMmemory=jvm_worker_memory): fp[0] for fp in data_pairs} + for future in concurrent.futures.as_completed(future_to_file): + f = future_to_file[future] + try: + data = future.result() + except Exception as exc: + raise + + def dedup_bams(data_pairs, threads=None, JVMmemory=None): + workers = util.misc.sanitize_thread_count(threads) + JVMmemory = JVMmemory if JVMmemory else tools.picard.DownsampleSamTool.jvmMemDefault + jvm_worker_memory = str(max(1,int(JVMmemory.rstrip(""g""))/workers))+'g' + with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor: + future_to_file = {executor.submit(rmdup_mvicuna_bam, *fp, JVMmemory=jvm_worker_memory): fp[0] for fp in data_pairs} + for future in concurrent.futures.as_completed(future_to_file): + f = future_to_file[future] + try: + data = future.result() + except Exception as exc: + raise + + data_pairs = [] + if deduplicate_before: + with util.file.tempfnames(suffixes=[ '{}.dedup.bam'.format(os.path.splitext(os.path.basename(x))[0]) for x in in_bams]) as deduped_bams: + data_pairs = list(zip(in_bams, deduped_bams)) + dedup_bams(data_pairs, threads=threads, JVMmemory=JVMmemory) + downsample_target = get_downsample_target_count(deduped_bams, specified_read_count) + + if out_path: + util.file.mkdir_p(out_path) + data_pairs = list(zip(deduped_bams, [os.path.join(out_path, os.path.splitext(os.path.basename(x))[0]+"".dedup.downsampled-{}.bam"".format(downsample_target)) for x in in_bams])) + else: + data_pairs = list(zip(deduped_bams, [os.path.splitext(x)[0]+"".dedup.downsampled-{}.bam"".format(downsample_target) for x in in_bams])) + downsample_bams(data_pairs, downsample_target, threads=threads, JVMmemory=JVMmemory) + else: + downsample_target = get_downsample_target_count(in_bams, specified_read_count) + if deduplicate_after: + log.warning(""--deduplicateAfter has been specified. Read count of output files is not guaranteed."") + with util.file.tempfnames(suffixes=[ '{}.downsampled-{}.bam'.format(os.path.splitext(os.path.basename(x))[0], downsample_target) for x in in_bams]) as downsampled_tmp_bams: + data_pairs = list(zip(in_bams, downsampled_tmp_bams)) + downsample_bams(data_pairs, downsample_target, threads=threads, JVMmemory=JVMmemory) + + if out_path: + util.file.mkdir_p(out_path) + data_pairs = list(zip(downsampled_tmp_bams, [os.path.join(out_path, os.path.splitext(os.path.basename(x))[0]+"".downsampled-{}.dedup.bam"").format(downsample_target) for x in in_bams])) + else: + data_pairs = list(zip(downsampled_tmp_bams, [os.path.splitext(x)[0]+"".downsampled-{}.dedup.bam"".format(downsample_target) for x in in_bams])) + dedup_bams(data_pairs, threads=threads, JVMmemory=JVMmemory) + else: + if out_path: + util.file.mkdir_p(out_path) + data_pairs = list(zip(in_bams, [os.path.join(out_path, os.path.splitext(os.path.basename(x))[0]+"".downsampled-{}.bam"".format(downsample_target)) for x in in_bams])) + else: + data_pairs = list(zip(in_bams, [os.path.splitext(x)[0]+"".downsampled-{}.bam"".format(downsample_target) for x in in_bams])) + downsample_bams(data_pairs, downsample_target, threads=threads, JVMmemory=JVMmemory) + return 0 + +__commands__.append(('downsample_bams', parser_downsample_bams)) + +# ==================== +# *** merge_bams *** +# ==================== + + +def parser_merge_bams(parser=argparse.ArgumentParser()): + parser.add_argument('inBams', help='Input bam files.', nargs='+') + parser.add_argument('outBam', help='Output bam file.') + parser.add_argument( + '--JVMmemory', + default=tools.picard.MergeSamFilesTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], + nargs='*', + help='Optional arguments to Picard\'s MergeSamFiles, OPTIONNAME=value ...' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_merge_bams) + return parser + + +def main_merge_bams(args): + '''Merge multiple BAMs into one''' + opts = list(args.picardOptions) + ['USE_THREADING=true'] + tools.picard.MergeSamFilesTool().execute(args.inBams, args.outBam, picardOptions=opts, JVMmemory=args.JVMmemory) + return 0 + + +__commands__.append(('merge_bams', parser_merge_bams)) + +# ==================== +# *** filter_bam *** +# ==================== + + +def parser_filter_bam(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input bam file.') + parser.add_argument('readList', help='Input file of read IDs.') + parser.add_argument('outBam', help='Output bam file.') + parser.add_argument( + ""--exclude"", + help=""""""If specified, readList is a list of reads to remove from input. + Default behavior is to treat readList as an inclusion list (all unnamed + reads are removed)."""""", + default=False, + action=""store_true"", + dest=""exclude"" + ) + parser.add_argument( + '--JVMmemory', + default=tools.picard.FilterSamReadsTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], + nargs='*', + help='Optional arguments to Picard\'s FilterSamReads, OPTIONNAME=value ...' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_filter_bam) + return parser + + +def main_filter_bam(args): + '''Filter BAM file by read name''' + tools.picard.FilterSamReadsTool().execute( + args.inBam, + args.exclude, + args.readList, + args.outBam, + picardOptions=args.picardOptions, + JVMmemory=args.JVMmemory + ) + return 0 + + +__commands__.append(('filter_bam', parser_filter_bam)) + + + +# ======================= +# *** fastq_to_bam *** +# ======================= + + +def fastq_to_bam( + inFastq1, + inFastq2, + outBam, + sampleName=None, + header=None, + JVMmemory=tools.picard.FastqToSamTool.jvmMemDefault, + picardOptions=None +): + ''' Convert a pair of fastq paired-end read files and optional text header + to a single bam file. + ''' + picardOptions = picardOptions or [] + + if header: + fastqToSamOut = mkstempfname('.bam') + else: + fastqToSamOut = outBam + if sampleName is None: + sampleName = 'Dummy' # Will get overwritten by rehead command + if header: + # With the header option, rehead will be called after FastqToSam. + # This will invalidate any md5 file, which would be a slow to construct + # on our own, so just disallow and let the caller run md5sum if desired. + if any(opt.lower() == 'CREATE_MD5_FILE=True'.lower() for opt in picardOptions): + raise Exception(""""""CREATE_MD5_FILE is not allowed with '--header.'"""""") + tools.picard.FastqToSamTool().execute( + inFastq1, inFastq2, + sampleName, fastqToSamOut, + picardOptions=picardOptions, + JVMmemory=JVMmemory + ) + + if header: + tools.samtools.SamtoolsTool().reheader(fastqToSamOut, header, outBam) + + return 0 + + +def parser_fastq_to_bam(parser=argparse.ArgumentParser()): + parser.add_argument('inFastq1', help='Input fastq file; 1st end of paired-end reads.') + parser.add_argument('inFastq2', help='Input fastq file; 2nd end of paired-end reads.') + parser.add_argument('outBam', help='Output bam file.') + headerGroup = parser.add_mutually_exclusive_group(required=True) + headerGroup.add_argument('--sampleName', help='Sample name to insert into the read group header.') + headerGroup.add_argument('--header', help='Optional text file containing header.') + parser.add_argument( + '--JVMmemory', + default=tools.picard.FastqToSamTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--picardOptions', + default=[], + nargs='*', + help='''Optional arguments to Picard\'s FastqToSam, + OPTIONNAME=value ... Note that header-related options will be + overwritten by HEADER if present.''' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, fastq_to_bam, split_args=True) + return parser + + +__commands__.append(('fastq_to_bam', parser_fastq_to_bam)) + + +def join_paired_fastq( + inFastqs, + output, + outFormat +): + ''' Join paired fastq reads into single reads with Ns + ''' + inFastqs = list(inFastqs) + if output == '-': + output = sys.stdout + SeqIO.write(util.file.join_paired_fastq(inFastqs, output_format=outFormat), output, outFormat) + return 0 + + +def parser_join_paired_fastq(parser=argparse.ArgumentParser()): + parser.add_argument('output', help='Output file.') + parser.add_argument('inFastqs', nargs='+', help='Input fastq file (2 if paired, 1 if interleaved)') + parser.add_argument('--outFormat', default='fastq', help='Output file format.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, join_paired_fastq, split_args=True) + return parser + +__commands__.append(('join_paired_fastq', parser_join_paired_fastq)) + + +# ====================== +# *** split_reads *** +# ====================== +defaultIndexLen = 2 +defaultMaxReads = 1000 +defaultFormat = 'fastq' + + +def split_bam(inBam, outBams): + '''Split BAM file equally into several output BAM files. ''' + samtools = tools.samtools.SamtoolsTool() + picard = tools.picard.PicardTools() + + # get totalReadCount and maxReads + # maxReads = totalReadCount / num files, but round up to the nearest + # even number in order to keep read pairs together (assuming the input + # is sorted in query order and has no unmated reads, which can be + # accomplished by Picard RevertSam with SANITIZE=true) + totalReadCount = samtools.count(inBam) + maxReads = int(math.ceil(float(totalReadCount) / len(outBams) / 2) * 2) + log.info(""splitting %d reads into %d files of %d reads each"", totalReadCount, len(outBams), maxReads) + + # load BAM header into memory + header = samtools.getHeader(inBam) + if 'SO:queryname' not in header[0]: + raise Exception('Input BAM file must be sorted in queryame order') + + # dump to bigsam + bigsam = mkstempfname('.sam') + samtools.view(['-@', '3'], inBam, bigsam) + + # split bigsam into little ones + with util.file.open_or_gzopen(bigsam, 'rt') as inf: + for outBam in outBams: + log.info(""preparing file "" + outBam) + tmp_sam_reads = mkstempfname('.sam') + with open(tmp_sam_reads, 'wt') as outf: + for row in header: + outf.write('\t'.join(row) + '\n') + for _ in range(maxReads): + line = inf.readline() + if not line: + break + outf.write(line) + if outBam == outBams[-1]: + for line in inf: + outf.write(line) + picard.execute( + ""SamFormatConverter"", [ + 'INPUT=' + tmp_sam_reads, 'OUTPUT=' + outBam, 'VERBOSITY=WARNING' + ], + JVMmemory='512m' + ) + os.unlink(tmp_sam_reads) + os.unlink(bigsam) + + +def parser_split_bam(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input BAM file.') + parser.add_argument('outBams', nargs='+', help='Output BAM files') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, split_bam, split_args=True) + return parser + + +__commands__.append(('split_bam', parser_split_bam)) + +# ======================= +# *** reheader_bam *** +# ======================= + + +def parser_reheader_bam(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input reads, BAM format.') + parser.add_argument('rgMap', help='Tabular file containing three columns: field, old, new.') + parser.add_argument('outBam', help='Output reads, BAM format.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_reheader_bam) + return parser + + +def main_reheader_bam(args): + ''' Copy a BAM file (inBam to outBam) while renaming elements of the BAM header. + The mapping file specifies which (key, old value, new value) mappings. For + example: + LB lib1 lib_one + SM sample1 Sample_1 + SM sample2 Sample_2 + SM sample3 Sample_3 + CN broad BI + ''' + # read mapping file + mapper = dict((a + ':' + b, a + ':' + c) for a, b, c in util.file.read_tabfile(args.rgMap)) + # read and convert bam header + header_file = mkstempfname('.sam') + with open(header_file, 'wt') as outf: + for row in tools.samtools.SamtoolsTool().getHeader(args.inBam): + if row[0] == '@RG': + row = [mapper.get(x, x) for x in row] + outf.write('\t'.join(row) + '\n') + # write new bam with new header + tools.samtools.SamtoolsTool().reheader(args.inBam, header_file, args.outBam) + os.unlink(header_file) + return 0 + + +__commands__.append(('reheader_bam', parser_reheader_bam)) + + +def parser_reheader_bams(parser=argparse.ArgumentParser()): + parser.add_argument('rgMap', help='Tabular file containing three columns: field, old, new.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_reheader_bams) + return parser + + +def main_reheader_bams(args): + ''' Copy BAM files while renaming elements of the BAM header. + The mapping file specifies which (key, old value, new value) mappings. For + example: + LB lib1 lib_one + SM sample1 Sample_1 + SM sample2 Sample_2 + SM sample3 Sample_3 + CN broad BI + FN in1.bam out1.bam + FN in2.bam out2.bam + ''' + # read mapping file + mapper = dict((a + ':' + b, a + ':' + c) for a, b, c in util.file.read_tabfile(args.rgMap) if a != 'FN') + files = list((b, c) for a, b, c in util.file.read_tabfile(args.rgMap) if a == 'FN') + header_file = mkstempfname('.sam') + # read and convert bam headers + for inBam, outBam in files: + if os.path.isfile(inBam): + with open(header_file, 'wt') as outf: + for row in tools.samtools.SamtoolsTool().getHeader(inBam): + if row[0] == '@RG': + row = [mapper.get(x, x) for x in row] + outf.write('\t'.join(row) + '\n') + # write new bam with new header + tools.samtools.SamtoolsTool().reheader(inBam, header_file, outBam) + os.unlink(header_file) + return 0 + + +__commands__.append(('reheader_bams', parser_reheader_bams)) + +# ============================ +# *** dup_remove_mvicuna *** +# ============================ + + +def mvicuna_fastqs_to_readlist(inFastq1, inFastq2, readList): + # Run M-Vicuna on FASTQ files + outFastq1 = mkstempfname('.1.fastq') + outFastq2 = mkstempfname('.2.fastq') + if inFastq2 is None or os.path.getsize(inFastq2) < 10: + tools.mvicuna.MvicunaTool().rmdup_single(inFastq1, outFastq1) + else: + tools.mvicuna.MvicunaTool().rmdup((inFastq1, inFastq2), (outFastq1, outFastq2), None) + + # Make a list of reads to keep + with open(readList, 'at') as outf: + for fq in (outFastq1, outFastq2): + with util.file.open_or_gzopen(fq, 'rt') as inf: + line_num = 0 + for line in inf: + if (line_num % 4) == 0: + idVal = line.rstrip('\n')[1:] + if idVal.endswith('/1'): + outf.write(idVal[:-2] + '\n') + line_num += 1 + os.unlink(outFastq1) + os.unlink(outFastq2) + + +def rmdup_cdhit_bam(inBam, outBam, max_mismatches=None, jvm_memory=None): + ''' Remove duplicate reads from BAM file using cd-hit-dup. + ''' + max_mismatches = max_mismatches or 4 + tmp_dir = tempfile.mkdtemp() + + tools.picard.SplitSamByLibraryTool().execute(inBam, tmp_dir) + + s2fq_tool = tools.picard.SamToFastqTool() + cdhit = tools.cdhit.CdHit() + out_bams = [] + for f in os.listdir(tmp_dir): + out_bam = mkstempfname('.bam') + out_bams.append(out_bam) + library_sam = os.path.join(tmp_dir, f) + + in_fastqs = mkstempfname('.1.fastq'), mkstempfname('.2.fastq') + + s2fq_tool.execute(library_sam, in_fastqs[0], in_fastqs[1]) + if not os.path.getsize(in_fastqs[0]) > 0 and not os.path.getsize(in_fastqs[1]) > 0: + continue + + out_fastqs = mkstempfname('.1.fastq'), mkstempfname('.2.fastq') + options = { + '-e': max_mismatches, + } + if in_fastqs[1] is not None and os.path.getsize(in_fastqs[1]) > 10: + options['-i2'] = in_fastqs[1] + options['-o2'] = out_fastqs[1] + + log.info(""executing cd-hit-est on library "" + library_sam) + # cd-hit-dup cannot operate on piped fastq input because it reads twice + cdhit.execute('cd-hit-dup', in_fastqs[0], out_fastqs[0], options=options, background=True) + + tools.picard.FastqToSamTool().execute(out_fastqs[0], out_fastqs[1], f, out_bam, JVMmemory=jvm_memory) + for fn in in_fastqs: + os.unlink(fn) + + with util.file.fifo(name='merged.sam') as merged_bam: + merge_opts = ['SORT_ORDER=queryname'] + tools.picard.MergeSamFilesTool().execute(out_bams, merged_bam, picardOptions=merge_opts, JVMmemory=jvm_memory, background=True) + tools.picard.ReplaceSamHeaderTool().execute(merged_bam, inBam, outBam, JVMmemory=jvm_memory) + + +def parser_rmdup_cdhit_bam(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input reads, BAM format.') + parser.add_argument('outBam', help='Output reads, BAM format.') + parser.add_argument( + '--JVMmemory', + default=tools.picard.FilterSamReadsTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)', + dest='jvm_memory' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, rmdup_cdhit_bam, split_args=True) + return parser + + +__commands__.append(('rmdup_cdhit_bam', parser_rmdup_cdhit_bam)) + +def _merge_fastqs_and_mvicuna(lb, files): + readList = mkstempfname('.keep_reads.txt') + log.info(""executing M-Vicuna DupRm on library "" + lb) + + # create merged FASTQs per library + infastqs = (mkstempfname('.1.fastq'), mkstempfname('.2.fastq')) + for d in range(2): + with open(infastqs[d], 'wt') as outf: + for fprefix in files: + fn = '%s_%d.fastq' % (fprefix, d + 1) + + if os.path.isfile(fn): + with open(fn, 'rt') as inf: + for line in inf: + outf.write(line) + os.unlink(fn) + else: + log.warning( + """"""no reads found in %s, + assuming that's because there's no reads in that read group"""""", fn + ) + + # M-Vicuna DupRm to see what we should keep (append IDs to running file) + if os.path.getsize(infastqs[0]) > 0 or os.path.getsize(infastqs[1]) > 0: + mvicuna_fastqs_to_readlist(infastqs[0], infastqs[1], readList) + for fn in infastqs: + os.unlink(fn) + + return readList + +def rmdup_mvicuna_bam(inBam, outBam, JVMmemory=None): + ''' Remove duplicate reads from BAM file using M-Vicuna. The + primary advantage to this approach over Picard's MarkDuplicates tool + is that Picard requires that input reads are aligned to a reference, + and M-Vicuna can operate on unaligned reads. + ''' + + # Convert BAM -> FASTQ pairs per read group and load all read groups + tempDir = tempfile.mkdtemp() + tools.picard.SamToFastqTool().per_read_group(inBam, tempDir, picardOptions=['VALIDATION_STRINGENCY=LENIENT'], JVMmemory=JVMmemory) + read_groups = [x[1:] for x in tools.samtools.SamtoolsTool().getHeader(inBam) if x[0] == '@RG'] + read_groups = [dict(pair.split(':', 1) for pair in rg) for rg in read_groups] + + # Collect FASTQ pairs for each library + lb_to_files = {} + for rg in read_groups: + lb_to_files.setdefault(rg.get('LB', 'none'), set()) + fname = rg['ID'] + lb_to_files[rg.get('LB', 'none')].add(os.path.join(tempDir, fname)) + log.info(""found %d distinct libraries and %d read groups"", len(lb_to_files), len(read_groups)) + + # For each library, merge FASTQs and run rmdup for entire library + readListAll = mkstempfname('.keep_reads_all.txt') + per_lb_read_lists = [] + with concurrent.futures.ProcessPoolExecutor(max_workers=util.misc.available_cpu_count()) as executor: + futures = [executor.submit(_merge_fastqs_and_mvicuna, lb, files) for lb, files in lb_to_files.items()] + for future in concurrent.futures.as_completed(futures): + log.info(""mvicuna finished processing library"") + try: + readList = future.result() + per_lb_read_lists.append(readList) + except Exception as exc: + log.error('mvicuna process call generated an exception: %s' % (exc)) + + # merge per-library read lists together + util.file.concat(per_lb_read_lists, readListAll) + # remove per-library read lists + for fl in per_lb_read_lists: + os.unlink(fl) + + # Filter original input BAM against keep-list + tools.picard.FilterSamReadsTool().execute(inBam, False, readListAll, outBam, JVMmemory=JVMmemory) + return 0 + + +def parser_rmdup_mvicuna_bam(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input reads, BAM format.') + parser.add_argument('outBam', help='Output reads, BAM format.') + parser.add_argument( + '--JVMmemory', + default=tools.picard.FilterSamReadsTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, rmdup_mvicuna_bam, split_args=True) + return parser + + +__commands__.append(('rmdup_mvicuna_bam', parser_rmdup_mvicuna_bam)) + + + +def parser_rmdup_prinseq_fastq(parser=argparse.ArgumentParser()): + parser.add_argument('inFastq1', help='Input fastq file; 1st end of paired-end reads.') + parser.add_argument('inFastq2', help='Input fastq file; 2nd end of paired-end reads.') + parser.add_argument('outFastq1', help='Output fastq file; 1st end of paired-end reads.') + parser.add_argument('outFastq2', help='Output fastq file; 2nd end of paired-end reads.') + parser.add_argument( + ""--includeUnmated"", + help=""Include unmated reads in the main output fastq files (default: %(default)s)"", + default=False, + action=""store_true"" + ) + parser.add_argument('--unpairedOutFastq1', default=None, help='File name of output unpaired reads from 1st end of paired-end reads (independent of --includeUnmated)') + parser.add_argument('--unpairedOutFastq2', default=None, help='File name of output unpaired reads from 2nd end of paired-end reads (independent of --includeUnmated)') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_rmdup_prinseq_fastq) + return parser + + +def main_rmdup_prinseq_fastq(args): + ''' Run prinseq-lite's duplicate removal operation on paired-end + reads. Also removes reads with more than one N. + ''' + prinseq = tools.prinseq.PrinseqTool() + prinseq.rmdup_fastq_paired(args.inFastq1, args.inFastq2, args.outFastq1, args.outFastq2, args.includeUnmated, args.unpairedOutFastq1, args.unpairedOutFastq2) + return 0 + + +__commands__.append(('rmdup_prinseq_fastq', parser_rmdup_prinseq_fastq)) + + +def filter_bam_mapped_only(inBam, outBam): + ''' Samtools to reduce a BAM file to only reads that are + aligned (-F 4) with a non-zero mapping quality (-q 1) + and are not marked as a PCR/optical duplicate (-F 1024). + ''' + tools.samtools.SamtoolsTool().view(['-b', '-q', '1', '-F', '1028'], inBam, outBam) + tools.picard.BuildBamIndexTool().execute(outBam) + return 0 + + +def parser_filter_bam_mapped_only(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input aligned reads, BAM format.') + parser.add_argument('outBam', help='Output sorted indexed reads, filtered to aligned-only, BAM format.') + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, filter_bam_mapped_only, split_args=True) + return parser + + +__commands__.append(('filter_bam_mapped_only', parser_filter_bam_mapped_only)) + +# ======= Novoalign ======== + + +def parser_novoalign(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input reads, BAM format.') + parser.add_argument('refFasta', help='Reference genome, FASTA format, pre-indexed by Novoindex.') + parser.add_argument('outBam', help='Output reads, BAM format (aligned).') + parser.add_argument('--options', default='-r Random', help='Novoalign options (default: %(default)s)') + parser.add_argument('--min_qual', default=0, help='Filter outBam to minimum mapping quality (default: %(default)s)') + parser.add_argument( + '--JVMmemory', + default=tools.picard.SortSamTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--NOVOALIGN_LICENSE_PATH', + default=None, + dest=""novoalign_license_path"", + help='A path to the novoalign.lic file. This overrides the NOVOALIGN_LICENSE_PATH environment variable. (default: %(default)s)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_novoalign) + return parser + + +def main_novoalign(args): + '''Align reads with Novoalign. Sort and index BAM output.''' + tools.novoalign.NovoalignTool(license_path=args.novoalign_license_path).execute( + args.inBam, + args.refFasta, + args.outBam, + options=args.options.split(), + min_qual=args.min_qual, + JVMmemory=args.JVMmemory + ) + return 0 + + +__commands__.append(('novoalign', parser_novoalign)) + + +def parser_novoindex(parser=argparse.ArgumentParser()): + parser.add_argument('refFasta', help='Reference genome, FASTA format.') + parser.add_argument( + '--NOVOALIGN_LICENSE_PATH', + default=None, + dest=""novoalign_license_path"", + help='A path to the novoalign.lic file. This overrides the NOVOALIGN_LICENSE_PATH environment variable. (default: %(default)s)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, main_novoindex) + return parser + +def main_novoindex(args): + tools.novoalign.NovoalignTool(license_path=args.novoalign_license_path).index_fasta(args.refFasta) + return 0 + + +__commands__.append(('novoindex', parser_novoindex)) + +# ========= GATK ========== + + +def parser_gatk_ug(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input reads, BAM format.') + parser.add_argument('refFasta', help='Reference genome, FASTA format, pre-indexed by Picard.') + parser.add_argument( + 'outVcf', + help='''Output calls in VCF format. If this filename ends with .gz, + GATK will BGZIP compress the output and produce a Tabix index file as well.''' + ) + parser.add_argument( + '--options', + default='--min_base_quality_score 15 -ploidy 4', + help='UnifiedGenotyper options (default: %(default)s)' + ) + parser.add_argument( + '--JVMmemory', + default=tools.gatk.GATKTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--GATK_PATH', + default=None, + help='A path containing the GATK jar file. This overrides the GATK_ENV environment variable or the GATK conda package. (default: %(default)s)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_gatk_ug) + return parser + + +def main_gatk_ug(args): + '''Call genotypes using the GATK UnifiedGenotyper.''' + tools.gatk.GATKTool(path=args.GATK_PATH).ug( + args.inBam, args.refFasta, + args.outVcf, options=args.options.split(), + JVMmemory=args.JVMmemory + ) + return 0 + + +__commands__.append(('gatk_ug', parser_gatk_ug)) + + +def parser_gatk_realign(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input reads, BAM format, aligned to refFasta.') + parser.add_argument('refFasta', help='Reference genome, FASTA format, pre-indexed by Picard.') + parser.add_argument('outBam', help='Realigned reads.') + parser.add_argument( + '--JVMmemory', + default=tools.gatk.GATKTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser.add_argument( + '--GATK_PATH', + default=None, + help='A path containing the GATK jar file. This overrides the GATK_ENV environment variable or the GATK conda package. (default: %(default)s)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_gatk_realign) + parser.add_argument('--threads', type=int, default=None, help='Number of threads (default: all available cores)') + return parser + + +def main_gatk_realign(args): + '''Local realignment of BAM files with GATK IndelRealigner.''' + tools.gatk.GATKTool(path=args.GATK_PATH).local_realign( + args.inBam, args.refFasta, + args.outBam, JVMmemory=args.JVMmemory, + threads=args.threads, + ) + return 0 + + +__commands__.append(('gatk_realign', parser_gatk_realign)) + +# ========================= + + +def align_and_fix( + inBam, refFasta, + outBamAll=None, + outBamFiltered=None, + aligner_options='', + aligner=""novoalign"", + JVMmemory=None, + threads=None, + skip_mark_dupes=False, + gatk_path=None, + novoalign_license_path=None +): + ''' Take reads, align to reference with Novoalign, optionally mark duplicates + with Picard, realign indels with GATK, and optionally filters + final file to mapped/non-dupe reads. + ''' + if not (outBamAll or outBamFiltered): + log.warning(""are you sure you meant to do nothing?"") + return + + assert aligner in [""novoalign"", ""bwa""] + + refFastaCopy = mkstempfname('.ref_copy.fasta') + shutil.copyfile(refFasta, refFastaCopy) + + tools.picard.CreateSequenceDictionaryTool().execute(refFastaCopy, overwrite=True) + tools.samtools.SamtoolsTool().faidx(refFastaCopy, overwrite=True) + + if aligner_options is None: + if aligner==""novoalign"": + aligner_options = '-r Random' + elif aligner=='bwa': + aligner_options = '' # use defaults + + bam_aligned = mkstempfname('.aligned.bam') + if aligner==""novoalign"": + + tools.novoalign.NovoalignTool(license_path=novoalign_license_path).index_fasta(refFastaCopy) + + tools.novoalign.NovoalignTool(license_path=novoalign_license_path).execute( + inBam, refFastaCopy, bam_aligned, + options=aligner_options.split(), + JVMmemory=JVMmemory + ) + elif aligner=='bwa': + bwa = tools.bwa.Bwa() + bwa.index(refFastaCopy) + + opts = aligner_options.split() + + bwa.align_mem_bam(inBam, refFastaCopy, bam_aligned, options=opts) + + if skip_mark_dupes: + bam_marked = bam_aligned + else: + bam_marked = mkstempfname('.mkdup.bam') + tools.picard.MarkDuplicatesTool().execute( + [bam_aligned], bam_marked, picardOptions=['CREATE_INDEX=true'], + JVMmemory=JVMmemory + ) + os.unlink(bam_aligned) + + tools.samtools.SamtoolsTool().index(bam_marked) + + bam_realigned = mkstempfname('.realigned.bam') + tools.gatk.GATKTool(path=gatk_path).local_realign(bam_marked, refFastaCopy, bam_realigned, JVMmemory=JVMmemory, threads=threads) + os.unlink(bam_marked) + + if outBamAll: + shutil.copyfile(bam_realigned, outBamAll) + tools.picard.BuildBamIndexTool().execute(outBamAll) + if outBamFiltered: + tools.samtools.SamtoolsTool().view(['-b', '-q', '1', '-F', '1028'], bam_realigned, outBamFiltered) + tools.picard.BuildBamIndexTool().execute(outBamFiltered) + os.unlink(bam_realigned) + + +def parser_align_and_fix(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input unaligned reads, BAM format.') + parser.add_argument('refFasta', help='Reference genome, FASTA format; will be indexed by Picard and Novoalign.') + parser.add_argument( + '--outBamAll', + default=None, + help='''Aligned, sorted, and indexed reads. Unmapped and duplicate reads are + retained. By default, duplicate reads are marked. If ""--skipMarkDupes"" + is specified duplicate reads are included in outout without being marked.''' + ) + parser.add_argument( + '--outBamFiltered', + default=None, + help='''Aligned, sorted, and indexed reads. Unmapped reads are removed from this file, + as well as any marked duplicate reads. Note that if ""--skipMarkDupes"" is provided, + duplicates will be not be marked and will be included in the output.''' + ) + parser.add_argument('--aligner_options', default=None, help='aligner options (default for novoalign: ""-r Random"", bwa: ""-T 30""') + parser.add_argument('--aligner', choices=['novoalign', 'bwa'], default='novoalign', help='aligner (default: %(default)s)') + parser.add_argument('--JVMmemory', default='4g', help='JVM virtual memory size (default: %(default)s)') + parser.add_argument('--threads', type=int, default=None, help='Number of threads (default: all available cores)') + parser.add_argument('--skipMarkDupes', + help='If specified, duplicate reads will not be marked in the resulting output file.', + dest=""skip_mark_dupes"", + action='store_true') + parser.add_argument( + '--GATK_PATH', + default=None, + dest=""gatk_path"", + help='A path containing the GATK jar file. This overrides the GATK_ENV environment variable or the GATK conda package. (default: %(default)s)' + ) + parser.add_argument( + '--NOVOALIGN_LICENSE_PATH', + default=None, + dest=""novoalign_license_path"", + help='A path to the novoalign.lic file. This overrides the NOVOALIGN_LICENSE_PATH environment variable. (default: %(default)s)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, align_and_fix, split_args=True) + return parser + + +__commands__.append(('align_and_fix', parser_align_and_fix)) + +# ========================= + + +def bwamem_idxstats(inBam, refFasta, outBam=None, outStats=None, + min_score_to_filter=None, aligner_options=None): + ''' Take reads, align to reference with BWA-MEM and perform samtools idxstats. + ''' + + assert outBam or outStats, ""Either outBam or outStats must be specified"" + + if outBam is None: + bam_aligned = mkstempfname('.aligned.bam') + else: + bam_aligned = outBam + + samtools = tools.samtools.SamtoolsTool() + bwa = tools.bwa.Bwa() + + ref_indexed = util.file.mkstempfname('.reference.fasta') + shutil.copyfile(refFasta, ref_indexed) + bwa.index(ref_indexed) + + bwa_opts = [] if aligner_options is None else aligner_options.split() + bwa.mem(inBam, ref_indexed, bam_aligned, options=bwa_opts, + min_score_to_filter=min_score_to_filter) + + if outStats is not None: + samtools.idxstats(bam_aligned, outStats) + + if outBam is None: + os.unlink(bam_aligned) + + +def parser_bwamem_idxstats(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input unaligned reads, BAM format.') + parser.add_argument('refFasta', help='Reference genome, FASTA format, pre-indexed by Picard and Novoalign.') + parser.add_argument('--outBam', help='Output aligned, indexed BAM file', default=None) + parser.add_argument('--outStats', help='Output idxstats file', default=None) + parser.add_argument( + '--minScoreToFilter', + dest=""min_score_to_filter"", + type=int, + help=(""Filter bwa alignments using this value as the minimum allowed "" + ""alignment score. Specifically, sum the alignment scores across "" + ""all alignments for each query (including reads in a pair, "" + ""supplementary and secondary alignments) and then only include, "" + ""in the output, queries whose summed alignment score is at least "" + ""this value. This is only applied when the aligner is 'bwa'. "" + ""The filtering on a summed alignment score is sensible for reads "" + ""in a pair and supplementary alignments, but may not be "" + ""reasonable if bwa outputs secondary alignments (i.e., if '-a' "" + ""is in the aligner options). (default: not set - i.e., do not "" + ""filter bwa's output)"") + ) + parser.add_argument( + '--alignerOptions', + dest=""aligner_options"", + help=""bwa options (default: bwa defaults)"") + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, bwamem_idxstats, split_args=True) + return parser + +__commands__.append(('bwamem_idxstats', parser_bwamem_idxstats)) + + +def parser_extract_tarball(parser=argparse.ArgumentParser()): + parser.add_argument('tarfile', help='Input tar file. May be ""-"" for stdin.') + parser.add_argument('out_dir', help='Output directory') + parser.add_argument('--compression', + help='Compression type (default: %(default)s). Auto-detect is incompatible with stdin input unless pipe_hint is specified.', + choices=('gz', 'bz2', 'lz4', 'zip', 'none', 'auto'), + default='auto') + parser.add_argument('--pipe_hint', + help='If tarfile is stdin, you can provide a file-like URI string for pipe_hint which ends with a common compression file extension if you want to use compression=auto.', + default=None) + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_extract_tarball, split_args=True) + return parser +def main_extract_tarball(*args, **kwargs): + ''' Extract an input .tar, .tgz, .tar.gz, .tar.bz2, .tar.lz4, or .zip file + to a given directory (or we will choose one on our own). Emit the + resulting directory path to stdout. + ''' + print(util.file.extract_tarball(*args, **kwargs)) +__commands__.append(('extract_tarball', parser_extract_tarball)) + +# ========================= + +def fasta_read_names(in_fasta, out_read_names): + """"""Save the read names of reads in a .fasta file to a text file"""""" + with util.file.open_or_gzopen(in_fasta) as in_fasta_f, open(out_read_names, 'wt') as out_read_names_f: + last_read_name = None + for line in in_fasta_f: + if line.startswith('>'): + read_name = line[1:].strip() + if read_name.endswith('/1') or read_name.endswith('/2'): + read_name = read_name[:-2] + if read_name != last_read_name: + out_read_names_f.write(read_name+'\n') + last_read_name = read_name + + +def read_names(in_reads, out_read_names, threads=None): + """"""Extract read names from a sequence file"""""" + _in_reads = in_reads + with util.file.tmp_dir(suffix='_read_names.txt') as t_dir: + if in_reads.endswith('.bam'): + _in_reads = os.path.join(t_dir, 'reads.fasta') + tools.samtools.SamtoolsTool().bam2fa(in_reads, _in_reads) + fasta_read_names(_in_reads, out_read_names) + +def parser_read_names(parser=argparse.ArgumentParser()): + parser.add_argument('in_reads', help='the input reads ([compressed] fasta or bam)') + parser.add_argument('out_read_names', help='the read names') + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, read_names, split_args=True) + return parser + +__commands__.append(('read_names', parser_read_names)) + + +# ========================= + +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","taxon_filter.py",".py","37067","893","#!/usr/bin/env python +'''This script contains a number of utilities for filtering NGS reads based +on membership or non-membership in a species / genus / taxonomic grouping. +''' + +from __future__ import print_function +__author__ = ""dpark@broadinstitute.org, irwin@broadinstitute.org,"" \ + + ""hlevitin@broadinstitute.org"" +__commands__ = [] + +import argparse +import glob +import logging +import subprocess +import os +import math +import tempfile +import shutil +import concurrent.futures +import contextlib + +from Bio import SeqIO +import pysam + +import util.cmd +import util.file +import util.misc +import tools +import tools.blast +import tools.last +import tools.prinseq +import tools.bmtagger +import tools.picard +import tools.samtools +from util.file import mkstempfname +import read_utils +from errors import QCError + +log = logging.getLogger(__name__) + + +# ======================= +# *** deplete_human *** +# ======================= + +def parser_deplete(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input BAM file.') + parser.add_argument('revertBam', nargs='?', help='Output BAM: read markup reverted with Picard.') + parser.add_argument('bwaBam', help='Output BAM: depleted of reads with BWA.') + parser.add_argument('bmtaggerBam', help='Output BAM: depleted of reads with BMTagger.') + parser.add_argument('rmdupBam', help='Output BAM: bmtaggerBam run through M-Vicuna duplicate removal.') + parser.add_argument( + 'blastnBam', help='Output BAM: rmdupBam run through another depletion of reads with BLASTN.' + ) + parser.add_argument( + '--bwaDbs', + nargs='*', + default=(), + help='Reference databases for blast to deplete from input.' + ) + parser.add_argument( + '--bmtaggerDbs', + nargs='*', + default=(), + help='''Reference databases to deplete from input. + For each db, requires prior creation of db.bitmask by bmtool, + and db.srprism.idx, db.srprism.map, etc. by srprism mkindex.''' + ) + parser.add_argument( + '--blastDbs', + nargs='*', + default=(), + help='Reference databases for blast to deplete from input.' + ) + parser.add_argument('--srprismMemory', dest=""srprism_memory"", type=int, default=7168, help='Memory for srprism.') + parser.add_argument(""--chunkSize"", type=int, default=1000000, help='blastn chunk size (default: %(default)s)') + parser.add_argument( + '--JVMmemory', + default=tools.picard.FilterSamReadsTool.jvmMemDefault, + help='JVM virtual memory size for Picard FilterSamReads (default: %(default)s)' + ) + parser = read_utils.parser_revert_sam_common(parser) + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_deplete) + + return parser + + + +def main_deplete(args): + ''' Run the entire depletion pipeline: bwa, bmtagger, mvicuna, blastn. + ''' + + assert len(args.bmtaggerDbs) + len(args.blastDbs) + len(args.bwaDbs) > 0 + + # only RevertSam if inBam is already aligned + # Most of the time the input will be unaligned + # so we can save save time if we can skip RevertSam in the unaligned case + # + # via the SAM/BAM spec, if the file is aligned, an SQ line should be present + # in the header. Using pysam, we can check this if header['SQ'])>0 + # https://samtools.github.io/hts-specs/SAMv1.pdf + + # if the user has requested a revertBam + + with read_utils.revert_bam_if_aligned( args.inBam, + revert_bam = args.revertBam, + clear_tags = args.clear_tags, + tags_to_clear = args.tags_to_clear, + picardOptions = ['MAX_DISCARD_FRACTION=0.5'], + JVMmemory = args.JVMmemory, + sanitize = not args.do_not_sanitize) as bamToDeplete: + multi_db_deplete_bam( + bamToDeplete, + args.bwaDbs, + deplete_bwa_bam, + args.bwaBam, + threads=args.threads + ) + + def bmtagger_wrapper(inBam, db, outBam, JVMmemory=None): + return deplete_bmtagger_bam(inBam, db, outBam, srprism_memory=args.srprism_memory, JVMmemory=JVMmemory) + + multi_db_deplete_bam( + args.bwaBam, + args.bmtaggerDbs, + bmtagger_wrapper, + args.bmtaggerBam, + JVMmemory=args.JVMmemory + ) + + # if the user has not specified saving a revertBam, we used a temp file and can remove it + if not args.revertBam: + os.unlink(revertBamOut) + + read_utils.rmdup_mvicuna_bam(args.bmtaggerBam, args.rmdupBam, JVMmemory=args.JVMmemory) + multi_db_deplete_bam( + args.rmdupBam, + args.blastDbs, + deplete_blastn_bam, + args.blastnBam, + chunkSize=args.chunkSize, + threads=args.threads, + JVMmemory=args.JVMmemory + ) + return 0 + +__commands__.append(('deplete', parser_deplete)) + + +def parser_deplete_human(parser=argparse.ArgumentParser()): + parser = parser_deplete(parser) + util.cmd.attach_main(parser, main_deplete_human) + + return parser + +def main_deplete_human(args): + ''' A wrapper around 'deplete'; deprecated but preserved for legacy compatibility. + ''' + main_deplete(args) +__commands__.append(('deplete_human', parser_deplete_human)) + +# ======================= +# *** filter_lastal *** +# ======================= + + +def filter_lastal_bam( + inBam, + db, + outBam, + max_gapless_alignments_per_position=1, + min_length_for_initial_matches=5, + max_length_for_initial_matches=50, + max_initial_matches_per_position=100, + error_on_reads_in_neg_control=False, + neg_control_prefixes=None, #set below: ""neg"",""water"",""NTC"" + negative_control_reads_threshold=0, + JVMmemory=None, threads=None +): + ''' Restrict input reads to those that align to the given + reference database using LASTAL. + ''' + neg_control_prefixes = neg_control_prefixes or [""neg"",""water"",""NTC""] + + with util.file.tmp_dir('-lastdb') as tmp_db_dir: + # index db if necessary + lastdb = tools.last.Lastdb() + if not lastdb.is_indexed(db): + db = lastdb.build_database(db, os.path.join(tmp_db_dir, 'lastdb')) + + with util.file.tempfname('.read_ids.txt') as hitList: + number_of_hits=0 + + # look for lastal hits in BAM and write to temp file + with open(hitList, 'wt') as outf: + for read_id in tools.last.Lastal().get_hits( + inBam, db, + max_gapless_alignments_per_position, + min_length_for_initial_matches, + max_length_for_initial_matches, + max_initial_matches_per_position, + threads=threads + ): + number_of_hits+=1 + outf.write(read_id + '\n') + + if error_on_reads_in_neg_control: + sample_name=os.path.basename(inBam) + if any(sample_name.lower().startswith(prefix.lower()) for prefix in neg_control_prefixes): + if number_of_hits > max(0,negative_control_reads_threshold): + log.warning(""Error raised due to reads in negative control; re-run this without '--errorOnReadsInNegControl' if this execution should succeed."") + raise QCError(""The sample '{}' appears to be a negative control, but it contains {} reads after filtering to desired taxa."".format(sample_name,number_of_hits)) + + # filter original BAM file against keep list + tools.picard.FilterSamReadsTool().execute(inBam, False, hitList, outBam, JVMmemory=JVMmemory) + + +def parser_filter_lastal_bam(parser=argparse.ArgumentParser()): + parser.add_argument(""inBam"", help=""Input reads"") + parser.add_argument(""db"", help=""Database of taxa we keep"") + parser.add_argument(""outBam"", help=""Output reads, filtered to refDb"") + parser.add_argument( + '-n', + dest=""max_gapless_alignments_per_position"", + help='maximum gapless alignments per query position (default: %(default)s)', + type=int, + default=1 + ) + parser.add_argument( + '-l', + dest=""min_length_for_initial_matches"", + help='minimum length for initial matches (default: %(default)s)', + type=int, + default=5 + ) + parser.add_argument( + '-L', + dest=""max_length_for_initial_matches"", + help='maximum length for initial matches (default: %(default)s)', + type=int, + default=50 + ) + parser.add_argument( + '-m', + dest=""max_initial_matches_per_position"", + help='maximum initial matches per query position (default: %(default)s)', + type=int, + default=100 + ) + parser.add_argument( + '--errorOnReadsInNegControl', + dest=""error_on_reads_in_neg_control"", + help='If specified, the function will return an error if there are reads after filtering for samples with names containing: (water,neg,ntc) (default: %(default)s)', + action=""store_true"", + ) + parser.add_argument( + '--negativeControlReadsThreshold', + dest=""negative_control_reads_threshold"", + help='maximum number of reads (single-end) or read pairs (paired-end) to tolerate in samples identified as negative controls (default: %(default)s)', + type=int, + default=0 + ) + parser.add_argument( + '--negControlPrefixes', + dest=""neg_control_prefixes"", + default=[""neg"",""water"",""NTC""], + nargs='*', + help='Bam file name prefixes to interpret as negative controls, space-separated (default: %(default)s)' + ) + parser.add_argument( + '--JVMmemory', + default=tools.picard.FilterSamReadsTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, filter_lastal_bam, split_args=True) + return parser + + +__commands__.append(('filter_lastal_bam', parser_filter_lastal_bam)) + + +# ============================== +# *** deplete_bmtagger_bam *** +# ============================== + + +def deplete_bmtagger_bam(inBam, db, outBam, srprism_memory=7168, JVMmemory=None): + """""" + Use bmtagger to partition the input reads into ones that match at least one + of the databases and ones that don't match any of the databases. + inBam: paired-end input reads in BAM format. + db: bmtagger expects files + db.bitmask created by bmtool, and + db.srprism.idx, db.srprism.map, etc. created by srprism mkindex + outBam: the output BAM files to hold the unmatched reads. + srprism_memory: srprism memory in megabytes. + """""" + bmtaggerPath = tools.bmtagger.BmtaggerShTool().install_and_get_path() + + # bmtagger calls several executables in the same directory, and blastn; + # make sure they are accessible through $PATH + blastnPath = tools.blast.BlastnTool().install_and_get_path() + path = os.environ['PATH'].split(os.pathsep) + for t in (bmtaggerPath, blastnPath): + d = os.path.dirname(t) + if d not in path: + path = [d] + path + path = os.pathsep.join(path) + os.environ['PATH'] = path + + with util.file.tempfname('.1.fastq') as inReads1: + tools.samtools.SamtoolsTool().bam2fq(inBam, inReads1) + + with util.file.tempfname('.bmtagger.conf') as bmtaggerConf: + with open(bmtaggerConf, 'w') as f: + # Default srprismopts: ""-b 100000000 -n 5 -R 0 -r 1 -M 7168"" + print('srprismopts=""-b 100000000 -n 5 -R 0 -r 1 -M {srprism_memory} --paired false""'.format(srprism_memory=srprism_memory), file=f) + + with extract_build_or_use_database(db, bmtagger_build_db, 'bitmask', tmp_suffix=""-bmtagger"", db_prefix=""bmtagger"") as (db_prefix,tempDir): + matchesFile = mkstempfname('.txt') + cmdline = [ + bmtaggerPath, '-b', db_prefix + '.bitmask', '-C', bmtaggerConf, '-x', db_prefix + '.srprism', '-T', tempDir, '-q1', + '-1', inReads1, '-o', matchesFile + ] + log.debug(' '.join(cmdline)) + util.misc.run_and_print(cmdline, check=True) + + tools.picard.FilterSamReadsTool().execute(inBam, True, matchesFile, outBam, JVMmemory=JVMmemory) + +def parser_deplete_bam_bmtagger(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input BAM file.') + parser.add_argument( + 'refDbs', + nargs='+', + help='''Reference databases (one or more) to deplete from input. + For each db, requires prior creation of db.bitmask by bmtool, + and db.srprism.idx, db.srprism.map, etc. by srprism mkindex.''' + ) + parser.add_argument('outBam', help='Output BAM file.') + parser.add_argument('--srprismMemory', dest=""srprism_memory"", type=int, default=7168, help='Memory for srprism.') + parser.add_argument( + '--JVMmemory', + default=tools.picard.FilterSamReadsTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser = read_utils.parser_revert_sam_common(parser) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_deplete_bam_bmtagger) + return parser + +def main_deplete_bam_bmtagger(args): + '''Use bmtagger to deplete input reads against several databases.''' + + def bmtagger_wrapper(inBam, db, outBam, JVMmemory=None): + return deplete_bmtagger_bam(inBam, db, outBam, srprism_memory=args.srprism_memory, JVMmemory=JVMmemory) + + with read_utils.revert_bam_if_aligned( args.inBam, + clear_tags = args.clear_tags, + tags_to_clear = args.tags_to_clear, + picardOptions = ['MAX_DISCARD_FRACTION=0.5'], + JVMmemory = args.JVMmemory, + sanitize = not args.do_not_sanitize) as bamToDeplete: + multi_db_deplete_bam( + args.inBam, + args.refDbs, + bmtagger_wrapper, + args.outBam, + JVMmemory=args.JVMmemory + ) + +__commands__.append(('deplete_bam_bmtagger', parser_deplete_bam_bmtagger)) + + +def multi_db_deplete_bam(inBam, refDbs, deplete_method, outBam, **kwargs): + + tmpDb = None + if len(refDbs)>1 and not any( + not os.path.exists(db) # indexed db prefix + or os.path.isdir(db) # indexed db in directory + or (os.path.isfile(db) and ('.tar' in db or '.tgz' in db or '.zip' in db)) # packaged indexed db + for db in refDbs): + # this is a scenario where all refDbs are unbuilt fasta + # files. we can simplify and speed up execution by + # concatenating them all and running deplete_method + # just once + tmpDb = mkstempfname('.fasta') + merge_compressed_files(refDbs, tmpDb, sep='\n') + refDbs = [tmpDb] + + samtools = tools.samtools.SamtoolsTool() + tmpBamIn = inBam + for db in refDbs: + if not samtools.isEmpty(tmpBamIn): + tmpBamOut = mkstempfname('.bam') + deplete_method(tmpBamIn, db, tmpBamOut, **kwargs) + if tmpBamIn != inBam: + os.unlink(tmpBamIn) + tmpBamIn = tmpBamOut + shutil.copyfile(tmpBamIn, outBam) + + if tmpDb: + os.unlink(tmpDb) + + +# ======================== +# *** deplete_blastn *** +# ======================== + + +def _run_blastn_chunk(db, input_fasta, out_hits, blast_threads): + """""" run blastn on the input fasta file. this is intended to be run in parallel + by blastn_chunked_fasta + """""" + with util.file.open_or_gzopen(out_hits, 'wt') as outf: + for read_id in tools.blast.BlastnTool().get_hits_fasta(input_fasta, db, threads=blast_threads): + outf.write(read_id + '\n') + +def blastn_chunked_fasta(fasta, db, out_hits, chunkSize=1000000, threads=None): + """""" + Helper function: blastn a fasta file, overcoming apparent memory leaks on + an input with many query sequences, by splitting it into multiple chunks + and running a new blastn process on each chunk. Return a list of output + filenames containing hits + """""" + # the lower bound of how small a fasta chunk can be. + # too small and the overhead of spawning a new blast process + # will be detrimental relative to actual computation time + MIN_CHUNK_SIZE = 20000 + + # just in case blast is not installed, install it once, not many times in parallel! + tools.blast.BlastnTool().install() + + # clamp threadcount to number of CPU cores + threads = util.misc.sanitize_thread_count(threads) + + # determine size of input data; records in fasta file + number_of_reads = util.file.fasta_length(fasta) + log.debug(""number of reads in fasta file %s"" % number_of_reads) + if number_of_reads == 0: + util.file.make_empty(out_hits) + + # divide (max, single-thread) chunksize by thread count + # to find the absolute max chunk size per thread + chunk_max_size_per_thread = chunkSize // threads + + # find the chunk size if evenly divided among blast threads + reads_per_thread = number_of_reads // threads + + # use the smaller of the two chunk sizes so we can run more copies of blast in parallel + chunkSize = min(reads_per_thread, chunk_max_size_per_thread) + + # if the chunk size is too small, impose a sensible size + chunkSize = max(chunkSize, MIN_CHUNK_SIZE) + + log.debug(""chunk_max_size_per_thread %s"" % chunk_max_size_per_thread) + + # adjust chunk size so we don't have a small fraction + # of a chunk running in its own blast process + # if the size of the last chunk is <80% the size of the others, + # decrease the chunk size until the last chunk is 80% + # this is bounded by the MIN_CHUNK_SIZE + while (number_of_reads / chunkSize) % 1 < 0.8 and chunkSize > MIN_CHUNK_SIZE: + chunkSize = chunkSize - 1 + + log.debug(""blastn chunk size %s"" % chunkSize) + log.debug(""number of chunks to create %s"" % (number_of_reads / chunkSize)) + log.debug(""blastn parallel instances %s"" % threads) + + # chunk the input file. This is a sequential operation + input_fastas = [] + with open(fasta, ""rt"") as fastaFile: + record_iter = SeqIO.parse(fastaFile, ""fasta"") + for batch in util.misc.batch_iterator(record_iter, chunkSize): + chunk_fasta = mkstempfname('.fasta') + + with open(chunk_fasta, ""wt"") as handle: + SeqIO.write(batch, handle, ""fasta"") + batch = None + input_fastas.append(chunk_fasta) + + num_chunks = len(input_fastas) + log.debug(""number of chunk files to be processed by blastn %d"" % num_chunks) + + # run blastn on each of the fasta input chunks + hits_files = list(mkstempfname('.hits.txt') for f in input_fastas) + with concurrent.futures.ProcessPoolExecutor(max_workers=threads) as executor: + # If we have so few chunks that there are cpus left over, + # divide extra cpus evenly among chunks where possible + # rounding to 1 if there are more chunks than extra threads. + # Then double up this number to better maximize CPU usage. + cpus_leftover = threads - num_chunks + blast_threads = 2*max(1, int(cpus_leftover / num_chunks)) + for i in range(num_chunks): + executor.submit( + _run_blastn_chunk, db, input_fastas[i], hits_files[i], blast_threads) + + # merge results and clean up + util.file.cat(out_hits, hits_files) + for i in range(num_chunks): + os.unlink(input_fastas[i]) + os.unlink(hits_files[i]) + + +def deplete_blastn_bam(inBam, db, outBam, threads=None, chunkSize=1000000, JVMmemory=None): +#def deplete_blastn_bam(inBam, db, outBam, threads, chunkSize=0, JVMmemory=None): + 'Use blastn to remove reads that match at least one of the databases.' + + blast_hits = mkstempfname('.blast_hits.txt') + + with extract_build_or_use_database(db, blastn_build_db, 'nin', tmp_suffix=""-blastn_db_unpack"", db_prefix=""blastn"") as (db_prefix,tempDir): + if chunkSize: + ## chunk up input and perform blastn in several parallel threads + with util.file.tempfname('.fasta') as reads_fasta: + tools.samtools.SamtoolsTool().bam2fa(inBam, reads_fasta) + log.info(""running blastn on %s against %s"", inBam, db) + blastn_chunked_fasta(reads_fasta, db_prefix, blast_hits, chunkSize, threads) + + else: + ## pipe tools together and run blastn multithreaded + with open(blast_hits, 'wt') as outf: + for read_id in tools.blast.BlastnTool().get_hits_bam(inBam, db_prefix, threads=threads): + outf.write(read_id + '\n') + + # Deplete BAM of hits + tools.picard.FilterSamReadsTool().execute(inBam, True, blast_hits, outBam, JVMmemory=JVMmemory) + os.unlink(blast_hits) + + +def parser_deplete_blastn_bam(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input BAM file.') + parser.add_argument('refDbs', nargs='+', help='One or more reference databases for blast. ' + 'An ephemeral database will be created if a fasta file is provided.') + parser.add_argument('outBam', help='Output BAM file with matching reads removed.') + parser.add_argument(""--chunkSize"", type=int, default=1000000, help='FASTA chunk size (default: %(default)s)') + parser.add_argument( + '--JVMmemory', + default=tools.picard.FilterSamReadsTool.jvmMemDefault, + help='JVM virtual memory size (default: %(default)s)' + ) + parser = read_utils.parser_revert_sam_common(parser) + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_deplete_blastn_bam) + return parser + + +def main_deplete_blastn_bam(args): + '''Use blastn to remove reads that match at least one of the specified databases.''' + + def wrapper(inBam, db, outBam, threads, JVMmemory=None): + return deplete_blastn_bam(inBam, db, outBam, threads=threads, chunkSize=args.chunkSize, JVMmemory=JVMmemory) + + with read_utils.revert_bam_if_aligned( args.inBam, + clear_tags = args.clear_tags, + tags_to_clear = args.tags_to_clear, + picardOptions = ['MAX_DISCARD_FRACTION=0.5'], + JVMmemory = args.JVMmemory, + sanitize = not args.do_not_sanitize) as bamToDeplete: + multi_db_deplete_bam(bamToDeplete, args.refDbs, wrapper, args.outBam, threads=args.threads, JVMmemory=args.JVMmemory) + return 0 +__commands__.append(('deplete_blastn_bam', parser_deplete_blastn_bam)) + + +@contextlib.contextmanager +def extract_build_or_use_database(db, db_build_command, db_extension_to_expect, tmp_suffix='db_unpack', db_prefix=""db""): + ''' + db_extension_to_expect = file extension, sans dot prefix + ''' + with util.file.tmp_dir(tmp_suffix) as tempDbDir: + db_dir = """" + if os.path.exists(db): + if os.path.isfile(db): + # this is a single file + if db.endswith('.fasta') or db.endswith('.fasta.gz') or db.endswith('.fasta.lz4') or db.endswith('.fa') or db.endswith('.fa.gz') or db.endswith('.fa.lz4'): + # this is an unindexed fasta file, we will need to index it + # function should conform to the signature: + # db_build_command(inputFasta, outputDirectory, outputFilePrefix) + # the function will need to be able to handle lz4, etc. + db_build_command(db, tempDbDir, db_prefix) + db_dir = tempDbDir + else: + # this is a tarball with prebuilt indexes + db_dir = util.file.extract_tarball(db, tempDbDir) + else: + # this is a directory + db_dir = db + # this directory should have a .{ext} file, where {ext} is specific to the type of db + hits = list(glob.glob(os.path.join(db_dir, '*.{ext}'.format(ext=db_extension_to_expect)))) + if len(hits) == 0: + raise Exception(""The blast database does not appear to a *.{ext} file."".format(ext=db_extension_to_expect)) + elif len(hits) == 1: + db_prefix = hits[0][:-(len('.{ext}'.format(ext=db_extension_to_expect)))] # remove the '.extension' + elif len(hits) >1: + db_prefix = os.path.commonprefix(hits).rsplit('.', 1)[0] # remove extension and split-db prefix + else: + # this is simply a prefix to a bunch of files, not an actual file + db_prefix = db.rsplit('.', 1)[0] if db.endswith('.') else db + + yield (db_prefix,tempDbDir) + +# ======================== +# *** deplete_bwa *** +# ======================== + +def deplete_bwa_bam(inBam, db, outBam, threads=None, clear_tags=True, tags_to_clear=None, JVMmemory=None): + 'Use bwa to remove reads from an unaligned bam that match at least one of the databases.' + tags_to_clear = tags_to_clear or [] + + threads = util.misc.sanitize_thread_count(threads) + + with extract_build_or_use_database(db, bwa_build_db, 'bwt', tmp_suffix=""-bwa_db_unpack"", db_prefix=""bwa"") as (db_prefix,tempDbDir): + with util.file.tempfname('.aligned.sam') as aligned_sam: + tools.bwa.Bwa().align_mem_bam(inBam, db_prefix, aligned_sam, threads=threads, should_index=False, JVMmemory=JVMmemory) + #with util.file.fifo(name='filtered.sam') as filtered_sam: + with util.file.tempfname('.filtered.sam') as filtered_sam: + # filter proper pairs + tools.samtools.SamtoolsTool().view(['-h','-F0x2'], aligned_sam, filtered_sam) + + picardOptions = [] + if clear_tags: + for tag in tags_to_clear: + picardOptions.append(""ATTRIBUTE_TO_CLEAR={}"".format(tag)) + tools.picard.RevertSamTool().execute( + filtered_sam, + outBam, + picardOptions=['SORT_ORDER=queryname'] + picardOptions, + JVMmemory=JVMmemory + ) + # TODO: consider using Bwa().mem() so the input bam is not broken out by read group + # TODO: pipe bwa input directly to samtools process (need to use Bwa().mem() directly, ) + # with Popen to background bwa process + +def parser_deplete_bwa_bam(parser=argparse.ArgumentParser()): + parser.add_argument('inBam', help='Input BAM file.') + parser.add_argument('refDbs', nargs='+', help='One or more reference databases for bwa. ' + 'An ephemeral database will be created if a fasta file is provided.') + parser.add_argument('outBam', help='Ouput BAM file with matching reads removed.') + parser = read_utils.parser_revert_sam_common(parser) + util.cmd.common_args(parser, (('threads', None), ('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, main_deplete_bwa_bam) + return parser + +def main_deplete_bwa_bam(args): + '''Use BWA to remove reads that match at least one of the specified databases.''' + with read_utils.revert_bam_if_aligned( args.inBam, + clear_tags = args.clear_tags, + tags_to_clear = args.tags_to_clear, + picardOptions = ['MAX_DISCARD_FRACTION=0.5'], + JVMmemory = args.JVMmemory, + sanitize = not args.do_not_sanitize) as bamToDeplete: + + #def wrapper(inBam, db, outBam, threads, JVMmemory=None): + # return deplete_bwa_bam(inBam, db, outBam, threads=threads, ) + multi_db_deplete_bam(bamToDeplete, args.refDbs, deplete_bwa_bam, args.outBam, threads=args.threads, clear_tags=args.clear_tags, tags_to_clear=args.tags_to_clear, JVMmemory=args.JVMmemory) + return 0 +__commands__.append(('deplete_bwa_bam', parser_deplete_bwa_bam)) + + +# ======================== +# *** lastal_build_db *** +# ======================== + + +def lastal_build_db(inputFasta, outputDirectory, outputFilePrefix): + ''' build a database for use with last based on an input fasta file ''' + if outputFilePrefix: + outPrefix = outputFilePrefix + else: + baseName = os.path.basename(inputFasta) + fileNameSansExtension = os.path.splitext(baseName)[0] + outPrefix = fileNameSansExtension + + tools.last.Lastdb().build_database(inputFasta, os.path.join(outputDirectory, outPrefix)) + + +def parser_lastal_build_db(parser=argparse.ArgumentParser()): + parser.add_argument('inputFasta', help='Location of the input FASTA file') + parser.add_argument('outputDirectory', help='Location for the output files (default is cwd: %(default)s)') + parser.add_argument( + '--outputFilePrefix', + help='Prefix for the output file name (default: inputFasta name, sans "".fasta"" extension)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, lastal_build_db, split_args=True) + return parser + + +__commands__.append(('lastal_build_db', parser_lastal_build_db)) + +# ================================ +# *** merge_compressed_files *** +# ================================ + +def merge_compressed_files(inFiles, outFile, sep=''): + ''' Take a collection of input text files, possibly compressed, + and concatenate into a single output text file. + TO DO: if we made util.file.open_or_gzopen more multilingual, + we wouldn't need this. + ''' + with util.file.open_or_gzopen(outFile, 'wt') as outf: + first = True + for infname in inFiles: + if not first: + if sep: + outf.write(sep) + else: + first = False + if infname.endswith('.gz') or infname.endswith('.lz4') or infname.endswith('.bz2'): + if infname.endswith('.gz'): + decompressor = ['pigz', '-d'] + elif infname.endswith('.lz4'): + decompressor = ['lz4', '-d'] + else: + decompressor = ['lbzip2', '-d'] + with open(infname, 'rb') as inf: + subprocess.check_call(decompressor, stdin=inf, stdout=outf) + else: + with open(infname, 'rt') as inf: + for line in inf: + outf.write(line) + +# ======================== +# *** bwa_build_db *** +# ======================== + + +def bwa_build_db(inputFasta, outputDirectory, outputFilePrefix): + """""" Create a database for use with bwa from an input reference FASTA file + """""" + + new_fasta = None + if inputFasta.endswith('.gz') or inputFasta.endswith('.lz4'): + if inputFasta.endswith('.gz'): + decompressor = ['pigz', '-dc'] + else: + decompressor = ['lz4', '-d'] + new_fasta = util.file.mkstempfname('.fasta') + with open(inputFasta, 'rb') as inf, open(new_fasta, 'wb') as outf: + subprocess.check_call(decompressor, stdin=inf, stdout=outf) + inputFasta = new_fasta + + # make the output path if it does not exist + util.file.mkdir_p(outputDirectory) + + if outputFilePrefix: + outPrefix = outputFilePrefix + else: + baseName = os.path.basename(inputFasta) + fileNameSansExtension = os.path.splitext(baseName)[0] + outPrefix = fileNameSansExtension + + tools.bwa.Bwa().index(inputFasta, output=os.path.join(outputDirectory, outPrefix)) + + if new_fasta is not None: + os.unlink(new_fasta) + + +def parser_bwa_build_db(parser=argparse.ArgumentParser()): + parser.add_argument('inputFasta', help='Location of the input FASTA file') + parser.add_argument('outputDirectory', help='Location for the output files') + parser.add_argument( + '--outputFilePrefix', + help='Prefix for the output file name (default: inputFasta name, sans "".fasta"" extension)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, bwa_build_db, split_args=True) + return parser + + +__commands__.append(('bwa_build_db', parser_bwa_build_db)) + + +# ======================== +# *** blastn_build_db *** +# ======================== + + +def blastn_build_db(inputFasta, outputDirectory, outputFilePrefix): + """""" Create a database for use with blastn from an input reference FASTA file + """""" + + new_fasta = None + if inputFasta.endswith('.gz') or inputFasta.endswith('.lz4'): + if inputFasta.endswith('.gz'): + decompressor = ['pigz', '-dc'] + else: + decompressor = ['lz4', '-d'] + new_fasta = util.file.mkstempfname('.fasta') + with open(inputFasta, 'rb') as inf, open(new_fasta, 'wb') as outf: + subprocess.check_call(decompressor, stdin=inf, stdout=outf) + inputFasta = new_fasta + + if outputFilePrefix: + outPrefix = outputFilePrefix + else: + baseName = os.path.basename(inputFasta) + fileNameSansExtension = os.path.splitext(baseName)[0] + outPrefix = fileNameSansExtension + + blastdb_path = tools.blast.MakeblastdbTool().build_database(inputFasta, os.path.join(outputDirectory, outPrefix)) + + if new_fasta is not None: + os.unlink(new_fasta) + + +def parser_blastn_build_db(parser=argparse.ArgumentParser()): + parser.add_argument('inputFasta', help='Location of the input FASTA file') + parser.add_argument('outputDirectory', help='Location for the output files') + parser.add_argument( + '--outputFilePrefix', + help='Prefix for the output file name (default: inputFasta name, sans "".fasta"" extension)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, blastn_build_db, split_args=True) + return parser + + +__commands__.append(('blastn_build_db', parser_blastn_build_db)) + +# ======================== +# *** bmtagger_build_db *** +# ======================== + + +def bmtagger_build_db(inputFasta, outputDirectory, outputFilePrefix, word_size=18): + """""" Create a database for use with Bmtagger from an input FASTA file. + """""" + + new_fasta = None + if inputFasta.endswith('.gz') or inputFasta.endswith('.lz4'): + if inputFasta.endswith('.gz'): + decompressor = ['pigz', '-dc'] + else: + decompressor = ['lz4', '-d'] + new_fasta = util.file.mkstempfname('.fasta') + log.debug(""cat {} | {} > {}"".format(inputFasta, ' '.join(decompressor), new_fasta)) + with open(inputFasta, 'rb') as inf, open(new_fasta, 'wb') as outf: + subprocess.check_call(decompressor, stdin=inf, stdout=outf) + inputFasta = new_fasta + + if outputFilePrefix: + outPrefix = outputFilePrefix + else: + baseName = os.path.basename(inputFasta) + fileNameSansExtension = os.path.splitext(baseName)[0] + outPrefix = fileNameSansExtension + + log.debug(""building bmtagger and srprism databases on {}"".format(os.path.join(outputDirectory, outPrefix))) + bmtooldb_path = tools.bmtagger.BmtoolTool().build_database( + inputFasta, os.path.join(outputDirectory, outPrefix + "".bitmask""), word_size=word_size + ) + srprismdb_path = tools.bmtagger.SrprismTool().build_database( + inputFasta, os.path.join(outputDirectory, outPrefix + "".srprism"") + ) + + if new_fasta is not None: + os.unlink(new_fasta) + + +def parser_bmtagger_build_db(parser=argparse.ArgumentParser()): + parser.add_argument('inputFasta', help='Location of the input FASTA file') + parser.add_argument( + 'outputDirectory', + help='Location for the output files (Where *.bitmask and *.srprism files will be stored)' + ) + parser.add_argument( + '--outputFilePrefix', + help='Prefix for the output file name (default: inputFasta name, sans "".fasta"" extension)' + ) + parser.add_argument( + '--word_size', + type=int, + default=18, + help='Database word size (default: %(default)s)' + ) + util.cmd.common_args(parser, (('loglevel', None), ('version', None), ('tmp_dir', None))) + util.cmd.attach_main(parser, bmtagger_build_db, split_args=True) + return parser + + +__commands__.append(('bmtagger_build_db', parser_bmtagger_build_db)) + +# ======================== + + +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","conftest.py",".py","6911","195","import operator +import os +import shutil +import sys +import tempfile +import time +import contextlib +import string +import inspect +import copy +import functools + +import util.misc +import util.file + +import pytest + +import test.stubs +import tools + +def timer(): + if sys.version_info < (3, 3): + return time.time() + return time.perf_counter() + + +def pytest_addoption(parser): + group = parser.getgroup(""reporting"", description=""terminal reporting"", after=""general"") + group.addoption( + '--fixture-durations', + action=""store"", + type=int, + default=None, + metavar=""N"", + help=""show N slowest fixture durations (N=0 for all)."" + ) + parser.addoption( + ""--runslow"", action=""store_true"", default=False, help=""run slow tests"" + ) + + +def pytest_configure(config): + reporter = FixtureReporter(config) + config.pluginmanager.register(reporter, 'fixturereporter') + + +def pytest_collection_modifyitems(config, items): + if config.getoption(""--runslow""): + # --runslow given in cli: do not skip slow tests + return + skip_slow = pytest.mark.skip(reason=""need --runslow option to run"") + for item in items: + if ""slow"" in item.keywords: + item.add_marker(skip_slow) + + +# Fixtures for creating a temp dir at session/module/class/function scope. +# Unlike pytest's tmpdir fixture, they use tempfile.mkdtemp to create a +# tempdir in the most secure/race-condition-free manner possible. +# Also, since util.file.tmp_dir() is used, the tempdir contens can be +# preserved for debugging by setting the environment variable VIRAL_NGS_TMP_DIRKEEP. + + +@contextlib.contextmanager +def _tmpdir_aux(base_dir, scope, name): + """"""Create and return a temporary directory; remove it and its contents on context exit."""""" + with util.file.tmp_dir(dir=base_dir, + prefix='test-{}-{}-'.format(scope, name)) as tmpdir: + yield tmpdir + +@pytest.fixture(scope='session') +def tmpdir_session(request, tmpdir_factory): + """"""Create a session-scope temporary directory."""""" + with _tmpdir_aux(str(tmpdir_factory.getbasetemp()), + 'session', id(request.session)) as tmpdir: + yield tmpdir + +@pytest.fixture(scope='module') +def tmpdir_module(request, tmpdir_session): + """"""Create a module-scope temporary directory."""""" + with _tmpdir_aux(tmpdir_session, 'module', request.module.__name__) as tmpdir: + yield tmpdir + +@pytest.fixture(scope='class') +def tmpdir_class(request, tmpdir_module): + """"""Create a class-scope temporary directory."""""" + with _tmpdir_aux(tmpdir_module, 'class', + request.cls.__name__ if request.cls else '__noclass__') as tmpdir: + yield tmpdir + +@pytest.fixture(autouse=True) +def tmpdir_function(request, tmpdir_class, monkeypatch): + """"""Create a temporary directory and set it to be used by the tempfile module and as the TMPDIR environment variable."""""" + with _tmpdir_aux(tmpdir_class, 'node', request.node.name) as tmpdir: + monkeypatch.setattr(tempfile, 'tempdir', tmpdir) + monkeypatch.setenv('TMPDIR', tmpdir) + yield tmpdir + + +@pytest.fixture +def monkeypatch_function_result(monkeypatch): + """"""Patches result of a function for specified args"""""" + + @contextlib.contextmanager + def _set_function_result(f, *patch_args, **patch_kwargs): + """"""Within the context, calls to function `f` with `patch_args` and `patch_kwargs` will return the + `patch_result` (a keyword-only arg), or raise the `patch_exception` (a keyword-only arg) if that is given. + Note that for the patched args, f will not be called, so any side effects of it won't happen. + The function will be patched in the module `patch_module` (a keyword-only arg), or in `f` 's module + if `patch_module` is None. The keyword-only args `patch_result`, `patch_exception` and `patch_module` + will be removed from `patch_kwargs` before calling f. This context manager monkeypatches f for exactly + one argument combination; multiple argument combos can be patched by nesting calls to this context manager. + + For a usage example, see test.unit.test_util_misc.test_available_cpu_count() . + """""" + + patch_kwargs = copy.copy(patch_kwargs) + patch_result = patch_kwargs.pop('patch_result', None) + patch_exception = patch_kwargs.pop('patch_exception', None) + util.misc.chk(patch_exception is None or patch_result is None) + patch_module = patch_kwargs.pop('patch_module', inspect.getmodule(f)) + get_call_args = functools.partial(inspect.getcallargs, util.misc.unwrap(f)) + patch_call_args = get_call_args(*patch_args, **patch_kwargs) + + @util.misc.wraps(f) + def patched_f(*args, **kwargs): + if get_call_args(*args, **kwargs) != patch_call_args: + return f(*args, **kwargs) + + if patch_exception: + raise patch_exception + + return patch_result + + util.misc.chk(inspect.ismodule(patch_module) and getattr(patch_module, f.__name__) == f) + with monkeypatch.context() as m: + m.setattr(patch_module, f.__name__, patched_f) + yield + + return _set_function_result + + +@pytest.fixture(scope='module', autouse=True) +def stub_conda(request): + cls = tools.CondaPackage + tools.CondaPackage = test.stubs.StubCondaPackage + yield + tools.CondaPackage = cls + + +class FixtureReporter: + + def __init__(self, config): + import _pytest.config + self.config = config + self.stats = {} + self.writer = _pytest.config.create_terminal_writer(config) + self.durations = config.option.fixture_durations + + @pytest.hookimpl(hookwrapper=True) + def pytest_fixture_setup(self, fixturedef, request): + funcname = request._pyfuncitem.name + fixname = fixturedef.argname + + fixturedef._timer_start = timer() + yield + duration = timer() - fixturedef._timer_start + fixturedef._timer_duration = duration + + self.stats[(fixname, funcname)] = duration + + def pytest_terminal_summary(self, terminalreporter, exitstatus): + if self.durations is None: + return + + writer = terminalreporter.writer + + slowest = sorted(self.stats.items(), key=operator.itemgetter(1), reverse=True) + if not self.durations: + writer.sep(""="", ""slowest fixture durations"") + else: + writer.sep(""="", ""slowest %s fixture durations"" % self.durations) + slowest = slowest[:self.durations] + + + rows = [] + for (fixname, funcname), duration in slowest: + row = ['{:.2f}s'.format(duration), fixname, funcname] + rows.append(row) + + widths = [max(map(len, col)) for col in zip(*rows)] + for row in rows: + writer.write("" "".join((val.ljust(width) for val, width in zip(row, widths)))) + writer.line() +","Python" +"Viral","broadinstitute/viral-ngs","install_tools.py",".py","1314","43","#!/usr/bin/env python +''' This script installs every Tool needed by viral-ngs +''' + +from __future__ import print_function +import os.path +import sys +import timeit +import tools +from tools import * +import util.file + +__author__ = ""dpark@broadinstitute.org"" + +def install_all_tools(): + sumtime = 0.0 + n_tools = 0 + n_success = 0 + for tool_class in tools.all_tool_classes(): + t = tool_class() + print(""installing %s .. "" % tool_class.__name__, end="""") + sys.stdout.flush() + runtime = timeit.timeit(t.install) + sumtime += runtime + success = t.is_installed() + print(""SUCCESS"" if success else ""FAILED"", end="""") + print("" (%0.1f seconds)"" % runtime) + sys.stdout.flush() + if success: + n_success += 1 + n_tools += 1 + print(""Total %d tools attempted, %d succeeded, %d failed, cumulative install time %0.1f seconds"" % ( + n_tools, n_success, n_tools - n_success, sumtime)) + return (n_tools == n_success) + + +if __name__ == '__main__': + print(""this install script is %s"" % ( + os.path.abspath(os.path.expanduser(__file__)))) + print(""installing tools into: %s (build, conda-tools, conda-cache)"" % ( + os.path.join(util.file.get_project_path(), 'tools'))) + sys.exit(0 if install_all_tools() else 1) +","Python" +"Viral","broadinstitute/viral-ngs","ncbi.py",".py","29308","620","#!/usr/bin/env python +'''This script contains a number of utilities for submitting our analyses +to NCBI's Genbank and SRA databases, as well as retreiving records from Genbank. +''' + +__author__ = ""tomkinsc@broadinstitute.org"" +__commands__ = [] + +import argparse +import logging +import collections +import shutil +import os +import os.path + +import Bio.SeqIO + +import util.cmd +import util.file +import util.version +import util.genbank +import tools.tbl2asn +import interhost +import util.feature_table + +log = logging.getLogger(__name__) + + +def fasta_chrlens(fasta): + out = collections.OrderedDict() + with open(fasta, 'rt') as inf: + for seq in Bio.SeqIO.parse(inf, 'fasta'): + out[seq.id] = len(seq) + return out + +def tbl_transfer_common(cmap, ref_tbl, out_tbl, alt_chrlens, oob_clip=False, ignore_ambig_feature_edge=False): + """""" + This function is the feature transfer machinery used by tbl_transfer() + and tbl_transfer_prealigned(). cmap is an instance of CoordMapper. + """""" + + ft = util.feature_table.FeatureTable(ref_tbl) + remapped_ft = util.feature_table.FeatureTable() + + # sequence identifier + refSeqID = [x for x in cmap.keys() if ft.refID in x][0] + altid = list(set(cmap.keys()) - set([refSeqID]))[0] + ft.refID = altid + + # feature with numeric coordinates (map them) + def remap_function(start, end, feature): + """""" + start/end are SeqPositions from util.feature_table + """""" + strand = None + if end.position >= start.position: + strand = '+' + start.position = cmap.mapChr(refSeqID, altid, start.position, -1)[1] + end.position = cmap.mapChr(refSeqID, altid, end.position, 1)[1] + else: + # negative strand feature + strand = '-' + start.position = cmap.mapChr(refSeqID, altid, start.position, 1)[1] + end.position = cmap.mapChr(refSeqID, altid, end.position, -1)[1] + + if ignore_ambig_feature_edge: + start.location_operator = None + end.location_operator = None + + if start.position and end.position: + # feature completely within bounds + return (start, end) + elif start.position == None and end.position == None: + # feature completely out of bounds + return (None, None) + else: + # feature overhangs end of sequence + if oob_clip: + if feature.type == ""CDS"": + feature.add_note(""sequencing did not capture complete CDS"") + if strand == '+': + # clip pos strand feature + if start.position == None: + # clip the beginning + if feature.type == 'CDS': + # for CDS features, clip in multiples of 3 + r = (end.position if end.position is not None else alt_chrlens[altid]) + start.position = '{}'.format((r % 3) + 1) + start.location_operator = '<' + else: + start.position = '1' + start.location_operator = '<' + if end.position == None: + # clip the end + end.position = '{}'.format(alt_chrlens[altid]) + end.location_operator = '>' + else: + # clip neg strand feature + if start.position == None: + # clip the beginning (right side) + r = alt_chrlens[altid] + if feature.type == 'CDS': + # for CDS features, clip in multiples of 3 + l = (end.position if end.position is not None else 1) # new left + r = r - ((r-l+1) % 3) # create new right in multiples of 3 from left + if (r-l) < 3: + # less than a codon remains, drop it + return (None, None) + start.position = '{}'.format(r) + start.location_operator = '<' + if end.position == None: + # clip the end (left side) + end.position = '1' + end.location_operator = '<' + else: + return (None, None) + return (start, end) + + ft.remap_locations(remap_function) + + with open(out_tbl, 'wt') as outf: + exclude_patterns = [ + # regexp, matched anywhere in line + r""protein_id"" + ] + for line in ft.lines(exclude_patterns=exclude_patterns): + outf.write(str(line) + '\n') + # extra newline at the end + outf.write('\n') + + +def tbl_transfer(ref_fasta, ref_tbl, alt_fasta, out_tbl, oob_clip=False, ignore_ambig_feature_edge=False): + ''' This function takes an NCBI TBL file describing features on a genome + (genes, etc) and transfers them to a new genome. + ''' + cmap = interhost.CoordMapper() + cmap.align_and_load_sequences([ref_fasta, alt_fasta]) + alt_chrlens = fasta_chrlens(alt_fasta) + + tbl_transfer_common(cmap, ref_tbl, out_tbl, alt_chrlens, oob_clip, ignore_ambig_feature_edge) + + +def parser_tbl_transfer(parser=argparse.ArgumentParser()): + parser.add_argument(""ref_fasta"", help=""Input sequence of reference genome"") + parser.add_argument(""ref_tbl"", help=""Input reference annotations (NCBI TBL format)"") + parser.add_argument(""alt_fasta"", help=""Input sequence of new genome"") + parser.add_argument(""out_tbl"", help=""Output file with transferred annotations"") + parser.add_argument('--oob_clip', + default=False, + action='store_true', + help='''Out of bounds feature behavior. + False: drop all features that are completely or partly out of bounds + True: drop all features completely out of bounds + but truncate any features that are partly out of bounds''') + parser.add_argument('--ignoreAmbigFeatureEdge', + dest=""ignore_ambig_feature_edge"", + default=False, + action='store_true', + help='''Ambiguous feature behavior. + False: features specified as ambiguous (""<####"" or "">####"") are mapped, + where possible + True: features specified as ambiguous (""<####"" or "">####"") are interpreted + as exact values''') + util.cmd.common_args(parser, (('tmp_dir', None), ('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, tbl_transfer, split_args=True) + return parser + + +__commands__.append(('tbl_transfer', parser_tbl_transfer)) + + +def tbl_transfer_prealigned(inputFasta, refFasta, refAnnotTblFiles, outputDir, oob_clip=False, ignore_ambig_feature_edge=False): + """""" + This breaks out the ref and alt sequences into separate fasta files, and then + creates unified files containing the reference sequence first and the alt second. Each of these unified files + is then passed as a cmap to tbl_transfer_common. + + This function expects to receive one fasta file containing a multialignment of a single segment/chromosome along + with the respective reference sequence for that segment/chromosome. It also expects a reference containing all + reference segments/chromosomes, so that the reference sequence can be identified in the input file by name. It + also expects a list of reference tbl files, where each file is named according to the ID present for its + corresponding sequence in the refFasta. For each non-reference sequence present in the inputFasta, two files are + written: a fasta containing the segment/chromosome for the same, along with its corresponding feature table as + created by tbl_transfer_common. + """""" + + ref_tbl = """" # must be identified in list of tables + ref_fasta_filename = """" + matchingRefSeq = None + + if not os.path.exists(outputDir): + os.makedirs(outputDir) + + # identify which of the sequences in the multialignment is the reference, + # matching by ID to one of the sequences in the refFasta + with util.file.open_or_gzopen(inputFasta, 'r') as inf: + for seq in Bio.SeqIO.parse(inf, 'fasta'): + with util.file.open_or_gzopen(refFasta, 'r') as reff: + for refSeq in Bio.SeqIO.parse(reff, 'fasta'): + if seq.id == refSeq.id: + ref_fasta_filename = util.file.mkstempfname('.fasta') + matchingRefSeq = seq + break + if matchingRefSeq: + break + + if ref_fasta_filename == """": + raise KeyError(""No reference was found in the input file %s"" % (inputFasta)) + + # identify the correct feature table source based on its filename, + # which should correspond to a unique component of the ref sequence ID (i.e. the genbank accession) + for tblFilename in refAnnotTblFiles: + # identify the correct feature table as the one that has an ID that is + # part of the ref seq ID + fileAccession = util.genbank.get_feature_table_id(tblFilename) + if fileAccession == matchingRefSeq.id.split('|')[0]: + ref_tbl = tblFilename + break + if ref_tbl == """": + raise KeyError(""No reference table was found for the reference %s"" % (matchingRefSeq.id)) + + # write out the desired sequences to separate fasta files + with util.file.open_or_gzopen(inputFasta, 'r') as inf: + for seq in Bio.SeqIO.parse(inf, 'fasta'): + # if we are looking at the reference sequence in the multialignment, + # continue to the next sequence + if seq.id == matchingRefSeq.id: + continue + + combined_fasta_filename = """" + + combined_fasta_filename = util.file.mkstempfname('.fasta') + # write ref and alt sequences to a combined fasta file, sourced from the + # alignment so gaps are present for the CoordMapper instance, cmap + with open(combined_fasta_filename, 'wt') as outf: + Bio.SeqIO.write([matchingRefSeq, seq], outf, ""fasta"") + + # create a filepath for the output table + out_tbl = os.path.join(outputDir, seq.id + "".tbl"") + + cmap = interhost.CoordMapper() + cmap.load_alignments([combined_fasta_filename]) + # sequences in the fasta file here should NOT include gaps + # since alt_chrlens is only used in the case where features would + # extend beyond the genome (for reporting >{seq.len}) + alt_chrlens = {}#fasta_chrlens(combined_fasta_filename) + alt_chrlens[seq.id] = len(seq.seq.ungap(""-"")) + alt_chrlens[matchingRefSeq.id] = len(matchingRefSeq.seq.ungap(""-"")) + + tbl_transfer_common(cmap, ref_tbl, out_tbl, alt_chrlens, oob_clip, ignore_ambig_feature_edge) + +def parser_tbl_transfer_prealigned(parser=argparse.ArgumentParser()): + parser.add_argument(""inputFasta"", + help=""""""FASTA file containing input sequences, + including pre-made alignments and reference sequence"""""") + parser.add_argument(""refFasta"", help=""FASTA file containing the reference genome"") + parser.add_argument(""refAnnotTblFiles"", + nargs='+', + help=""""""Name of the reference feature tables, + each of which should have a filename comrised of [refId].tbl + so they can be matched against the reference sequences"""""") + parser.add_argument(""outputDir"", help=""The output directory"") + parser.add_argument('--oob_clip', + default=False, + action='store_true', + help='''Out of bounds feature behavior. + False: drop all features that are completely or partly out of bounds + True: drop all features completely out of bounds + but truncate any features that are partly out of bounds''') + parser.add_argument('--ignoreAmbigFeatureEdge', + dest=""ignore_ambig_feature_edge"", + default=False, + action='store_true', + help='''Ambiguous feature behavior. + False: features specified as ambiguous (""<####"" or "">####"") are mapped, + where possible + True: features specified as ambiguous (""<####"" or "">####"") are interpreted + as exact values''') + util.cmd.common_args(parser, (('tmp_dir', None), ('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, tbl_transfer_prealigned, split_args=True) + return parser + + +__commands__.append(('tbl_transfer_prealigned', parser_tbl_transfer_prealigned)) + + +def fetch_fastas(accession_IDs, destinationDir, emailAddress, forceOverwrite, combinedFilePrefix, fileExt, + removeSeparateFiles, chunkSize, api_key=None): + ''' + This function downloads and saves the FASTA files + from the Genbank CoreNucleotide database given a given list of accession IDs. + ''' + util.genbank.fetch_fastas_from_genbank(accession_IDs, + destinationDir, + emailAddress, + forceOverwrite, + combinedFilePrefix, + removeSeparateFiles, + fileExt, + ""fasta"", + chunkSize=chunkSize, + api_key=api_key) + + +def fetch_feature_tables(accession_IDs, destinationDir, emailAddress, forceOverwrite, combinedFilePrefix, fileExt, + removeSeparateFiles, chunkSize, api_key=None): + ''' + This function downloads and saves + feature tables from the Genbank CoreNucleotide database given a given list of accession IDs. + ''' + util.genbank.fetch_feature_tables_from_genbank(accession_IDs, + destinationDir, + emailAddress, + forceOverwrite, + combinedFilePrefix, + removeSeparateFiles, + fileExt, + ""ft"", + chunkSize=chunkSize, + api_key=api_key) + + +def fetch_genbank_records(accession_IDs, destinationDir, emailAddress, forceOverwrite, combinedFilePrefix, fileExt, + removeSeparateFiles, chunkSize, api_key=None): + ''' + This function downloads and saves + full flat text records from Genbank CoreNucleotide database given a given list of accession IDs. + ''' + util.genbank.fetch_full_records_from_genbank(accession_IDs, + destinationDir, + emailAddress, + forceOverwrite, + combinedFilePrefix, + removeSeparateFiles, + fileExt, + ""gb"", + chunkSize=chunkSize, + api_key=api_key) + + +def parser_fetch_reference_common(parser=argparse.ArgumentParser()): + parser.add_argument(""emailAddress"", + help=""""""Your email address. To access Genbank databases, + NCBI requires you to specify your email address with each request. + In case of excessive usage of the E-utilities, NCBI will attempt to contact + a user at the email address provided before blocking access. This email address should + be registered with NCBI. To register an email address, simply send + an email to eutilities@ncbi.nlm.nih.gov including your email address and + the tool name (tool='https://github.com/broadinstitute/viral-ngs')."""""") + parser.add_argument(""--api_key"", + dest=""api_key"", + help=""""""Your NCBI API key. If an API key is not provided, NCBI + requests are limited to 3/second. If an API key is provided, + requests may be submitted at a rate up to 10/second. + For more information, see: https://ncbiinsights.ncbi.nlm.nih.gov/2017/11/02/new-api-keys-for-the-e-utilities/ + """""") + parser.add_argument(""destinationDir"", help=""Output directory with where .fasta and .tbl files will be saved"") + parser.add_argument(""accession_IDs"", nargs='+', help=""List of Genbank nuccore accession IDs"") + parser.add_argument('--forceOverwrite', + default=False, + action='store_true', + help='''Overwrite existing files, if present.''') + parser.add_argument('--combinedFilePrefix', + help='''The prefix of the file containing the combined concatenated + results returned by the list of accession IDs, in the order provided.''') + parser.add_argument('--fileExt', default=None, help='''The extension to use for the downloaded files''') + parser.add_argument('--removeSeparateFiles', + default=False, + action='store_true', + help='''If specified, remove the individual files and leave only the combined file.''') + parser.add_argument('--chunkSize', + default=1, + type=int, + help='''Causes files to be downloaded from GenBank in chunks of N accessions. + Each chunk will be its own combined file, separate from any combined + file created via --combinedFilePrefix (default: %(default)s). If chunkSize is + unspecified and >500 accessions are provided, chunkSize will be set to 500 to + adhere to the NCBI guidelines on information retreival.''') + return parser + + +def parser_fetch_fastas(parser): + parser = parser_fetch_reference_common(parser) + + util.cmd.common_args(parser, (('tmp_dir', None), ('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, fetch_fastas, split_args=True) + return parser + + +__commands__.append(('fetch_fastas', parser_fetch_fastas)) + + +def parser_fetch_feature_tables(parser): + parser = parser_fetch_reference_common(parser) + + util.cmd.common_args(parser, (('tmp_dir', None), ('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, fetch_feature_tables, split_args=True) + return parser + + +__commands__.append(('fetch_feature_tables', parser_fetch_feature_tables)) + + +def parser_fetch_genbank_records(parser): + parser = parser_fetch_reference_common(parser) + + util.cmd.common_args(parser, (('tmp_dir', None), ('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, fetch_genbank_records, split_args=True) + return parser + + +__commands__.append(('fetch_genbank_records', parser_fetch_genbank_records)) + + +def fasta2fsa(infname, outdir, biosample=None): + ''' copy a fasta file to a new directory and change its filename to end in .fsa + for NCBI's sake. ''' + outfname = os.path.basename(infname) + if outfname.endswith('.fasta'): + outfname = outfname[:-6] + elif outfname.endswith('.fa'): + outfname = outfname[:-3] + if not outfname.endswith('.fsa'): + outfname = outfname + '.fsa' + outfname = os.path.join(outdir, outfname) + with open(infname, 'rU') as inf: + with open(outfname, 'wt') as outf: + for line in inf: + if line.startswith('>') and biosample: + line = line.rstrip('\n\r') + line = '{} [biosample={}]\n'.format(line, biosample) + outf.write(line) + return outfname + + +def make_structured_comment_file(cmt_fname, name=None, seq_tech=None, coverage=None): + with open(cmt_fname, 'wt') as outf: + outf.write(""StructuredCommentPrefix\t##Genome-Assembly-Data-START##\n"") + # note: the v. format is required by NCBI, don't remove the "" v. "" + outf.write(""Assembly Method\tgithub.com/broadinstitute/viral-ngs v. {}\n"".format(util.version.get_version())) + if name: + outf.write(""Assembly Name\t{}\n"".format(name)) + if coverage: + coverage = str(coverage) + if not coverage.endswith('x') or coverage.endswith('X'): + coverage = coverage + 'x' + outf.write(""Genome Coverage\t{}\n"".format(coverage)) + if seq_tech: + outf.write(""Sequencing Technology\t{}\n"".format(seq_tech)) + outf.write(""StructuredCommentSuffix\t##Genome-Assembly-Data-END##\n"") + + +def prep_genbank_files(templateFile, fasta_files, annotDir, + master_source_table=None, comment=None, sequencing_tech=None, + coverage_table=None, biosample_map=None, organism=None, mol_type=None): + ''' Prepare genbank submission files. Requires .fasta and .tbl files as input, + as well as numerous other metadata files for the submission. Creates a + directory full of files (.sqn in particular) that can be sent to GenBank. + ''' + # get coverage map + coverage = {} + if coverage_table: + for row in util.file.read_tabfile_dict(coverage_table): + if row.get('sample') and row.get('aln2self_cov_median'): + coverage[row['sample']] = row['aln2self_cov_median'] + + # get biosample id map + biosample = {} + if biosample_map: + for row in util.file.read_tabfile_dict(biosample_map): + if row.get('sample') and row.get('BioSample'): + biosample[row['sample']] = row['BioSample'] + + # make output directory + util.file.mkdir_p(annotDir) + for fn in fasta_files: + if not fn.endswith('.fasta'): + raise Exception(""fasta files must end in .fasta"") + sample_base = os.path.basename(fn)[:-6] + + # for each segment/chromosome in the fasta file, + # create a separate new *.fsa file + with open(fn, ""r"") as inf: + asm_fasta = Bio.SeqIO.parse(inf, 'fasta') + for idx, seq_obj in enumerate(asm_fasta): + sample = sample_base + ""-"" + str(idx+1) + + # write the segment to a temp .fasta file + # in the same dir so fasta2fsa functions as expected + out_file_name = os.path.join(os.path.dirname(fn),sample+"".fasta"") + with open(out_file_name, ""w"") as out_chr_fasta: + Bio.SeqIO.write(seq_obj, out_chr_fasta, ""fasta"") + + # make .fsa files + fasta2fsa(out_file_name, annotDir, biosample=biosample.get(sample_base)) + # remove the .fasta file + os.unlink(out_file_name) + + # make .src files + if master_source_table: + out_src_fname = os.path.join(annotDir, sample + '.src') + with open(master_source_table, 'rt') as inf: + with open(out_src_fname, 'wt') as outf: + outf.write(inf.readline()) + for line in inf: + row = line.rstrip('\n').split('\t') + if row[0] == sample_base or row[0] == sample: + row[0] = sample + outf.write('\t'.join(row) + '\n') + + # make .cmt files + make_structured_comment_file(os.path.join(annotDir, sample + '.cmt'), + name=sample, + coverage=coverage.get(sample), + seq_tech=sequencing_tech) + + # run tbl2asn (relies on filesnames matching by prefix) + tbl2asn = tools.tbl2asn.Tbl2AsnTool() + source_quals = [] + if organism: + source_quals.append(('organism', organism)) + if mol_type: + source_quals.append(('mol_type', mol_type)) + tbl2asn.execute(templateFile, annotDir, comment=comment, + per_genome_comment=True, source_quals=source_quals) + + +def parser_prep_genbank_files(parser=argparse.ArgumentParser()): + parser.add_argument('templateFile', help='Submission template file (.sbt) including author and contact info') + parser.add_argument(""fasta_files"", nargs='+', help=""Input fasta files"") + parser.add_argument(""annotDir"", + help=""Output directory with genbank submission files (.tbl files must already be there)"") + parser.add_argument('--comment', default=None, help='comment field') + parser.add_argument('--sequencing_tech', default=None, help='sequencing technology (e.g. Illumina HiSeq 2500)') + parser.add_argument('--master_source_table', default=None, help='source modifier table') + parser.add_argument('--organism', default=None, help='species name') + parser.add_argument('--mol_type', default=None, help='molecule type') + parser.add_argument(""--biosample_map"", + help=""""""A file with two columns and a header: sample and BioSample. + This file may refer to samples that are not included in this submission."""""") + parser.add_argument('--coverage_table', + default=None, + help='''A genome coverage report file with a header row. The table must + have at least two columns named sample and aln2self_cov_median. All other + columns are ignored. Rows referring to samples not in this submission are + ignored.''') + util.cmd.common_args(parser, (('tmp_dir', None), ('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, prep_genbank_files, split_args=True) + return parser + + +__commands__.append(('prep_genbank_files', parser_prep_genbank_files)) + + +def prep_sra_table(lib_fname, biosampleFile, md5_fname, outFile): + ''' This is a very lazy hack that creates a basic table that can be + pasted into various columns of an SRA submission spreadsheet. It probably + doesn't work in all cases. + ''' + metadata = {} + + with util.file.open_or_gzopen(biosampleFile, 'rU') as inf: + header = inf.readline() + for line in inf: + row = line.rstrip('\n\r').split('\t') + metadata.setdefault(row[0], {}) + metadata[row[0]]['biosample_accession'] = row[1] + + with util.file.open_or_gzopen(md5_fname, 'rU') as inf: + for line in inf: + row = line.rstrip('\n\r').split() + s = os.path.basename(row[1]) + assert s.endswith('.cleaned.bam') + s = s[:-len('.cleaned.bam')] + metadata.setdefault(s, {}) + metadata[s]['filename'] = row[1] + metadata[s]['MD5_checksum'] = row[0] + + with open(outFile, 'wt') as outf: + header = ['biosample_accession', 'sample_name', 'library_ID', 'filename', 'MD5_checksum'] + outf.write('\t'.join(header) + '\n') + with open(lib_fname, 'rU') as inf: + for line in inf: + lib = line.rstrip('\n\r') + parts = lib.split('.') + assert len(parts) > 1 and parts[-1].startswith('l') + s = '.'.join(parts[:-1]) + metadata.setdefault(s, {}) + metadata[s]['library_ID'] = lib + metadata[s]['sample_name'] = s + outf.write('\t'.join(metadata[s].get(h, '') for h in header) + '\n') + + +def parser_prep_sra_table(parser=argparse.ArgumentParser()): + parser.add_argument('lib_fname', + help='A file that lists all of the library IDs that will be submitted in this batch') + parser.add_argument(""biosampleFile"", + help=""""""A file with two columns and a header: sample and BioSample. + This file may refer to samples that are not included in this submission."""""") + parser.add_argument(""md5_fname"", + help=""""""A file with two columns and no header. Two columns are MD5 checksum and filename. + Should contain an entry for every bam file being submitted in this batch. + This is typical output from ""md5sum *.cleaned.bam""."""""") + parser.add_argument(""outFile"", + help=""Output table that contains most of the variable columns needed for SRA submission."") + util.cmd.common_args(parser, (('loglevel', None), ('version', None))) + util.cmd.attach_main(parser, prep_sra_table, split_args=True) + return parser + + +__commands__.append(('prep_sra_table', parser_prep_sra_table)) + + +def full_parser(): + return util.cmd.make_parser(__commands__, __doc__) + + +if __name__ == '__main__': + util.cmd.main_argparse(__commands__, __doc__) +","Python" +"Viral","broadinstitute/viral-ngs","travis/activate-conda.sh",".sh","69","5","#!/bin/bash + +source activate tools/conda-tools/default +conda info -a +","Shell" +"Viral","broadinstitute/viral-ngs","travis/upgrade-docker.sh",".sh","222","9","#!/bin/bash + +set -e + +# upgrade docker (Travis's is old) +#sudo apt-get update || echo ""apt-get update failed, but we will ignore that"" +sudo apt-get -y -o Dpkg::Options::=""--force-confnew"" install docker-ce +docker --version +","Shell" +"Viral","broadinstitute/viral-ngs","travis/install-wdl.sh",".sh","1066","38","#!/bin/bash +set -e -o pipefail + +cached_fetch_jar_from_github () { + _github_org=$1 + _repo_name=$2 + _tool_name=$3 + _jar_version=$4 + _jar_fname=""$_tool_name-$_jar_version.jar"" + if [ ! -f $CACHE_DIR/$_jar_fname ]; then + echo ""Fetching $_jar_fname"" + wget --quiet https://github.com/$_github_org/$_repo_name/releases/download/$_jar_version/$_jar_fname + mv $_jar_fname $CACHE_DIR + else + echo ""Using cached $_jar_fname"" + fi + ln -s $CACHE_DIR/$_jar_fname $_tool_name.jar +} + +cached_fetch_jar_from_github broadinstitute cromwell womtool 49 +cached_fetch_jar_from_github broadinstitute cromwell cromwell 49 +cached_fetch_jar_from_github dnanexus dxWDL dxWDL v1.46.2 + +TGZ=dx-toolkit-v0.291.1-ubuntu-16.04-amd64.tar.gz +if [ ! -f $CACHE_DIR/$TGZ ]; then + echo ""Fetching $TGZ"" + wget --quiet https://dnanexus-sdk.s3.amazonaws.com/$TGZ + mv $TGZ $CACHE_DIR +else + echo ""Using cached $TGZ"" +fi +tar -xzpf $CACHE_DIR/$TGZ + +#echo ""Fetching quayctl"" +#wget --quiet https://github.com/coreos/quayctl/releases/download/v0.0.1/quayctl-linux-x64 +#mv quayctl-linux-x64 quayctl +#chmod a+x quayctl +","Shell" +"Viral","broadinstitute/viral-ngs","travis/install-tools.sh",".sh","1400","45","#!/bin/bash +set -e -o pipefail #exit on error or within pipes + +CONDA_CHANNEL_STRING=""--override-channels -c broad-viral -c conda-forge -c bioconda -c defaults"" +CONDA_ENV=""$(pwd)/tools/conda-tools/default"" + +# Set to conda's java +export JAVA_HOME=""$CONDA_ENV/jre"" + +echo ""Installing and validating bioinformatic tools"" +export CONDA_ENVS_PATH=tools/conda-cache:tools/conda-tools/default + +PYVER=`echo $TRAVIS_PYTHON_VERSION | cut -c 1` + +if [ ! -d $CONDA_ENV ]; then + conda create -y -m --quiet -p $CONDA_ENV python=""$TRAVIS_PYTHON_VERSION"" || exit $? +fi + +# commented out custom retry logic for now +# until we establish the built-in conda retry logic +# works as intended when we retry more than the default +# 3 times +# remote_max_retries is set in install-conda.sh +#set +e # disable exit on error +#RETRIES=0 +#RETRY_LIMIT=3 +#until #conda... +conda install -y --quiet \ + $CONDA_CHANNEL_STRING \ + --file requirements-conda.txt \ + --file requirements-conda-tests.txt \ + --file requirements-py$PYVER.txt \ + -p $CONDA_ENV #; do +# let RETRIES++ +# if [ ""$RETRIES"" -gt ""$RETRY_LIMIT"" ]; then +# break +# fi +# echo ""Conda install failed, likely due to transient server errors. Retrying (${RETRIES}/${RETRY_LIMIT})..."" +#done +#set -e #(re)enable exit on error + +conda clean --all --yes # clean temp/cache files to reduce Travis cache size + +conda list -p $CONDA_ENV +","Shell" +"Viral","broadinstitute/viral-ngs","travis/build-docs.sh",".sh","278","9","#!/bin/bash + +set -e -o pipefail + +if [[ ( -n $TRAVIS_PULL_REQUEST && $TRAVIS_PULL_REQUEST != ""false"" ) || $TRAVIS_BRANCH = ""master"" || -n ""$TRAVIS_TAG"" ]]; then + pushd docs + make html && echo ""Docs built successfully!"" || echo ""Docs did NOT build successfully."" + popd +fi","Shell" +"Viral","broadinstitute/viral-ngs","travis/tests-unit.sh",".sh","175","7","#!/bin/bash + +pytest --cov-append test/unit + +rc=$?; if [[ $rc != 0 ]]; then sleep 10; exit $rc; fi +# sleep to allow logs to be printed without truncation in the event of error +","Shell" +"Viral","broadinstitute/viral-ngs","travis/tests-cromwell.sh",".sh","1143","37","#!/bin/bash +set -e # intentionally allow for pipe failures below + +ln -s $GATK_PATH/GenomeAnalysisTK.jar . +mkdir -p workflows +cp *.jar pipes/WDL/workflows/*.wdl pipes/WDL/workflows/tasks/*.wdl workflows +cp -r test workflows/ +cd workflows + +for workflow in ../pipes/WDL/workflows/*.wdl; do + workflow_name=$(basename $workflow .wdl) + input_json=""test/input/WDL/test_inputs-$workflow_name-local.json"" + if [ -f $input_json ]; then + date + echo ""Executing $workflow_name using Cromwell on local instance"" + # the ""cat"" is to allow a pipe failure (otherwise it halts because of set -e) + java -jar cromwell.jar run \ + $workflow_name.wdl \ + -i $input_json | tee cromwell.out + if [ ${PIPESTATUS[0]} -gt 0 ]; then + echo ""error running $workflow_name"" + error_logs=$(grep stderr cromwell.out | perl -lape 's/.*\s(\S+)$/$1/g') + for log in $error_logs; do + echo ""contents of stderr ($log):"" + cat $log | sed ""s/^/[STDERR] /"" + echo ""contents of stdout ($log):"" + cat `dirname $log`/stdout | sed ""s/^/[STDOUT] /"" + done + sync; sleep 30; exit 1 + fi + fi +done + +cd - +date +echo ""note: there is no testing of output correctness yet..."" +","Shell" +"Viral","broadinstitute/viral-ngs","travis/list-docker-tags.sh",".sh","2368","55","#!/bin/bash +# +# This script lists all docker tags that should apply to this particular +# deploy, including short tags (like repo:latest) and long tags (like +# repo:full-version-number). Tags are emitted one per line. +# +# Important note: the last tag is considered the definitive, uniquely +# identifiable tag that should be used for all build steps that depend on +# the docker image (e.g. version-wdl-runtimes.sh). All others are aliases. + +set -e -o pipefail + +if [ -z ""$DOCKER_REPO_PROD"" -o -z ""$DOCKER_REPO_DEV"" -o -z ""$TRAVIS_BRANCH"" ]; then + echo ""This script requires the following environment variables set: DOCKER_REPO_PROD, DOCKER_REPO_DEV, and TRAVIS_BRANCH."" + exit 1 +fi + +# figure out appropriate tag names +if [ -n ""$TRAVIS_TAG"" ]; then + # this is an official tagged release + DOCKER_REPO=$DOCKER_REPO_PROD + DOCKER_SHORT_TAG=""latest"" + DOCKER_LONG_TAG=""$(echo $TRAVIS_TAG | sed 's/^v//')"" + PUSH_TO_MIRROR=true +elif [ -n ""$TRAVIS_PULL_REQUEST_BRANCH"" ]; then + # this is a PR build (TRAVIS_BRANCH=target of PR, TRAVIS_PULL_REQUEST_BRANCH=source of PR) + DOCKER_REPO=$DOCKER_REPO_DEV + BRANCH_NAME=""$TRAVIS_PULL_REQUEST_BRANCH"" + DOCKER_SHORT_TAG=""$BRANCH_NAME-pull_request"" + DOCKER_LONG_TAG=""$(git describe --tags --always | sed s/^v//)-$(echo $DOCKER_SHORT_TAG)"" + #DOCKER_LONG_TAG=""$(git describe --tags --always | perl -lape 's/^v?(\S+)-(\d+)-g(\S+)/$1-beta$2-g$3/')-$(echo $BRANCH_NAME | sed 's/-/_/g')"" +elif [[ ""$TRAVIS_BRANCH"" == ""master"" ]]; then + # this is a master branch commit (e.g. merged pull request) + DOCKER_REPO=$DOCKER_REPO_PROD + DOCKER_SHORT_TAG=""latest"" + DOCKER_LONG_TAG=""$(git describe --tags --always | perl -lape 's/^v?(\S+)-(\d+)-g\S+/$1-rc$2/')"" + PUSH_TO_MIRROR=true +else + # this is an normal non-master branch commit + DOCKER_REPO=$DOCKER_REPO_DEV + BRANCH_NAME=""$TRAVIS_BRANCH"" + DOCKER_SHORT_TAG=""$BRANCH_NAME"" + DOCKER_LONG_TAG=""$(git describe --tags --always | sed s/^v//)-$(echo $DOCKER_SHORT_TAG)"" + #DOCKER_LONG_TAG=""$(git describe --tags --always | perl -lape 's/^v?(\S+)-(\d+)-g(\S+)/$1-dev$2-g$3/')-$(echo $DOCKER_SHORT_TAG)"" +fi + +if [ -n ""$DOCKER_REPO_PROD_MIRROR"" -a -n ""$PUSH_TO_MIRROR"" ]; then + # if this should be sent to prod, also echo the mirror registry tags + echo $DOCKER_REPO_PROD_MIRROR:$DOCKER_SHORT_TAG + echo $DOCKER_REPO_PROD_MIRROR:$DOCKER_LONG_TAG +fi + +echo $DOCKER_REPO:$DOCKER_SHORT_TAG +echo $DOCKER_REPO:$DOCKER_LONG_TAG +","Shell" +"Viral","broadinstitute/viral-ngs","travis/install-gatk.sh",".sh","1062","34","#!/bin/bash +set -e -o pipefail + +GATK_VERSION=3.8 +GATK_BUILD=1-0-gf15c1c3ef +GATK_URL=""https://storage.googleapis.com/gatk-software/package-archive/gatk/GenomeAnalysisTK-${GATK_VERSION}-${GATK_BUILD}.tar.bz2"" +GATK_TAR=GenomeAnalysisTK-${GATK_VERSION}.tar +GATK_JAR=${CACHE_DIR}/GenomeAnalysisTK.jar +GATK_JAR_MD5=186aee868bb7cffc18007966ace8d053 + +if [[ ""$TRAVIS_OS_NAME"" == ""osx"" ]]; then + MD5_PROG=md5 +else + MD5_PROG=md5sum +fi + +if [ -f ""${GATK_JAR}"" ]; then + echo ""GATK already exists in cache, skipping download"" + +else + echo ""Fetching GATK bundle for Travis"" + pwd + wget --quiet ""${GATK_URL}"" -O ${GATK_TAR} + + # It appears that GATK tarball is produced on OS X leading to warnings + TAR_OPTS= + [[ ""$TRAVIS_OS_NAME"" = ""linux"" ]] && TAR_OPTS=""--warning=no-unknown-keyword"" + tar ""$TAR_OPTS"" -xvpf ${GATK_TAR} -C ""$CACHE_DIR"" + mv ${CACHE_DIR}/GenomeAnalysisTK-${GATK_VERSION}-${GATK_BUILD}/GenomeAnalysisTK.jar ${GATK_JAR} + rmdir ${CACHE_DIR}/GenomeAnalysisTK-${GATK_VERSION}-${GATK_BUILD} +fi + +${MD5_PROG} --strict -c <(echo ${GATK_JAR_MD5} ${GATK_JAR}) +","Shell" +"Viral","broadinstitute/viral-ngs","travis/deploy-docker.sh",".sh","818","25","#!/bin/bash +set -e -o pipefail + +if [[ -n ""$DOCKER_PASS"" && -n ""$DOCKER_USER"" && -n ""$DOCKER_REGISTRY"" ]]; then + echo ""Deploying docker image to $DOCKER_REGISTRY"" + + # log in to Docker registry + echo ""$DOCKER_PASS"" | docker login --password-stdin --username ""$DOCKER_USER"" ""$DOCKER_REGISTRY"" + + if [ -n ""$DOCKER_USER_MIRROR"" -a -n ""$DOCKER_PASS_MIRROR"" -a -n ""$DOCKER_REGISTRY_MIRROR"" ]; then + echo ""$DOCKER_PASS_MIRROR"" | docker login --password-stdin --username ""$DOCKER_USER_MIRROR"" ""$DOCKER_REGISTRY_MIRROR"" + fi + + # tag and deploy + for TAG in `travis/list-docker-tags.sh`; do + echo ""Pushing docker image to docker registry as $TAG"" + docker tag local/viral-ngs:build $TAG + docker push $TAG + done + +else + echo ""Skipping Docker image deploy unless DOCKER_REGISTRY, DOCKER_USER and DOCKER_PASS variables are set."" + +fi +","Shell" +"Viral","broadinstitute/viral-ngs","travis/version-wdl-runtimes.sh",".sh","619","18","#!/bin/bash +set -e -o pipefail + +NEW_TAG=`travis/list-docker-tags.sh | tail -1` +OLD_TAG=""quay.io/broadinstitute/viral-ngs"" + +echo Replacing $OLD_TAG with $NEW_TAG in all task WDL files +sed -i -- ""s|$OLD_TAG|$NEW_TAG|g"" pipes/WDL/workflows/tasks/*.wdl + +CURRENT_VERSION=`echo ""$NEW_TAG"" | cut -d\: -f2` +VERSION_PLACEHOLDER=""viral-ngs_version_unknown"" + +echo Replacing $VERSION_PLACEHOLDER with $CURRENT_VERSION in all task WDL files +sed -i -- ""s|$VERSION_PLACEHOLDER|$CURRENT_VERSION|g"" pipes/WDL/workflows/tasks/*.wdl + +#echo ""DEBUG: here are the modified runtime lines:"" +#grep -n ""$NEW_TAG"" pipes/WDL/workflows/tasks/*.wdl +","Shell" +"Viral","broadinstitute/viral-ngs","travis/install-pip-docs.sh",".sh","120","5","#!/bin/bash + +echo ""pip installing test-related packages (Sphinx, etc.)"" +pip install --quiet -r requirements-py-docs.txt +","Shell" +"Viral","broadinstitute/viral-ngs","travis/trigger-travis.sh",".sh","6497","181","#!/bin/sh -f + +# Derived from: https://github.com/mernst/plume-lib/blob/master/bin/trigger-travis.sh +# Which is originally under an MIT license + +# Trigger a new Travis-CI job. +# Ordinarily, a new Travis job is triggered when a commit is pushed to a +# GitHub repository. The trigger-travis.sh script provides a programmatic +# way to trigger a new Travis job. + +# Usage: +# trigger-travis.sh [--pro] [--branch BRANCH] GITHUBID GITHUBPROJECT TRAVIS_ACCESS_TOKEN [MESSAGE] +# For example: +# trigger-travis.sh typetools checker-framework `cat ~/private/.travis-access-token` ""Trigger for testing"" +# +# where --pro means to use travis-ci.com instead of travis-ci.com, and +# where TRAVIS_ACCESS_TOKEN is, or ~/private/.travis-access-token contains, +# the Travis access token. +# +# Your Travis access token is the text after ""Your access token is "" in +# the ouput of these commands: +# travis login && travis token +# (If the travis program isn't installed, do so with one of these two commands: +# gem install travis +# sudo apt-get install ruby-dev && sudo gem install travis +# Don't do ""sudo apt-get install travis"" which installs a trajectory analyzer.) +# Note that the Travis access token output by `travis token` differs from the +# Travis token available at https://travis-ci.com/profile . +# If you store it in in a file, make sure the file is not readable by others, +# for example by running: chmod og-rwx ~/private + +# To use this script to trigger a dependent build in Travis, do two things: +# +# 1. Set an environment variable TRAVIS_ACCESS_TOKEN by navigating to +# https://travis-ci.com/MYGITHUBID/MYGITHUBPROJECT/settings +# The TRAVIS_ACCESS_TOKEN environment variable will be set when Travis runs +# the job, but won't be visible to anyone browsing https://travis-ci.com/. +# +# 2. Add the following before_install and after_script block to your +# .travis.yml file, where you replace OTHERGITHUB* by a specific downstream +# project, but you leave $TRAVIS_ACCESS_TOKEN as literal text: +# +# before_install: +# - npm install --save-dev travis-after-all +# +# after_script: +# - | +# declare exitCode; +# $(npm bin)/travis-after-all +# exitCode=$? +# +# if [ ""$exitCode"" -eq 0 ]; then +# if [[ ($TRAVIS_BRANCH == master) && +# ($TRAVIS_PULL_REQUEST == false) ]] ; then +# curl -LO https://raw.github.com/mernst/plume-lib/master/bin/trigger-travis.sh +# sh trigger-travis.sh OTHERGITHUBID OTHERGITHUBPROJECT $TRAVIS_ACCESS_TOKEN +# fi +# fi +# +# Your .travis.yml file must not use `language: generic` because then +# npm won't be installed. +# +# Note that Travis does not fail a job if an after_success command fails. +# If you misspell a GitHub ID or project name, then this script will fail, +# but Travis won't inform you of the mistake. So, check the end of the +# Travis build log the first time that a build succeeds. + +# Here is an explanation of the conditional in the after_success block: +# +# 1. Downstream projects are triggered only for builds of the mainline, not +# branches or pull requests. The reason is that typically a downstream +# project clones and uses the mainline. You could enhance this script to +# accept pass an environment variable for the upstream project; the +# downstream project's build script would need to read and use that +# environment variable. If you make this enhancement, feel free to submit +# a pull request so that others can benefit from it. +# +# 2. Downstream projects are triggered only if the Travis job number +# contains no ""."" or ends with "".1"". In other words, if your .travis.yml +# defines a build matrix +# (https://docs.travis-ci.com/user/customizing-the-build/#Build-Matrix) +# that runs the same job using different configurations, then the +# ""after_success:"" block is run only for the first configuration. +# By default an after_success: block is run for every build in the matrix, +# but you really want it to run once if all the builds in the matrix +# succeed. Running if the first job succeeds is simple and it is usually +# adequate, even though the downstream job is triggered even if some job +# other than the first one fails. + +# TODO: enable the script to clone a particular branch rather than master. +# This would require a way to know the relationships among branches in +# different GitHub projects. It's easier to run all your tests within a +# single Travis job, if they fit within Travis's 50-minute time limit. + +# An alternative to this script would be to install the Travis command-line +# client and then run: +# travis restart -r OTHERGITHUBID/OTHERGITHUBPROJECT +# That is undesirable because it restarts an old job, destroying its history, +# rather than starting a new job which is our goal. + +# Parts of this script were originally taken from +# http://docs.travis-ci.com/user/triggering-builds/ + +# TODO: take a --branch command-line argument. + +if [ ""$#"" -lt 3 ] || [ ""$#"" -ge 7 ]; then + echo ""Wrong number of arguments $# to trigger-travis.sh; run like:"" + echo "" trigger-travis.sh [--pro] [--script 'script value...'] [--branch BRANCH] GITHUBID GITHUBPROJECT TRAVIS_ACCESS_TOKEN [MESSAGE]"" >&2 + exit 1 +fi + +if [ ""$1"" = ""--pro"" ] ; then + TRAVIS_URL=travis-ci.com + shift +else + TRAVIS_URL=travis-ci.com +fi + +if [ ""$1"" = ""--branch"" ] ; then + shift + BRANCH=""$1"" + shift +else + BRANCH=master +fi + +if [ ""$1"" = ""--script"" ] ; then + shift + SCRIPT_VAL=""$1"" + shift +else + SCRIPT_VAL="""" +fi + +USER=$1 +REPO=$2 +TOKEN=$3 +if [ $# -eq 4 ] ; then + MESSAGE="",\""message\"": \""$4\"""" +elif [ -n ""$TRAVIS_REPO_SLUG"" ] ; then + MESSAGE="",\""message\"": \""Triggered by upstream build of $TRAVIS_REPO_SLUG commit ""`git rev-parse --short HEAD`""\"""" +else + MESSAGE="""" +fi + +if [ -n ""$SCRIPT_VAL"" ]; then + SCRIPT_BODY=""\""script\"": \""$SCRIPT_VAL\"""" +else + SCRIPT_BODY="""" +fi + +body=""{ +\""request\"": { + \""branch\"":\""$BRANCH\""$MESSAGE, + + \""config\"":{ + $SCRIPT_BODY +}}}"" + +echo ""Travis API request body:\n$body"" + +#exit 0 + +echo ""Making request to start tests in other repository..."" + +# It does not work to put / in place of %2F in the URL below. +curl -S -X POST \ + -H ""Content-Type: application/json"" \ + -H ""Accept: application/json"" \ + -H ""Travis-API-Version: 3"" \ + -H ""Authorization: token ${TOKEN}"" \ + -d ""$body"" \ + https://api.${TRAVIS_URL}/repo/${USER}%2F${REPO}/requests \ + | tee /tmp/travis-request-output.$$.txt + +if grep -q '""@type"": ""error""' /tmp/travis-request-output.$$.txt; then + exit 1 +fi +if grep -q 'access denied' /tmp/travis-request-output.$$.txt; then + exit 1 +fi","Shell" +"Viral","broadinstitute/viral-ngs","travis/tests-snakemake.sh",".sh","190","7","#!/bin/bash + +pytest --cov-append test/pipelines/snakemake + +rc=$?; if [[ $rc != 0 ]]; then sleep 10; exit $rc; fi +# sleep to allow logs to be printed without truncation in the event of error +","Shell" +"Viral","broadinstitute/viral-ngs","travis/build-dx.sh",".sh","2603","76","#!/bin/bash +set -e -o pipefail + +if [ -z ""$DX_API_TOKEN"" ]; then + echo ""ERROR: DX_API_TOKEN is not set, this is needed to build dxWDL workflows."" + exit 1 +fi + +# obtain version tag +VERSION=`travis/list-docker-tags.sh | tail -1 | sed 's/:/\//'` + +# log in to DNAnexus +source dx-toolkit/environment +dx login --token ""$DX_API_TOKEN"" --noprojects +dx select $DX_PROJECT + +# compile with dxWDL +COMPILE_SUCCESS=""dxWDL-compile_all-success.txt"" +touch $COMPILE_SUCCESS +for workflow in pipes/WDL/workflows/*.wdl; do + if [ -n ""$(grep DX_SKIP_WORKFLOW $workflow)"" ]; then + echo ""Skipping $workflow due to the presence of the DX_SKIP_WORKFLOW tag"" + else + workflow_name=`basename $workflow .wdl` + echo ""Building $workflow to DNAnexus: /build/$VERSION/$workflow_name"" + + test_input_json_wdl=""test/input/WDL/test_inputs-$workflow_name-dnanexus.json"" + if [ -f ""$test_input_json_wdl"" ]; then + CMD_INPUT=""-inputs $test_input_json_wdl"" + # blank this out until we're sure we want to test it this way... + CMD_INPUT="""" + else + CMD_INPUT="""" + fi + + defaults_json=""pipes/WDL/dx-defaults-$workflow_name.json"" + if [ -f ""$defaults_json"" ]; then + CMD_DEFAULTS=""-defaults $defaults_json"" + else + CMD_DEFAULTS="""" + fi + + extras_json=""pipes/WDL/dx-extras.json"" + CMD_DEFAULTS+="" -extras $extras_json"" + + dx_id=$(java -jar dxWDL.jar compile \ + $workflow $CMD_INPUT $CMD_DEFAULTS -f -verbose \ + -imports pipes/WDL/workflows/tasks/ \ + -project $DX_PROJECT \ + -destination /build/$VERSION/$workflow_name) + if [ $? -eq 0 ]; then + echo ""Succeeded: $workflow_name = $dx_id"" + else + echo ""Failed to build: $workflow_name"" + exit $? + fi + echo -e ""$workflow_name\t$dx_id"" >> $COMPILE_SUCCESS + fi +done + +# Special case: build demux_launcher (a native DNAnexus applet), embedding the +# demux_plus workflow ID as a default input +demux_plus_workflow_id=$(grep demux_plus $COMPILE_SUCCESS | cut -f 2) +pushd pipes/WDL/dx-launcher +cp consolidate_run_tarballs.yml dxapp.yml +dx_id=$(./dx-yml-build -a --destination /build/$VERSION/ | jq -r "".id"") +echo -e ""consolidate_run_tarballs\t$dx_id"" >> $COMPILE_SUCCESS +sed ""s/DEFAULT_DEMUX_WORKFLOW_ID/$demux_plus_workflow_id/"" demux_launcher.yml \ + | sed ""s/DEFAULT_CONSOLIDATE_RUN_TARBALLS_APPLET_ID/$dx_id/"" > dxapp.yml +dx_id=$(./dx-yml-build -a --destination /build/$VERSION/ | jq -r "".id"") +popd +echo -e ""demux_launcher\t$dx_id"" >> $COMPILE_SUCCESS + +# the presence of this file in the project denotes successful build +dx upload --brief --no-progress --destination /build/$VERSION/ $COMPILE_SUCCESS +","Shell" +"Viral","broadinstitute/viral-ngs","travis/tests-dx.sh",".sh","3134","89","#!/bin/bash +set -e -o pipefail + +# obtain version tag +VERSION=`travis/list-docker-tags.sh | tail -1 | sed 's/:/\//'` + +# log in to DNAnexus +source dx-toolkit/environment +if [ -n ""$DX_API_TOKEN"" ]; then + dx login --token ""$DX_API_TOKEN"" --noprojects + dx select $DX_PROJECT +fi + +COMPILE_SUCCESS=""dxWDL-compile_all-success.txt"" +if [ ! -f $COMPILE_SUCCESS ]; then + dx download --no-progress /build/$VERSION/$COMPILE_SUCCESS +fi + +function dx_run_timeout_args { + # + # Construct command-line arguments for 'dx run' command + # to set a timeout on the applets it runs + # + + local dx_workflow_id=""$1"" + local dx_extra_applet_id=""$2"" + + local dx_workflow_applet_ids=$(dx describe $dx_workflow_id | grep applet- | awk '{print $2;}') + local dx_applet_ids=""$dx_workflow_applet_ids $dx_extra_applet_id"" + local comma="""" + local timeout_args=""{\""timeoutPolicyByExecutable\"":{"" + for dx_applet_id in $dx_applet_ids + do + timeout_args=""${timeout_args}${comma}\""$dx_applet_id\"":{\""*\"":{\""hours\"":3}}"" + comma="","" + done + timeout_args=""$timeout_args}}"" + echo $timeout_args +} + +TEST_LAUNCH_ALL=""dxWDL-execute_all-launched.txt"" +touch $TEST_LAUNCH_ALL +for workflow in pipes/WDL/workflows/*.wdl; do + echo ""testing $workflow..."" + if [ -n ""$(grep DX_SKIP_WORKFLOW $workflow)"" ]; then + echo ""Skipping $workflow due to the presence of the DX_SKIP_WORKFLOW tag"" + else + workflow_name=`basename $workflow .wdl` + input_json=""test/input/WDL/test_inputs-$workflow_name-dnanexus.dx.json"" + if [ -f $input_json ]; then + # launch simple test cases on DNAnexus CI project + dx_workflow_id=$(grep -w ""^$workflow_name"" $COMPILE_SUCCESS | cut -f 2) + timeout_args=$(dx_run_timeout_args $dx_workflow_id) + dx_job_id=$(dx run \ + $dx_workflow_id -y --brief \ + -f $input_json \ + --name ""$VERSION $workflow_name"" \ + --destination /tests/$VERSION/$workflow_name \ + --extra-args $timeout_args \ + ) + if [ $? -eq 0 ]; then + echo ""Launched $workflow_name as $dx_job_id"" + else + echo ""Failed to build: $workflow_name"" + fi + echo ""Launched $workflow_name as $dx_job_id"" + echo -e ""$workflow_name\t$dx_workflow_id\t$dx_job_id"" >> $TEST_LAUNCH_ALL + fi + fi +done + +# Special case: run test for the demux_launcher native applet (which invokes +# the demux_plus WDL workflow) +demux_launcher_id=$(grep demux_launcher $COMPILE_SUCCESS | cut -f 2) +demux_plus_workflow_id=$(grep demux_plus $COMPILE_SUCCESS | cut -f 2) +timeout_args=$(dx_run_timeout_args $demux_plus_workflow_id $demux_launcher_id) +dx_job_id=$(dx run \ + $demux_launcher_id -y --brief \ + -i upload_sentinel_record=record-Bv8qkgQ0jy198GK0QVz2PV8Y \ + --name ""$VERSION demux_launcher"" \ + -i folder=/tests/$VERSION/demux_launcher \ + --extra-args $timeout_args \ + ) +echo ""Launched demux_launcher as $dx_job_id"" +echo -e ""demux_launcher\t$demux_launcher_id\t$dx_job_id"" >> $TEST_LAUNCH_ALL + +# the presence of this file in the project denotes all tests launched +dx upload --brief --no-progress --destination /build/$VERSION/ $TEST_LAUNCH_ALL +","Shell" +"Viral","broadinstitute/viral-ngs","travis/tests-docker.sh",".sh","616","23","#!/bin/bash +set -eu -o pipefail + +# +# Script: tests-docker.sh +# +# Run tests on the docker image +# + +# Tests of util.misc.available_cpu_count() +for TEST_CPUS in $(seq 1 2) +do + REPORTED_CPUS=$(docker run --cpus $TEST_CPUS local/viral-ngs:build /bin/bash -c \ + 'cd source && python -c ""import util.misc; print(util.misc.available_cpu_count())""') + if [[ $REPORTED_CPUS -ne $TEST_CPUS ]] + then + echo ""Problem with util.misc.available_cpu_count: reports $REPORTED_CPUS instead of $TEST_CPUS"" + exit 1 + else + echo ""util.misc.available_cpu_count correctly reported $REPORTED_CPUS cpus."" + fi +done +","Shell" +"Viral","broadinstitute/viral-ngs","travis/before_install.sh",".sh","752","21","#!/bin/bash +# This script primarily enables or disables the Travis dependency +# cache depending on whether we're on the master branch or not. +set -e -o pipefail + +# Only sometimes cache the tools/build directory +if [ -z ""$TRAVIS_TAG"" ]; then + echo ""Travis docker caches allowed for branch $TRAVIS_BRANCH"" + rm -rf tools/build + mkdir -p $CACHE_DIR/tools_build $CACHE_DIR/conda-tools $CACHE_DIR/conda-cache + # ln -s $CACHE_DIR/tools_build tools/build + #ln -s $CACHE_DIR/conda-cache tools/conda-cache + ln -s $CACHE_DIR/conda-tools tools + + # Report how big things are + echo ""Docker cache space usage:"" + du -hs $MINICONDA_DIR $PIP_DIR $CACHE_DIR/* +else + echo ""Travis docker cache disabled for tools/build on tag: $TRAVIS_TAG"" +fi +","Shell" +"Viral","broadinstitute/viral-ngs","travis/install-pip.sh",".sh","454","13","#!/bin/bash +set -e + +CONDA_CHANNEL_STRING=""--override-channels -c broad-viral -c conda-forge -c bioconda -c defaults"" +PYVER=`echo $TRAVIS_PYTHON_VERSION | cut -c 1` +if [ ""$PYVER"" = ""3"" ]; then + echo ""pip installing snakemake packages (py3 only)"" + #conda install -q -y $CONDA_CHANNEL_STRING -p tools/conda-tools/default --file requirements-py3.txt python=""$TRAVIS_PYTHON_VERSION"" + pip install --quiet -r requirements-py3.txt +fi + +#python --version +","Shell" +"Viral","broadinstitute/viral-ngs","travis/tests-long.sh",".sh","182","7","#!/bin/bash + +pytest --cov-append test/integration + +rc=$?; if [[ $rc != 0 ]]; then sleep 10; exit $rc; fi +# sleep to allow logs to be printed without truncation in the event of error +","Shell" +"Viral","broadinstitute/viral-ngs","travis/install-conda-build.sh",".sh","76","4","#!/bin/bash + +conda install -q -y conda-build==3.18.9 anaconda-client jinja2 +","Shell" +"Viral","broadinstitute/viral-ngs","travis/install-conda.sh",".sh","2390","56","#!/bin/bash +set -e + +# the miniconda directory may exist if it has been restored from cache +if [ -d ""$MINICONDA_DIR"" ] && [ -e ""$MINICONDA_DIR/bin/conda"" ]; then + echo ""Miniconda install already present from cache: $MINICONDA_DIR"" + if [[ ""$TRAVIS_OS_NAME"" == ""osx"" ]]; then + # on OSX we need to rely on the conda Python rather than the Travis-supplied system Python + # so conda has a higher precedence + export PATH=""$MINICONDA_DIR/bin:$PATH"" + else + export PATH=""$MINICONDA_DIR/bin:$PATH"" + fi + hash -r +else # if it does not exist, we need to install miniconda + rm -rf ""$MINICONDA_DIR"" # remove the directory in case we have an empty cached directory + + if [[ ""$TRAVIS_PYTHON_VERSION"" == 2* ]]; then + if [[ ""$TRAVIS_OS_NAME"" == ""osx"" ]]; then + curl -S https://repo.continuum.io/miniconda/Miniconda2-latest-MacOSX-x86_64.sh > miniconda.sh; + else + curl -S https://repo.continuum.io/miniconda/Miniconda2-latest-Linux-x86_64.sh > miniconda.sh; + fi + else + if [[ ""$TRAVIS_OS_NAME"" == ""osx"" ]]; then + curl -S https://repo.continuum.io/miniconda/Miniconda3-latest-MacOSX-x86_64.sh > miniconda.sh; + else + curl -S https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh > miniconda.sh; + fi + fi + + bash miniconda.sh -b -p ""$MINICONDA_DIR"" + chown -R ""$USER"" ""$MINICONDA_DIR"" + if [[ ""$TRAVIS_OS_NAME"" == ""osx"" ]]; then + # on OSX we need to rely on the conda Python rather than the Travis-supplied system Python + # so conda has a higher precedence + export PATH=""$MINICONDA_DIR/bin:$PATH"" + else + export PATH=""$MINICONDA_DIR/bin:$PATH"" + fi + hash -r + conda install -y conda==4.7.10 # specify ""conda update -c conda-canary conda"" for pre-release conda + conda config --set always_yes yes --set changeps1 no --set remote_max_retries 6 #--set channel_priority strict + conda config --add channels defaults + conda config --add channels bioconda + conda config --add channels conda-forge + conda config --add channels broad-viral + conda config --show-sources # print channels + # Use recommendations from https://github.com/bioconda/bioconda-recipes/issues/13774 + #conda update --quiet -y conda + # conda config --set channel_priority strict +fi + +# update certs +conda info -a # for debugging +","Shell" +"Viral","broadinstitute/viral-ngs","travis/build-conda.sh",".sh","2658","56","#!/bin/bash +# This script performs various packing and deployment operations. + +set -e -o pipefail + +# === Build conda package +CONDA_CHANNEL_STRING=""--override-channels -c broad-viral -c conda-forge -c bioconda -c defaults"" +CONDA_PACKAGE_OUTDIR=packaging/conda-packages +echo ""Rendering and building conda package..."" +echo ""Python binary: $(which python)"" +echo ""Python version: $(python --version 2>&1)"" +# Render recipe from template and dependency files, setting the tag as the current version +# if this is a tag build+upload, otherwise just test building + +# if the ANACONDA_TOKEN is defined (not on an external branch) +if [ -z ""$ANACONDA_TOKEN"" ]; then + echo ""ANACONDA_TOKEN is not defined. Conda package upload is only supported for branches on the original repository."" + exit 1 +fi + +conda config --set anaconda_upload no +if [ -n ""$TRAVIS_TAG"" ]; then + # This is an official release, upload it + conda config --set anaconda_upload yes + + # render and build the conda package + echo ""Rendering recipe..."" + python packaging/conda-recipe/render-recipe.py ""$TRAVIS_TAG"" --run-reqs requirements-conda.txt --py3-run-reqs requirements-py3.txt --test-reqs requirements-conda-tests.txt # --build-reqs requirements-conda.txt + echo ""Building recipe..."" + CONDA_PERL=5.26 conda build $CONDA_CHANNEL_STRING --python ""$TRAVIS_PYTHON_VERSION"" --token ""$ANACONDA_TOKEN"" packaging/conda-recipe/viral-ngs + +else + # This is a development build + conda config --set anaconda_upload no + + # make a directory to hold the built conda package + mkdir -p CONDA_PACKAGE_OUTDIR + + if [ -z ""$TRAVIS_PULL_REQUEST_BRANCH"" ]; then + # if a commit is being pushed, TRAVIS_PULL_REQUEST_BRANCH is empty + BRANCH_NAME=""$TRAVIS_BRANCH"" + else + BRANCH_NAME=""$TRAVIS_PULL_REQUEST_BRANCH"" + fi + + SANITIZED_BRANCH_NAME=""$(echo $BRANCH_NAME | sed 's/-/_/g')"" + CONDA_PKG_VERSION=""$(git describe --tags --always | sed 's/^v//' | perl -lape 's/(\d+.\d+.\d+)-?/$1+dev/' | sed 's/-/_/g')_$(echo $SANITIZED_BRANCH_NAME)"" + echo ""Building conda package version $CONDA_PKG_VERSION"" + + # render and build the conda package + echo ""Rendering recipe..."" + python packaging/conda-recipe/render-recipe.py ""$CONDA_PKG_VERSION"" --package-name ""viral-ngs-dev"" --download-filename ""$TRAVIS_COMMIT"" --run-reqs requirements-conda.txt --py3-run-reqs requirements-py3.txt --test-reqs requirements-conda-tests.txt --build-reqs requirements-conda.txt + echo ""Building recipe..."" + CONDA_PERL=5.26 conda build $CONDA_CHANNEL_STRING --python ""$TRAVIS_PYTHON_VERSION"" --output-folder ""$CONDA_PACKAGE_OUTDIR"" packaging/conda-recipe/viral-ngs +fi +","Shell" +"Viral","broadinstitute/viral-ngs","travis/validate-wdl.sh",".sh","2031","63","#!/bin/bash +set -e -o pipefail + +starting_dir=""$(pwd)"" +test_dir=""wdl_validate_test"" + +function cleanup(){ + echo ""Cleaning up from WDL womtool; exit code: $?"" + cd ""$starting_dir"" + if [ -d ""$test_dir"" ]; then + rm -r ""$test_dir"" + fi +} +trap cleanup EXIT SIGINT SIGQUIT SIGTERM + +# ===== [ for WDL 1.0] ===== +# validate each imported library of tasks on its own +# for tasks in pipes/WDL/workflows/tasks/*.wdl; do +# echo ""validating tasks $tasks"" +# if $(hash -r womtool &> /dev/null); then +# womtool validate $tasks +# else +# java -jar womtool.jar validate $tasks +# fi +# done +# ========================== + +mkdir ""$test_dir"" +cd ""$test_dir"" +cp ../pipes/WDL/workflows/tasks/*.wdl ../pipes/WDL/workflows/*.wdl . + +# ===== [ for WDL draft-2 under womtool 32 ] ===== +# only necessary for draft-2 WDL under womtool >30, with 1.0 task-only WDL files should validate +# the task validation block above can be uncommented and replace this with WDL 1.0 +for workflow in ../pipes/WDL/workflows/tasks/*.wdl; do + workflow=`basename $workflow` + echo ""validating $workflow"" + # include dummy workflow to validate under womtool 32 + printf ""\n\nworkflow dummyworkflow_$(basename $workflow .wdl) {}"" >> $workflow + if $(hash -r womtool &> /dev/null); then + womtool validate $workflow + else + java -jar ../womtool.jar validate $workflow + fi +done +# ================================================ + +# copy in the original task.wdl files [remove with WDL 1.0] that lack dummy workflow +cp ../pipes/WDL/workflows/tasks/*.wdl ../pipes/WDL/workflows/*.wdl . +# validate the workflow files +# unfortunately, dxWDL now requires the -imports parameter and cromwell supports +# it as well but womtool validate does not yet support it! so we have to copy +# everything to a temp dir +for workflow in ../pipes/WDL/workflows/*.wdl; do + workflow=`basename $workflow` + echo ""validating $workflow"" + if $(hash -r womtool &> /dev/null); then + womtool validate $workflow + else + java -jar ../womtool.jar validate $workflow + fi +done +","Shell" +"Viral","broadinstitute/viral-ngs","tools/picard.py",".py","22580","578","''' + Tools in the Picard suite +''' + +import logging +import os +import os.path +import tempfile +import shutil +import subprocess +import contextlib +from decimal import * + +import pysam + +import tools +import tools.samtools +import util.file +import util.misc + +TOOL_NAME = ""picard"" +TOOL_VERSION = '2.21.1' +TOOL_URL = 'https://github.com/broadinstitute/picard/releases/download/' \ + + '{ver}/picard-tools-{ver}.zip'.format(ver=TOOL_VERSION) +# Note: /seq/software/picard/{versionnumber}/ does not correspond with github release numbers! + +_log = logging.getLogger(__name__) + + +class PicardTools(tools.Tool): + """"""Base class for tools in the picard suite."""""" + jvmMemDefault = '2g' + + def install(self): + pass + + def is_installed(self): + return True + + def install_and_get_path(self): + # the conda version wraps the jar file with a shell script + return 'picard' + + def __init__(self, install_methods=None): + self.subtool_name = self.subtool_name if hasattr(self, ""subtool_name"") else None + self.installed_method = True + + def version(self): + return TOOL_VERSION + + def execute(self, command, picardOptions=None, JVMmemory=None, background=False, **kwargs): # pylint: disable=W0221 + picardOptions = picardOptions or [] + + if JVMmemory is None: + JVMmemory = self.jvmMemDefault + + # the conda version wraps the jar file with a shell script + path = self.install_and_get_path() + tool_cmd = [path, '-Xmx' + JVMmemory, '-Djava.io.tmpdir=' + tempfile.gettempdir(), command] + picardOptions + ['USE_JDK_DEFLATER=true','USE_JDK_INFLATER=true'] + _log.debug(' '.join(tool_cmd)) + + env = os.environ.copy() + env.pop('JAVA_HOME', None) + if background: + return subprocess.Popen(tool_cmd, env=env, **kwargs) + else: + return subprocess.check_call(tool_cmd, env=env, **kwargs) + + @staticmethod + def dict_to_picard_opts(options): + return [""%s=%s"" % (k, v) for k, v in options.items()] + + +class RevertSamTool(PicardTools): + subtoolName = 'RevertSam' + + def execute(self, inBam, outBam, picardOptions=None, JVMmemory=None, background=False): # pylint: disable=W0221 + if tools.samtools.SamtoolsTool().isEmpty(inBam): + shutil.copyfile(inBam, outBam) + else: + picardOptions = picardOptions or [] + opts = ['INPUT=' + inBam, 'OUTPUT=' + outBam] + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory, background=background) + + +class CheckIlluminaDirectoryTool(PicardTools): + subtoolName = 'CheckIlluminaDirectory' + + def execute(self, basecalls_dir, lanes, read_structure, data_types=None, fake_files=False, tile_numbers=None, link_locs=False, picardOptions=None, JVMmemory=None): # pylint: disable=W0221 + picardOptions = picardOptions or [] + opts = [ + 'BASECALLS_DIR=' + basecalls_dir, + 'READ_STRUCTURE=' + read_structure + ] + + if fake_files: + opts += ['FAKE_FILES=true'] + + if tile_numbers is not None: + if type(tile_numbers)==int: + tile_numbers = [tile_numbers] + for tile_number in set(tile_numbers): + opts += ['TILE_NUMBERS=' + str(tile_number)] + + if data_types is not None: + if isinstance(arg, str): + data_types = [data_types] + for data_type in set(data_types): + opts += ['DATA_TYPES=' + data_type] + + # if lanes is a single int, cast it to a list + if type(lanes)==int: + lanes = [lanes] + + assert type(lanes)==list, ""Lanes must be a list specifying the lanes"" + for lane in set(lanes): + opts += ['LANES=' + str(lane)] + + if link_locs: + opts += ['LINK_LOCS=true'] + + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory) + + +class MarkDuplicatesTool(PicardTools): + subtoolName = 'MarkDuplicates' + + def execute( + self, inBams, outBam, outMetrics=None, taggingPolicy=None, picardOptions=None, JVMmemory=None + ): # pylint: disable=W0221 + picardOptions = picardOptions or [] + + if not outMetrics: + outMetrics = util.file.mkstempfname('.metrics') + opts = ['INPUT=' + bam for bam in inBams] + ['OUTPUT=' + outBam, 'METRICS_FILE=' + outMetrics] + if taggingPolicy: + opts += ['TAGGING_POLICY={}'.format(taggingPolicy)] + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory) + + +class SplitSamByLibraryTool(PicardTools): + subtoolName = 'SplitSamByLibrary' + + def execute( + self, in_bam, out_dir, picardOptions=None, JVMmemory=None + ): # pylint: disable=W0221 + + if tools.samtools.SamtoolsTool().isEmpty(in_bam): + # Picard SplitSamByLibrary cannot deal with an empty input BAM file + shutil.copyfile(in_bam, os.path.join(out_dir, 'output.bam')) + return + + opts = ['INPUT=' + in_bam, 'OUTPUT=' + out_dir] + PicardTools.execute(self, self.subtoolName, opts, JVMmemory=JVMmemory) + + +class SamToFastqTool(PicardTools): + subtoolName = 'SamToFastq' + illumina_clipping_attribute = 'XT' + + def execute(self, inBam, outFastq1, outFastq2=None, outFastq0=None, + illuminaClipping=False, interleave=False, + picardOptions=None, JVMmemory=None, background=None, **kwargs): # pylint: disable=W0221 + '''Write paired reads from `inBam` to `outFastq1` and `outFastq1`. If `outFastq0` is given, write + any unpaired reads from `inBam` there, else ignore them. If `illuminaClipping` is True, + trim reads at the clipping position specified by the Illumina clipping attribute + (which is defined by the class variable SamToFastqTool.illumina_clipping_attribute).''' + + picardOptions = picardOptions or [] + + opts = [ + 'INPUT=' + inBam, 'VALIDATION_STRINGENCY=SILENT', 'FASTQ=' + outFastq1, + ] + if outFastq2: + opts.append('SECOND_END_FASTQ=' + outFastq2) + else: + if interleave: + opts.append('INTERLEAVE=true') + + if outFastq0: + assert outFastq2, ""outFastq0 option only applies in paired-end output mode"" + opts.append('UNPAIRED_FASTQ=' + outFastq0) + + if illuminaClipping: + opts += PicardTools.dict_to_picard_opts({ + 'CLIPPING_ATTRIBUTE': tools.picard.SamToFastqTool.illumina_clipping_attribute, + 'CLIPPING_ACTION': 'X' + }) + + return PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory, + background=background, **kwargs) + + @contextlib.contextmanager + def execute_tmp(self, inBam, sfx='', includeUnpaired=False, **kwargs): + '''Output reads from `inBam` to temp fastq files, and yield their filenames as a tuple. + If `includeUnpaired` is True, output unpaired reads to a third temp fastq file and yield it as a third + element of the tuple. + ''' + if not includeUnpaired: + with util.file.tempfnames((sfx+'.1.fq', sfx+'.2.fq')) as (outFastq1, outFastq2): + self.execute(inBam, outFastq1, outFastq2, **kwargs) + yield outFastq1, outFastq2 + else: + with util.file.tempfnames((sfx+'.1.fq', sfx+'.2.fq', sfx+'.0.fq')) as (outFastq1, outFastq2, outFastq0): + self.execute(inBam, outFastq1, outFastq2, outFastq0=outFastq0, **kwargs) + yield outFastq1, outFastq2, outFastq0 + + def per_read_group(self, inBam, outDir, picardOptions=None, JVMmemory=None): + if tools.samtools.SamtoolsTool().isEmpty(inBam): + # Picard SamToFastq cannot deal with an empty input BAM file + if not os.path.isdir(outDir): + os.mkdir(outDir) + else: + picardOptions = picardOptions or [] + opts = ['INPUT=' + inBam, 'OUTPUT_DIR=' + outDir, 'OUTPUT_PER_RG=true', 'RG_TAG=ID'] + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory) + + +class FastqToSamTool(PicardTools): + subtoolName = 'FastqToSam' + + def execute( + self, inFastq1, inFastq2, sampleName, + outBam, picardOptions=None, JVMmemory=None + ): # pylint: disable=W0221 + picardOptions = picardOptions or [] + + if inFastq2: + opts = ['FASTQ=' + inFastq1, 'FASTQ2=' + inFastq2, 'OUTPUT=' + outBam, 'SAMPLE_NAME=' + sampleName] + else: + opts = ['FASTQ=' + inFastq1, 'OUTPUT=' + outBam, 'SAMPLE_NAME=' + sampleName] + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory) + + +class SortSamTool(PicardTools): + subtoolName = 'SortSam' + valid_sort_orders = ['unsorted', 'queryname', 'coordinate'] + default_sort_order = 'coordinate' + + def execute( + self, inBam, outBam, sort_order=default_sort_order, + picardOptions=None, JVMmemory=None + ): # pylint: disable=W0221 + picardOptions = picardOptions or [] + + if sort_order not in self.valid_sort_orders: + raise Exception(""invalid sort order"") + opts = ['INPUT=' + inBam, 'OUTPUT=' + outBam, 'SORT_ORDER=' + sort_order] + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory) + + +class DownsampleSamTool(PicardTools): + subtoolName = 'DownsampleSam' + valid_strategies = ['HighAccuracy', 'ConstantMemory', 'Chained'] + default_strategy = 'Chained' # ConstantMemory first, then HighAccuracy to get closer to the target probability + default_random_seed = 1 # Set to constant int for deterministic results + jvmMemDefault = '4g' + + def execute(self, + inBam, + outBam, + probability, + accuracy=None, #Picard default is 1.0E-4 + strategy=default_strategy, + random_seed=default_random_seed, + picardOptions=None, + JVMmemory=None): # pylint: disable=W0221 + picardOptions = picardOptions or [] + JVMmemory = JVMmemory or self.jvmMemDefault + + if strategy not in self.valid_strategies: + raise Exception(""invalid subsample strategy: %s"" % strategy) + if not probability: + raise Exception(""Probability must be defined"") + if float(probability) <= 0 or float(probability) > 1: + raise Exception(""Probability must be in range (0,1]. This value was given: %s"" % probability) + + opts = ['INPUT=' + inBam, 'OUTPUT=' + outBam, 'PROBABILITY=' + str(probability)] + + if accuracy: + opts.extend(['ACCURACY=' + str(accuracy)]) + + if strategy: + opts.extend(['STRATEGY=' + strategy]) + + if not random_seed: + _log.info(""No random seed is set for subsample operation; results will be non-deterministic"") + opts.extend([""RANDOM_SEED=null""]) + raise Exception( + ""Setting RANDOM_SEED=null crashes Picard 1.141, though it may be available when viral-ngs updates to a later version of Picard."" + ) + else: + _log.info(""Random seed is set for subsample operation; results will be deterministic"") + opts.extend(['RANDOM_SEED=' + str(random_seed)]) + + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory) + + + def downsample_to_approx_count( + self, inBam, outBam, read_count, picardOptions=None, + JVMmemory=None + ): # pylint: disable=W0221): + + samtools = tools.samtools.SamtoolsTool() + total_read_count = samtools.count(inBam) + + if total_read_count == 0: + _log.info(""Input BAM has no reads. Copying to output."") + shutil.copyfile(inBam, outBam) + + probability = Decimal(int(read_count)) / Decimal(total_read_count) + probability = 1 if probability > 1 else probability + + assert probability >= 0 + + if probability < 1: + # per the Picard docs, HighAccuracy is recommended for read counts <50k + strategy = ""HighAccuracy"" if total_read_count < 50000 else ""Chained"" + _log.info(""Setting downsample accuracy to %s based on read count of %s"" % (strategy, total_read_count)) + + self.execute(inBam, outBam, probability, strategy=strategy, accuracy=0.00001, picardOptions=picardOptions, JVMmemory=JVMmemory) + else: + _log.info(""Requested downsample count exceeds number of reads. Including all reads in output."") + shutil.copyfile(inBam, outBam) + + +class MergeSamFilesTool(PicardTools): + subtoolName = 'MergeSamFiles' + + def execute(self, inBams, outBam, picardOptions=None, JVMmemory=None, background=None): # pylint: disable=W0221 + picardOptions = picardOptions or [] + + if not any(opt.startswith('USE_THREADING') for opt in picardOptions): + picardOptions.append('USE_THREADING=true') + + opts = ['INPUT=' + bam for bam in inBams] + ['OUTPUT=' + outBam] + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory=JVMmemory, background=background) + + +class ReplaceSamHeaderTool(PicardTools): + subtoolName = 'ReplaceSamHeader' + + def execute(self, inBam, headerBam, outBam, picardOptions=None, JVMmemory=None, background=None): # pylint: disable=W0221 + + opts = ['INPUT=' + inBam, + 'HEADER=' + headerBam, + 'OUTPUT=' + outBam] + PicardTools.execute(self, self.subtoolName, opts, JVMmemory=JVMmemory, background=background) + + +class FilterSamReadsTool(PicardTools): + ''' TO DO: it might be desirable to replace this tool with a + non-Picard/non-Java approach that uses samtools/pysam, sqlite, + and O(1) memory. + ''' + subtoolName = 'FilterSamReads' + jvmMemDefault = '4g' + + def execute(self, inBam, exclude, readList, outBam, picardOptions=None, JVMmemory=None): # pylint: disable=W0221 + picardOptions = picardOptions or [] + + if tools.samtools.SamtoolsTool().isEmpty(inBam): + # Picard FilterSamReads cannot deal with an empty input BAM file + shutil.copyfile(inBam, outBam) + elif os.path.getsize(readList) == 0: + # Picard FilterSamReads cannot deal with an empty READ_LIST_FILE + if exclude: + shutil.copyfile(inBam, outBam) + else: + tmpf = util.file.mkstempfname('.sam') + if inBam.endswith('.sam'): + # output format (sam/bam) is inferred by samtools based on file extension + header = pysam.view('-o', tmpf, '-H', '-S', inBam, catch_stdout=False) + else: + header = pysam.view('-o', tmpf, '-H', inBam, catch_stdout=False) + # pysam.AlignmentFile cannot write an empty file + # samtools cannot convert SAM -> BAM on an empty file + # but Picard SamFormatConverter can deal with empty files + opts = ['INPUT=' + tmpf, 'OUTPUT=' + outBam, 'VERBOSITY=ERROR'] + PicardTools.execute(self, 'SamFormatConverter', opts, JVMmemory='50m') + else: + opts = [ + 'INPUT=' + inBam, 'OUTPUT=' + outBam, 'READ_LIST_FILE=' + readList, + 'FILTER=' + (exclude and 'excludeReadList' or 'includeReadList'), 'WRITE_READS_FILES=false' + ] + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory) + + +class CreateSequenceDictionaryTool(PicardTools): + subtoolName = 'CreateSequenceDictionary' + jvmMemDefault = '512m' + + def execute( + self, inFasta, outDict=None, overwrite=False, + picardOptions=None, JVMmemory=None + ): # pylint: disable=W0221 + picardOptions = picardOptions or [] + + if not outDict: + if inFasta.lower().endswith('.fa'): + outDict = inFasta[:-3] + '.dict' + elif inFasta.lower().endswith('.fasta'): + outDict = inFasta[:-6] + '.dict' + else: + raise Exception(""bad input"") + if os.path.isfile(outDict): + if overwrite: + os.unlink(outDict) + else: + return + with util.file.fastas_with_sanitized_ids(inFasta, use_tmp=False) as sanitized_fastas: + opts = ['REFERENCE=' + sanitized_fastas[0], 'OUTPUT=' + outDict] + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory) + + +class BuildBamIndexTool(PicardTools): + subtoolName = 'BuildBamIndex' + jvmMemDefault = '512m' + + def execute(self, inBam, picardOptions=None, JVMmemory=None): # pylint: disable=W0221 + picardOptions = picardOptions or [] + + opts = ['INPUT=' + inBam] + PicardTools.execute(self, self.subtoolName, opts + picardOptions, JVMmemory) + +class CollectIlluminaLaneMetricsTool(PicardTools): + subtoolName = 'CollectIlluminaLaneMetrics' + jvmMemDefault = '8g' + defaults = {'read_structure': '101T8B8B101T'} + option_list = ( + 'read_structure', + ) + + def execute( + self, run_dir, + output_dir, output_prefix, + picardOptions=None, + JVMmemory=None + ): # pylint: disable=W0221 + picardOptions = picardOptions or {} + + opts_dict = self.defaults.copy() + for k, v in picardOptions.items(): + opts_dict[k] = v + opts = [] + for k, v in opts_dict.items(): + if v is not None: + if type(v) in (list, tuple): + for x in v: + opts.append('='.join((k.upper(), str(x)))) + else: + opts.append('='.join((k.upper(), str(v)))) + + opts += ['RUN_DIRECTORY=' + run_dir] + opts += ['OUTPUT_DIRECTORY=' + output_dir] + opts += ['OUTPUT_PREFIX=' + output_prefix] + PicardTools.execute(self, self.subtoolName, opts, JVMmemory) + +class ExtractIlluminaBarcodesTool(PicardTools): + subtoolName = 'ExtractIlluminaBarcodes' + jvmMemDefault = '8g' + # minimum_base_quality=20 used to accommodate NovaSeq, which with RTA3 writes only four Q-score values: 2, 12, 23, and 37 + defaults = {'read_structure': '101T8B8B101T', 'max_mismatches': 0, 'minimum_base_quality': 20, 'num_processors': 0} + option_list = ( + 'read_structure', 'max_mismatches', 'minimum_base_quality', 'min_mismatch_delta', 'max_no_calls', + 'minimum_quality', 'compress_outputs', 'num_processors' + ) + + def execute( + self, basecalls_dir, + lane, barcode_file, + output_dir, metrics, + picardOptions=None, + JVMmemory=None + ): # pylint: disable=W0221 + picardOptions = picardOptions or {} + + opts_dict = self.defaults.copy() + for k, v in picardOptions.items(): + opts_dict[k] = v + opts = [] + for k, v in opts_dict.items(): + if v is not None: + if type(v) in (list, tuple): + for x in v: + opts.append('='.join((k.upper(), str(x)))) + else: + opts.append('='.join((k.upper(), str(v)))) + opts += [ + 'BASECALLS_DIR=' + basecalls_dir, 'LANE=' + str(lane), 'BARCODE_FILE=' + barcode_file, + 'METRICS_FILE=' + metrics + ] + if output_dir is not None: + opts += ['OUTPUT_DIR=' + output_dir] + PicardTools.execute(self, self.subtoolName, opts, JVMmemory) + + +class IlluminaBasecallsToSamTool(PicardTools): + subtoolName = 'IlluminaBasecallsToSam' + jvmMemDefault = '7g' + defaults = { + 'read_structure': '101T8B8B101T', + 'adapters_to_check': ('PAIRED_END', 'NEXTERA_V1', 'NEXTERA_V2'), + 'max_reads_in_ram_per_tile': 1000000, + 'max_records_in_ram': 2000000, + 'num_processors': 0, + 'include_non_pf_reads': False, + 'compression_level': 7, + } + option_list = ( + 'read_structure', 'sequencing_center', 'adapters_to_check', 'platform', 'max_reads_in_ram_per_tile', + 'max_records_in_ram', 'num_processors', 'apply_eamss_filter', 'force_gc', 'first_tile', 'tile_limit', + 'include_non_pf_reads', 'run_start_date', 'read_group_id', 'compression_level' + ) + + # pylint: disable=W0221 + def execute(self, + basecalls_dir, + barcodes_dir, + read_group_id_precursor, + lane, library_params, + picardOptions=None, + JVMmemory=None + ): + picardOptions = picardOptions or {} + + opts_dict = self.defaults.copy() + for k, v in picardOptions.items(): + opts_dict[k] = v + opts = [] + for k, v in opts_dict.items(): + if v is not None: + if type(v) in (list, tuple): + for x in v: + opts.append('='.join((k.upper(), str(x)))) + else: + opts.append('='.join((k.upper(), str(v)))) + opts += [ + 'BASECALLS_DIR=' + basecalls_dir, 'BARCODES_DIR=' + barcodes_dir, 'LANE=' + str(lane), + 'RUN_BARCODE=' + read_group_id_precursor, 'LIBRARY_PARAMS=' + library_params + ] + PicardTools.execute(self, self.subtoolName, opts, JVMmemory) + + def execute_single_sample(self, + basecalls_dir, + output_file, + read_group_id_precursor, # this is a run-specific ID, ex. the flowcell ID + lane, + sample_alias, + picardOptions=None, + JVMmemory=None + ): + picardOptions = picardOptions or {} + + assert len(read_group_id_precursor) >= 5, ""read_group_id_precursor must be >=5 chars per https://github.com/broadinstitute/picard/blob/2.17.6/src/main/java/picard/illumina/IlluminaBasecallsToSam.java#L510"" + + opts_dict = self.defaults.copy() + for k, v in picardOptions.items(): + opts_dict[k] = v + opts = [] + for k, v in opts_dict.items(): + if v is not None: + if type(v) in (list, tuple): + for x in v: + opts.append('='.join((k.upper(), str(x)))) + else: + opts.append('='.join((k.upper(), str(v)))) + opts += [ + 'OUTPUT=' + output_file, + 'BASECALLS_DIR=' + basecalls_dir, + 'LANE=' + str(lane), + 'RUN_BARCODE=' + read_group_id_precursor, # + 'SAMPLE_ALIAS=' + sample_alias, + 'LIBRARY_NAME=' + sample_alias + ] + PicardTools.execute(self, self.subtoolName, opts, JVMmemory) + # pylint: enable=W0221 +","Python" +"Viral","broadinstitute/viral-ngs","tools/gatk.py",".py","4497","122","''' + GATK genotyping toolkit from the Broad Institute + + This software has different licenses depending on use cases. + As such, we do not have an auto-downloader. The user must have GATK + pre-installed on their own and available in $GATK_PATH. +''' + +import tools +import tools.picard +import tools.samtools +import util.file +import util.misc + +import logging +import os +import os.path +import subprocess +import tempfile + +_log = logging.getLogger(__name__) + + +TOOL_NAME = 'gatk' +TOOL_VERSION_TUPLE = (3, 8) +TOOL_VERSION = '.'.join(map(str, TOOL_VERSION_TUPLE)) + +class GATKTool(tools.Tool): + jvmMemDefault = '2g' + + def __init__(self, path=None): + self.tool_version = None + install_methods = [] + for jarpath in [path, os.environ.get('GATK_PATH')]: + if jarpath: + if not jarpath.endswith('.jar'): + jarpath = os.path.join(jarpath, 'GenomeAnalysisTK.jar') + install_methods.append( + tools.PrexistingUnixCommand( + jarpath, + verifycmd='java -jar %s --version &> /dev/null' % jarpath, + verifycode=0, + require_executability=False + ) + ) + install_methods.append(tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION, executable=""gatk3"")) + install_methods.append(tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION, executable=""gatk"")) + tools.Tool.__init__(self, install_methods=install_methods) + + def execute(self, command, gatkOptions=None, JVMmemory=None): # pylint: disable=W0221 + gatkOptions = gatkOptions or [] + + if not JVMmemory: + JVMmemory = self.jvmMemDefault + + # the conda version wraps the jar file with a shell script + if self.install_and_get_path().endswith("".jar""): + tool_cmd = [ + 'java', '-Xmx' + JVMmemory, '-Djava.io.tmpdir=' + tempfile.gettempdir(), '-jar', self.install_and_get_path(), + '-T', command + ] + list(map(str, gatkOptions)) + else: + tool_cmd = [ + self.install_and_get_path(), '-Xmx' + JVMmemory, '-Djava.io.tmpdir=' + tempfile.gettempdir(), '-T', command + ] + list(map(str, gatkOptions)) + + _log.debug(' '.join(tool_cmd)) + subprocess.check_call(tool_cmd) + + @staticmethod + def dict_to_gatk_opts(options): + return [""%s=%s"" % (k, v) for k, v in options.items()] + + def version(self): + if self.tool_version is None: + self._get_tool_version() + return self.tool_version + + def _get_tool_version(self): + if self.install_and_get_path().endswith("".jar""): + cmd = [ + 'java', '-Djava.io.tmpdir=' + tempfile.gettempdir(), '-jar', self.install_and_get_path(), + '--version' + ] + else: + cmd = [ + self.install_and_get_path(), '--version' + ] + + self.tool_version = util.misc.run_and_print(cmd, buffered=False, silent=True).stdout.decode(""utf-8"").strip() + + def ug(self, inBam, refFasta, outVcf, options=None, JVMmemory=None, threads=None): + options = options or [""--min_base_quality_score"", 15, ""-ploidy"", 4] + + threads = util.misc.sanitize_thread_count(threads) + opts = [ + '-I', inBam, + '-R', refFasta, + '-o', outVcf, + '-glm', 'BOTH', + '--baq', 'OFF', + '--useOriginalQualities', + '-out_mode', 'EMIT_ALL_SITES', + '-dt', 'NONE', + '--num_threads', threads, + '-A', 'AlleleBalance', + ] + if TOOL_VERSION_TUPLE < (3, 7): + opts += ['-stand_call_conf', 0, '-stand_emit_conf', 0] # deprecated in 3.7+ + + self.execute('UnifiedGenotyper', opts + options, JVMmemory=JVMmemory) + + def local_realign(self, inBam, refFasta, outBam, JVMmemory=None, threads=None): + threads = util.misc.sanitize_thread_count(threads) + _log.debug(""Running local realign with %s threads"", threads) + intervals = util.file.mkstempfname('.intervals') + opts = ['-I', inBam, '-R', refFasta, '-o', intervals, '--num_threads', threads] + self.execute('RealignerTargetCreator', opts, JVMmemory=JVMmemory) + opts = ['-I', inBam, '-R', refFasta, '-targetIntervals', intervals, '-o', outBam] + self.execute('IndelRealigner', opts, JVMmemory=JVMmemory) + os.unlink(intervals) +","Python" +"Viral","broadinstitute/viral-ngs","tools/megan.py",".py","4431","113","''' +MEGAN - Metagenome Analyzer + +MEGAN needs to be installed through the installer and a license also needs to +be obtained out of band. + +The user needs to set environment variables: +MEGAN_PATH +MEGAN_LICENSE_PATH +MEGAN_DATA_PATH + +The data directory can be populated with unzipped archives from +http://ab.inf.uni-tuebingen.de/data/software/megan5/download/welcome.html + +If installed on MacOS, the likely MEGAN_PATH will be: +/Applications/MEGAN/MEGAN.app/Contents/MacOS/JavaApplicationStub +''' +from builtins import super +import os +import subprocess +import tempfile +import textwrap +import tools + +SPECIES_PROJECTION = textwrap.dedent( + ''' +load taxGIFile='{gi_taxid}'; +import blastFile='{blast_file}' meganFile='{megan_file}' maxMatches=100 minScore=50.0 maxExpected=0.01 topPercent=10.0 minSupportPercent=0.1 minSupport=1 minComplexity=0.3 useMinimalCoverageHeuristic=false useSeed=false useCOG=false useKegg=false paired=false useIdentityFilter=false textStoragePolicy=Embed blastFormat=BlastTAB mapping='Taxonomy:BUILT_IN=true,Taxonomy:GI_MAP=true'; + +collapse rank=Species; +compute profile=Projection rank=Species minPercent=1.0; +select rank=Species; +export what=CSV format=taxonname_count separator=tab counts=summarized file='{species_file}'; +quit; +''' +) + + +@tools.skip_install_test() +class Megan(tools.Tool): + """""" Tool wrapper for the MEGAN metagenome analyzer + """""" + JVM_DEFAULT_MEM = '2G' + + def __init__(self, path=None): + self.tool_version = None + for megan_path in [path, os.environ.get('MEGAN_PATH')]: + if not megan_path: + continue + if os.path.isdir(megan_path): + megan_path = os.path.join(megan_path, 'MEGAN') + install_methods = [ + tools.PrexistingUnixCommand( + megan_path, + verifycmd='{} -h > /dev/null'.format(megan_path), + verifycode=0, + require_executability=True + ) + ] + + self.license_file = os.environ.get('MEGAN_LICENSE_PATH') + self.data_dir = os.environ.get('MEGAN_DATA_PATH') + + super(Megan, self).__init__(install_methods=install_methods) + + @property + def gi_taxid(self): + return os.path.join(self.data_dir, 'gi_taxid-March2015X.bin') + + def execute(self, commands, memory=None, shell=False): + with tempfile.NamedTemporaryFile(mode='w', prefix='megan_commands_', suffix='.txt') as command_file: + command_file.write(commands) + command_file.flush() + + memory = memory or Megan.JVM_DEFAULT_MEM + megan = self.install_and_get_path() + env = os.environ.copy() + # Changing mem dynamically like this actually requires a slightly + # modified version of MEGAN to work. + env['INSTALL4J_ADD_VM_PARAMS'] = '-Xmx{}'.format(memory) + megan_cmd = [ + megan, '--commandLineMode', '--licenseFile', self.license_file, '--commandFile', command_file.name + ] + if os.uname()[0] == 'Darwin': + # OS X is an Aqua app which ignores $DISPLAY so we're going to + # have to open the GUI. + stdout = subprocess.check_output(megan_cmd, env=env) + return 0, stdout + elif 'linux' in os.uname()[0]: + cmd = ['xvfb-run', '--auto-display'] + cmd.extend(megan_cmd) + stdout = subprocess.check_output(cmd, env=env, shell=shell) + return 0, stdout + + def species_projection(self, blast_file, output_file, memory=None): + '''Calculate a species projection. + + Calculate a species projection of a blast m8 tab file with recommended + filtering and support parameters from the manual. This requires the + gi_taxid file downloaded to assign proper names. + ''' + # We don't really care about the megan file since it's an on disk cache + # of the imported blast file to make future imports faster. We just + # want to do one shot analysis + with tempfile.NamedTemporaryFile(prefix='megan_', suffix='.rma') as megan_file: + commands = SPECIES_PROJECTION.format( + gi_taxid=self.gi_taxid, + blast_file=blast_file, + megan_file=megan_file.name, + species_file=output_file + ) + self.execute(commands, memory=memory) +","Python" +"Viral","broadinstitute/viral-ngs","tools/trimmomatic.py",".py","2866","84","""tools.Tool for trimmomatic."" + +import logging +import os +import subprocess +import tools +import util.file +import util.misc + +TOOL_NAME = ""trimmomatic"" +TOOL_VERSION = ""0.38"" + +_log = logging.getLogger(__name__) + +class TrimmomaticTool(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION)) + tools.Tool.__init__(self, install_methods=install_methods) + + def execute(self, + inFastq1, + inFastq2, + pairedOutFastq1, + pairedOutFastq2, + clipFasta, + unpairedOutFastq1=None, + unpairedOutFastq2=None, + leading_q_cutoff=15, + trailing_q_cutoff=15, + minlength_to_keep=30, + sliding_window_size=4, + sliding_window_q_cutoff=25, + maxinfo_target_length=None, + maxinfo_strictness=None + ): + '''Trim read sequences with Trimmomatic.''' + trimmomaticPath = self.install_and_get_path() + unpairedFastq1 = unpairedOutFastq1 or util.file.mkstempfname() + unpairedFastq2 = unpairedOutFastq2 or util.file.mkstempfname() + javaCmd = [trimmomaticPath] + + if inFastq2 is None or os.path.getsize(inFastq2) < 10: + # Unpaired reads + javaCmd.extend([ + 'SE', '-phred33', + inFastq1, unpairedFastq1 + ]) + else: + # Paired reads + javaCmd.extend([ + 'PE', '-phred33', + inFastq1, inFastq2, + pairedOutFastq1, unpairedFastq1, pairedOutFastq2, unpairedFastq2 + ]) + + # all the options + javaCmd.extend( + [ + 'LEADING:{leading_q_cutoff}'.format(leading_q_cutoff=leading_q_cutoff), + 'TRAILING:{trailing_q_cutoff}'.format(trailing_q_cutoff=trailing_q_cutoff), + 'SLIDINGWINDOW:{sliding_window_size}:{sliding_window_q_cutoff}'.format( + sliding_window_size=sliding_window_size, + sliding_window_q_cutoff=sliding_window_q_cutoff, + ) if not maxinfo_target_length else \ + 'MAXINFO:{maxinfo_target_length}:{maxinfo_strictness}'.format( + maxinfo_target_length=maxinfo_target_length, + maxinfo_strictness=maxinfo_strictness, + ), + 'MINLEN:{minlength_to_keep}'.format(minlength_to_keep=minlength_to_keep), + 'ILLUMINACLIP:{clipFasta}:2:30:12'.format(clipFasta=clipFasta) + ] + ) + + _log.debug(' '.join(javaCmd)) + util.misc.run_and_print(javaCmd, check=True) + + if not unpairedOutFastq1: + os.unlink(unpairedFastq1) + if not unpairedOutFastq2: + os.unlink(unpairedFastq2) +","Python" +"Viral","broadinstitute/viral-ngs","tools/kmc.py",".py","15607","306","''' + Tool wrapper for the KMC kmer counter + ( http://sun.aei.polsl.pl/REFRESH/index.php?page=projects&project=kmc&subpage=about ) +''' + +import logging +import os +import os.path +import sys +import subprocess +import shlex +import argparse +import shutil +import re +import collections + +import Bio.SeqIO + +import read_utils +import tools +import tools.samtools +import tools.picard +import util.file +import util.misc + + +TOOL_NAME = 'kmc' +TOOL_VERSION = '3.1.1rc1' + +_log = logging.getLogger(__name__) # pylint: disable=invalid-name + +_chk = util.misc.chk + +DEFAULT_KMER_SIZE = 25 +DEFAULT_COUNTER_CAP = 255 # default for ""cap counter values at"" params + +class KmcTool(tools.Tool): + '''Tool wrapper for KMC kmer counter''' + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION, executable='kmc', + verifycmd='kmc -h > /dev/null')] + + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def _kmer_db_name(self, kmer_db): + """"""Return the kmer database path, given either the db path of the file name of the .kmc_pre or .kmc_suf file"""""" + base, ext = os.path.splitext(kmer_db) + return base if ext in ('.kmc_pre', '.kmc_suf') else kmer_db + + def is_kmer_db(self, kmer_db): + """"""Quickly check that the given kmer database exists"""""" + kmer_db = self._kmer_db_name(kmer_db) + return os.path.isfile(kmer_db + '.kmc_pre') and os.path.isfile(kmer_db + '.kmc_suf') + + def _get_file_format_opt(self, fname): + """"""Get the KMC command-line option to specify file format"""""" + file_type = util.file.uncompressed_file_type(fname) + if file_type in ('.fasta', '.fa'): + return 'm' + elif file_type in ('.fastq', '.fq'): + return 'q' + elif file_type == '.bam': + return 'bam' + else: + raise RuntimeError('Unknown seq file format: {}'.format(file_type)) + + def build_kmer_db(self, seq_files, kmer_db, kmer_size=DEFAULT_KMER_SIZE, min_occs=1, max_occs=util.misc.MAX_INT32, + counter_cap=DEFAULT_COUNTER_CAP, single_strand=False, mem_limit_gb=8, mem_limit_laxness=0, + threads=None, kmc_opts=''): + """"""Build a database of kmers occurring in the given sequence files. + + Inputs: + seq_files: filename(s) of files from which to gather kmers. Files can be fasta, fastq or bam; fasta and fastq + may be compressed with gzip or bzip2. + + Outputs: + kmer_db: kmer database path, with or without the .kmc_pre/.kmc_suf extension. + + Params: + kmer_size: kmer size + + min_occs: ignore kmers occurring fewer than this many times + max_occs: ignore kmers occurring more than this many times + + counter_cap: when writing kmer counts to the database, cap the values at this number + + single_strand: if True, do not include kmers from reverse complements of input sequences + + mem_limit_gb: max RAM to use when building kmer database. Might be exceeded unless `mem_limit_strict` + is True. + mem_limit_laxness: how strictly to adhere to `mem_limit_gb`: 0=strictly, higher values permit more laxness + + kmc_opts: any additional kmc flags + """""" + seq_files = util.misc.make_seq(seq_files) + kmer_db = self._kmer_db_name(kmer_db) + threads = util.misc.sanitize_thread_count(threads) + with util.file.tmp_dir(suffix='_kmc_db') as t_dir, \ + util.file.tempfname(suffix='_kmc_seq_files') as seq_file_list: + util.file.dump_file(seq_file_list, '\n'.join(seq_files)) + args = ['-v'] + + input_fmt_opts_set = set(map(self._get_file_format_opt, seq_files)) + _chk(len(input_fmt_opts_set) == 1, ""All input sequence files must be in the same format"") + input_fmt_opt = list(input_fmt_opts_set)[0] + + args += '-f{} -k{} -ci{} -cx{} -cs{} -m{} -t{}'.format(input_fmt_opt, kmer_size, min_occs, max_occs, + counter_cap, mem_limit_gb, threads).split() + if single_strand: + args += ['-b'] + if mem_limit_laxness == 0: + args += ['-sm'] # strict memory mode + elif mem_limit_laxness == 2: + args += ['-r'] # RAM-only mode + + if kmc_opts: + args += shlex.split(kmc_opts) + + args += ['@'+seq_file_list, kmer_db, t_dir] + tool_cmd = [self.install_and_get_path()] + args + _log.info('Building kmer database with command: %s', ' '.join(tool_cmd)) + subprocess.check_call(tool_cmd) + _chk(os.path.isfile(kmer_db+'.kmc_pre') and os.path.isfile(kmer_db+'.kmc_suf'), + 'kmer database files not created: {}'.format(kmer_db)) + + def execute(self, args, threads=None, return_output=False): # pylint: disable=arguments-differ + """"""Run kmc_tools with the given args. If `return_output` is True, returns the stdout output."""""" + threads = util.misc.sanitize_thread_count(threads) + tool_cmd = [self.install_and_get_path()+'_tools'] + ['-t{}'.format(threads)] + list(map(str, args)) + _log.info('Running kmc_tools command: %s', ' '.join(tool_cmd)) + + result = None + if not return_output: + subprocess.check_call(tool_cmd) + else: + result = subprocess.check_output(tool_cmd).decode('utf-8') + _log.info('Done running kmc_tools command: %s', ' '.join(tool_cmd)) + return result + + + def dump_kmer_counts(self, kmer_db, out_kmers, min_occs=1, max_occs=util.misc.MAX_INT32, threads=None): + """"""Dump the kmers from the database, with their counts, to a text file. Kmers with counts + below `min_occs` or above `max_occs` are ignored."""""" + self.execute('transform {} -ci{} -cx{} dump {}'.format(self._kmer_db_name(kmer_db), + min_occs, max_occs, out_kmers).split(), + threads=threads) + _chk(os.path.isfile(out_kmers), 'dump_kmer_counts: output file not created') + + def read_kmer_counts(self, kmer_counts_txt): + """"""Read kmer counts from a file written by dump_kmer_counts, as collections.Counter"""""" + counts = collections.Counter() + with util.file.open_or_gzopen(kmer_counts_txt) as kmers_f: + for line in kmers_f: + kmer, count = line.strip().split() + counts[kmer] = int(count) + return counts + + def get_kmer_counts(self, kmer_db, **kwargs): + """"""Extract and return the kmer counts from the kmer database as a dict. `kwargs` are passed through + to read_kmer_counts()."""""" + with util.file.tempfname(suffix='_kmer_cnts.txt') as kmer_counts_file: + self.dump_kmer_counts(kmer_db, out_kmers=kmer_counts_file, **kwargs) + return self.read_kmer_counts(kmer_counts_file) + + def get_kmer_db_info(self, kmer_db): + """"""Return params of a kmer db. + This functionality is not documented in KMC docs but is supported + ( https://github.com/refresh-bio/KMC/issues/83 ) + + Returns: an argparse.Namespace() with attributes kmer_size, min_occs, max_occs, + counter_size_bytes, and total_kmers. + """""" + output = self.execute(['info', self._kmer_db_name(kmer_db)], return_output=True, threads=1) + db_info = dict(re.split('\\s+:\\s+', line.strip()) for line in output.strip().split('\n')) + def fix_val(v): + return v=='yes' if v in ('yes', 'no') else util.misc.as_type(v, (int, str)) + db_info = {k: fix_val(v) for k, v in db_info.items()} + + return argparse.Namespace(kmer_size=db_info['k'], single_strand=not db_info['both strands'], + min_occs=db_info['cutoff min'], + max_occs=db_info['cutoff max'], + counter_size_bytes=int(db_info['counter size'].split()[0]), + total_kmers=db_info['total k-mers']) + + def filter_reads(self, kmer_db, in_reads, out_reads, db_min_occs=1, db_max_occs=util.misc.MAX_INT32, + read_min_occs=0, read_max_occs=util.misc.MAX_INT32, + read_min_occs_frac=0.0, read_max_occs_frac=1.0, hard_mask=False, threads=None): + """"""Filter reads based on their kmer contents. + + Note that ""occurrence of a kmer"" means ""occurrence of the kmer or its reverse complement"" if kmer_db was built + with single_strand==False. + + Inputs: + kmer_db: the kmc kmer database + in_reads: the reads to filter. can be a .fasta or .fastq or .bam; fasta or fastq can be compressed + with gzip or bzip2. If a .bam, a read pair is kept if either mate passes the filter. + + Outputs: + out_reads: file to which filtered reads are written. type is determined from extension, + same types as above are supported. + + Params: + db_min_occs: only consider database kmers with at least this count + db_max_occs: only consider database kmers with at most this count + + read_min_occs: only keep reads with at least this many occurrences of kmers from database. + read_max_occs: only keep reads with no more than this many occurrence of kmers from the database. + read_min_occs_frac: only keep reads with at least this many occurrences of kmers from database, + interpreted as a fraction of read length in kmers + read_max_occs_frac: only keep reads with no more than this many occurrence of kmers from the database. + interpreted as a fraction of read length in kmers. + + (Note: minimal read kmer content can be given as absolute counts or fraction of read length, but not both). + + hard_mask: if True, in the output reads, kmers not passing the filter are replaced by Ns + threads: use this many threads + """""" + _log.debug('FILTER_READS: locals=%s dbinfo=%s', locals(), self.get_kmer_db_info(kmer_db)) + + abs_thresholds = (read_min_occs, read_max_occs) != (0, util.misc.MAX_INT32) + rel_thresholds = (read_min_occs_frac, read_max_occs_frac) != (0., 1.) + if not (abs_thresholds or rel_thresholds): abs_thresholds = True + _chk(not (abs_thresholds and rel_thresholds), + ""Mixing absolute and relative thresholds for kmer content not currently supported"") + _chk(0 <= read_min_occs <= read_max_occs <= util.misc.MAX_INT32, + 'Invalid kmer contents thresholds') + _chk(0.0 <= read_min_occs_frac <= read_max_occs_frac <= 1.0, + 'Invalid kmer contents thresholds') + + in_reads_type = util.file.uncompressed_file_type(in_reads) + _in_reads = in_reads + _out_reads = out_reads + with util.file.tmp_dir(suffix='_kmcfilt') as t_dir: + if in_reads_type in ('.fa', '.fasta'): + # kmc_tools filter currently requires fasta files to be in fasta-2line format + # https://github.com/refresh-bio/KMC/issues/57 + _in_reads = os.path.join(t_dir, 'in_reads.fasta') + Bio.SeqIO.convert(in_reads, 'fasta', _in_reads, 'fasta-2line') + if in_reads_type == '.bam': + # kmc_tools filter currently does not support .bam files + # https://github.com/refresh-bio/KMC/issues/66 + _in_reads = os.path.join(t_dir, 'in_reads.fasta') + tools.samtools.SamtoolsTool().bam2fa(in_reads, _in_reads) + _out_reads = os.path.join(t_dir, 'out_reads.fasta') + + # TODO: if db is single-strand, reverse-complement read2's? + + in_reads_fmt = 'q' if in_reads_type in ('.fq', '.fastq') else 'a' + + if os.path.getsize(self._kmer_db_name(kmer_db)+'.kmc_suf') == 8: + _chk(self.get_kmer_db_info(kmer_db).total_kmers == 0, + 'Something odd: did kmc file format change?') + # kmc has a bug filtering on empty kmer databases: + # https://github.com/refresh-bio/KMC/issues/86 + if read_min_occs > 0 or read_min_occs_frac > 0.0: + util.file.make_empty(_out_reads) + else: + shutil.copyfile(_in_reads, _out_reads) + else: + thresholds_opt = ' -ci{} -cx{}'.format(*((read_min_occs, read_max_occs) if abs_thresholds else \ + (read_min_occs_frac, read_max_occs_frac))) + self.execute('filter {} {} -ci{} -cx{} {} -f{} {} {}'.format('-hm' if hard_mask else '', + self._kmer_db_name(kmer_db), + db_min_occs, db_max_occs, + _in_reads, in_reads_fmt, + thresholds_opt, + _out_reads).split(), + threads=threads) + + if in_reads_type == '.bam': + _chk(out_reads.endswith('.bam'), 'output from .bam to non-.bam not yet supported') + passing_read_names = os.path.join(t_dir, 'passing_read_names.txt') + read_utils.fasta_read_names(_out_reads, passing_read_names) + tools.picard.FilterSamReadsTool().execute(inBam=in_reads, exclude=False, + readList=passing_read_names, outBam=out_reads) + # end: with util.file.tmp_dir(suffix='kmcfilt') as t_dir + # end: def filter_reads(self, kmer_db, in_reads, out_reads, db_min_occs=1, db_max_occs=util.misc.MAX_INT32, ...) + + def kmers_binary_op(self, op, kmer_db1, kmer_db2, kmer_db_out, + result_min_occs=1, result_max_occs=util.misc.MAX_INT32, + result_counter_cap=DEFAULT_COUNTER_CAP, + threads=None): + """"""Perform a simple binary operation on two kmer sets"""""" + kmer_db1, kmer_db2, kmer_db_out = map(self._kmer_db_name, (kmer_db1, kmer_db2, kmer_db_out)) + # db1_min_occs, db1_max_occs, db2_min_occs, db2_max_occs, db_out_min_occs, db_out_max_occs, + self.execute(['simple', kmer_db1, kmer_db2, op, kmer_db_out, + '-ci{}'.format(result_min_occs), + '-cx{}'.format(result_max_occs), + '-cs{}'.format(result_counter_cap)], threads=threads) + _chk(self.is_kmer_db(kmer_db_out), 'kmer_binary_op: output not created') + + def set_kmer_counts(self, kmer_db_in, value, kmer_db_out, threads=None): + """"""Create a copy of the kmer database with all counts set to specified value"""""" + _chk(1 <= value <= util.misc.MAX_INT32, 'can only set kmer counts to a positive 32-bit int') + kmer_db_in, kmer_db_out = map(self._kmer_db_name, (kmer_db_in, kmer_db_out)) + # db1_min_occs, db1_max_occs, db2_min_occs, db2_max_occs, db_out_min_occs, db_out_max_occs, + self.execute(['transform', kmer_db_in, 'set_counts', value, kmer_db_out], threads=threads) + _chk(self.is_kmer_db(kmer_db_out), 'set_kmer_counts: output not created') + +# end: class KmcTool(tools.Tool) +","Python" +"Viral","broadinstitute/viral-ngs","tools/kraken.py",".py","15507","382","''' +KRAKEN metagenomics classifier +''' +from __future__ import print_function +import collections +import itertools +import logging +import os +import os.path +import shlex +import shutil +import subprocess +import sys +import tempfile + +import tools +import tools.picard +import tools.samtools +import util.file +import util.misc +from builtins import super + +KRAKEN_VERSION = '1.0.0_fork3' +KRAKENUNIQ_VERSION = '0.5.7_yesimon' + + +log = logging.getLogger(__name__) + + +class Kraken(tools.Tool): + + BINS = { + 'classify': 'kraken', + 'build': 'kraken-build', + 'filter': 'kraken-filter', + 'report': 'kraken-report'} + + def __init__(self, install_methods=None): + self.subtool_name = self.subtool_name if hasattr(self, ""subtool_name"") else ""kraken"" + if not install_methods: + install_methods = [] + install_methods.append(tools.CondaPackage('kraken', executable=self.subtool_name, version=KRAKEN_VERSION, channel='broad-viral')) + super(Kraken, self).__init__(install_methods=install_methods) + + def version(self): + return KRAKEN_VERSION + + @property + def libexec(self): + if not self.executable_path(): + self.install_and_get_path() + return os.path.dirname(self.executable_path()) + + def build(self, db, options=None, option_string=None): + '''Create a kraken database. + + Args: + db: Kraken database directory to build. Must have library/ and + taxonomy/ subdirectories to build from. + *args: List of input filenames to process. + ''' + options['--threads'] = util.misc.sanitize_thread_count(options.get('--threads')) + self.execute(self.BINS['build'], db, db, options=options, + option_string=option_string) + + def _db_opts(self, db, threads): + '''Determine kraken command line options based on db string''' + + env = os.environ.copy() + def s3_psub(path): + cmd = 'aws s3 cp {} -'.format(path) + if path.endswith('.bz2'): + cmd += ' | lbzip2 -n {threads} -d'.format(threads=threads) + elif path.endswith('.gz'): + cmd += ' | pigz -p {threads} -d'.format(threads=threads) + elif path.endswith('.lz4'): + cmd += ' | lz4 -d' + cmd = '<({cmd})'.format(cmd=cmd) + return cmd + + if db.startswith('s3://'): + import boto3 + import yaml + s3 = boto3.resource('s3') + path = db[5:] + bucket_name, db_dir = path.split('/', 1) + obj = s3.Object(bucket_name, '/'.join([db_dir, 'config.yaml'])) + db_config = yaml.load(obj.get()['Body'].read()) + + db_opts = (' --db-pipe --db-index {index_f} --index-size {index_size} --db-file {db_f} --db-size {db_size} ' + '--taxonomy {nodes}'.format( + index_f=s3_psub(db_config['db_index']), + index_size=db_config['index_size'], + db_f=s3_psub(db_config['db_file']), + db_size=db_config['db_size'], + nodes=s3_psub(db_config['taxonomy_nodes']))) + tax_filter_opts = ' --taxonomy-nodes {nodes}'.format( + nodes=s3_psub(db_config['taxonomy_nodes'])) + tax_report_opts = tax_filter_opts + ' --taxonomy-names {names}'.format( + names=s3_psub(db_config['taxonomy_names'])) + env['KRAKEN_DEFAULT_DB'] = '.' + else: + env['KRAKEN_DEFAULT_DB'] = db + db_opts = '' + tax_filter_opts = '' + tax_report_opts = '' + return db_opts, env, tax_filter_opts, tax_report_opts + + def pipeline(self, db, inBams, outReports=None, outReads=None, + lockMemory=None, filterThreshold=None, numThreads=None): + assert outReads is not None or outReports is not None + + n_bams = len(inBams) + # 2n for paired fastq, 1n for kraken output + n_pipes = n_bams * 3 + if outReports and len(outReports) != n_bams: + raise Exception(""--outReports specified with {} output files, which does not match the number of input bams ({})"".format(len(outReports), n_bams)) + if outReads and len(outReads) != n_bams: + raise Exception(""--outReads specified with {} output files, which does not match the number of input bams ({})"".format(len(outReads), n_bams)) + threads = util.misc.sanitize_thread_count(numThreads) + + with util.file.fifo(n_pipes) as pipes: + fastq_pipes = pipes[:n_bams * 2] + kraken_output_pipes = pipes[n_bams * 2:] + + kraken_bin = 'kraken' + opts = '' + if lockMemory: + opts += ' --lock-memory' + + db_opts, env, tax_filter_opts, tax_report_opts = self._db_opts(db, threads) + opts += db_opts + + cmd = '''set -ex -o pipefail; {kraken}{opts} --paired --fastq-input --threads {threads} {outputs} {fastqs}'''.format( + kraken=kraken_bin, + opts=opts, + threads=threads, + outputs=' '.join('--output {}'.format(x) for x in kraken_output_pipes), + fastqs=' '.join(fastq_pipes)) + log.debug('Calling kraken command line: %s', cmd) + subprocess.Popen(cmd, shell=True, executable='/bin/bash', env=env) + + for i, in_bam in enumerate(inBams): + cmd = 'cat {kraken_output}'.format(kraken_output=kraken_output_pipes[i]) + + if outReads: + if outReports: + cmd += ' | tee >(pigz --best > {kraken_reads})' + else: + cmd += ' | pigz --best > {kraken_reads}' + + cmd = cmd.format(kraken_reads=outReads[i]) + + if outReports: + if filterThreshold is not None: + + kraken_filter_bin = 'kraken-filter' + cmd += ' | {kraken_filter}{tax_opts} --threshold {filterThreshold}'.format( + kraken_filter=kraken_filter_bin, + tax_opts=tax_filter_opts, + filterThreshold=filterThreshold) + + kraken_report_bin = 'kraken-report' + cmd += ' | {kraken_report}{tax_opts} > {outReport}'.format( + kraken_report=kraken_report_bin, + tax_opts=tax_report_opts, + outReport=outReports[i]) + + # do not convert this to samtools bam2fq unless we can figure out how to replicate + # the clipping functionality of Picard SamToFastq + picard = tools.picard.SamToFastqTool() + picard_opts = { + 'CLIPPING_ATTRIBUTE': tools.picard.SamToFastqTool.illumina_clipping_attribute, + 'CLIPPING_ACTION': 'X' + } + bam2fq_ps = picard.execute(in_bam, fastq_pipes[i*2], fastq_pipes[i*2 + 1], + picardOptions=tools.picard.PicardTools.dict_to_picard_opts(picard_opts), + JVMmemory=picard.jvmMemDefault, background=True) + + log.debug('Calling kraken output command line: %s', cmd) + subprocess.check_call(cmd, shell=True, executable='/bin/bash', env=env) + + if bam2fq_ps.poll(): + raise subprocess.CalledProcessError(bam2fq_ps.returncode, ""SamToFastqTool().execute({})"".format(in_bam)) + + + def classify(self, inBam, db, outReads, numThreads=None): + """"""Classify input reads (bam) + + Args: + inBam: unaligned reads + db: Kraken built database directory. + outReads: Output file of command. + """""" + if tools.samtools.SamtoolsTool().isEmpty(inBam): + # kraken cannot deal with empty input + with open(outReads, 'rt') as outf: + pass + return + tmp_fastq1 = util.file.mkstempfname('.1.fastq.gz') + tmp_fastq2 = util.file.mkstempfname('.2.fastq.gz') + # do not convert this to samtools bam2fq unless we can figure out how to replicate + # the clipping functionality of Picard SamToFastq + picard = tools.picard.SamToFastqTool() + picard_opts = { + 'CLIPPING_ATTRIBUTE': tools.picard.SamToFastqTool.illumina_clipping_attribute, + 'CLIPPING_ACTION': 'X' + } + picard.execute(inBam, tmp_fastq1, tmp_fastq2, + picardOptions=tools.picard.PicardTools.dict_to_picard_opts(picard_opts), + JVMmemory=picard.jvmMemDefault) + + opts = { + '--threads': util.misc.sanitize_thread_count(numThreads), + '--fastq-input': None, + '--gzip-compressed': None, + } + # Detect if input bam was paired by checking fastq 2 + if os.path.getsize(tmp_fastq2) < 50: + res = self.execute('kraken', db, outReads, args=[tmp_fastq1], options=opts) + else: + opts['--paired'] = None + res = self.execute('kraken', db, outReads, args=[tmp_fastq1, tmp_fastq2], options=opts) + os.unlink(tmp_fastq1) + os.unlink(tmp_fastq2) + + def filter(self, inReads, db, outReads, filterThreshold): + """"""Filter Kraken hits + """""" + self.execute(self.BINS['filter'], db, outReads, args=[inReads], + options={'--threshold': filterThreshold}) + + def report(self, inReads, db, outReport): + """"""Convert Kraken read-based output to summary reports + """""" + self.execute(self.BINS['report'], db, outReport, args=[inReads]) + + def execute(self, command, db, output, args=None, options=None, + option_string=None): + '''Run a kraken-* command. + + Args: + db: Kraken database directory. + output: Output file of command. + args: List of positional args. + options: List of keyword options. + option_string: Raw strip command line options. + ''' + options = options or {} + + if command == self.BINS['classify']: + if output: + options['--output'] = output + elif 'krakenuniq' in command: + options['--output'] = 'off' + option_string = option_string or '' + args = args or [] + + cmd = [command, '--db', db] + # We need some way to allow empty options args like --build, hence + # we filter out on 'x is None'. + cmd.extend([str(x) for x in itertools.chain(*options.items()) + if x is not None]) + cmd.extend(shlex.split(option_string)) + cmd.extend(args) + log.debug('Calling %s: %s', command, ' '.join(cmd)) + + if command == self.BINS['classify']: + subprocess.check_call(cmd) + elif command == self.BINS['build']: + subprocess.check_call(cmd) + else: + with util.file.open_or_gzopen(output, 'w') as of: + util.misc.run(cmd, stdout=of, stderr=subprocess.PIPE, check=True) + + +@tools.skip_install_test() +class Jellyfish(Kraken): + """""" Tool wrapper for Jellyfish (installed by kraken-all metapackage) """""" + subtool_name = 'jellyfish' + + +class KrakenUniq(Kraken): + + BINS = { + 'classify': 'krakenuniq', + 'build': 'krakenuniq-build', + 'filter': 'krakenuniq-filter', + 'report': 'krakenuniq-report'} + + def __init__(self, install_methods=None): + self.subtool_name = self.subtool_name if hasattr(self, 'subtool_name') else 'krakenuniq' + if not install_methods: + install_methods = [] + install_methods.append(tools.CondaPackage('krakenuniq', executable=self.subtool_name, version=KRAKENUNIQ_VERSION, channel='broad-viral')) + super(KrakenUniq, self).__init__(install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def pipeline(self, db, in_bams, out_reports=None, out_reads=None, + filter_threshold=None, num_threads=None): + + from itertools import zip_longest + + assert out_reads is not None or out_reports is not None + out_reports = out_reports or [] + out_reads = out_reads or [] + + for in_bam, out_read, out_report in zip_longest(in_bams, out_reads, out_reports): + self.classify(in_bam, db, out_reads=out_read, out_report=out_report, num_threads=None) + + def classify(self, in_bam, db, out_reads=None, out_report=None, num_threads=None): + """"""Classify input reads (bam) + + Args: + in_bam: unaligned reads + db: Kraken built database directory. + outReads: Output file of command. + """""" + tmp_fastq1 = util.file.mkstempfname('.1.fastq.gz') + tmp_fastq2 = util.file.mkstempfname('.2.fastq.gz') + # Do not convert this to samtools bam2fq unless we can figure out how to replicate + # the clipping functionality of Picard SamToFastq + picard = tools.picard.SamToFastqTool() + picard_opts = { + 'CLIPPING_ATTRIBUTE': tools.picard.SamToFastqTool.illumina_clipping_attribute, + 'CLIPPING_ACTION': 'X' + } + picard.execute(in_bam, tmp_fastq1, tmp_fastq2, + picardOptions=tools.picard.PicardTools.dict_to_picard_opts(picard_opts), + JVMmemory=picard.jvmMemDefault) + + opts = { + '--threads': util.misc.sanitize_thread_count(num_threads), + '--fastq-input': None, + '--gzip-compressed': None, + '--preload': None + } + if out_report: + opts['--report-file'] = out_report + # Detect if input bam was paired by checking fastq 2 + if os.path.getsize(tmp_fastq2) < 50: + res = self.execute(self.BINS['classify'], db, out_reads, args=[tmp_fastq1], options=opts) + else: + opts['--paired'] = None + res = self.execute(self.BINS['classify'], db, out_reads, args=[tmp_fastq1, tmp_fastq2], options=opts) + os.unlink(tmp_fastq1) + os.unlink(tmp_fastq2) + if out_report: + with open(out_report, 'rt+') as f: + lines = [line.strip() for line in f.readlines() if not line.startswith('#')] + lines = [line for line in lines if line] + if not lines: + f.seek(f.tell() - 1, os.SEEK_SET) + print('\t'.join(['%', 'reads', 'taxReads', 'kmers', 'dup', 'cov', 'taxID', 'rank', 'taxName']), file=f) + print('\t'.join(['100.00', '0', '0', '0', '0', 'NA', '0', 'no rank', 'unclassified']), file=f) + + def read_report(self, report_fn): + report = collections.Counter() + with open(report_fn) as f: + for line in f: + if line.startswith('#') or line.startswith('%'): + continue + line = line.strip() + if not line: + continue + parts = line.split('\t') + percent = float(parts[0]) + cum_reads = int(parts[1]) + tax_reads = int(parts[2]) + tax_kmers = int(parts[3]) + if parts[5] == 'NA': # unclassified + cov = 0 + else: + cov = float(parts[5]) + tax_id = int(parts[6]) + rank = parts[7] + name = parts[8] + report[tax_id] = (tax_reads, tax_kmers) + return report +","Python" +"Viral","broadinstitute/viral-ngs","tools/prinseq.py",".py","4043","94","""tools.Tool for prinseq."" + +import logging +import os.path +import shutil +import subprocess +import tools +import util.file + +TOOL_NAME = ""prinseq"" +TOOL_VERSION = '0.20.4' + +log = logging.getLogger(__name__) + +class PrinseqTool(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, executable=""prinseq-lite.pl"", version=TOOL_VERSION)) + tools.Tool.__init__(self, install_methods=install_methods) + + def rmdup_fastq_single(self, inFastq, outFastq): + ''' remove duplicate reads and reads with multiple Ns ''' + + if os.path.getsize(inFastq) == 0: + # prinseq-lite fails on empty file input so handle this scenario specially + log.debug(""prinseq input is empty"") + shutil.copyfile(inFastq, outFastq) + else: + outprefix = util.file.mkstempfname(""-prinseq-rmdup-out"") + cmd = [ + 'perl', self.install_and_get_path(), '-verbose', + '-ns_max_n', '1', '-derep', '1', + '-fastq', inFastq, + '-out_bad', 'null', '-line_width', '0', '-out_good', outprefix + ] + log.debug(' '.join(cmd)) + subprocess.check_call(cmd) + shutil.copyfile(outprefix+'.fastq', outFastq) + os.unlink(outprefix+'.fastq') + + def rmdup_fastq_paired(self, inFastq1, inFastq2, outFastq1, outFastq2, includeUnmated=False, unpairedOutFastq1=None, unpairedOutFastq2=None): + ''' remove duplicate reads and reads with multiple Ns ''' + + if not os.path.exists(inFastq2) or os.path.getsize(inFastq2) == 0: + # input is single-end + log.debug(""prinseq input is unpaired"") + util.file.touch(outFastq2) + if not includeUnmated: + # excluding unmated on unpaired input implies no output + util.file.touch(outFastq1) + else: + self.rmdup_fastq_single(inFastq1, outFastq1) + elif os.path.getsize(inFastq1) == 0: + # prinseq-lite fails on empty file input so handle this scenario specially + log.debug(""prinseq input is empty"") + util.file.touch(outFastq1) + util.file.touch(outFastq2) + else: + outprefix = util.file.mkstempfname(""-prinseq-rmdup-out"") + cmd = [ + 'perl', self.install_and_get_path(), '-verbose', + '-ns_max_n', '1', '-derep', '1', + '-fastq', inFastq1, '-fastq2', inFastq2, + '-out_bad', 'null', '-line_width', '0', '-out_good', outprefix + ] + log.debug(' '.join(cmd)) + subprocess.check_call(cmd) + for fn in (outprefix+'_1.fastq', outprefix+'_1_singletons.fastq', + outprefix+'_2.fastq', outprefix+'_2_singletons.fastq'): + # if any of the four output files is empty, prinseq doesn't create it at all, which is bad for us + util.file.touch(fn) + + # if the user desires the unmated reads to be included in the output fastqs + if includeUnmated: + util.file.cat(outFastq1, (outprefix+'_1.fastq', outprefix+'_1_singletons.fastq')) + util.file.cat(outFastq2, (outprefix+'_2.fastq', outprefix+'_2_singletons.fastq')) + else: + shutil.copyfile(outprefix+'_1.fastq', outFastq1) + shutil.copyfile(outprefix+'_2.fastq', outFastq2) + + # if a path is specified for the unmated reads + if unpairedOutFastq1 is not None: + shutil.copyfile(outprefix+'_1_singletons.fastq', unpairedOutFastq1) + + if unpairedOutFastq2 is not None: + shutil.copyfile(outprefix+'_2_singletons.fastq', unpairedOutFastq2) + + os.unlink(outprefix+'_1.fastq') + os.unlink(outprefix+'_2.fastq') + os.unlink(outprefix+'_1_singletons.fastq') + os.unlink(outprefix+'_2_singletons.fastq') +","Python" +"Viral","broadinstitute/viral-ngs","tools/gap2seq.py",".py","5724","117","''' + Gap2Seq - assembly gap closing tool +''' + +import itertools +import functools +import operator +import logging +import os +import os.path +import subprocess +import shlex +import shutil +import tempfile +import time + +import Bio.Seq + +import tools +import tools.samtools +import util.file +import util.misc + +TOOL_NAME = 'gap2seq' +TOOL_VERSION = '3.1.1a2' + +log = logging.getLogger(__name__) + +class Gap2SeqTool(tools.Tool): + """"""Tool wrapper for the Gap2Seq gap-closing tool."""""" + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION, executable='Gap2Seq')] + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def execute(self, args): # pylint: disable=W0221 + tool_cmd = [self.install_and_get_path()] + list(args) + log.debug('running gap2seq: ' + ' '.join(tool_cmd)) + subprocess.check_call(tool_cmd) + + def _run_gap2seq(self, reads, scaffolds, filled, *args, **kwargs): + # gap2seq (or rather the gatb library it uses) currently has a bug where tempfiles are left in the + # current working directory. So we run it in its own temp dir, but then must give absolute paths + # for all files. + + abspath = os.path.abspath + file_args = ('-s', abspath(scaffolds), '--filled', abspath(filled), + '--reads', ','.join(map(abspath,reads))) + more_args = functools.reduce(operator.concat, + [(('--' if len(arg) > 1 else '-') + arg.replace('_','-'), str(val)) + for arg, val in kwargs.items()], ()) + with util.file.tmp_dir('_gap2seq_run_dir') as gap2seq_run_dir: + with util.file.pushd_popd(gap2seq_run_dir): + self.execute(file_args+args+more_args) + + def gapfill(self, in_scaffold, in_bam, out_scaffold, solid_kmer_thresholds=(3,), kmer_sizes=(90, 80, 70, 60, 50, 40, 31), + min_gap_to_close=4, gap2seq_opts='', mem_limit_gb=4.0, threads=None, time_soft_limit_minutes=60.0, random_seed=0): + """"""Try to fill the gaps in the given scaffold, using the reads. + + Inputs: + in_scaffold: a FASTA file containing the scaffold. Each FASTA record corresponds to one + segment (for multi-segment genomes). Contigs within each segment are + separated by Ns. The exact number of Ns between contigs does not matter, as the length of the gap is one + of the things determined by the gap-filling tool. (But see `min_gap_to_close`). + in_bam: reads to use for filling the gaps. Only paired-end reads from the bam file are used, any unpaired reads + are ignored. + + Outputs: + out_scaffold: the input scaffold, with some of the gaps between contigs possibly filled. + + Params: + solid_kmer_thresholds: kmers must appear at least this many times in the reads to be considered solid. + We try gapfilling for all combinations of values of solid_kmer_thresholds and kmer_sizes. + kmer_sizes: kmer sizes to use. We try gapfilling for all combinations of values of solid_kmer_thresholds and kmer_sizes. + min_gap_to_close: stop gap-closing if all gaps are no longer than this many Ns + gap2seq_opts: extra command-line flags to pass to Gap2Seq + mem_limit_gb: max memory to use, in gigabytes + threads: number of threads to use; None means use all available cores. + time_soft_limit_minutes: stop trying to close more gaps after this many minutes (currently this is a soft/advisory limit) + random_seed: random seed for choosing random paths (0 to use current time) + + """""" + solid_kmer_thresholds = sorted(util.misc.make_seq(solid_kmer_thresholds), reverse=True) + kmer_sizes = sorted(util.misc.make_seq(kmer_sizes), reverse=True) + stop_time = time.time() + 60*time_soft_limit_minutes + threads = util.misc.sanitize_thread_count(threads, tool_max_cores_value=0) + util.misc.chk(out_scaffold != in_scaffold) + with tools.samtools.SamtoolsTool().bam2fq_tmp(in_bam) as reads, util.file.tmp_dir('_gap2seq_dir') as gap2seq_dir: + + # We call Gap2Seq for a range of parameter combinations. Output of each call is input to the next call, so + # each call only deals with gaps not closed by prior calls. We first try to close using higher-quality kmers, + # and if that fails try with lower-quality ones. + prev_scaffold = in_scaffold + for solid_kmer_threshold, kmer_size in itertools.product(solid_kmer_thresholds, kmer_sizes): + + if not any('N'*min_gap_to_close in str(rec.seq) for rec in Bio.SeqIO.parse(prev_scaffold, 'fasta')): + log.info('no gaps left, quittting gap2seq early') + break + if time.time() > stop_time: + log.info('Time limit for gap closing reached') + break + + filled_scaffold = os.path.join(gap2seq_dir, 'gap2seq-filled.s{}.k{}.fasta'.format(solid_kmer_threshold, kmer_size)) + self._run_gap2seq(reads, prev_scaffold, filled_scaffold, + *(['--all-upper']+shlex.split(gap2seq_opts)), + solid=solid_kmer_threshold, k=kmer_size, threads=threads, + max_mem=mem_limit_gb, randseed=random_seed) + + prev_scaffold = filled_scaffold + + Bio.SeqIO.convert(prev_scaffold, 'fasta', out_scaffold, 'fasta') + +","Python" +"Viral","broadinstitute/viral-ngs","tools/muscle.py",".py","1581","68","''' + The MUSCLE aligner + http://www.drive5.com/muscle +''' + + +import tools +import util.file +import util.misc + +import os +import os.path +import subprocess +import logging + +TOOL_NAME = ""muscle"" +TOOL_VERSION = '3.8.1551' +CONDA_TOOL_VERSION = '3.8.1551' + +_log = logging.getLogger(__name__) + + +class MuscleTool(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, version=CONDA_TOOL_VERSION)) + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + # pylint: disable=W0221 + def execute( + self, + inFasta, + outFasta, + maxiters=None, + maxhours=None, + fmt='fasta', + diags=None, + quiet=True, + logFile=None + ): + tool_cmd = [self.install_and_get_path(), '-in', inFasta, '-out', outFasta] + + if fmt in ('html', 'msf', 'clw', 'clwstrict'): + tool_cmd.append('-' + fmt) + else: + if fmt != 'fasta': + raise Exception() + if quiet: + tool_cmd.append('-quiet') + if diags: + tool_cmd.append('-diags') + if maxiters: + tool_cmd.extend(('-maxiters', str(maxiters))) + if maxhours: + tool_cmd.extend(('-maxhours', str(maxhours))) + if logFile: + tool_cmd.extend(('-log', logFile)) + + _log.debug(' '.join(tool_cmd)) + subprocess.check_call(tool_cmd) + # pylint: enable=W0221 + +","Python" +"Viral","broadinstitute/viral-ngs","tools/mafft.py",".py","5053","156","''' + MAFFT - Multiple alignment program for amino acid or nucleotide sequences + http://mafft.cbrc.jp/alignment/software/ +''' + +__author__ = ""tomkinsc@broadinstitute.org"" + +from Bio import SeqIO +import logging +import tools +import util.file +import util.misc +import os +import os.path +import subprocess + +TOOL_NAME = ""mafft"" +TOOL_VERSION = '7.402' + +_log = logging.getLogger(__name__) + + +class MafftTool(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION)) + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def __seqIdsAreAllUnique(self, filePath, inputFormat=""fasta""): + seqIds = [] + with open(filePath, ""r"") as inFile: + fastaFile = SeqIO.parse(inFile, inputFormat) + seqIds = [x.id for x in fastaFile] + + # collapse like IDs using set() + if len(seqIds) > len(set(seqIds)): + raise LookupError( + ""Not all sequence IDs in input are unique for file: {}"".format( + os.path.basename(filePath) + ) + ) + + # pylint: disable=W0221 + def execute( + self, + inFastas, + outFile, + localpair, + globalpair, + preservecase, + reorder, + outputAsClustal, + maxiters, + gapOpeningPenalty=None, + offset=None, + threads=None, + verbose=True, + retree=None + ): + inputFileName = """" + tempCombinedInputFile = """" + + # get the full paths of input and output files in case the user has specified relative paths + inputFiles = [] + for f in inFastas: + inputFiles.append(os.path.abspath(f)) + outFile = os.path.abspath(outFile) + + # ensure that all sequence IDs in each input file are unique + # (otherwise the alignment result makes little sense) + # we can check before combining to localize duplications to a specific file + for filePath in inputFiles: + self.__seqIdsAreAllUnique(filePath) + + # if multiple fasta files are specified for input + if len(inputFiles) > 1: + # combined specified input files into a single temp FASTA file so MAFFT can read them + tempFileSuffix = """" + for filePath in inputFiles: + tempFileSuffix += ""__"" + os.path.basename(filePath) + tempCombinedInputFile = util.file.mkstempfname('__combined.{}'.format(tempFileSuffix)) + with open(tempCombinedInputFile, ""w"") as outfile: + for f in inputFiles: + with open(f, ""r"") as infile: + outfile.write(infile.read()) + inputFileName = tempCombinedInputFile + # if there is only one file specified, just use it + else: + inputFileName = inputFiles[0] + + # check that all sequence IDs in a file are unique + self.__seqIdsAreAllUnique(inputFileName) + + # change the pwd, since the shell script that comes with mafft depends on the pwd + # being correct + pwdBeforeMafft = os.getcwd() + os.chdir(os.path.dirname(self.install_and_get_path())) + + # build the MAFFT command + tool_cmd = [self.install_and_get_path()] + + if not (retree or localpair or globalpair): + tool_cmd.append(""--auto"") + tool_cmd.extend([""--thread"", ""{}"".format(util.misc.sanitize_thread_count(threads))]) + + if localpair and globalpair: + raise Exception(""Alignment type must be either local or global, not both."") + + if localpair: + tool_cmd.append(""--localpair"") + if not maxiters: + maxiters = 1000 + if globalpair: + tool_cmd.append(""--globalpair"") + if not maxiters: + maxiters = 1000 + if preservecase: + tool_cmd.append(""--preservecase"") + if reorder: + tool_cmd.append(""--reorder"") + if retree: + tool_cmd.extend([""--retree"", ""{}"".format(retree)]) + if gapOpeningPenalty: + tool_cmd.extend([""--op"", ""{penalty}"".format(penalty=gapOpeningPenalty)]) + if offset: + tool_cmd.extend([""--ep"", ""{num}"".format(num=offset)]) + if not verbose: + tool_cmd.append(""--quiet"") + if outputAsClustal: + tool_cmd.append(""--clustalout"") + if maxiters: + tool_cmd.extend([""--maxiterate"", ""{iters}"".format(iters=maxiters)]) + + tool_cmd.append(inputFileName) + + _log.debug(' '.join(tool_cmd)) + + # run the MAFFT alignment + with open(outFile, 'w') as outf: + util.misc.run_and_save(tool_cmd, outf=outf) + + if len(tempCombinedInputFile): + # remove temp FASTA file + os.unlink(tempCombinedInputFile) + + # restore pwd + os.chdir(pwdBeforeMafft) + + return outFile + # pylint: enable=W0221 +","Python" +"Viral","broadinstitute/viral-ngs","tools/bbmap.py",".py","2457","66","''' + Tool wrapper for the BBMap aligner and related tools. +''' + +import logging +import os +import os.path +import subprocess + +import util.file +import tools +import tools.samtools +import tools.picard + +TOOL_NAME = 'bbmap' +TOOL_VERSION = '38.56' + +_log = logging.getLogger(__name__) # pylint: disable=invalid-name + +class BBMapTool(tools.Tool): + '''Tool wrapper for the BBMap aligner and related tools.''' + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION, executable='bbmap.sh')] + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def execute(self, tool, **kwargs): # pylint: disable=arguments-differ + tool_dir = os.path.dirname(self.install_and_get_path()) + tool_cmd = [os.path.join(tool_dir, tool)] + \ + ['{}={}'.format('in' if arg=='in_' else arg, + (val is True and 't') or (val is False and 'f') or val) + for arg, val in kwargs.items()] + _log.debug('Running BBMap tool: %s', ' '.join(tool_cmd)) + subprocess.check_call(tool_cmd) + + def align(self, inBam, refFasta, outBam, min_qual=0, nodisk=True, JVMmemory=None, **kwargs): + with tools.samtools.SamtoolsTool().bam2fq_tmp(inBam) as (in1, in2), \ + util.file.tmp_dir('_bbmap_align') as t_dir: + tmp_bam = os.path.join(t_dir, 'bbmap_out.bam') + self.execute(tool='bbmap.sh', in1=in1, in2=in2, ref=refFasta, out=tmp_bam, nodisk=nodisk, **kwargs) + + # Samtools filter (optional) + if min_qual: + tmp_bam2 = os.path.join(tdir, 'bbmap.filtered.bam') + cmd = [samtools.install_and_get_path(), 'view', '-b', '-S', '-1', '-q', str(min_qual), tmp_bam] + _log.debug('%s > %s', ' '.join(cmd), tmp_bam2) + with open(tmp_bam2, 'wb') as outf: + util.misc.run_and_save(cmd, outf=outf) + os.unlink(tmp_bam) + tmp_bam = tmp_bam2 + + # Picard SortSam + sorter = tools.picard.SortSamTool() + sorter.execute( + tmp_bam, + outBam, + sort_order='coordinate', + picardOptions=['CREATE_INDEX=true', 'VALIDATION_STRINGENCY=SILENT'], + JVMmemory=JVMmemory + ) + +","Python" +"Viral","broadinstitute/viral-ngs","tools/trinity.py",".py","3257","97","''' + The Trinity RNA-SEQ assembler + + This uses an older version of Trinity that uses an older + assembly algorithm that works better with highly diverse + viral genomes. +''' + +import contextlib +import logging +import os +import os.path +import platform +import resource +import subprocess +import tempfile +import shutil +import sys +import tools +import util.misc + +TOOL_NAME = ""trinity"" +TOOL_VERSION = ""2011-11-26"" +CONDA_TOOL_VERSION = ""date.2011_11_26"" # conda versions cannot have hyphens... + +log = logging.getLogger(__name__) + + +@contextlib.contextmanager +def unlimited_stack(): + '''Set the ulimit on stack size to be infinity. + + OS X has a fixed hard stack size limit of 64 MB, so we're not setting it here. + ''' + soft, hard = resource.getrlimit(resource.RLIMIT_STACK) + if sys.platform.startswith('linux'): + new_soft, new_hard = (resource.RLIM_INFINITY, resource.RLIM_INFINITY) + try: + resource.setrlimit(resource.RLIMIT_STACK, (new_soft, new_hard)) + yield + resource.setrlimit(resource.RLIMIT_STACK, (soft, hard)) + except (ValueError, OSError) as e: + log.warning('Error raising stacksize to unlimited: %s', str(e)) + yield + else: + yield + + +class TrinityTool(tools.Tool): + jvm_mem_default = '4g' + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, executable=""Trinity"", version=CONDA_TOOL_VERSION)) + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def execute(self, + inFastq1, + inFastq2, + outFasta, + min_contig_length=300, + JVMmemory=None, + threads=None): # pylint: disable=W0221 + if JVMmemory is None: + JVMmemory = self.jvm_mem_default + outdir = tempfile.mkdtemp(prefix='trinity-') + util.misc.sanitize_thread_count(threads) + cmd = [ + self.install_and_get_path(), '--CPU', '{}'.format(util.misc.sanitize_thread_count(threads)), '--bflyHeapSpace', JVMmemory.upper(), + '--min_contig_length', str(min_contig_length), '--seqType', 'fq', '--left', inFastq1, '--right', inFastq2, + '--output', outdir + ] + log.debug(' '.join(cmd)) + + # + # Fix some quirks of the Trinity.pl script + # + trinity_env = dict(os.environ) + # Ensure OSTYPE is set + if 'OSTYPE' not in trinity_env: + trinity_env['OSTYPE'] = platform.system().lower() + # Ensure _JAVA_OPTIONS is not set: OpenJDK java always prints a message to stdout that it picked up + # _JAVA_OPTIONS, which confuses Trinity.pl's attempt to get the java version. + # Note that the Java heap options will still be passed to trinity via the --bflyHeapSpace parameter. + if '_JAVA_OPTIONS' in trinity_env: + del trinity_env['_JAVA_OPTIONS'] + + with unlimited_stack(): + subprocess.check_call(cmd, env=trinity_env) + + shutil.copyfile(os.path.join(outdir, 'Trinity.fasta'), outFasta) + shutil.rmtree(outdir, ignore_errors=True) +","Python" +"Viral","broadinstitute/viral-ngs","tools/tbl2asn.py",".py","3720","115","''' + tbl2asn - from NCBI + http://www.ncbi.nlm.nih.gov/genbank/tbl2asn2/ +''' + +__author__ = ""dpark@broadinstitute.org"" + +import logging +import tools +import util.file +import os +import sys +import os.path +import subprocess +import gzip + +TOOL_NAME = ""tbl2asn"" +TOOL_VERSION = ""25.6"" # quirk: versions error-out one year after their compilation date +TOOL_URL = 'ftp://ftp.ncbi.nih.gov/toolbox/ncbi_tools/converters/by_program/tbl2asn/{os}.tbl2asn.gz' + +log = logging.getLogger(__name__) + + +class Tbl2AsnTool(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION)) + install_methods.append(DownloadGzipBinary(TOOL_URL.format(os=get_bintype()), 'tbl2asn')) + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return None + + # pylint: disable=W0221 + def execute( + self, + templateFile, + inputDir, + outputDir=None, + source_quals=None, + comment=None, + verification='vb', + file_type='s', + structured_comment_file=None, + per_genome_comment=False + ): + source_quals = source_quals or [] + + tool_cmd = [self.install_and_get_path(), '-t', templateFile] + + if inputDir: + tool_cmd += ['-p', inputDir] + if outputDir: + tool_cmd += ['-r', outputDir] + if source_quals: + tool_cmd.append('-j') + tool_cmd.append('""{}""'.format(' '.join(""[{}={}]"".format(k, v) for k, v in source_quals))) + if comment: + tool_cmd += ['-y', comment] + if structured_comment_file: + tool_cmd += ['-w', structured_comment_file] + if verification: + tool_cmd += ['-V', verification] + if file_type: + tool_cmd += ['-a', file_type] + if per_genome_comment: + tool_cmd += ['-X', 'C'] + + log.debug(' '.join(tool_cmd)) + + # tbl2asn has a fun quirk where if the build is more than a year old + # it exits with a non-zero code and tells you to upgrade + # See: https://www.ncbi.nlm.nih.gov/IEB/ToolBox/C_DOC/lxr/source/demo/tbl2asn.c#L9674 + # We can try to work around this by examining the output for the upgrade message + try: + tbl2asn_output = subprocess.check_output(tool_cmd, stderr=subprocess.STDOUT) + sys.stdout.write(tbl2asn_output.decode(""UTF-8"")) + sys.stdout.flush() + except subprocess.CalledProcessError as e: + old_version_expected_output = ""This copy of tbl2asn is more than a year old. Please download the current version."" + if old_version_expected_output in e.output.decode('UTF-8'): + pass + else: + sys.stdout.write(e.output.decode(""UTF-8"")) + sys.stdout.flush() + raise e + + # pylint: enable=W0221 + + +def get_bintype(): + uname = os.uname() + if uname[0] == 'Darwin': + return 'mac' + elif uname[0] == 'Linux': + if uname[4] == 'x86_64': + return 'linux64' + else: + return 'linux' + else: + raise Exception('unsupported OS') + + +class DownloadGzipBinary(tools.DownloadPackage): + + def unpack(self, download_dir): + util.file.mkdir_p(self.destination_dir) + if (self.download_file.endswith('.gz') and not self.download_file.endswith('.tar.gz')): + with gzip.open(os.path.join(download_dir, self.download_file)) as inf: + with open(self.targetpath, 'wb') as outf: + outf.write(inf.read()) + os.chmod(self.targetpath, 0o755) +","Python" +"Viral","broadinstitute/viral-ngs","tools/samtools.py",".py","11266","299","''' + The Samtools package. + + TO DO: much of this stuff can be all eliminated by using pysam instead, as + pysam (in its current versions) is meant to be the complete python + implementation of htslib/samtools. + + http://pysam.readthedocs.org/en/latest/usage.html#using-samtools-commands-within-python + + Current bug with pysam 0.8.1: nosetests does not work unless you use --nocapture. + python -m unittest works. Something about redirecting stdout. + Actually, Travis CI still has issues with pysam and stdout even with --nocapture. + + pysam 0.9.1 stops redirecting stdout which makes things much easier, + but it's a pain to pip install. +''' + +import logging +import shutil +import os +import re +import os.path +import subprocess +import tempfile +import contextlib +from collections import OrderedDict +from decimal import * + +import pysam + +import tools +import util.file +import util.misc + +TOOL_NAME = 'samtools' +TOOL_VERSION = '1.9' + +log = logging.getLogger(__name__) + + +class SamtoolsTool(tools.Tool): + + def __init__(self, install_methods=None): + self.installed_method = True + + def install(self): + pass + + def is_installed(self): + return True + + def install_and_get_path(self): + # the conda version wraps the jar file with a shell script + return 'samtools' + + def version(self): + return TOOL_VERSION + + def execute(self, command, args, stdout=None, stderr=None, background=False): # pylint: disable=W0221 + tool_cmd = [self.install_and_get_path(), command] + args + log.debug(' '.join(tool_cmd)) + if stdout: + stdout = open(stdout, 'w') + if stderr: + stderr = open(stderr, 'w') + + env = os.environ.copy() + env.pop('JAVA_HOME', None) + if background: + subprocess.Popen(tool_cmd, stdout=stdout, stderr=stderr, env=env) + else: + subprocess.check_call(tool_cmd, stdout=stdout, stderr=stderr, env=env) + + if stdout: + stdout.close() + if stderr: + stderr.close() + + def view(self, args, inFile, outFile, regions=None, threads=None, background=False): + regions = regions or [] + args = args or [] + + # -@ seems to result in segfaults in some cases + # so this is commented out for now... + + self.execute('view', args + ['-o', outFile, inFile] + regions, background=background) + #opts = args + ['-o', outFile, inFile] + regions + #pysam.view(*opts) + + def bam2fq(self, inBam, outFq1, outFq2=None): + if outFq2 is None: + self.execute('bam2fq', ['-n', inBam], stdout=outFq1) + else: + self.execute('bam2fq', ['-1', outFq1, '-2', outFq2, inBam]) + + def bam2fq_pipe(self, inBam): + tool_cmd = [self.install_and_get_path(), 'bam2fq', '-n', inBam] + log.debug(' '.join(tool_cmd) + ' |') + p = subprocess.Popen(tool_cmd, stdout=subprocess.PIPE) + return p + + def bam2fa(self, inBam, outFa1, outFa2=None, outFa0=None, append_mate_num=False): + if outFa2 is None: + args = ['-N' if append_mate_num else '-n'] + else: + args = ['-1', outFa1, '-2', outFa2] + if outFa0: + args += ['-0', outFa0] + args += [inBam] + if outFa2 is None: + self.execute('fasta', args, stdout=outFa1) + else: + self.execute('fasta', args) + + def bam2fa_pipe(self, inBam): + tool_cmd = [self.install_and_get_path(), 'fasta', '-n', inBam] + log.debug(' '.join(tool_cmd) + ' |') + p = subprocess.Popen(tool_cmd, stdout=subprocess.PIPE) + return p.stdout + + @contextlib.contextmanager + def bam2fq_tmp(self, inBam): + with util.file.tempfnames(('.1.fq', '.2.fq')) as (reads1, reads2): + self.bam2fq(inBam, reads1, reads2) + yield reads1, reads2 + + @contextlib.contextmanager + def bam2fa_tmp(self, inBam): + with util.file.tempfnames(('.1.fa', '.2.fa')) as (reads1, reads2): + self.bam2fa(inBam, reads1, reads2) + yield reads1, reads2 + + def sort(self, inFile, outFile, args=None, threads=None): + # inFile can be .sam, .bam, .cram + # outFile can be .sam, .bam, .cram + args = args or [] + if '-@' not in args: + args.extend(('-@', str(util.misc.sanitize_thread_count(threads)))) + if '-T' not in args and os.path.isdir(tempfile.tempdir): + args.extend(('-T', tempfile.tempdir)) + + args.extend(('-o', outFile, inFile)) + self.execute('sort', args) + + def merge(self, inFiles, outFile, options=None): + ""Merge a list of inFiles to create outFile."" + options = options or ['-f'] + + # We are using -f for now because mkstempfname actually makes an empty + # file, and merge fails with that as output target without the -f. + # When mkstempfname is fixed, we should remove the -f. + self.execute('merge', options + [outFile] + inFiles) + + def index(self, inBam): + # inBam can be .bam or .cram + self.execute('index', [inBam]) + + def faidx(self, inFasta, overwrite=False): + ''' Index reference genome for samtools ''' + outfname = inFasta + '.fai' + if os.path.isfile(outfname): + if overwrite: + os.unlink(outfname) + else: + return + #pysam.faidx(inFasta) + self.execute('faidx', [inFasta]) + + def depth(self, inBam, outFile, options=None): + """""" Write a TSV file with coverage depth by position """""" + options = options or [""-aa"", ""-m"", ""1000000""] + + self.execute('depth', options + [inBam], stdout=outFile) + + def idxstats(self, inBam, statsFile): + self.execute('idxstats', [inBam], stdout=statsFile) + + def reheader(self, inBam, headerFile, outBam): + self.execute('reheader', [headerFile, inBam], stdout=outBam) + + def dumpHeader(self, inBam, outHeader): + opts = [] + if inBam.endswith('.bam'): + opts = ['-H'] + elif inBam.endswith('.sam'): + opts = ['-H', '-S'] + #header = pysam.view(*opts) + self.view(opts, inBam, outHeader) + + def removeDoublyMappedReads(self, inBam, outBam): + #opts = ['-b', '-f 2'] + opts = ['-b', '-F' '1028', '-f', '2', '-@', '3'] + self.view(opts, inBam, outBam) + + def filterByCigarString(self, inBam, outBam, + regexToMatchForRemoval='^((?:[0-9]+[ID]){1}(?:[0-9]+[MNIDSHPX=])+)|((?:[0-9]+[MNIDSHPX=])+(?:[0-9]+[ID]){1})$', + invertResult=False): + ''' + This function applies a regex to the cigar string for each read. + If the regex matches, the read is not written to the output unless + invertResult is True. + The default regex matches cigar strings with trailing or leading indels: + '^((?:[0-9]+[ID]){1}(?:[0-9]+[MNIDSHPX=])+)|((?:[0-9]+[MNIDSHPX=])+(?:[0-9]+[ID]){1})$' + + ''' + regex = re.compile(regexToMatchForRemoval) + with pysam.AlignmentFile(inBam, 'rb', check_sq=False) as inb: + with pysam.AlignmentFile(outBam, 'wb', header=inb.header) as outf: + # process the lines individually and write them or not, depending on + # whether they match regexToMatchForRemoval + for read in inb: + if read.cigarstring: + # perform a regex match + matches = regex.search(read.cigarstring) + # if the regex was found (or not, if inverted) + if (not invertResult and matches) or (invertResult and not matches): + # continue to the next read (don't write out this one) + continue + else: + if invertResult: + continue + # otherwise write out the line + outf.write(read) + + + def downsample(self, inBam, outBam, probability): + + if not probability: + raise Exception(""Probability must be defined"") + if float(probability) <= 0 or float(probability) > 1: + raise Exception(""Probability must be in range (0,1]. This value was given: %s"" % probability) + + opts = ['-s', str(1) + '.' + str(probability).split('.')[1], '-@', '3'] # -s subsamples: seed.fraction + self.view(opts, inBam, outBam) + + def downsample_to_approx_count(self, inBam, outBam, read_count): + total_read_count = self.count(inBam) + probability = Decimal(int(read_count)) / Decimal(total_read_count) + probability = 1 if probability > 1 else probability + + if probability < 1: + self.downsample(inBam, outBam, probability) + else: + _log.info(""Requested downsample count exceeds number of reads. Including all reads in output."") + shutil.copyfile(inBam, outBam) + + def getHeader(self, inBam): + ''' fetch BAM header as a list of tuples (already split on tabs) ''' + tmpf = util.file.mkstempfname('.txt') + self.dumpHeader(inBam, tmpf) + with open(tmpf, 'rb') as inf: + header = list(line.decode(""latin-1"").rstrip('\n').split('\t') for line in inf) + os.unlink(tmpf) + return header + + def getReadGroups(self, inBam): + ''' fetch all read groups from the BAM header as an OrderedDict of + RG ID -> RG dict. The RG dict is a mapping of read group keyword + (like ID, DT, PU, LB, SM, CN, PL, etc) to value. ID is included + and not stripped out. ID is required for all read groups. + Resulting keys are in same order as @RG lines in bam file. + ''' + rgs = [ + dict(x.split(':', 1) for x in row[1:]) for row in self.getHeader(inBam) if len(row) > 0 and row[0] == '@RG' + ] + return OrderedDict((rg['ID'], rg) for rg in rgs) + + def count(self, inBam, opts=None, regions=None): + opts = opts or [] + regions = regions or [] + + cmd = [self.install_and_get_path(), 'view', '-c'] + opts + [inBam] + regions + return int(subprocess.check_output(cmd).strip()) + #if inBam.endswith('.sam') and '-S' not in opts: + # opts = ['-S'] + opts + #cmd = ['-c'] + opts + [inBam] + regions + #return int(pysam.view(*cmd)[0].strip()) + + def mpileup(self, inBam, outPileup, opts=None): + opts = opts or [] + + self.execute('mpileup', opts + [inBam], stdout=outPileup, stderr='/dev/null') # Suppress info messages + + def isEmpty(self, inBam): + if not os.path.isfile(inBam): + return True + else: + tmpf = util.file.mkstempfname('.txt') + self.dumpHeader(inBam, tmpf) + header_size = os.path.getsize(tmpf) + if (os.path.getsize(inBam) > (100 + 5 * header_size)): + # large BAM file: assume it is not empty + # a BAM file definitely has reads in it if its filesize is larger + # than just the header itself + return False + else: + # small BAM file: just count and see if it's non-zero + return (0 == self.count(inBam)) +","Python" +"Viral","broadinstitute/viral-ngs","tools/bwa.py",".py","13669","314","''' + The BWA aligner. + +''' + +from collections import defaultdict +import logging +import os +import os.path +import subprocess +import shutil +import concurrent.futures + +import tools +import tools.samtools +import tools.picard +import util.file +import util.misc + +TOOL_NAME = 'bwa' +TOOL_VERSION = '0.7.17' + +log = logging.getLogger(__name__) + + +class Bwa(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION)] + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def execute(self, command, args, stdout=None, stdin=None, background=False): # pylint: disable=W0221 + tool_cmd = [self.install_and_get_path(), command] + args + log.debug(' '.join(tool_cmd)) + if stdout: + stdout = open(stdout, 'w') + if background: + subprocess.Popen(tool_cmd, stdout=stdout, stdin=stdin) + else: + subprocess.check_call(tool_cmd, stdout=stdout, stdin=stdin) + if stdout: + stdout.close() + + def index(self, inFasta, output=None, algorithm=None): + cmd = [] + if algorithm is not None: + if algorithm not in ('is', 'bwtsw'): + raise NameError(algorithm + "" is not a recognized algorithm"") + cmd.extend(('-a', algorithm)) + if output: + cmd.extend(('-p', output)) + cmd.append(inFasta) + self.execute('index', cmd) + return output + + def align_mem_bam(self, inBam, refDb, outBam, options=None, + min_score_to_filter=None, threads=None, JVMmemory=None, invert_filter=False, should_index=True): + options = options or [] + + samtools = tools.samtools.SamtoolsTool() + threads = util.misc.sanitize_thread_count(threads) + + # fetch list of RGs + rgs = list(samtools.getReadGroups(inBam).keys()) + + if len(rgs) == 0: + # Can't do this + raise InvalidBamHeaderError(""{} lacks read groups"".format(inBam)) + + elif len(rgs) == 1: + # Only one RG, keep it simple + self.align_mem_one_rg(inBam, refDb, outBam, options=options, + min_score_to_filter=min_score_to_filter, + threads=threads, invert_filter=invert_filter) + + else: + # Multiple RGs, align one at a time and merge + align_bams = [] + + threads_for_chunk = int(round(min(max(threads / len(rgs),1),threads),0))+1 + # worker count limited to 1 for now to reduce in-memory index size resulting from + # running multiple copies of bwa in parallel + workers = 1 #len(rgs) if len(rgs) 0: + align_bams.append(aln_bam) + else: + log.warning(""No alignment output for RG %s in file %s against %s"", rg, inBam, refDb) + + if len(align_bams) == 0: + util.file.touch(outBam) + else: + # Merge BAMs, sort, and index + picardOptions = ['SORT_ORDER=coordinate', 'USE_THREADING=true'] + if should_index: + picardOptions.append('CREATE_INDEX=true') + tools.picard.MergeSamFilesTool().execute( + align_bams, + outBam, + picardOptions=picardOptions, + JVMmemory=JVMmemory + ) + # no longer required since MergeSamFiles creates the index + #if outBam.endswith("".bam"") or outBam.endswith("".cram""): + # samtools.index(outBam) + for bam in align_bams: + os.unlink(bam) + + def align_mem_one_rg(self, inBam, refDb, outBam, rgid=None, options=None, + min_score_to_filter=None, threads=None, JVMmemory=None, invert_filter=False, should_index=True): + """""" + Performs an alignment of one read group in a bam file to a reference fasta file + + TODO: With the addition of a third aligner to viral-ngs, the functionality + common to this method and to the comparable method in the Novoalign wrapper should + be broken out as an ""aligner"" superclass, capable of aligning bam or fastq files with an arbitrary + aligner, while preserving read groups. + """""" + options = options or [] + + samtools = tools.samtools.SamtoolsTool() + + # Require exactly one RG + rgs = samtools.getReadGroups(inBam) + if len(rgs) == 0: + raise InvalidBamHeaderError(""{} lacks read groups"".format(inBam)) + elif len(rgs) == 1: + if not rgid: + rgid = list(rgs.keys())[0] + elif not rgid: + raise InvalidBamHeaderError(""{} has {} read groups, but we require exactly one"".format(inBam, len(rgs))) + if rgid not in rgs: + raise InvalidBamHeaderError(""{} has read groups, but not {}"".format(inBam, rgid)) + + headerFile = util.file.mkstempfname('.{}.header.txt'.format(rgid)) + # Strip inBam to just one RG (if necessary) + removeInput = False + if len(rgs) == 1: + one_rg_inBam = inBam + tools.samtools.SamtoolsTool().dumpHeader(one_rg_inBam, headerFile) + else: + # strip inBam to one read group + with util.file.tempfname('.onebam.bam') as tmp_bam: + samtools.view(['-b', '-r', rgid], inBam, tmp_bam) + # special exit if this file is empty + if samtools.count(tmp_bam) == 0: + log.warning(""No reads present for RG %s in file: %s"", rgid, inBam) + return + # simplify BAM header otherwise Novoalign gets confused + one_rg_inBam = util.file.mkstempfname('.{}.in.bam'.format(rgid)) + removeInput = True + + with open(headerFile, 'wt') as outf: + for row in samtools.getHeader(inBam): + if len(row) > 0 and row[0] == '@RG': + if rgid != list(x[3:] for x in row if x.startswith('ID:'))[0]: + # skip all read groups that are not rgid + continue + outf.write('\t'.join(row) + '\n') + samtools.reheader(tmp_bam, headerFile, one_rg_inBam) + + # perform actual alignment + + # get the read group line to give to BWA + readgroup_line = """" + with open(headerFile) as inf: + for line in inf: + if line.startswith(""@RG""): + readgroup_line = line + + assert len(readgroup_line) > 0 + + #with util.file.tempfname('.aligned.bam') as tmp_bam_aligned: + # rather than reheader the alignment bam file later so it has the readgroup information + # from the original bam file, we'll pass the RG line to bwa to write out + self.mem(one_rg_inBam, refDb, outBam, options=options+['-R', + readgroup_line.rstrip(""\r\n"").replace('\t','\\t')], + min_score_to_filter=min_score_to_filter, threads=threads, invert_filter=invert_filter, should_index=should_index) + + return (rgid, outBam) + # if there was more than one RG in the input, we had to create a temporary file with the one RG specified + # and we can safely delete it this file + # if there was only one RG in the input, we used it directly and should not delete it + if removeInput: + os.unlink(one_rg_inBam) + + def mem(self, inReads, refDb, outAlign, options=None, min_score_to_filter=None, + threads=None, invert_filter=False, should_index=True): + options = [] if not options else options + + threads = util.misc.sanitize_thread_count(threads) + if '-t' not in options: + options.extend(('-t', str(threads))) + + samtools = tools.samtools.SamtoolsTool() + + aln_sam = util.file.mkstempfname('.aligned.sam') + fastq_pipe = samtools.bam2fq_pipe(inReads) + self.execute('mem', options + ['-p', refDb, '-'], stdout=aln_sam, stdin=fastq_pipe.stdout) + + if fastq_pipe.poll(): + raise subprocess.CalledProcessError(fastq_pipe.returncode, ""samtools.bam2fq_pipe() for {}"".format(inReads)) + + if min_score_to_filter: + # Filter reads in the alignment based on on their alignment score + aln_sam_filtered = util.file.mkstempfname('.sam') + self.filter_sam_on_alignment_score(aln_sam, aln_sam_filtered, + min_score_to_filter, options, invert_filter=invert_filter) + os.unlink(aln_sam) + else: + aln_sam_filtered = aln_sam + + + samtools.sort(aln_sam_filtered, outAlign, threads=threads) + os.unlink(aln_sam_filtered) + + # cannot index sam files; only do so if a bam/cram is desired + if should_index and (outAlign.endswith("".bam"") or outAlign.endswith("".cram"")): + samtools.index(outAlign) + + def filter_sam_on_alignment_score(self, in_sam, out_sam, min_score_to_filter, + bwa_options, invert_filter=False): + """"""Filter reads in an alignment based on their alignment score. + + This is useful because bwa mem ignores its -T option on paired-end + data (https://github.com/lh3/bwa/issues/133); -T normally specifies + the threshold on score below which alignments are not output. + + This sums the alignment score across all alignments for each + query name in the aligned SAM. This has the effect of summing + the score across both reads in a pair (their query name is the same) + as well as supplementary alignments (SAM flag 2048) and secondary + alignments (SAM flag 256). The use of a summed score is reasonable for + supplementary alignments, which bwa mem outputs. bwa mem normally + does not output secondary alignments, but if it does then the + use of a summed score might not be reasonable. + """""" + if '-a' in bwa_options: + log.warning((""'bwa mem -a' will output secondary alignments, "" + ""and the filter on alignment score will use "" + ""a score that is summed across the primary and "" + ""secondary alignments for each read; this might "" + ""not be desired"")) + + # Determine an alignment score for each query name + qname_alignment_scores = defaultdict(int) + with open(in_sam) as in_sam_f: + for line in in_sam_f: + line = line.rstrip() + if line.startswith('@'): + # Skip headers + continue + ls = line.split('\t') + + # bwa's output should have optional fields for all + # alignments + assert len(ls) >= 12 + + qname = ls[0] + aln_score = None + for opt_field in ls[11:]: + opt_field_tag, opt_field_type, opt_field_val = opt_field.split(':') + if opt_field_tag == 'AS': + # The alignment score output by bwa should be a + # signed integer + assert opt_field_type == 'i' + aln_score = int(opt_field_val) + break + if aln_score is None: + raise Exception((""Unknown alignment score for query "" + ""name %s"") % qname) + qname_alignment_scores[qname] += aln_score + + # Write a SAM file that only includes reads whose query has a + # sufficient alignment score summed across its alignments + with open(out_sam, 'w') as out_sam_f: + with open(in_sam) as in_sam_f: + for line in in_sam_f: + line = line.rstrip() + if line.startswith('@'): + # Rewrite all headers + out_sam_f.write(line + '\n') + continue + ls = line.split('\t') + + qname = ls[0] + if ((qname_alignment_scores[qname] >= min_score_to_filter and not invert_filter) or + (qname_alignment_scores[qname] < min_score_to_filter and invert_filter)): + # Write this query name + out_sam_f.write(line + '\n') +","Python" +"Viral","broadinstitute/viral-ngs","tools/__init__.py",".py","26287","667","'''class Tool, class InstallMethod, and related subclasses and methods''' + +__author__ = ""dpark@broadinstitute.org,irwin@broadinstitute.org"" + +import collections +import json +import operator +import os +import re +import logging +import tempfile +import shutil +import shlex +import subprocess +import util.file +import util.misc + +from urllib.request import urlretrieve # pylint: disable=E0611 +from urllib.parse import urlparse # pylint: disable=E0611 + +# Put all tool files in __all__ +# allows ""from tools import *"" to import all tools for testtools +__all__ = sorted( + [ + filename[:-3] # Remove .py + for filename in os.listdir(os.path.dirname(__file__)) # tools directory + if filename.endswith( + '.py') and filename != '__init__.py' and filename not in [ # Add any files to exclude here: + # e.g. 'sometool.py', + ] + ] +) +installed_tools = {} + +_log = logging.getLogger(__name__) + + +def iter_leaf_subclasses(a_class): + ""Iterate over subclasses at all levels that don't themselves have a subclass"" + is_leaf = True + for subclass in sorted(a_class.__subclasses__(), key=operator.attrgetter(""__name__"")): + is_leaf = False + for leaf_class in iter_leaf_subclasses(subclass): + if not getattr(leaf_class, '_skiptest', False): + yield leaf_class + if is_leaf: + yield a_class + +def all_tool_classes(): + return iter_leaf_subclasses(Tool) + + +def get_tool_by_name(name): + if name not in installed_tools: + raise NotImplementedError + return installed_tools[name] + + +def skip_install_test(condition=None): + '''Decorate the Tool class to skip the installation test.''' + + def decorator(klass): + if callable(condition) and not condition(): + return klass + klass._skiptest = True + return klass + + return decorator + + +def is_osx(): + return os.uname()[0] == 'Darwin' + + +class Tool(object): + ''' Base tool class that includes install machinery. + + TO DO: add something about dependencies.. + ''' + + def __init__(self, install_methods=None): + install_methods = install_methods or [] + + self.install_methods = install_methods + self.installed_method = None + self.exec_path = None + + def is_installed(self): + return (self.installed_method is not None) + + def install(self): + if not self.is_installed(): + for m in self.install_methods: + if not m.is_attempted(): + m.attempt_install() + if m.is_installed(): + self.installed_method = m + self.exec_path = m.executable_path() + installed_tools[self.__class__.__name__] = self + break + + def get_install_methods(self): + return self.install_methods + + def set_install_methods(self, methods): + self.install_methods = methods + + def version(self): + return None + + def executable_path(self): + return self.exec_path + + def execute(self, *args): + assert not os.system(self.exec_path + ' ' + args) + + def install_and_get_path(self): + self.install() + if self.executable_path() == None: + raise NameError(""unsuccessful in installing "" + type(self).__name__) + return self.executable_path() + + +class InstallMethod(object): + ''' Base class for installation methods for a given tool. + None of these methods should ever fail/error. attempt_install should + return silently regardless of the outcome (is_installed must be + called to verify success or failure). + ''' + + def __init__(self): + self.attempts = 0 + + def is_attempted(self): + return self.attempts + + def attempt_install(self): # Override _attempt_install, not this. + self.attempts += 1 + self._attempt_install() + + def _attempt_install(self): + raise NotImplementedError + + def is_installed(self): + raise NotImplementedError + + def executable_path(self): + raise NotImplementedError + + +class PrexistingUnixCommand(InstallMethod): + ''' This is an install method that tries to find whether an executable + binary already exists for free on the unix file system--it doesn't + actually try to install anything. + ''' + + def __init__(self, path, verifycmd=None, verifycode=0, require_executability=True): + self.path = path + self.verifycmd = verifycmd + self.verifycode = verifycode + self.installed = False + self.require_executability = require_executability + InstallMethod.__init__(self) + + def _attempt_install(self): + if os.access(self.path, (os.X_OK | os.R_OK) if self.require_executability else os.R_OK): + if self.verifycmd: + self.installed = (os.system(self.verifycmd) == self.verifycode) + else: + self.installed = True + else: + self.installed = False + + def is_installed(self): + if not self.is_attempted(): + self.attempt_install() + return self.installed + + def executable_path(self): + return self.installed and self.path or None + + +class CondaPackageVersion(object): + + def __init__(self, version, build_type=None): + self.version = version + self.build_type = build_type + + def __cmp__(self, other): + return self.__dict__ == other.__dict__ + + def __repr__(self): + if self.build_type: + return '{}-{}'.format(self.version, self.build_type) + else: + return self.version + + def satisfies(self, spec): + if spec.build_type: + if self.build_type != spec.build_type: + return False + # if the specified version is blank/None (not specified), any version will work + return (spec.version=="""") or (spec.version==None) or (self.version == spec.version) + + @property + def version_spec(self): + if self.build_type: + return '{}={}'.format(self.version, self.build_type) + else: + return self.version + + +class CondaPackage(InstallMethod): + ''' This is an install method for tools that can be installed via + conda. + ''' + + QUIET_COMMANDS = [ + 'install', + 'create', + 'remove', + ] + + def execute(self, cmd, loglevel=logging.DEBUG, buffered=None, check=None, silent=None, stderr=None): + run_cmd = ['conda'] + if cmd[0] in self.QUIET_COMMANDS: + run_cmd.extend(['-q', '-y']) + run_cmd.extend(cmd) + result = util.misc.run_and_print( + run_cmd, loglevel=loglevel, env=self.conda_env, buffered=buffered, check=check, silent=silent, stderr=stderr) + + if result.returncode == 0: + try: + command_output = result.stdout.decode(""UTF-8"") + if cmd[0] == '-V': + return command_output + return json.loads(self._string_from_start_of_json(command_output.strip())) + except Exception as e: + _log.warning(""Failed to decode JSON during conda command '%s' emitting output: %s"", "" "".join(run_cmd),result.stdout.decode(""UTF-8"")) + return # return rather than raise so we can fall back to the next install method + + def __init__( + self, + package, + channel=""bioconda"", + executable=None, + version="""", + verifycmd=None, + verifycode=0, + require_executability=True, + env=None, + env_root_path=None, + conda_cache_path=None, + patches=None, + post_install_command=None, + post_install_ret=0, + post_verify_command=None, + post_verify_ret=0 + ): + # if the executable name is specifed, use it; otherwise use the package name + self.executable = executable or package + self.package = package + self.channel = channel + if type(version) == CondaPackageVersion: + self.version = version + else: + self.version = CondaPackageVersion(version) + + self.post_install_command = post_install_command + self.post_install_ret = post_install_ret + + # call the post-verification command. + # Useful for copying in license files, building databases, etc. + # The post-verify command is executed relative to the conda environment bin/ + # And has the active conda environment on the PATH + self.post_verify_command = post_verify_command + self.post_verify_ret = post_verify_ret + self.post_verify_cmd_executed = False + + self.verifycmd = verifycmd + self.verifycode = verifycode + self.require_executability = require_executability + self.patches = patches or [] + + # if we have specified a conda env/root, use it + # alternatively, use cms tools dir as default env root if os.environ[""CONDA_PREFIX""] is not defined + # + # as it is always the path + # CONDA_PREFIX is always a full path, but may not be present in older versions + # CONDA_ENV_PATH may be used instead + # in even older versions of conda, CONDA_DEFAULT_ENV can be used as another fallback + self.env_path = None + if ""CONDA_PREFIX"" in os.environ and len(os.environ[""CONDA_PREFIX""]): + #_log.debug('CONDA_PREFIX found') + last_path_component = os.path.basename(os.path.normpath(os.environ[""CONDA_PREFIX""])) + self.env_path = os.path.dirname(os.environ[""CONDA_PREFIX""]) if last_path_component == ""bin"" else os.environ[""CONDA_PREFIX""] + elif ""CONDA_ENV_PATH"" in os.environ and len(os.environ[""CONDA_ENV_PATH""]): + #_log.debug('CONDA_ENV_PATH found') + last_path_component = os.path.basename(os.path.normpath(os.environ[""CONDA_ENV_PATH""])) + self.env_path = os.path.dirname(os.environ[""CONDA_ENV_PATH""]) if last_path_component == ""bin"" else os.environ[""CONDA_ENV_PATH""] + elif ""CONDA_DEFAULT_ENV"" in os.environ and len(os.environ[""CONDA_DEFAULT_ENV""]): + #_log.debug('CONDA_PREFIX not found, using CONDA_DEFAULT_ENV') + conda_env_path = os.environ.get('CONDA_DEFAULT_ENV') # path to current conda environment + if conda_env_path: + if os.path.isdir(conda_env_path): + #_log.debug('Conda env found is specified as dir: %s' % conda_env_path) + conda_env_path = os.path.abspath(conda_env_path) + last_path_component = os.path.basename(os.path.normpath(conda_env_path)) + self.env_path = os.path.dirname(last_path_component) if last_path_component == ""bin"" else conda_env_path + else: # if conda env is an environment name, infer the path + #_log.debug('Conda env found is specified by name: %s' % conda_env_path) + result = util.misc.run_and_print([""conda"", ""env"", ""list"", ""--json""], silent=True, env=os.environ) + if result.returncode == 0: + command_output = result.stdout.decode(""UTF-8"") + data = json.loads(self._string_from_start_of_json(command_output)) + if len(data) > 0: + if ""envs"" in data and len(data[""envs""]): + for item in data[""envs""]: + if os.path.basename(os.path.realpath(item)) == conda_env_path: + self.env_path = os.path.realpath(item) + break + + # if the env is being overridden, or if we could not find an active conda env + if env_root_path or env or not self.env_path: + env_root_path = env_root_path or os.path.join(util.file.get_project_path(), 'tools', 'conda-tools') + env = env or 'default' + self.env_path = os.path.realpath(os.path.expanduser( + os.path.join(env_root_path, env))) + + # set an env variable to the conda cache path. this env gets passed to the + # the subprocess, and the variable instructs conda where to place its cache files + conda_cache_path = conda_cache_path or os.path.join(util.file.get_project_path(), 'tools', 'conda-cache') + self.conda_cache_path = os.path.realpath(os.path.expanduser(conda_cache_path)) + self.conda_env = os.environ + old_envs_path = os.environ.get('CONDA_DEFAULT_ENV') + self.conda_env[""CONDA_ENVS_PATH""] = conda_cache_path+"":""+os.path.dirname(self.env_path) + + #_log.info(""Tool install conda env path: %s"", self.env_path) + self.installed = False + self._is_attempted = False + + super(CondaPackage, self).__init__() + + @staticmethod + def _string_from_start_of_json(string_with_json): + # JSON can start with ""{"" or ""["" + # via http://www.json.org/ + try: + matches = re.compile(""\{|\["").search(string_with_json) + if matches: + return string_with_json[matches.start():] + else: + _log.warning(""Does not look like json: %s"" % string_with_json) + return None + except: + _log.warning(""Does not look like json: %s"" % string_with_json) + return None + + @property + def _package_str(self): + if self.version: + ver_str = ""{pkg}={ver}"".format( + pkg=self.package, ver=self.version.version_spec) + else: + ver_str = self.package + return ver_str + + def is_attempted(self): + return self._is_attempted + + def is_installed(self): + return self.installed + + @property + def bin_path(self): + return os.path.join(self.env_path, ""bin"") + + def executable_path(self): + return os.path.join(self.bin_path, self.executable) + + def apply_patches(self): + for path, patch in self.patches: + self._patch(path, patch) + + + def _patch(self, path, patch): + """"""Patch a path relative to conda root. + + The patch is relative to the tools/patches directory. + """""" + file_path = os.path.join(self.env_path, path) + patch_path = os.path.join( + util.file.get_project_path(), 'tools', 'patches', patch) + subprocess.check_call(['patch', file_path, patch_path]) + + @property + def _package_installed(self): + data = self.execute(['list', ""-f"", ""-c"", ""-p"", self.env_path, ""--json"", self.package], silent=True) + if len(data) > 0: + _log.debug('Conda package found: {}'.format(data)) + return True + return False + + def verify_install(self): + # if conda does not the package as installed, no need to check further + installed_version = self.get_installed_version() + if not installed_version: + # report the package as not installed + return False + + # if the package is installed, check the binary for executability + if os.access(self.executable_path(), (os.X_OK | os.R_OK) if self.require_executability else os.R_OK): + # optionally use the verify command, if specified + if self.verifycmd: + if os.system(self.verifycmd) == self.verifycode: + _log.debug(""Validating with cmd: {}"".format(self.verifycmd)) + self.installed = installed_version + else: + self.installed = installed_version + else: + self.installed = False + if self.installed: + # call the post-verification command. + # Useful for copying in license files, building databases, etc. + # This is executed relative to the conda environment bin/ + # And has the active conda environment on the PATH + if (not self.post_verify_cmd_executed) and self.post_verify_command: + post_verify_command = shlex.split(self.post_verify_command) + _log.debug(""Running post-verification cmd: {}"".format(self.post_verify_command)) + + result = util.misc.run_and_print(post_verify_command, silent=False, check=False, env=self.conda_env, cwd=self.bin_path) + post_verify_cmd_return_code = result.returncode + if post_verify_cmd_return_code == self.post_verify_ret: + self.post_verify_cmd_executed = True + else: + raise subprocess.CalledProcessError(post_verify_cmd_return_code, ""Post verification command failed with exit %s: %s"" % (post_verify_cmd_return_code, self.post_verify_command)) + + return installed_version + return False + + def _attempt_install(self): + try: + # check for presence of conda command + data = self.execute(['-V'], check=True, silent=True) + except: + _log.warning(""conda NOT installed"") + self._is_attempted = True + self.installed = False + return + + # conda-build is not needed for pre-built binaries from conda channels + # though we may will need it in the future for custom local builds + # try: + # util.misc.run_and_print([""conda"", ""build"", ""-V""], silent=True, check=True, env=self.conda_env) + # except: + # _log.warning(""conda-build must be installed; installing..."") + # util.misc.run_and_print([""conda"", ""install"", ""-y"", ""conda-build""], check=True) + + # if the package is already installed, we need to check if the version is correct + pkg_version = self.verify_install() + if pkg_version: + _log.debug(""Currently installed version of {package}: {version}"".format( + package=self.package, version=pkg_version)) + # if the installed version is not the one specified + if not pkg_version.satisfies(self.version): + _log.debug(""Expected version of {package}: {version}"".format(package=self.package, version=self.version)) + _log.debug(""Incorrect version of {package} installed. Removing it..."".format(package=self.package) ) + + # uninstall the current (incorrect) version + self.uninstall_package() + # and continue to install... + else: + # if the package is installed and is the correct version + # return so we don't bother installing + return + + # install the package and verify + _log.debug(""Attempting install..."") + self.install_package() + self.verify_install() + self.post_install() + + def get_installed_version(self): + # If we ever use conda to install pip packages as tools, ""-c"" needs to be removed + + data = self.execute([""list"", ""-c"", ""--json"", ""-f"", ""-p"", self.env_path, self.package], check=True, silent=True) + if data is None or not len(data): + return + if isinstance(data[0], dict): + installed_package_string = data[0][""dist_name""] + else: + installed_package_string = data[0] + # regex to match package specs in the format bioconda::biopython-1.68-py35_0 + package_info_re = re.compile(r""(?:(?P.*)::)?(?P.*)-(?P.*)-(?P.*)"") + matches = package_info_re.match(installed_package_string) + if matches: + installed_version = matches.group(""version"") + installed_package = matches.group(""package_name"") + installed_build_type = matches.group(""build_type"") + return CondaPackageVersion(installed_version, installed_build_type) + + def package_available(self): + # If we ever use conda to install pip packages as tools, ""-c"" needs to be removed + data = self.execute([""search"", ""--json"", ""-c"", self.channel, self.package], check=False, loglevel=logging.INFO) + if data and len(data) and self.package in data and ""error"" not in data: + for sub_pkg in data[self.package]: + if sub_pkg.get(""version"", """") == self.version.version_spec: + return True + _log.info(""Conda package for %s is not available on this platform."", self.package) + return False + + def uninstall_package(self): + data = self.execute([""remove"", ""-q"", ""-y"", ""--json"", ""-p"", self.env_path, self.package], + loglevel=logging.INFO) + if not data: + return + if data[""success""] == True: + _log.debug(""Package removed."") + self.installed = False + + def install_package(self): + data = self.execute([""list"", ""--json"", ""-p"", self.env_path], silent=True, check=True) + if not data: + return + for d in data: + if ""error"" in d and ""Not a conda environment"" in d[""message""]: + _log.warning(""Conda environment doesn't exist"") + return + + # the environment already exists + # the package may not be installed... + _log.debug(""Conda environment already exists. Installing package..."") + + data = self.execute([""install"", ""--json"", ""-c"", self.channel, ""-y"", ""-q"", ""--no-update-deps"", ""-p"", self.env_path, self._package_str]) + if not data: + return + + if data[""success""] == True: + _log.debug(""Package installed."") + self.apply_patches() + + def post_install(self): + """""" + Runs a shell command after package installation, + relative to the directory containing the executable + """""" + if self.post_install_command: + destination_dir = os.path.dirname(os.path.realpath(self.executable_path())) + return_code = os.system('cd ""{}"" && {}'.format(destination_dir, self.post_install_command)) + if self.post_install_ret is not None: + assert return_code == self.post_install_ret + + +class DownloadPackage(InstallMethod): + ''' This is an install method for downloading, unpacking, and post- + processing straight from the source. + target_rel_path is the executable's path relative to destination_dir + destination_dir defaults to the project build directory + post_download_command will be executed if it isn't None, in + destination_dir. + if post_download_ret != None, assert it is returned by + post_download_command + ''' + + def __init__( + self, + url, + target_rel_path, + destination_dir=None, + verifycmd=None, + verifycode=0, + require_executability=True, + post_download_command=None, + post_download_ret=0 + ): + if destination_dir is None: + destination_dir = util.file.get_build_path() + self.url = url + self.targetpath = os.path.join(destination_dir, target_rel_path) + self.destination_dir = destination_dir + self.verifycmd = verifycmd + self.verifycode = verifycode + self.installed = False + self.require_executability = require_executability + self.post_download_command = post_download_command + self.post_download_ret = post_download_ret + self.download_file = None + InstallMethod.__init__(self) + + def is_installed(self): + return self.installed + + def executable_path(self): + return self.installed and self.targetpath or None + + def verify_install(self): + if os.access(self.targetpath, (os.X_OK | os.R_OK) if self.require_executability else os.R_OK): + if self.verifycmd: + _log.debug(""validating"") + self.installed = (os.system(self.verifycmd) == self.verifycode) + else: + self.installed = True + else: + self.installed = False + return self.installed + + def _attempt_install(self): + if not self.verify_install(): + self.pre_download() + self.download() + self.post_download() + self.verify_install() + + def pre_download(self): + pass + + def download(self): + download_dir = tempfile.gettempdir() + util.file.mkdir_p(download_dir) + filepath = urlparse(self.url).path + file_basename = filepath.split('/')[-1] + _log.info(""Downloading from %s to %s/%s ..."", self.url, download_dir, file_basename) + urlretrieve(self.url, os.path.join(download_dir, file_basename)) + self.download_file = file_basename + self.unpack(download_dir) + + def post_download(self): + if self.post_download_command: + return_code = os.system('cd ""{}"" && {}'.format(self.destination_dir, self.post_download_command)) + if self.post_download_ret is not None: + assert return_code == self.post_download_ret + + def unpack(self, download_dir): + _log.debug(""unpacking"") + util.file.mkdir_p(self.destination_dir) + if self.download_file.endswith('.zip'): + if os.system(""unzip -o %s/%s -d %s > /dev/null"" % (download_dir, self.download_file, self.destination_dir)): + + return + else: + os.unlink(os.path.join(download_dir, self.download_file)) + elif ( + self.download_file.endswith('.tar.gz') or self.download_file.endswith('.tgz') or + self.download_file.endswith('.tar.bz2') or self.download_file.endswith('.tar') + ): + if self.download_file.endswith('.tar'): + compression_option = '' + elif self.download_file.endswith('.tar.bz2'): + compression_option = 'j' + else: + compression_option = 'z' + untar_cmd = ""tar -C {} -x{}pf {}/{}"".format( + self.destination_dir, compression_option, download_dir, self.download_file + ) + _log.debug(""Untaring with command: %s"", untar_cmd) + exitCode = os.system(untar_cmd) + if exitCode: + _log.info(""tar returned non-zero exitcode %s"", exitCode) + return + else: + _log.debug(""tar returned with exit code 0"") + os.unlink(os.path.join(download_dir, self.download_file)) + else: + shutil.move( + os.path.join(download_dir, self.download_file), os.path.join(self.destination_dir, self.download_file) + ) +","Python" +"Viral","broadinstitute/viral-ngs","tools/cdhit.py",".py","1612","64","''' +CD-HIT +''' +from builtins import super +import itertools +import logging +import os +import os.path +import shlex +import shutil +import subprocess +import tools +import util.file + +log = logging.getLogger(__name__) + +class CdHit(tools.Tool): + + COMMANDS = [ + 'cd-hit', + 'cd-hit-est', + 'cd-hit-2d', + 'cd-hit-est-2d', + 'cd-hit-dup', + ] + + def install(self): + pass + + def is_installed(self): + return True + + def install_and_get_path(self): + # the conda version wraps the jar file with a shell script + return 'cd-hit' + + def __init__(self, install_methods=None): + self.installed_method = True + + def execute(self, command, input_fn, output_fn, options=None, option_string=None, background=None): + '''Perform a clustering on DNA/RNA sequences + + Args: + input_fn: Input fasta filename + output_fn: Output fasta filename + ''' + assert command in self.COMMANDS + cmd = [command] + cmd.extend(['-i', input_fn]) + cmd.extend(['-o', output_fn]) + + options = options or {} + if options: + # We need some way to allow empty options args like --log, hence + # we filter out on 'x is None'. + cmd.extend([str(x) for x in itertools.chain(*options.items()) if x is not None]) + if option_string: + cmd.extend(shlex.split(option_string)) + log.debug(""Calling {}: {}"".format(command, "" "".join(cmd))) + if background: + return subprocess.Popen(cmd) + else: + return subprocess.check_call(cmd) +","Python" +"Viral","broadinstitute/viral-ngs","tools/mvicuna.py",".py","4508","106","""tools.Tool for mvicuna."" + +import logging +import os +import subprocess +import shutil + +import tools +import util.file + +# BroadUnixPath = '/gsap/garage-viral/viral/analysis/xyang/programs'\ +# '/M-Vicuna/bin/mvicuna' + +TOOL_NAME = ""mvicuna"" +TOOL_VERSION = ""1.0"" + +_log = logging.getLogger(__name__) + + +class MvicunaTool(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + path = _get_mvicuna_path() + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION)) + install_methods.append(tools.PrexistingUnixCommand(path)) + tools.Tool.__init__(self, install_methods=install_methods) + + def rmdup(self, inPair, outPair, outUnpaired=None): + """""" + Run mvicuna's duplicate removal operation on paired-end input reads in + fastq format, producing various outputs in fastq format. + inPair, pairedOutPair are pairs of file names, + while unpairedOut is a single file name. + Notes on weird behaviors of M-Vicuna DupRm: + For some reason, it requires you to specify both -opfq and -drm_op. + The -drm_op pair (here, tmp1OutPair) is where the output is initially written. + Then M-Vicuna renames the -drm_op files to the -opfq filenames (here, tmp2OutPair). + So obviously, we use throwaway (tempfile) names for -drm_op and use the real + desired output file names in -opfq. + The problem is that M-Vicuna uses a rename/move operating system function, which + means your tempfiles cannot be on a different file system than the final output + files. This is our typical use case (local disks for tempfile.tempdir and + network file systems for final output). Hence, our wrapper sets -opfq to yet + another set of temp file names, and we move the final output files ourselves + using shutil.move (which is capable of crossing file system boundaries). + """""" + if not outUnpaired: + outUnpaired = util.file.mkstempfname(suffix='.unpaired.fastq') + tmp1OutPair = ( + util.file.mkstempfname(suffix='.tmp1out.1.fastq'), util.file.mkstempfname(suffix='.tmp1out.2.fastq') + ) + tmp2OutPair = ( + util.file.mkstempfname(suffix='.tmp2out.1.fastq'), util.file.mkstempfname(suffix='.tmp2out.2.fastq') + ) + cmdline = [ + self.install_and_get_path(), '-ipfq', ','.join(inPair), '-opfq', ','.join(tmp2OutPair), '-osfq', + outUnpaired, '-drm_op', ','.join(tmp1OutPair), '-tasks', 'DupRm' + ] + _log.debug(' '.join(cmdline)) + subprocess.check_call(cmdline) + for tmpfname, outfname in zip(tmp2OutPair, outPair): + shutil.copyfile(tmpfname, outfname) + + def rmdup_single(self, inFastq, outFastq): + """""" + Run mvicuna's duplicate removal operation on single-end input reads in + fastq format, producing output in fastq format. + Notes on weird behaviors of M-Vicuna DupRm: + For some reason, it requires you to specify both -opfq and -drm_op even for + single-end input. + + Actually, more interestingly, this doesn't work at all. + """""" + _log.warning(""MVicuna duplicate removal doesn't work for single-end reads. Copying input to output and allowing all reads to pass."") + shutil.copyfile(inFastq, outFastq) + ''' + tmp1OutPair = ( + util.file.mkstempfname(suffix='.tmp1out.1.fastq'), util.file.mkstempfname(suffix='.tmp1out.2.fastq') + ) + tmp2OutPair = ( + util.file.mkstempfname(suffix='.tmp2out.1.fastq'), util.file.mkstempfname(suffix='.tmp2out.2.fastq') + ) + cmdline = [ + self.install_and_get_path(), '-isfq', inFastq, '-osfq', outFastq, + '-opfq', ','.join(tmp2OutPair), '-drm_op', ','.join(tmp1OutPair), + '-tasks', 'DupRm' + ] + _log.debug(' '.join(cmdline)) + subprocess.check_call(cmdline) + ''' + + +def _get_mvicuna_path(): + uname = os.uname() + if uname[0] == 'Darwin': + osName = 'MacOSX' + elif uname[0] == 'Linux' and uname[4].endswith('64'): + osName = 'linux64' + else: + _log.debug('mvicuna not implemented for OS %s %s', uname[0], uname[4]) + return '' + binaries_path = util.file.get_binaries_path() + return os.path.join(binaries_path, 'mvicuna', osName, 'mvicuna') +","Python" +"Viral","broadinstitute/viral-ngs","tools/vphaser2.py",".py","4325","127","''' + V-Phaser 2 variant caller +''' + +import logging +import subprocess +import os +import tempfile +import shutil +import pysam +import tools +import util.file + +log = logging.getLogger(__name__) + +TOOL_NAME = ""vphaser2"" +TOOL_VERSION = ""2.0"" + + +class Vphaser2Tool(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + path = _get_vphaser2_path() + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION)) + install_methods.append(tools.PrexistingUnixCommand(path)) + tools.Tool.__init__(self, install_methods=install_methods) + + def execute(self, inBam, outDir, numThreads=None): # pylint: disable=W0221 + cmd = [self.install_and_get_path(), '-i', inBam, '-o', outDir] + cmd_str = ' '.join(cmd) + envCopy = os.environ.copy() + if numThreads is not None: + envCopy['OMP_NUM_THREADS'] = str(numThreads) + cmd_str = 'OMP_NUM_THREADS=%d ' % numThreads + cmd_str + log.debug(cmd_str) + + # Use check_output instead of check_call so that we get error information + # if the executable can't run on travis. + # Also has the effect of suppressing informational messages from vphaser, + # which is probably a good thing. + try: + # TODO: should this be cmd_str? + subprocess.check_output(cmd, env=envCopy, stderr=subprocess.STDOUT) + except subprocess.CalledProcessError as ex: + print(ex.output) # Useful in case of no log handler. + log.error(ex.output) + raise + + def iterate(self, inBam, numThreads=None): + """""" + Run V-Phaser 2 on inBam. Interate through lines in files + CHROM.var.raw.txt in order of chroms in the inBam header. + For each line yield: + [CHROM, Ref_Pos, Var, Cons, Strd_bias_pval, Type, Var_perc, + SNP_or_LP_Profile1, SNP_or_LP_Profile2, ...] + """""" + outdir = tempfile.mkdtemp('vphaser2') + try: + self.execute(inBam, outdir, numThreads) + finally: + # these V-Phaser droppings cause problems if they persist + bti = inBam + '.bti' + if os.path.isfile(bti): + os.unlink(bti) + chromNames = pysam.Samfile(inBam).references + for chromName in chromNames: + outfile = os.path.join(outdir, chromName + '.var.raw.txt') + if not os.path.exists(outfile): + continue + with open(outfile, 'rt') as inf: + for line in inf: + if not line.startswith('#'): + yield [chromName] + line.strip().split() + shutil.rmtree(outdir) + + +def _get_vphaser2_path(): + uname = os.uname() + if uname[0] == 'Darwin': + osName = 'MacOSX' + elif uname[0] == 'Linux' and uname[4].endswith('64'): + osName = 'linux64' + else: + log.debug('V-Phaser 2 not implemented for OS %s %s', uname[0], uname[4]) + return '' + binariesPath = util.file.get_binaries_path() + return os.path.join(binariesPath, 'V-Phaser-2.0', osName, 'variant_caller') + +# Process used to get the files in binaries/V-Phaser-2.0: + +# wget http://www.broadinstitute.org/software/viral/v_phaser_2/v_phaser_2.zip +# unzip +# Add ""#include "" to bam_manip.cpp +# Modify src/makefile to create makefile.MacOSX and makefile.linux64 +# Create linux64 and MacOSX subdirectories + +# On mac, gcc-4.9 and boost were installed using brew. + +# # CMake +# on linux, ""use CMake"" (perhaps instead download from www.cmake.org/download) +# on mac, ""brew install cmake"" + +# # Bamtools (Note: must use same compiler as V-Phaser 2, otherwise link can fail.) +# git clone git://github.com/pezmaster31/bamtools.git +# cd bamtools +# mkdir build +# cd build +# on linux ""cmake .."" +# on mac ""cmake -DCMAKE_CXX_COMPILER=/usr/local/bin/g++-4.9 \ +# -DCMAKE_CC_COMPILER=/usr/local/bin/gcc-4.9 .."" +# make +# cd ../.. # back to V-Phaser-2.0 directory + +# # boost (only on linux; for mac used brew) +# wget http://sourceforge.net/projects/boost/files/latest/download?source=files +# tar -xzf boost_1_57_0.tar.gz + +# # make V-Phaser 2 +# cd src +# make -f makefile.linux64 or makefile.MacOSX + +# # Cleanup +# delete all bamtools stuff +# delete all boost stuff +","Python" +"Viral","broadinstitute/viral-ngs","tools/mummer.py",".py","28687","627","''' + The MUMMER aligner + http://mummer.sourceforge.net/ +''' + +import logging +import tools +import util.file +import util.misc +import os +import os.path +import random +import subprocess +import Bio.SeqIO + +TOOL_NAME = ""mummer4"" +tool_version = '4.0.0beta2' + +log = logging.getLogger(__name__) + + +class MummerTool(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [ + tools.CondaPackage(TOOL_NAME, executable=""mummer"", version=tool_version) + ] + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return tool_version + + def executable_path(self): + exec_path = tools.Tool.executable_path(self) + if os.path.isdir(exec_path): + return exec_path + else: + return os.path.dirname(exec_path) + + def execute(self, refFasta, qryFastas): + toolCmd = [os.path.join(self.install_and_get_path(), 'mummer'), + refFasta] + qryFastas + log.debug(' '.join(toolCmd)) + subprocess.check_call(toolCmd) + + def nucmer(self, refFasta, qryFasta, outDelta, extend=None, breaklen=None, + maxgap=None, minmatch=None, mincluster=None): + if not outDelta.endswith('.delta'): + raise Exception() + outDelta = outDelta[:-6] + toolCmd = [os.path.join(self.install_and_get_path(), 'nucmer'), + '--prefix={}'.format(outDelta)] + if extend is not None: + if not extend: + # default behavior is --extend + # mummer4 no longer recognizes --extend and we should only + # specify an argument here if we want non-default behavior + toolCmd.append('--noextend') + if breaklen is not None: + toolCmd.extend(['--breaklen', str(breaklen)]) + if maxgap is not None: + toolCmd.extend(['--maxgap', str(maxgap)]) + if minmatch is not None: + toolCmd.extend(['--minmatch', str(minmatch)]) + if mincluster is not None: + toolCmd.extend(['--mincluster', str(mincluster)]) + toolCmd.extend([refFasta, qryFasta]) + log.debug(' '.join(toolCmd)) + subprocess.check_call(toolCmd) + + def promer(self, refFasta, qryFasta, outDelta, extend=None, breaklen=None, + maxgap=None, minmatch=None, mincluster=None): + if not outDelta.endswith('.delta'): + raise Exception() + outDelta = outDelta[:-6] + toolCmd = [os.path.join(self.install_and_get_path(), 'promer'), + '--prefix={}'.format(outDelta)] + if extend is not None: + if not extend: + # default behavior is --extend + # mummer4 no longer recognizes --extend and we should only + # specify an argument here if we want non-default behavior + toolCmd.append('--noextend') + if breaklen is not None: + toolCmd.extend(['--breaklen', str(breaklen)]) + if maxgap is not None: + toolCmd.extend(['--maxgap', str(maxgap)]) + if minmatch is not None: + toolCmd.extend(['--minmatch', str(minmatch)]) + if mincluster is not None: + toolCmd.extend(['--mincluster', str(mincluster)]) + toolCmd.extend([refFasta, qryFasta]) + log.debug(' '.join(toolCmd)) + subprocess.check_call(toolCmd) + + def delta_filter(self, inDelta, outDelta): + toolCmd = [os.path.join(self.install_and_get_path(), 'delta-filter'), + '-q', inDelta] + log.debug(' '.join(toolCmd)) + with open(outDelta, 'w') as outf: + subprocess.check_call(toolCmd, stdout=outf) + + def show_tiling(self, inDelta, outTiling, outFasta=None, + circular=False, min_pct_id=None, min_contig_len=None, + min_pct_contig_aligned=None, tab_delim=False, + min_contig_coverage_diff=None): + opts = [] + if circular: + opts.append('-c') + if tab_delim: + opts.append('-a') + if min_pct_id is not None: + opts.append('-i') + opts.append(str(100.0 * min_pct_id)) + if min_contig_len is not None: + opts.append('-l') + opts.append(str(min_contig_len)) + if min_pct_contig_aligned is not None: + opts.append('-v') + opts.append(str(100.0 * min_pct_contig_aligned)) + if min_contig_coverage_diff is not None: + opts.append('-V') + opts.append(str(100.0 * min_contig_coverage_diff)) + toolCmd = [os.path.join(self.install_and_get_path(), 'show-tiling')] + if outFasta: + toolCmd = toolCmd + ['-p', outFasta] + toolCmd = toolCmd + opts + [inDelta] + log.debug(' '.join(toolCmd)) + with open(outTiling, 'w') as outf: + subprocess.check_call(toolCmd, stdout=outf) + + def trim_contigs(self, refFasta, contigsFasta, outFasta, + aligner='nucmer', circular=False, extend=False, breaklen=None, + min_pct_id=0.6, min_pct_contig_aligned=0.5, min_contig_len=200): + ''' Align contigs with MUMmer and trim off the unused portions. + ''' + # run MUMmer to get best alignments + if aligner=='nucmer': + aligner = self.nucmer + elif aligner=='promer': + aligner = self.promer + else: + raise NameError() + delta_1 = util.file.mkstempfname('.delta') + delta_2 = util.file.mkstempfname('.delta') + tiling = util.file.mkstempfname('.tiling') + aligner(refFasta, contigsFasta, delta_1, extend=extend, breaklen=breaklen) + self.delta_filter(delta_1, delta_2) + self.show_tiling(delta_2, tiling, circular=circular, tab_delim=True, + min_pct_id=min_pct_id, min_contig_len=min_contig_len, + min_pct_contig_aligned=min_pct_contig_aligned) + os.unlink(delta_1) + os.unlink(delta_2) + + # get trim boundaries per contig + seq_bounds = {} + with open(tiling, 'rt') as inf: + for line in inf: + row = line.rstrip().split('\t') + seq_bounds.setdefault(row[-1], [float('inf'), 0]) + start = min(int(row[2]), int(row[3])) + stop = max(int(row[2]), int(row[3])) + seq_bounds[row[-1]][0] = min(seq_bounds[row[-1]][0], start) + seq_bounds[row[-1]][1] = max(seq_bounds[row[-1]][1], stop) + os.unlink(tiling) + + # trim contigs + out = [] + with open(contigsFasta, 'rt') as inf: + for record in Bio.SeqIO.parse(inf, 'fasta'): + if record.id in seq_bounds: + seq = record.seq[seq_bounds[record.id][0]-1:seq_bounds[record.id][1]] + record.seq = seq + out.append(record) + with open(outFasta, 'wt') as outf: + Bio.SeqIO.write(out, outf, 'fasta') + + def scaffold_contigs(self, refFasta, contigsFasta, outFasta, + aligner='nucmer', circular=False, extend=None, breaklen=None, + maxgap=None, minmatch=None, mincluster=None, + min_contig_coverage_diff=0.0, + min_pct_id=0.6, min_pct_contig_aligned=None, min_contig_len=200): + ''' Use MUMmer's pseudomolecule feature to scaffold contigs + onto a reference genome. + ''' + if aligner=='nucmer': + aligner = self.nucmer + elif aligner=='promer': + aligner = self.promer + else: + raise NameError() + delta_1 = util.file.mkstempfname('.delta') + delta_2 = util.file.mkstempfname('.delta') + tiling = util.file.mkstempfname('.tiling') + aligner(refFasta, contigsFasta, delta_1, extend=extend, breaklen=breaklen, + maxgap=maxgap, minmatch=minmatch, mincluster=mincluster) + self.delta_filter(delta_1, delta_2) + self.show_tiling(delta_2, tiling, outFasta=outFasta, circular=circular, + min_pct_id=min_pct_id, min_contig_len=min_contig_len, + min_contig_coverage_diff=min_contig_coverage_diff, + min_pct_contig_aligned=min_pct_contig_aligned) + os.unlink(delta_1) + os.unlink(delta_2) + os.unlink(tiling) + + def scaffold_contigs_custom(self, refFasta, contigsFasta, outFasta, + outAlternateContigs=None, + aligner='nucmer', extend=None, breaklen=None, + maxgap=None, minmatch=None, mincluster=None, + min_contig_coverage_diff=0.0, + min_pct_id=0.6, min_pct_contig_aligned=None, min_contig_len=200, + ambig_max_aligns=2, ambig_max_lens=1, ambig_max_frac=.01): + ''' Re-implement a less buggy version of MUMmer's pseudomolecule + feature to scaffold contigs onto a reference genome. + ''' + + # create tiling path with nucmer/promer and show-tiling + if aligner=='nucmer': + aligner = self.nucmer + elif aligner=='promer': + aligner = self.promer + raise NotImplementedError('we have not implemented a show-aligns file reader that works for protein alignments') + else: + raise NameError() + delta_1 = util.file.mkstempfname('.delta') + delta_2 = util.file.mkstempfname('.delta') + tiling = util.file.mkstempfname('.tiling') + aligner(refFasta, contigsFasta, delta_1, extend=extend, breaklen=breaklen, + maxgap=maxgap, minmatch=minmatch, mincluster=mincluster) + self.delta_filter(delta_1, delta_2) + self.show_tiling(delta_2, tiling, tab_delim=True, + min_pct_id=min_pct_id, + min_contig_len=min_contig_len, + min_contig_coverage_diff=min_contig_coverage_diff, + min_pct_contig_aligned=min_pct_contig_aligned) + os.unlink(delta_1) + + # load intervals into a FeatureSorter + fs = util.misc.FeatureSorter() + with util.file.open_or_gzopen(tiling, 'rU') as inf: + for line in inf: + row = line.rstrip('\n\r').split('\t') + c = row[11] + start, stop = (int(row[0]), int(row[1])) + alt_seq = (row[12], int(row[2]), int(row[3])) + if stop1 not currently supported') + n_tot = len(seqs[0]) + n_unambig = list(map(n_diff_vals, *seqs)).count(1) + return float(n_unambig) / float(n_tot or 1.0) + + # construct scaffolded sequence for this chromosome + seq = [] + for _, left, right, n_features, features in fs.get_intervals(c): + # get all proposed sequences for this specific region + alt_seqs = [] + for consider_ambig_aligns in (False, True): + for f in features: + alt_seqs_f = alnReaders[(c, f[-1][0])].retrieve_alts_by_ref(left, right, aln_start=f[1], aln_stop=f[2]) + if len(alt_seqs_f) == 1: + alt_seqs.append(alt_seqs_f[0]) + elif consider_ambig_aligns: + if len(alt_seqs_f) <= ambig_max_aligns and n_diff_lens(alt_seqs_f) <= ambig_max_lens and \ + frac_unambig(alt_seqs_f) > (1.0 - ambig_max_frac): + alt_seqs.append(alt_seqs_f[0]) + log.info(""using ambiguous alignment to ref seq {} at [{},{}]"".format(c, f[1], f[2])) + else: + log.warning(""dropping ambiguous alignment to ref seq {} at [{},{}]"".format(c, f[1], f[2])) + if alt_seqs: + # if have a non-unambiguous alignment, don't consider ambiguous ones + break + + # pick the ""right"" one and glue together into a chromosome + ranked_unique_seqs = contig_chooser(alt_seqs, right-left+1, ""%s:%d-%d"" % (c, left, right)) + seq.append(ranked_unique_seqs[0]) + # emit the ""alternates"" in a separate file + if outAlternateContigs and len(ranked_unique_seqs) > 1: + alternate_contigs.append((c, left, right, ranked_unique_seqs)) + + # write this chromosome to fasta file + for line in util.file.fastaMaker([(str(c)+""_contigs_ordered_and_oriented"", ''.join(seq))]): + outf.write(line) + + # if alternate scaffolds exist, emit to output fasta file (if specified) + if outAlternateContigs and alternate_contigs: + log.info(""emitting alternative scaffold sequences to {}"".format(outAlternateContigs)) + with open(outAlternateContigs, 'wt') as outf: + for c, left, right, seqs in alternate_contigs: + for line in util.file.fastaMaker([ + (""{}:{}-{}_option_{}"".format(c,left,right,i), s) + for i,s in enumerate(seqs)]): + outf.write(line) + + + def align_one_to_one(self, refFasta, otherFasta, outFasta): + ''' Take two sequences, align with nucmer, and produce + an aligned-fasta file of the two based on show-aligns + output. + ''' + # grab seq_ids (very inefficient, but whatever) + ref_id = Bio.SeqIO.read(refFasta, 'fasta').id + query_id = Bio.SeqIO.read(otherFasta, 'fasta').id + + # run nucmer + delta_1 = util.file.mkstempfname('.delta') + delta_2 = util.file.mkstempfname('.delta') + self.nucmer(refFasta, otherFasta, delta_1) + self.delta_filter(delta_1, delta_2) + + # run show-aligns + aln_file = util.file.mkstempfname('.aligns') + toolCmd = [os.path.join(self.install_and_get_path(), 'show-aligns'), + '-r', delta_2, ref_id, query_id] + log.debug(' '.join(toolCmd)) + with open(aln_file, 'wt') as outf: + subprocess.check_call(toolCmd, stdout=outf) + alns = AlignsReader(aln_file, refFasta) + + # write fasta + seqs = [[alns.seq_ids[0], []], [alns.seq_ids[1], []]] + for a in alns.get_intervals(): + seqs[0][1].append(a[6]) + seqs[1][1].append(a[7]) + seqs[0][1] = ''.join(seqs[0][1]) + seqs[1][1] = ''.join(seqs[1][1]) + util.file.makeFastaFile(seqs, outFasta) + + # cleanup + for fn in (delta_1, delta_2, aln_file): + os.unlink(fn) + +def contig_chooser(alt_seqs, ref_len, coords_debug=""""): + ''' Our little heuristic to choose an alternative sequence from a pile + of alignments to a reference. Takes a list of strings (one string per + contig). This method will choose a single sequence from the input: + 1. if there are no alt_seqs, emit a stretch of Ns, same length as ref + 2. if there is only one alt_seq, emit that one + 3. if there are many alt_seqs, emit the most popular (if there is one) + 4. otherwise, if there is a most popular sequence length (including + the ref_len as one vote), filter the alt_seqs to those of the + most popular length and emit the most popular sequence (if there + is one), otherwise, choose randomly amongst the remainder + 5. otherwise, choose randomly amongst the same-as-ref length sequences + 6. or just choose randomly if there are no same-as-ref length sequences + The output will be a list of unique strings, where the first string + is the ""chosen"" sequence, and the remaining strings are the alternative + sequences (in no particular order, but guaranteed to be unique). + ''' + if not alt_seqs: + # no contigs align here, emit Ns of appropriate length + new_seq = 'N' * ref_len + other_seqs = [] + elif len(alt_seqs) == 1: + # only one contig aligns here + new_seq = alt_seqs[0] + other_seqs = [] + else: + # multiple contigs align here + ranks = list(sorted(util.misc.histogram(alt_seqs).items(), + key=lambda x:x[1], reverse=True)) + other_seqs = list(s for s,n in ranks) + if len(ranks)==1: + # only one unique sequence exists + new_seq = ranks[0][0] + elif ranks[0][1]>ranks[1][1]: + # clear winner: a most popular sequence exists + new_seq = ranks[0][0] + else: + # multiple possible replacement sequences + len_ranks = list(sorted(util.misc.histogram( + [len(s) for s in alt_seqs] + [ref_len] # let the reference have one vote + ).items(), key=lambda x:x[1], reverse=True)) + if len(len_ranks)==1 or len_ranks[0][1]>len_ranks[1][1]: + # a most popular replacement length exists + # remove all alt_seqs that don't use that length + alt_seqs = list(s for s in alt_seqs if len(s)==len_ranks[0][0]) + assert alt_seqs + ranks = list(sorted(util.misc.histogram(alt_seqs).items(), + key=lambda x:x[1], reverse=True)) + if len(ranks)==1 or ranks[0][1]>ranks[1][1]: + # clear winner amongst remaining sequences of most popular length + new_seq = ranks[0][0] + else: + # more complicated scenario. choose randomly. + # perhaps in future, vote based on aligned read count? + if len(alt_seqs)>1: + log.warning(""choosing random contig from %d choices of most popular length in %s"" % (len(alt_seqs), coords_debug)) + new_seq = random.choice(alt_seqs) + else: + # no clear winner on replacement length + alt_ref_len_seqs = list(s for s in alt_seqs if len(s)==ref_len) + if alt_ref_len_seqs: + # choose randomly among same-as-ref-length sequences + alt_seqs = alt_ref_len_seqs + if len(alt_seqs)>1: + log.warning(""choosing random contig from %d choices of reference length in %s"" % (len(alt_seqs), coords_debug)) + new_seq = random.choice(alt_seqs) + else: + # no clear winner and all replacement lengths are different from reference length + # just choose randomly + if len(alt_seqs)>1: + log.warning(""choosing random contig from %d choices in %s"" % (len(alt_seqs), coords_debug)) + new_seq = random.choice(alt_seqs) + other_seqs = list(s for s in other_seqs if s!=new_seq) + return [new_seq] + other_seqs + + +class AmbiguousAlignmentException(Exception): + pass + +class AlignsReader(object): + ''' This class assists in the parsing and reading of show-aligns output. + ''' + def __init__(self, aligns_file, ref_fasta=None): + self.aligns_file = aligns_file + self.ref_fasta = ref_fasta + self.reference_seq = None + self.alignments = [] + self.seq_ids = [] + self._load_align() + self._load_fastas() + + def _load_align(self): + with open(self.aligns_file, 'rt') as inf: + # read ref_fasta, query_fasta from header + header = inf.readline().strip().split() + assert len(header) == 2 + if self.ref_fasta is None: + self.ref_fasta = header[0] + + # iterate row by row + mode = 'start' + coords = None + seqs = None + for line in inf: + line = line.rstrip() + if not line: + pass # empty lines + elif not line.strip('='): + pass # header and footer of file + elif line[0] in (' ', '\t'): + pass # describes mismatches in alignment + elif line.startswith('--'): + if line.startswith('-- Alignments between '): + assert mode == 'start' + mode = 'between' + self.seq_ids = line[22:].split(' and ') + assert len(self.seq_ids) == 2 + elif line.startswith('-- BEGIN alignment [ '): + assert mode == 'between' + mode = 'align' + coords = list(x.split() for x in line[21:-2].split(' | ')) + assert len(coords) == 2 and coords[0][2] == coords[1][2] == '-' + assert coords[0][0] == '+1', ""error with line: %s"" % line + seqs = [[], []] + align_lines = 0 + elif line.startswith('-- END alignment [ '): + assert mode == 'align' + mode = 'between' + new_coords = list(x.split() for x in line[21:-2].split(' | ')) + assert coords == new_coords, ""error: %s != %s"" % (new_coords, coords) + assert len(seqs[0]) == len(seqs[1]) + seqs = list(''.join(x) for x in seqs) + assert len(seqs[0]) == len(seqs[1]) + self.alignments.append([coords[0][0], int(coords[0][1]), int(coords[0][3]), + coords[1][0], int(coords[1][1]), int(coords[1][3]), + seqs[0], seqs[1]]) + coords = None + seqs = None + else: + raise AssertionError(""file format: line '%s'"" % line) + else: + # read in one line of an alignment + assert mode == 'align', ""file format: line '%s' before alignment begins"" % line + seq_str = line.split()[1].upper().replace('.','-') + seqs[align_lines % 2].append(seq_str) + align_lines += 1 + + def _load_fastas(self): + assert self.ref_fasta and self.seq_ids + self.reference_seq = Bio.SeqIO.index(self.ref_fasta, 'fasta')[self.seq_ids[0]] + + def get_alignments(self): + for a in self.alignments: + yield a + + def get_intervals(self): + prev = None + for a in self.alignments: + cur = a[1:3] + assert cur[1] >= cur[0] + if prev is None: + if cur[0] > 1: + # emit leading reference sequence before first alignment + yield self._dummy_row(1, cur[0]-1, '-') + else: + assert cur[0] > prev[1], ""overlaps not allowed"" + if cur[0] > prev[1] + 1: + # emit gap between alignments + yield self._dummy_row(prev[1]+1, cur[0]-1, 'N') + # emit actual alignment + yield a + prev = cur + if prev and prev[1] < len(self.reference_seq): + # emit trailing reference sequence after last alignment + yield self._dummy_row(prev[1]+1, len(self.reference_seq), '-') + + def _dummy_row(self, start, stop, filler='N'): + return ['+1', start, stop, '+1', start, stop, + self.get_ref_seq(start, stop), + filler * (stop-start+1)] + + def get_ref_seq(self, start, stop): + ''' Retrieve a sub-sequence from the reference (1st) sequence in the + alignment using coordinates relative to the reference sequence. + No gaps will be emitted. + ''' + return str(self.reference_seq.seq[start-1:stop]) + + def retrieve_alts_by_ref(self, start, stop, aln_start=None, aln_stop=None): + ''' Retrieve sub-sequence(s) from the alternate (2nd) sequence in the + alignment using coordinates relative to the reference sequence. + No gaps will be emitted. + Required: start-stop interval must be wholly contained within + an alignment. + ''' + + # grab the one alignment that contains this window + alns = list(a for a in self.alignments if a[1]<=start and a[2]>=stop) + if aln_start is not None and aln_stop is not None: + # if specified, restrict to a specific alignment that comes from show-tiling + # (sometimes show-aligns is more promiscuous than show-tiling) + new_alns = [] + for a in alns: + if a[1] > aln_start or a[2] < aln_stop: + log.debug(""dropping undesired alignment: %s(%s):%s-%s to %s(%s):%s-%s (%s:%s-%s requested)"", + self.seq_ids[0], a[0], a[1], a[2], + self.seq_ids[1], a[3], a[4], a[5], + self.seq_ids[0], aln_start, aln_stop) + else: + new_alns.append(a) + alns = new_alns + if len(alns) != 1: + log.warning(""invalid %s:%d-%d -> %s specified, %d alignments found that contain it"", + self.seq_ids[0], start, stop, self.seq_ids[1], len(alns)) + for aln in alns: + log.debug(""alignment: %s"", str(aln[:6])) + + return [self._aln_to_alt_seq(aln, start, stop) for aln in alns] + + def _aln_to_alt_seq(self, aln, start, stop): + """"""Given an alignment of a contig to ref, return the contig sequence aligned to a given stretch of ref"""""" + ref_l, ref_r, ref_seq, alt_seq = (aln[1], aln[2], aln[-2], aln[-1]) + + # convert desired start/stop relative to this reference window + # such that 0 <= start <= stop <= ref_r-ref_l+1 + aln_start = start - ref_l + aln_stop = stop - ref_l + + # travel down alignment until we've reached the left edge + # (because of gaps, you must check each position one by one) + # end loop when ref_seq[:i_left] contains {aln_start} bases + n_ref_bases = 0 + i_left = 0 + while n_ref_bases < aln_start: + if ref_seq[i_left] != '-': + n_ref_bases += 1 + i_left += 1 + + # travel down alignment until we've reached the right edge + # (because of gaps, you must check each position one by one) + # end loop when ref_seq[:i_right] contains {aln_stop} bases + i_right = i_left + while n_ref_bases < aln_stop: + if ref_seq[i_right] != '-': + n_ref_bases += 1 + i_right += 1 + # consume and include any trailing gaps + while i_right < len(ref_seq) and ref_seq[i_right] == '-': + i_right += 1 + + # grab the alternate sequence and strip gaps + return alt_seq[i_left:i_right+1].replace('-','') +","Python" +"Viral","broadinstitute/viral-ngs","tools/fastqc.py",".py","1450","50","''' + FastQC +''' + +import logging +import os +import os.path +import shutil +import subprocess +import sys + +import tools +import tools.samtools +import util.file +import util.misc + +TOOL_NAME = 'fastqc' +TOOL_VERSION = '0.11.7' + +log = logging.getLogger(__name__) + +class FastQC(tools.Tool): + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION)] + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def execute(self, inBam, outHtml): # pylint: disable=W0221 + if tools.samtools.SamtoolsTool().isEmpty(inBam): + # fastqc can't deal with empty input + with open(outHtml, 'wt') as outf: + outf.write(""Input BAM has zero reads.\n"") + + else: + # run fastqc + with util.file.tmp_dir() as out_dir: + tool_cmd = [self.install_and_get_path(), + '-t', str(util.misc.sanitize_thread_count()), + '-o', out_dir, + inBam] + log.debug(' '.join(tool_cmd)) + subprocess.check_call(tool_cmd, stdout=sys.stderr) + expected_out = os.path.join(out_dir, os.path.basename(inBam)[:-4]) + ""_fastqc.html"" + shutil.copyfile(expected_out, outHtml) + log.debug(""complete"") +","Python" +"Viral","broadinstitute/viral-ngs","tools/blast.py",".py","4082","117","""Tools in the blast+ suite."" + +import logging +import os +import subprocess + +import tools +import tools.samtools +import util.misc + +TOOL_NAME = ""blast"" +TOOL_VERSION = ""2.7.1"" + +_log = logging.getLogger(__name__) + +class BlastTools(tools.Tool): + """"""'Abstract' base class for tools in the blast+ suite. + Subclasses must define class member subtool_name."""""" + + def __init__(self, install_methods=None): + unwanted = [ + 'blast_formatter', 'blastdb_aliastool', 'blastdbcheck', 'blastdbcmd', 'convert2blastmask', 'deltablast', + 'legacy_blast.pl', 'makembindex', 'makeprofiledb', 'psiblast', 'rpsblast', 'rpstblastn', 'segmasker', + 'tblastn', 'tblastx', 'update_blastdb.pl', 'windowmasker' + ] + self.subtool_name = self.subtool_name if hasattr(self, ""subtool_name"") else ""blastn"" + if install_methods is None: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, executable=self.subtool_name, version=TOOL_VERSION)) + super(BlastTools, self).__init__(install_methods=install_methods) + + def execute(self, *args): + cmd = [self.install_and_get_path()] + cmd.extend(args) + util.misc.run_and_print(cmd, buffered=True, check=True) + + +class BlastnTool(BlastTools): + """""" Tool wrapper for blastn """""" + subtool_name = 'blastn' + + def get_hits_pipe(self, inPipe, db, threads=None): + + # run blastn and emit list of read IDs + threads = util.misc.sanitize_thread_count(threads) + cmd = [self.install_and_get_path(), + '-db', db, + '-word_size', 16, + '-num_threads', threads, + '-evalue', '1e-6', + '-outfmt', 6, + '-max_target_seqs', 1, + ] + cmd = [str(x) for x in cmd] + _log.debug('| ' + ' '.join(cmd) + ' |') + blast_pipe = subprocess.Popen(cmd, stdin=inPipe, stdout=subprocess.PIPE) + + # strip tab output to just query read ID names and emit + last_read_id = None + for line in blast_pipe.stdout: + line = line.decode('UTF-8').rstrip('\n\r') + read_id = line.split('\t')[0] + # only emit if it is not a duplicate of the previous read ID + if read_id != last_read_id: + last_read_id = read_id + yield read_id + + if blast_pipe.poll(): + raise subprocess.CalledProcessError(blast_pipe.returncode, cmd) + + def get_hits_bam(self, inBam, db, threads=None): + return self.get_hits_pipe( + tools.samtools.SamtoolsTool().bam2fa_pipe(inBam), + db, + threads=threads) + + def get_hits_fasta(self, inFasta, db, threads=None): + with open(inFasta, 'rt') as inf: + for hit in self.get_hits_pipe(inf, db, threads=threads): + yield hit + + +class MakeblastdbTool(BlastTools): + """""" Tool wrapper for makeblastdb """""" + subtool_name = 'makeblastdb' + + def build_database(self, fasta_files, database_prefix_path): + """""" builds a srprism database """""" + + input_fasta = """" + + # we can pass in a string containing a fasta file path + # or a list of strings + if 'basestring' not in globals(): + basestring = str + if isinstance(fasta_files, basestring): + fasta_files = [fasta_files] + elif isinstance(fasta_files, list): + pass + else: + raise TypeError(""fasta_files was not a single fasta file, nor a list of fasta files"") # or something along that line + + # if more than one fasta file is specified, join them + # otherwise if only one is specified, just use it + if len(fasta_files) > 1: + input_fasta = util.file.mkstempfname(""fasta"") + util.file.cat(input_fasta, fasta_files) + elif len(fasta_files) == 1: + input_fasta = fasta_files[0] + else: + raise IOError(""No fasta file provided"") + + args = ['-dbtype', 'nucl', '-in', input_fasta, '-out', database_prefix_path] + self.execute(*args) + + return database_prefix_path +","Python" +"Viral","broadinstitute/viral-ngs","tools/kaiju.py",".py","6863","186","''' +Kaiju - DNA-to-protein metagenomic classifier +''' +from builtins import super +import collections +import itertools +import logging +import os +import os.path +import shlex +import shutil +import subprocess +import tools + +from Bio import SeqIO + +import util.file + +TOOL_VERSION = '1.6.3_yesimon' + +log = logging.getLogger(__name__) + + +def read_a2t(fn, base_accession=True): + if base_accession: + accession_col = 0 + else: + accession_col = 1 + d = {} + with open(fn) as f: + next(f) + for line in f.readlines(): + parts = line.split('\t') + taxid = int(parts[2]) + accession = parts[accession_col] + d[accession] = taxid + return d + + +class Kaiju(tools.Tool): + + def __init__(self, install_methods=None): + if not install_methods: + install_methods = [ + tools.CondaPackage(""kaiju"", version=TOOL_VERSION) + ] + super(Kaiju, self).__init__(install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def build(self, db_prefix, protein_fastas, threads=None, options=None, option_string=None, + tax_db=None, translate_accessions=False): + '''Create a kaiju database. + + Args: + db_prefix: Kaiju database prefix (file path not containing extension) to create. + protein_fastas: List of input fasta files to process. + tax_db: Contains accession2taxid used if translate_accessions is True. + translate_accessions: If fasta IDs are accessions, translate to + _ format kaiju expects. + ''' + assert len(protein_fastas), ('Kaiju requires input files to create a database.') + options = options or {} + options['-a'] = 'protein' + options['-n'] = util.misc.sanitize_thread_count(threads) + options['-o'] = db_prefix + + temp_file = util.file.temp_catted_files(protein_fastas, prefix='kaiju_', suffix='.faa') + + db_fasta_fn = util.file.tempfname() + with db_fasta_fn as db_fasta_fn: + if translate_accessions: + with temp_file as input_fasta: + with open(db_fasta_fn, 'w') as db_fasta: + prot2taxid_fn = os.path.join(tax_db, 'accession2taxid', 'prot.accession2taxid') + prot2taxid = read_a2t(prot2taxid_fn) + for record in SeqIO.parse(input_fasta, 'fasta'): + accession = record.id.split('.', 1)[0] + taxid = prot2taxid.get(accession) + if taxid is not None: + new_id = '_'.join([record.id, str(taxid)]) + record.id = new_id + record.description = new_id + SeqIO.write(record, db_fasta, 'fasta') + option_string = db_fasta_fn + else: + option_string = temp_ + + self.execute('mkbwt', options=options, option_string=option_string) + self.execute('mkfmi', option_string=db_prefix) + + def classify(self, db, tax_db, in_bam, output_reads=None, output_report=None, rank='species', verbose=None, num_threads=None): + assert output_reads or output_report + output_ctx = util.file.tempfname() + with util.file.tempfname() as temp_reads: + # Fake loop to break out early if report is not wanted + while True: + tmp_fastq1 = util.file.mkstempfname('_1.fastq') + tmp_fastq2 = util.file.mkstempfname('_2.fastq') + picard = tools.picard.SamToFastqTool() + picard_opts = { + 'CLIPPING_ATTRIBUTE': tools.picard.SamToFastqTool.illumina_clipping_attribute, + 'CLIPPING_ACTION': 'X' + } + picard.execute(in_bam, tmp_fastq1, tmp_fastq2, + picardOptions=tools.picard.PicardTools.dict_to_picard_opts(picard_opts), + JVMmemory=picard.jvmMemDefault) + + nodes_dmp = os.path.join(tax_db, 'nodes.dmp') + names_dmp = os.path.join(tax_db, 'names.dmp') + + opts = { + '-t': nodes_dmp, + '-f': db, + '-o': temp_reads, + '-z': util.misc.sanitize_thread_count(num_threads), + '-i': tmp_fastq1 + } + if verbose: + opts['-v'] = None + + if os.path.getsize(tmp_fastq2) >= 50: + opts['-j'] = tmp_fastq2 + + self.execute('kaiju', options=opts) + if not output_report: + break + + opts = { + '-r': rank, + '-p': True, + '-t': nodes_dmp, + '-n': names_dmp, + '-i': temp_reads, + '-o': output_report, + '-w': None, + '-x': None + } + if verbose: + opts['-v'] = None + self.execute('kaijuReport', options=opts) + break + if output_reads: + subprocess.check_call(['pigz', '-9', temp_reads]) + shutil.move(temp_reads + '.gz', output_reads) + + def execute(self, command, options=None, option_string=None, return_stdout=False): + '''Run a kaiju command + + Args: + options: Dict of command line options to values. Set value to None + for an option with no value. + return_stdout: Whether to return stdout as well as in + (exitcode, stdout). + ''' + cmd = [command] + if options: + # We need some way to allow empty options args like --log, hence + # we filter out on 'x is None'. + cmd.extend([str(x) for x in itertools.chain(*options.items()) if x is not None]) + if option_string: + cmd.extend(shlex.split(option_string)) + log.debug(""Calling {}: {}"".format(command, "" "".join(cmd))) + subprocess.check_call(cmd) + + def read_report(self, report_fn): + report = collections.Counter() + with open(report_fn) as f: + next(f) + for line in f: + if line.startswith('---'): + continue + parts = line.strip().split('\t') + percent = float(parts[0]) + reads = int(parts[1]) + fullname = parts[2] + if 'cannot be assigned to a species' in fullname: + tax_id = 1 + elif 'unclassified' == fullname: + tax_id = 0 + else: + tax_id = parts[3] + report[tax_id] = reads + return report +","Python" +"Viral","broadinstitute/viral-ngs","tools/krona.py",".py","2618","75","import tools +import os.path +import subprocess +from os.path import join +from builtins import super + +TOOL_NAME = 'krona' +CONDA_TOOL_VERSION = '2.7.1' + + +class Krona(tools.Tool): + def __init__(self, install_methods=None): + if not install_methods: + install_methods = [] + install_methods.append( + tools.CondaPackage( + TOOL_NAME, + version=CONDA_TOOL_VERSION, + executable='ktImportTaxonomy')) + super(Krona, self).__init__(install_methods=install_methods) + + @property + def opt(self): + if not self.executable_path(): + self.install_and_get_path() + bin_path = os.path.dirname(self.executable_path()) + # Get at the opt directory from the conda env root + opt = os.path.abspath(join(bin_path, '..', 'opt', 'krona')) + return opt + + def import_taxonomy(self, + db, + input_tsvs, + output, + query_column=None, + taxid_column=None, + score_column=None, + magnitude_column=None, + root_name=None, + no_hits=None, + no_rank=None): + if not self.executable_path(): + self.install_and_get_path() + bin_path = os.path.dirname(self.executable_path()) + env = os.environ.copy() + env['PATH'] = '{}:{}'.format(bin_path, env['PATH']) + cmd = ['ktImportTaxonomy', '-tax', db, '-o', output] + if query_column is not None: + cmd.extend(['-q', str(query_column)]) + if taxid_column is not None: + cmd.extend(['-t', str(taxid_column)]) + if score_column is not None: + cmd.extend(['-s', str(score_column)]) + if magnitude_column is not None: + cmd.extend(['-m', str(magnitude_column)]) + if root_name is not None: + cmd.extend(['-n', root_name]) + if no_hits is not None: + cmd.append('-i') + if no_rank is not None: + cmd.append('-k') + cmd.extend(input_tsvs) + + subprocess.check_call(cmd, env=env) + + def create_db(self, db_dir): + """"""Caution - this deletes the original .dmp files."""""" + bin_path = os.path.dirname(self.executable_path()) + env = os.environ.copy() + env['PATH'] = '{}:{}'.format(bin_path, env['PATH']) + + sh = join(self.opt, 'updateTaxonomy.sh') + cmd = [sh, '--only-build', os.path.abspath(db_dir)] + subprocess.check_call(cmd, env=env) +","Python" +"Viral","broadinstitute/viral-ngs","tools/snpeff.py",".py","10920","268","''' +snpEff - a tool for annotating genetic consequences of variants in VCF format +http://snpeff.sourceforge.net/ +''' + +# built-ins +import hashlib +import os +import tempfile +import logging +import subprocess +import shutil + +# third-party +import pysam + +# module-specific +import tools +import util.file +import util.misc +import util.genbank + +_log = logging.getLogger(__name__) + +TOOL_NAME = 'snpeff' +TOOL_VERSION = '4.3.1t' + +URL = 'http://downloads.sourceforge.net/project/snpeff/snpEff_v4_3t_core.zip' + + +class SnpEff(tools.Tool): + + def __init__(self, install_methods=None, extra_genomes=None): + self.jvmMemDefault = '4g' + extra_genomes = extra_genomes or ['KJ660346.2'] + if not install_methods: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, executable=""snpEff"", version=TOOL_VERSION)) + install_methods.append(DownloadAndTweakSnpEff(URL, extra_genomes)) + self.known_dbs = set() + self.installed_dbs = set() + super(SnpEff, self).__init__(install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def execute(self, command, args, JVMmemory=None, stdin=None, stdout=None, stderr=None): # pylint: disable=W0221 + if not JVMmemory: + JVMmemory = self.jvmMemDefault + + # the conda version wraps the jar file with a shell script + if self.install_and_get_path().endswith("".jar""): + tool_cmd = [ + 'java', '-Xmx' + JVMmemory, '-Djava.io.tmpdir=' + tempfile.gettempdir(), '-jar', self.install_and_get_path(), + command + ] + args + else: + tool_cmd = [ + self.install_and_get_path(), '-Xmx' + JVMmemory, '-Djava.io.tmpdir=' + tempfile.gettempdir(), command + ] + args + + _log.debug(' '.join(tool_cmd)) + return util.misc.run_and_print(tool_cmd, stdin=stdin, stderr=stderr, buffered=True, silent=command in (""databases"",""build""), check=True) + + def has_genome(self, genome): + if not self.known_dbs: + for _ in self.available_databases(): + pass + + return genome in self.installed_dbs + + def download_db(self, dbname, verbose=False): + opts = [dbname] + if verbose: + opts.append('-v') + self.execute('download', opts) + self.known_dbs.add(dbname) + self.installed_dbs.add(dbname) + + def create_db(self, accessions, emailAddress=None, JVMmemory=None): + sortedAccessionString = "", "".join([util.genbank.parse_accession_str(acc) for acc in sorted(accessions)]) + databaseId = hashlib.sha256(sortedAccessionString.encode('utf-8')).hexdigest()[:55] + + # if the database is not installed, we need to make it + if not self.has_genome(databaseId): + config_file = os.path.join(os.path.dirname(os.path.realpath(self.install_and_get_path())), 'snpEff.config') + data_dir = get_data_dir(config_file) + + # if the data directory specified in the config is absolute, use it + # otherwise get the data directory relative to the location of the config file + if os.path.isabs(data_dir): + outputDir = os.path.join(data_dir, databaseId) + else: + outputDir = os.path.realpath(os.path.join(os.path.dirname(config_file), data_dir, databaseId)) + + util.genbank.fetch_full_records_from_genbank( + sorted(accessions), + outputDir, + emailAddress, + forceOverwrite=True, + combinedFilePrefix=""genes"", + removeSeparateFiles=False + ) + + # create a temp config file in the same location as the original + # since the data dir for the built database has a relative + # location by default + tmp_config_file = config_file+"".temp"" + + # build a new snpEff database using the downloaded genbank file + # Note that if the snpEff command fails for some reason, + # we should take care to not include an entry for the database + # in the config file, which is the record of installed databases. + # In the event the build fails, the config file must reflect + # databases present in the data_dir, otherwise calls to execute snpEff will + # fail if the data_dir lacks databases for entries listed in the config file. + + # make a temp copy of the old config file + shutil.copyfile(config_file, tmp_config_file) + + # add the new genome to the temp config file + # since snpEff will not attempt to build unless the + # database is in the config file + add_genomes_to_snpeff_config_file(tmp_config_file, [(databaseId, sortedAccessionString, sortedAccessionString)]) + + try: + args = ['-genbank', '-v', databaseId, ""-c"", tmp_config_file] + self.execute('build', args, JVMmemory=JVMmemory) + except: + # remove temp config file if the database build failed + shutil.unlink(tmp_config_file) + raise + + # copy the temp config including the built database + # if the execute('build') command did not raise an exception + shutil.move(tmp_config_file, config_file) + self.known_dbs.add(databaseId) + self.installed_dbs.add(databaseId) + + def available_databases(self): + # do not capture stderr, since snpEff writes 'Picked up _JAVA_OPTIONS' + # which is not helpful for reading the stdout of the databases command + with open(os.devnull, ""wb"") as devnull: + command_ps = self.execute(""databases"", args=[], stderr=devnull) + + split_points = [] + keys = ['Genome', 'Organism', 'Status', 'Bundle', 'Database'] + self.installed_dbs = set() + self.known_dbs = set() + for line in command_ps.stdout.decode(""utf-8"").splitlines(): + line = line.strip() + if not split_points: + if not line.startswith('Genome'): + raise Exception() + split_points = list(line.index(key) for key in keys) + elif not line.startswith('----'): + indexes = split_points + [len(line)] + row = dict((keys[i], line[indexes[i]:indexes[i + 1]].strip()) for i in range(len(split_points))) + self.known_dbs.add(row['Genome']) + if row.get('Status') == 'OK': + self.installed_dbs.add(row['Genome']) + yield row + + def annotate_vcf(self, inVcf, genomes, outVcf, emailAddress=None, JVMmemory=None): + """""" + Annotate variants in VCF file with translation consequences using snpEff. + """""" + if outVcf.endswith('.vcf.gz'): + tmpVcf = util.file.mkstempfname(prefix='vcf_snpEff-', suffix='.vcf') + elif outVcf.endswith('.vcf'): + tmpVcf = outVcf + else: + raise Exception(""invalid input"") + + sortedAccessionString = "", "".join([util.genbank.parse_accession_str(acc) for acc in sorted(genomes)]) + databaseId = hashlib.sha256(sortedAccessionString.encode('utf-8')).hexdigest()[:55] + + genomeToUse = """" + + # if we don't have the genome, by name (snpEff official) or by hash (custom) + if (not self.has_genome(databaseId)): + if (not self.has_genome(genomes[0])): + _log.info(""Checking for snpEff database online..."") + # check to see if it is available for download, and if so install it + for row in self.available_databases(): + if (genomes[0].lower() in row['Genome'].lower()) or ( + genomes[0].lower() in row['Bundle'].lower() + ) or ( + genomes[0].lower() in row['Organism'].lower() + ): + self.download_db(row['Genome']) + + # backward compatability for where a single genome name is provided + if self.has_genome(genomes[0]): + genomeToUse = genomes[0] + else: + # if the hash of the accessions passed in is not present in the genomes db + if not self.has_genome(databaseId): + self.create_db(genomes, emailAddress, JVMmemory) + + if self.has_genome(databaseId): + genomeToUse = databaseId + + if not genomeToUse: + raise Exception() + + args = [ + '-treatAllAsProteinCoding', 'false', '-t', '-noLog', '-ud', '0', '-noStats', '-noShiftHgvs', genomeToUse, + os.path.realpath(inVcf) + ] + + command_ps = self.execute('ann', args, JVMmemory=JVMmemory) + if command_ps.returncode == 0: + with open(tmpVcf, 'wt') as outf: + outf.write(command_ps.stdout.decode(""utf-8"")) + + if outVcf.endswith('.vcf.gz'): + pysam.tabix_compress(tmpVcf, outVcf, force=True) + pysam.tabix_index(outVcf, force=True, preset='vcf') + os.unlink(tmpVcf) + else: + raise subprocess.CalledProcessError(cmd=command_ps.args, returncode=command_ps.returncode, output=command_ps.stdout) + + +def get_data_dir(config_file): + data_dir = """" + with open(config_file, 'rt') as inf: + for line in inf: + if line.strip().startswith('data.dir'): + data_dir = line[line.find(""="") + 1:].strip() + break + return data_dir + + +def add_genomes_to_snpeff_config_file(config_file, new_genomes): + """""" + new_genomes is a 3-tuple (g,d,c): + where g is the genome name + d is the description + c is a comma-separated list of chromosomes + """""" + genomes = set() + with open(config_file, 'rt') as inf: + for line in inf: + if not line.startswith('#') and line.strip(): + i = line.find('.genome : ') + if i >= 0: + genomes.add(line[:i]) + with open(config_file, 'at') as outf: + for (g, d, c) in new_genomes: + if g not in genomes: + outf.write('{}.genome : {}\n'.format(g, d)) + if g != c: + outf.write(""\t{}.chromosomes : {}\n"".format(g, c)) + + +class DownloadAndTweakSnpEff(tools.DownloadPackage): + + def __init__(self, url, extra_genomes=None): + extra_genomes = extra_genomes or [] + + self.extra_genomes = extra_genomes + super(DownloadAndTweakSnpEff, self).__init__(url, 'snpEff/snpEff.jar', require_executability=False) + + def post_download(self): + config_file = os.path.join(self.destination_dir, 'snpEff', 'snpEff.config') + add_genomes_to_snpeff_config_file(config_file, zip(self.extra_genomes, self.extra_genomes, self.extra_genomes)) +","Python" +"Viral","broadinstitute/viral-ngs","tools/last.py",".py","5808","149","""Tools in the 'last' suite."" + +# built-ins +import os +import logging +import subprocess + +# within this module +import util.file +import util.misc +import tools +import tools.samtools + +_log = logging.getLogger(__name__) + +TOOL_NAME = ""last"" +TOOL_VERSION = ""876"" + + +class LastTools(tools.Tool): + """""" + ""Abstract"" base class for tools in the 'last' suite. + Subclasses must define class members subtool_name #and subtool_name_on_broad. + """""" + + def __init__(self, install_methods=None): + self.subtool_name = self.subtool_name if hasattr(self, ""subtool_name"") else None + self.subtool_name_on_broad = self.subtool_name_on_broad if hasattr(self, ""subtool_name_on_broad"") else None + if install_methods is None: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, executable=self.subtool_name, version=TOOL_VERSION)) + tools.Tool.__init__(self, install_methods=install_methods) + + +class Lastal(LastTools): + """""" wrapper for lastal subtool """""" + subtool_name = 'lastal' + subtool_name_on_broad = 'lastal' + + def get_hits(self, inBam, db, + max_gapless_alignments_per_position=1, + min_length_for_initial_matches=5, + max_length_for_initial_matches=50, + max_initial_matches_per_position=100, + threads=None + ): + + # convert BAM to interleaved FASTQ with no /1 /2 appended to the read IDs + fastq_pipe = tools.samtools.SamtoolsTool().bam2fq_pipe(inBam) + + # run lastal and emit list of read IDs + # -P 0 = use threads = core count + # -N 1 = report at most one alignment per query sequence + # -i 1G = perform work in batches of at most 1GB of query sequence at a time + # -f tab = write output in tab format instead of maf format + cmd = [self.install_and_get_path(), + '-n', max_gapless_alignments_per_position, + '-l', min_length_for_initial_matches, + '-L', max_length_for_initial_matches, + '-m', max_initial_matches_per_position, + '-Q', '1', + '-P', str(util.misc.sanitize_thread_count(threads, tool_max_cores_value=0)), + '-N', '1', '-i', '1G', '-f', 'tab', + db, + ] + cmd = [str(x) for x in cmd] + _log.debug('| ' + ' '.join(cmd) + ' |') + lastal_pipe = subprocess.Popen(cmd, stdin=fastq_pipe.stdout, stdout=subprocess.PIPE) + + if fastq_pipe.poll(): + raise subprocess.CalledProcessError(fastq_pipe.returncode, ""SamtoolsTool().bam2fq_pipe({})"".format(inBam)) + + # strip tab output to just query read ID names and emit + last_read_id = None + for line in lastal_pipe.stdout: + line = line.decode('UTF-8').rstrip('\n\r') + if not line.startswith('#'): + read_id = line.split('\t')[6] + # only emit if it is not a duplicate of the previous read ID + if read_id != last_read_id: + last_read_id = read_id + yield read_id + + if lastal_pipe.poll(): + raise subprocess.CalledProcessError(lastal_pipe.returncode, cmd) + + +class Lastdb(LastTools): + """""" wrapper for lastdb subtool """""" + subtool_name = 'lastdb' + subtool_name_on_broad = 'lastdb' + + def is_indexed(self, db_prefix): + return all(os.path.exists(db_prefix + x) + for x in ('.bck', '.des', '.prj', '.sds', '.ssp', '.suf', '.tis')) + + def build_database(self, fasta_files, database_prefix_path=None): # pylint: disable=W0221 + if database_prefix_path is None: + output_file_prefix = ""lastdb"" + output_directory = tempfile.mkdtemp() + else: + output_file_prefix = os.path.basename(os.path.abspath(database_prefix_path)) + output_directory = os.path.dirname(os.path.abspath(database_prefix_path)) + + # we can pass in a string containing a fasta file path + # or a list of strings + if isinstance(fasta_files, str): + fasta_files = [fasta_files] + elif isinstance(fasta_files, list) and fasta_files: + pass + else: + raise TypeError(""fasta_files was not a single fasta file, nor a list of fasta files"") # or something along that line + + # if more than one fasta file is specified, join them + # otherwise if only one is specified, just use it + if len(fasta_files) == 1 and not fasta_files[0].endswith('.gz'): + input_fasta = fasta_files[0] + else: + input_fasta = util.file.mkstempfname("".fasta"") + util.file.cat(input_fasta, fasta_files) # automatically decompresses gz inputs + + self.execute(input_fasta, output_directory, output_file_prefix) + + return os.path.join(output_directory, output_file_prefix) + + + def execute(self, inputFasta, outputDirectory, outputFilePrefix): # pylint: disable=W0221 + # get the path to the binary + tool_cmd = [self.install_and_get_path()] + + # if the output directory (and its parents) do not exist, create them + if not os.path.exists(outputDirectory): + os.makedirs(outputDirectory) + + # append the prefix given to files created by lastdb + tool_cmd.append(outputFilePrefix) + + # append the input filepath + tool_cmd.append(os.path.realpath(inputFasta)) + + # execute the lastdb command + # lastdb writes files to the current working directory, so we need to set + # it to the desired output location + with util.file.pushd_popd(os.path.realpath(outputDirectory)): + _log.debug("" "".join(tool_cmd)) + subprocess.check_call(tool_cmd) + + +","Python" +"Viral","broadinstitute/viral-ngs","tools/spades.py",".py","6871","142","''' + Tool wrapper for SPAdes, St. Petersburg Assembler ( http://cab.spbu.ru/software/spades/ ) +''' + +import logging +import os +import os.path +import subprocess +import shutil +import random +import shlex +import tempfile + +import Bio.SeqIO + +import tools +import tools.samtools +import tools.picard +import util.file +import util.misc + +TOOL_NAME = 'spades' +TOOL_VERSION = '3.12.0' + +log = logging.getLogger(__name__) + +class SpadesTool(tools.Tool): + '''Tool wrapper for SPAdes tool (St. Petersburg Assembler)''' + + def __init__(self, install_methods=None): + if install_methods is None: + install_methods = [tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION, executable='spades.py', + verifycmd='spades.py --version')] + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def execute(self, args): # pylint: disable=W0221 + tool_cmd = [self.install_and_get_path()] + list(map(str, args)) + log.debug(' '.join(tool_cmd)) + subprocess.check_call(tool_cmd) + + def assemble(self, reads_fwd, reads_bwd, contigs_out, reads_unpaired=None, contigs_trusted=None, + contigs_untrusted=None, kmer_sizes=(55,65), always_succeed=False, max_kmer_sizes=1, + filter_contigs=False, min_contig_len=0, mem_limit_gb=8, threads=None, spades_opts=''): + '''Assemble contigs from RNA-seq reads and (optionally) pre-existing contigs. + + Inputs: + Required: + reads_fwd, reads_bwd (fasta/q): paired reads + Optional: + reads_unpaired (fasta/q): optionally, additional unpaired reads + contigs_trusted (fasta/q): optionally, already-assembled contigs of high quality + contigs_untrusted (fasta/q): optionally, already-assembled contigs of average quality + Params: + kmer_sizes: if given, use these kmer sizes and combine the resulting contigs. kmer size of 0 or None means use size auto-selected + by SPAdes based on read length. + always_succeed: if True, if spades fails with an error for a kmer size, pretend it just produced no contigs for that kmer size + max_kmer_sizes: if this many kmer sizes succeed, do not try further ones + filter_contigs: if True, outputs only ""long and reliable transcripts with rather high expression"" (per SPAdes docs) + min_contig_len: drop contigs shorter than this many bp + mem_limit_gb: max memory to use, in gigabytes + threads: number of threads to use + spades_opts: additional options to pass to spades + Outputs: + contigs_out: assembled contigs in fasta format. Note that, since we use the + RNA-seq assembly mode, for some genome regions we may get several contigs + representing alternative transcripts. Fasta record name of each contig indicates + its length, coverage, and the group of alternative transcripts to which it belongs. + See details at + http://cab.spbu.ru/files/release3.11.1/rnaspades_manual.html#sec2.4 . + ''' + + threads = util.misc.sanitize_thread_count(threads) + + util.file.make_empty(contigs_out) + contigs_cumul_count = 0 + + if ((reads_fwd and reads_bwd and os.path.getsize(reads_fwd) > 0 and os.path.getsize(reads_bwd) > 0) or + (reads_unpaired and os.path.getsize(reads_unpaired) > 0)): + + kmer_sizes_succeeded = 0 + for kmer_size in util.misc.make_seq(kmer_sizes): + + with util.file.tmp_dir('_spades') as spades_dir: + log.debug('spades_dir=' + spades_dir) + args = [] + if reads_fwd and reads_bwd and os.path.getsize(reads_fwd) > 0 and os.path.getsize(reads_bwd) > 0: + args += ['-1', reads_fwd, '-2', reads_bwd ] + if reads_unpaired and os.path.getsize(reads_unpaired) > 0: + args += [ '--s1', reads_unpaired ] + if contigs_trusted: args += [ '--trusted-contigs', contigs_trusted ] + if contigs_untrusted: args += [ '--untrusted-contigs', contigs_untrusted ] + if kmer_size: args += [ '-k', kmer_size ] + if spades_opts: args += shlex.split(spades_opts) + args += [ '--rna', '-m' + str(mem_limit_gb), '-t', str(threads), '-o', spades_dir ] + + transcripts_fname = os.path.join(spades_dir, ('hard_filtered_' if filter_contigs else '') + 'transcripts.fasta') + + try: + self.execute(args=args) + except Exception as e: + if always_succeed: + log.warning('SPAdes failed for k={}: {}'.format(kmer_size, e)) + util.file.make_empty(transcripts_fname) + else: + raise + + # work around the bug that spades may succeed yet not create the transcripts.fasta file + if not os.path.isfile(transcripts_fname): + msg = 'SPAdes failed to make transcripts.fasta for k={}'.format(kmer_size) + if always_succeed: + log.warning(msg) + util.file.make_empty(transcripts_fname) + else: + raise RuntimeError(msg) + + if min_contig_len: + transcripts = Bio.SeqIO.parse(transcripts_fname, 'fasta') + transcripts_sans_short = [r for r in transcripts if len(r.seq) >= min_contig_len] + transcripts_fname = os.path.join(spades_dir, 'transcripts_over_{}bp.fasta'.format(min_contig_len)) + Bio.SeqIO.write(transcripts_sans_short, transcripts_fname, 'fasta') + + contigs_cumul = os.path.join(spades_dir, 'contigs_cumul.{}.fasta'.format(contigs_cumul_count)) + contigs_cumul_count += 1 + + util.file.concat(inputFilePaths=(contigs_out, transcripts_fname), outputFilePath=contigs_cumul, append=True) + shutil.copyfile(contigs_cumul, contigs_out) + + if os.path.getsize(transcripts_fname): + kmer_sizes_succeeded += 1 + if kmer_sizes_succeeded >= max_kmer_sizes: + break + # end: with util.file.tmp_dir('_spades') as spades_dir + # end: for kmer_size in util.misc.make_seq(kmer_sizes) + # if input non-empty + # end: def assemble(self, reads_fwd, reads_bwd, contigs_out, reads_unpaired=None, contigs_trusted=None, ...) +# end: class SpadesTool(tools.Tool) + + +","Python" +"Viral","broadinstitute/viral-ngs","tools/bmtagger.py",".py","4380","133","""tools.Tool for bmtagger.sh."" + +import tools +import util.file +import os +import logging +import subprocess +from tools import urlretrieve +_log = logging.getLogger(__name__) + +TOOL_NAME = ""bmtagger"" +TOOL_VERSION = ""3.101"" + + +class BmtaggerTools(tools.Tool): + ''' + ""Abstract"" base class for bmtagger.sh, bmfilter, extract_fullseq, srprism. + Subclasses must define class member subtool_name. + + Note: bmtagger calls blastn so that must be installed somewhere in $PATH. + + WARNING: bmtagger.sh does not work with the version of getopt that ships + with Mac OS X. This can be worked around by installing linux getopt + using fink and assuring that /sw/bin comes before /usr/bin in $PATH. + + ''' + + # subtool_name must be defined in subclass + + def __init__(self, install_methods=None): + self.subtool_name = self.subtool_name if hasattr(self, ""subtool_name"") else ""bmtagger.sh"" + if install_methods is None: + install_methods = [] + install_methods.append(tools.CondaPackage(TOOL_NAME, executable=self.subtool_name, version=TOOL_VERSION)) + tools.Tool.__init__(self, install_methods=install_methods) + + def execute(self, *args): + cmd = [self.install_and_get_path()] + cmd.extend(args) + subprocess.check_call(cmd) + + def silent_execute(self, *args): + cmd = [self.install_and_get_path()] + cmd.extend(args) + with open(os.devnull, 'w') as fnull: + subprocess.check_call(cmd, stderr=fnull) + + +class BmtaggerShTool(BmtaggerTools): + """""" tool wrapper for bmtagger """""" + subtool_name = 'bmtagger.sh' + + +class BmfilterTool(BmtaggerTools): + """""" tool wrapper for bmfilter """""" + subtool_name = 'bmfilter' + + +class BmtoolTool(BmtaggerTools): + """""" tool wrapper for bmtool """""" + subtool_name = 'bmtool' + + def build_database(self, fasta_files, bitmask_file_path, max_ambig=0, word_size=18): + """""" builds a bmtool database (*.bitmask file) """""" + + input_fasta = """" + + # we can pass in a string containing a fasta file path + # or a list of strings + if 'basestring' not in globals(): + basestring = str + if isinstance(fasta_files, basestring): + fasta_files = [fasta_files] + elif isinstance(fasta_files, list): + pass + else: + raise TypeError(""fasta_files was not a single fasta file, nor a list of fasta files"") # or something along that line + + # if more than one fasta file is specified, join them + # otherwise if only one is specified, just use it + if len(fasta_files) > 1: + input_fasta = util.file.mkstempfname(""fasta"") + util.file.cat(input_fasta, fasta_files) + elif len(fasta_files) == 1: + input_fasta = fasta_files[0] + else: + raise IOError(""No fasta file provided"") + + args = ['-d', input_fasta, '-o', bitmask_file_path, '-A', str(max_ambig), '-w', str(word_size)] + self.silent_execute(*args) + + return bitmask_file_path + +class ExtractFullseqTool(BmtaggerTools): + """""" tool wrapper for extract_fullseq """""" + subtool_name = 'extract_fullseq' + + +class SrprismTool(BmtaggerTools): + """""" tool wrapper for srprism """""" + subtool_name = 'srprism' + + def build_database(self, fasta_files, database_prefix_path): + """""" builds a srprism database """""" + + input_fasta = """" + + # we can pass in a string containing a fasta file path + # or a list of strings + if 'basestring' not in globals(): + basestring = str + if isinstance(fasta_files, basestring): + fasta_files = [fasta_files] + elif isinstance(fasta_files, list): + pass + else: + raise TypeError(""fasta_files was not a single fasta file, nor a list of fasta files"") # or something along that line + + # if more than one fasta file is specified, join them + # otherwise if only one is specified, just use it + if len(fasta_files) > 1: + input_fasta = util.file.mkstempfname(""fasta"") + util.file.cat(input_fasta, fasta_files) + elif len(fasta_files) == 1: + input_fasta = fasta_files[0] + else: + raise IOError(""No fasta file provided"") + + args = ['mkindex', '-i', input_fasta, '-o', database_prefix_path] + self.execute(*args) + + return database_prefix_path +","Python" +"Viral","broadinstitute/viral-ngs","tools/diamond.py",".py","2843","81","''' +DIAMOND - blastx replacement for large database protein sequence queries +''' +from builtins import super +import itertools +import logging +import os +import os.path +import shlex +import shutil +import subprocess +import tools +import util.file + +TOOL_VERSION = '0.9.10' + +log = logging.getLogger(__name__) + +@tools.skip_install_test(condition=tools.is_osx()) +class Diamond(tools.Tool): + + SUBCOMMANDS = ['makedb', 'blastx', 'blastp', 'view'] + + def __init__(self, install_methods=None): + if not install_methods: + install_methods = [ + tools.CondaPackage(""diamond"", version=TOOL_VERSION) + ] + super(Diamond, self).__init__(install_methods=install_methods) + + def version(self): + return TOOL_VERSION + + def build(self, db, protein_fastas, options=None, option_string=None): + '''Create a diamond database. + + Args: + db: Diamond database file to create. + protein_fastas: List of input fasta files to process. + ''' + assert len(protein_fastas), ('Diamond requires input files to create a database.') + options = options or {} + temp_file = util.file.temp_catted_files(protein_fastas, prefix='diamond_', suffix='.fasta') + with temp_file as input_fasta: + options['--in'] = input_fasta + options['--db'] = db + + self.execute('makedb', options=options, option_string=option_string) + + def view(self, diamond_alignment, output_file, output_format='tab', options=None, option_string=None): + '''Perform translation between diamond output and blast tab/sam output. + ''' + + assert output_format in ('tab', 'sam'), 'Invalid diamond view format' + options = options or {} + options['--out'] = output_file + options['--daa'] = diamond_alignment + options['--outfmt'] = output_format + self.execute('view', options=options, option_string=option_string) + + def execute(self, command, options=None, option_string=None, return_stdout=False): + '''Run a diamond command + + Args: + options: Dict of command line options to values. Set value to None + for an option with no value. + return_stdout: Whether to return stdout as well as in + (exitcode, stdout). + ''' + assert command in Diamond.SUBCOMMANDS, 'Diamond command is unknown' + + cmd = [self.install_and_get_path(), command] + if options: + # We need some way to allow empty options args like --log, hence + # we filter out on 'x is None'. + cmd.extend([str(x) for x in itertools.chain(*options.items()) if x is not None]) + if option_string: + cmd.extend(shlex.split(option_string)) + log.debug(""Calling {}: {}"".format(command, "" "".join(cmd))) + subprocess.check_call(cmd) +","Python" +"Viral","broadinstitute/viral-ngs","tools/novoalign.py",".py","9347","235","''' + Novoalign aligner by Novocraft + + This is commercial software that has different licenses depending + on use cases. As such, we do not have an auto-downloader. The user + must have Novoalign pre-installed on their own and available + either in $PATH or $NOVOALIGN_PATH. +''' + +import tools +import tools.picard +import tools.samtools +import util.file +import util.misc + +import logging +import os +import os.path +import subprocess +import stat +import sys + +_log = logging.getLogger(__name__) + +TOOL_NAME = ""novoalign"" +TOOL_VERSION = ""3.07.00"" + + +class NovoalignTool(tools.Tool): + + def __init__(self, path=None, license_path=None): + self.tool_version = None + install_methods = [] + for novopath in [path, os.environ.get('NOVOALIGN_PATH'), '']: + if novopath is not None: + install_methods.append( + tools.PrexistingUnixCommand( + os.path.join(novopath, 'novoalign'), + require_executability=True + ) + ) + + post_verify_command = None + for novo_license_path in [license_path, os.environ.get(""NOVOALIGN_LICENSE_PATH""), '']: + if novo_license_path is not None and os.path.isfile(novo_license_path): + # called relative to the conda bin/ directory + uname = os.uname() + # we ideally want the ""update"" copy operation + # but only GNU cp has it. On OSX, the license will be copied each time. + if uname[0] == 'Darwin': + copy_operation = '' + else: + copy_operation = '-u' + + post_verify_command = ""cp {copy_operation} {lic_path} ./"".format(copy_operation=copy_operation, lic_path=novo_license_path) + break # if we've found a license file, stop looking + + install_methods.append(tools.CondaPackage(TOOL_NAME, version=TOOL_VERSION, post_verify_command=post_verify_command)) + tools.Tool.__init__(self, install_methods=install_methods) + + def version(self): + if self.tool_version is None: + self._get_tool_version() + return self.tool_version + + def _get_tool_version(self): + tmpf = util.file.mkstempfname('.novohelp.txt') + with open(tmpf, 'wt') as outf: + util.misc.run_and_save([self.install_and_get_path(), ""-V""], outf=outf, check=False) + with open(tmpf, 'rt') as inf: + self.tool_version = inf.readline().strip().split()[1] + os.unlink(tmpf) + + def _fasta_to_idx_name(self, fasta): + if not fasta.endswith('.fasta'): + raise ValueError('input file %s must end with .fasta' % fasta) + return fasta[:-6] + '.nix' + + def execute(self, inBam, refFasta, outBam, options=None, min_qual=0, JVMmemory=None): # pylint: disable=W0221 + ''' Execute Novoalign on BAM inputs and outputs. + If the BAM contains multiple read groups, break up + the input and perform Novoalign separately on each one + (because Novoalign mangles read groups). + Use Picard to sort and index the output BAM. + If min_qual>0, use Samtools to filter on mapping quality. + ''' + options = options or [""-r"", ""Random""] + + samtools = tools.samtools.SamtoolsTool() + + # fetch list of RGs + rgs = samtools.getReadGroups(inBam) + + rgs_list = list(samtools.getReadGroups(inBam).keys()) + if len(rgs) == 0: + # Can't do this + raise InvalidBamHeaderError(""{} lacks read groups"".format(inBam)) + + elif len(rgs) == 1: + # Only one RG, keep it simple + self.align_one_rg_bam(inBam, refFasta, outBam, rgs=rgs, options=options, min_qual=min_qual, JVMmemory=JVMmemory) + + else: + # Multiple RGs, align one at a time and merge + align_bams = [] + for rg in rgs: + tmp_bam = util.file.mkstempfname('.{}.bam'.format(rg)) + self.align_one_rg_bam( + inBam, + refFasta, + tmp_bam, + rgid=rg, + rgs=rgs, + options=options, + min_qual=min_qual, + JVMmemory=JVMmemory + ) + if os.path.getsize(tmp_bam) > 0: + align_bams.append(tmp_bam) + + # Merge BAMs, sort, and index + tools.picard.MergeSamFilesTool().execute( + align_bams, + outBam, + picardOptions=['SORT_ORDER=coordinate', 'USE_THREADING=true', 'CREATE_INDEX=true'], + JVMmemory=JVMmemory + ) + for bam in align_bams: + os.unlink(bam) + + def align_one_rg_bam(self, inBam, refFasta, outBam, rgid=None, rgs=None, options=None, min_qual=0, JVMmemory=None): + ''' Execute Novoalign on BAM inputs and outputs. + Requires that only one RG exists (will error otherwise). + Use Picard to sort and index the output BAM. + If min_qual>0, use Samtools to filter on mapping quality. + ''' + options = options or [""-r"", ""Random""] + + samtools = tools.samtools.SamtoolsTool() + + # Require exactly one RG + rgs = rgs if rgs is not None else samtools.getReadGroups(inBam) + if len(rgs) == 0: + raise InvalidBamHeaderError(""{} lacks read groups"".format(inBam)) + elif len(rgs) == 1: + if not rgid: + rgid = list(rgs.keys())[0] + elif not rgid: + raise InvalidBamHeaderError(""{} has {} read groups, but we require exactly one"".format(inBam, len(rgs))) + if rgid not in rgs: + raise InvalidBamHeaderError(""{} has read groups, but not {}"".format(inBam, rgid)) + #rg = rgs[rgid] + + # Strip inBam to just one RG (if necessary) + if len(rgs) == 1: + one_rg_inBam = inBam + else: + # strip inBam to one read group + tmp_bam = util.file.mkstempfname('.onebam.bam') + samtools.view(['-b', '-r', rgid], inBam, tmp_bam) + # special exit if this file is empty + if samtools.count(tmp_bam) == 0: + return + + # simplify BAM header otherwise Novoalign gets confused + one_rg_inBam = util.file.mkstempfname('.{}.in.bam'.format(rgid)) + headerFile = util.file.mkstempfname('.{}.header.txt'.format(rgid)) + with open(headerFile, 'wt') as outf: + for row in samtools.getHeader(inBam): + if len(row) > 0 and row[0] == '@RG': + if rgid != list(x[3:] for x in row if x.startswith('ID:'))[0]: + # skip all read groups that are not rgid + continue + outf.write('\t'.join(row) + '\n') + samtools.reheader(tmp_bam, headerFile, one_rg_inBam) + os.unlink(tmp_bam) + os.unlink(headerFile) + + # Novoalign + tmp_sam = util.file.mkstempfname('.novoalign.sam') + tmp_sam_err = util.file.mkstempfname('.novoalign.sam.err') + cmd = [self.install_and_get_path(), '-f', one_rg_inBam] + list(map(str, options)) + cmd = cmd + ['-F', 'BAM', '-d', self._fasta_to_idx_name(refFasta), '-o', 'SAM'] + _log.debug(' '.join(cmd)) + with open(tmp_sam, 'wt') as outf: + util.misc.run_and_save(cmd, outf=outf) + + # Samtools filter (optional) + if min_qual: + tmp_bam2 = util.file.mkstempfname('.filtered.bam') + cmd = [samtools.install_and_get_path(), 'view', '-b', '-S', '-1', '-q', str(min_qual), tmp_sam] + _log.debug('%s > %s', ' '.join(cmd), tmp_bam2) + with open(tmp_bam2, 'wb') as outf: + util.misc.run_and_save(cmd, outf=outf) + os.unlink(tmp_sam) + tmp_sam = tmp_bam2 + + # Picard SortSam + sorter = tools.picard.SortSamTool() + sorter.execute( + tmp_sam, + outBam, + sort_order='coordinate', + picardOptions=['CREATE_INDEX=true', 'VALIDATION_STRINGENCY=SILENT'], + JVMmemory=JVMmemory + ) + + def index_fasta(self, refFasta, k=None, s=None): + ''' Index a FASTA file (reference genome) for use with Novoalign. + The input file name must end in "".fasta"". This will create a + new "".nix"" file in the same directory. If it already exists, + it will be deleted and regenerated. + ''' + novoindex = os.path.join(os.path.dirname(self.install_and_get_path()), 'novoindex') + outfname = self._fasta_to_idx_name(refFasta) + if os.path.isfile(outfname): + os.unlink(outfname) + cmd = [novoindex] + if k is not None: + cmd.extend(['-k', str(k)]) + if s is not None: + cmd.extend(['-s', str(s)]) + cmd.extend([outfname, refFasta]) + _log.debug(' '.join(cmd)) + subprocess.check_call(cmd) + try: + mode = os.stat(outfname).st_mode & ~stat.S_IXUSR & ~stat.S_IXGRP & ~stat.S_IXOTH + os.chmod(outfname, mode) + except (IOError, OSError): + _log.warning('could not chmod ""%s"", this is likely OK', refFasta) + + +class InvalidBamHeaderError(ValueError): + pass +","Python" +"Viral","broadinstitute/viral-ngs","tools/scripts/subsampler.py",".py","5529","173","#!/usr/bin/env python +import argparse +import random +import sys +import subprocess + +parser = argparse.ArgumentParser( + description='This program outputs to stdout a user-defined number of reads from given reads file[s]') +parser.add_argument('-mode', action=""store"", dest=""mode"", required=True, help=""s => single-end, p => paired-end"") +# parser.add_argument('-format',action=""store"",dest=""format"",required=True,\ +# help=""fasta => fasta, fastq => fastq"",choices=['fasta','fastq']) +parser.add_argument('-n', + action=""store"", + type=int, + dest=""numSeq"", + required=True, + help=""specifies number of reads to output"") +parser.add_argument('-in', + action=""store"", + dest=""inputs"", + nargs='+', + required=True, + help=""specifies input files (put both input files separated by a space for paired end)"") +parser.add_argument('-out', + action=""store"", + dest=""outputs"", + nargs='*', + required=False, + default=['/dev/stdout'], + help=""specifies output files (default for single end is stdout)"") +args = parser.parse_args() +#format = args.format +numSeq = args.numSeq +mode = args.mode +reads = args.inputs +outs = args.outputs +if mode == 's': + if len(reads) != 1 or len(outs) > 1: + print(""please specify only one read file and at most one output file (if paired end, specify with -pe)"") + sys.exit() +elif mode == 'p': + if len(reads) != 2 or len(outs) != 2: + print(""please specify both read files and two output files"") + sys.exit() +fileName1 = reads[0] +if fileName1.find("".gz"") != -1: + subprocess.call(""gunzip "" + fileName1, shell=True) + fileName1 = fileName1[0:-3] +FILE = open(fileName1, 'r') +if mode == 'p': + fileName2 = reads[1] + if fileName2.find("".gz"") != -1: + subprocess.call(""gunzip "" + fileName2, shell=True) + fileName2 = fileName1[0:-3] + FILE2 = open(fileName2, 'r') +random.seed() +# name of the input file (fasta or fastq) +# assumes input file is standard fasta/fastq format +"""""" +calculate number of total reads +pseudorandomly determine which reads will be extracted +"""""" +count = 0 +char = FILE.readline()[0:1] +FILE.seek(0) +offsets = list() +# fasta format +if char == '>': + while True: + line = FILE.readline() + if not line: + break + if line[0:1] == char: + count += 1 + offsets.append(FILE.tell() - len(line)) + if mode == 'p': + offsets2 = list() + while True: + line = FILE2.readline() + if not line: + break + if line[0:1] == char: + offsets2.append(FILE2.tell() - len(line)) +# fastq format +elif char == '@': + while True: + offsets.append(FILE.tell()) + line = FILE.readline() + if not line: + offsets.pop(count) + break + count += 1 + linesToPlus = 0 + while FILE.readline()[0:1] != '+': + linesToPlus += 1 + for i in range(0, linesToPlus): + FILE.readline() + if mode == 'p': + offsets2 = list() + while True: + offsets2.append(FILE2.tell()) + line = FILE2.readline() + if not line: + offsets2.pop(count) + break + linesToPlus = 0 + while FILE2.readline()[0:1] != '+': + linesToPlus += 1 + for i in range(0, linesToPlus): + FILE2.readline() +else: + print(""Your file does not appear to be a valid format"") + sys.exit() + +if count < numSeq: + numSeq = count +selected = list(range(0, count)) +random.shuffle(selected) +selected = sorted(selected[0:numSeq]) + +if mode == 's': + out = open(outs[0], 'w') + for i in range(0, numSeq): + if selected[i] == count - 1: + FILE.seek(offsets[selected[i]]) + while True: + line = FILE.readline() + if not line: + break + out.write(line) + else: + curOffset = 0 + targetOffset = offsets[selected[i] + 1] - offsets[selected[i]] + FILE.seek(offsets[selected[i]]) + while curOffset != targetOffset: + line = FILE.readline() + curOffset += len(line) + out.write(line) + FILE.close() + out.close() + sys.exit() +# to avoid incessant checking +elif mode == 'p': + out1 = open(outs[0], 'w') + out2 = open(outs[1], 'w') + for i in range(0, numSeq): + if selected[i] == count - 1: + FILE.seek(offsets[selected[i]]) + FILE2.seek(offsets2[selected[i]]) + while True: + line = FILE.readline() + line2 = FILE2.readline() + if not line: + break + out1.write(line) + out2.write(line2) + else: + curOffset = 0 + targetOffset = offsets[selected[i] + 1] - offsets[selected[i]] + FILE.seek(offsets[selected[i]]) + FILE2.seek(offsets2[selected[i]]) + while curOffset != targetOffset: + line = FILE.readline() + line2 = FILE2.readline() + curOffset += len(line) + out1.write(line) + out2.write(line2) + FILE.close() + FILE2.close() + out1.close() + out2.close() + sys.exit() +","Python" +"Viral","broadinstitute/viral-ngs","easy-deploy-script/easy-deploy-viral-ngs.sh",".sh","28200","764","#!/bin/bash + +#set -e -o pipefail + +STARTING_DIR=$(pwd) + +# way to get the absolute path to this script that should +# work regardless of whether or not this script has been sourced +# Find original directory of bash script, resovling symlinks +# http://stackoverflow.com/questions/59895/can-a-bash-script-tell-what-directory-its-stored-in/246128#246128 +function absolute_path() { + local SOURCE=""$1"" + while [ -h ""$SOURCE"" ]; do # resolve $SOURCE until the file is no longer a symlink + DIR=""$( cd -P ""$( dirname ""$SOURCE"" )"" && pwd )"" + if [[ ""$OSTYPE"" == ""darwin""* ]]; then + SOURCE=""$(readlink ""$SOURCE"")"" + else + SOURCE=""$(readlink -f ""$SOURCE"")"" + fi + [[ $SOURCE != /* ]] && SOURCE=""$DIR/$SOURCE"" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located + done + echo ""$SOURCE"" +} +SOURCE=""${BASH_SOURCE[0]}"" +SCRIPT=$(absolute_path ""$SOURCE"") +SCRIPT_DIRNAME=""$(dirname ""$SOURCE"")"" +SCRIPTPATH=""$(cd -P ""$(echo $SCRIPT_DIRNAME)"" &> /dev/null && pwd)"" +SCRIPT=""$SCRIPTPATH/$(basename ""$SCRIPT"")"" + +CONDA_PREFIX_LENGTH_LIMIT=250 + +CONTAINING_DIR=""viral-ngs-etc"" +VIRAL_NGS_DIR=""viral-ngs"" +CONDA_ENV_BASENAME=""conda-env"" +CONDA_ENV_CACHE=""conda-cache"" +PROJECTS_DIR=""projects"" +MINICONDA_DIR=""mc3"" + +INSTALL_PATH=""${VIRAL_NGS_INSTALL_PATH:-$SCRIPTPATH/$CONTAINING_DIR}"" +INSTALL_PATH=$(absolute_path ""$INSTALL_PATH"") + +if [ -z ""$VIRAL_CONDA_ENV_PATH"" ]; then + VIRAL_CONDA_ENV_PATH=""$INSTALL_PATH/$CONDA_ENV_BASENAME"" +fi +PROJECTS_PATH=""$INSTALL_PATH/$PROJECTS_DIR"" +VIRAL_NGS_PATH=""$INSTALL_PATH/$VIRAL_NGS_DIR"" +if [ -z ""$MINICONDA_PATH"" ]; then + MINICONDA_PATH=""$INSTALL_PATH/$MINICONDA_DIR"" +fi + +SELF_UPDATE_URL=""https://raw.githubusercontent.com/broadinstitute/viral-ngs/master/easy-deploy-script/easy-deploy-viral-ngs.sh"" + +CONDA_CHANNEL_STRING=""--override-channels -c broad-viral -c conda-forge -c bioconda -c defaults"" + +if [ -z ""$VIRAL_NGS_PACKAGE"" ]; then + VIRAL_NGS_PACKAGE=""viral-ngs"" +fi + +# determine if this script has been sourced +# via: http://stackoverflow.com/a/28776166/2328433 +([[ -n $ZSH_EVAL_CONTEXT && $ZSH_EVAL_CONTEXT =~ :file$ ]] || + [[ -n $KSH_VERSION && $(cd ""$(dirname -- ""$0"")"" && + printf '%s' ""${PWD%/}/"")$(basename -- ""$0"") != ""${.sh.file}"" ]] || + [[ -n $BASH_VERSION && $0 != ""$BASH_SOURCE"" ]]) && sourced=1 || sourced=0 + +current_prefix_length=$(echo $MINICONDA_PATH | wc -c | sed -n '1h;1!H;${;g;s/^[ \t]*//g;s/[ \t]*$//g;p;}') # sed trims whitespace +if [ $current_prefix_length -ge $CONDA_PREFIX_LENGTH_LIMIT ]; then + echo ""ERROR: The conda path to be created by this script is too long to work with conda ($current_prefix_length characters):"" + echo ""$MINICONDA_PATH"" + echo ""This is a known bug in conda ($CONDA_PREFIX_LENGTH_LIMIT character limit): "" + echo ""https://github.com/conda/conda-build/pull/877"" + echo ""To prevent this error, move this script higher in the filesystem hierarchy."" + exit 80 +fi + +python_check=$(hash python &> /dev/null || hash python3 &> /dev/null) +if [ $? -ne 0 ]; then + echo ""It looks like Python is not installed. Exiting."" + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi +fi + +python3_check=$(hash python3 &> /dev/null) +if [ $? -eq 0 ]; then + python_to_use=""$(which python3)"" +fi + +$python_to_use --version + +ram_check=$($python_to_use -c ""bytearray(768000000)"" &> /dev/null) +if [ $? -ne 0 ]; then + echo """" + echo ""Unable to allocate 768MB."" + echo ""=============================================================="" + echo ""It appears your current system does not have enough free RAM."" + echo ""Consider logging in to a machine with more available memory."" + echo ""=============================================================="" + echo """" + + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi +fi + + +# Usage: puniq [] +# Remove duplicate entries from a PATH style value while retaining +# the original order. Use PATH if no is given. +# +# Example: +# $ puniq /usr/bin:/usr/local/bin:/usr/bin +# /usr/bin:/usr/local/bin +puniq() { + echo ${1%:} |tr : '\n' |nl |sort -u -k 2,2 |sort -n | + cut -f 2- |tr '\n' : |sed -e 's/:$//' -e 's/^://' +} + + +function set_locale(){ + export LANG=""$1"" + export LC_CTYPE=""$1"" + export LC_NUMERIC=""$1"" + export LC_TIME=""$1"" + export LC_COLLATE=""$1"" + export LC_MONETARY=""$1"" + export LC_MESSAGES=""$1"" + export LC_PAPER=""$1"" + export LC_NAME=""$1"" + export LC_ADDRESS=""$1"" + export LC_TELEPHONE=""$1"" + export LC_MEASUREMENT=""$1"" + export LC_IDENTIFICATION=""$1"" + export LC_ALL=""$1"" +} + + +function ask() { + while true; do + + if [ ""${2:-}"" = ""Y"" ]; then + prompt=""Y/n"" + default=Y + elif [ ""${2:-}"" = ""N"" ]; then + prompt=""y/N"" + default=N + else + prompt=""y/n"" + default= + fi + + # Ask the question + read -p ""$1 [$prompt] "" REPLY + + # Default? + if [ -z ""$REPLY"" ]; then + REPLY=$default + fi + + # Check if the reply is valid + case ""$REPLY"" in + Y*|y*) echo "" ""; return 0 ;; + N*|n*) echo "" ""; return 1 ;; + esac + + done +} + +if [[ ""$OSTYPE"" == ""darwin""* ]]; then + set_locale ""en_US.UTF-8"" +else + set_locale ""en_US.utf8"" +fi + +function prepend_miniconda(){ + if [ -d ""$MINICONDA_PATH/bin"" ]; then + echo ""Miniconda installed."" >&2 + + echo ""Prepending miniconda to PATH..."" >&2 + PATH=""$MINICONDA_PATH/bin:$PATH"" + export PATH=$(puniq $PATH) + hash -r + + # update to the latest conda this way, since the shell script + # is often months out of date + #if [ -z ""$SKIP_CONDA_UPDATE"" ]; then + # echo ""Updating conda..."" + # conda update -y conda + #fi + else + echo ""Miniconda directory not found."" >&2 + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi + fi +} + +function install_miniconda(){ + if [ -d ""$MINICONDA_PATH/bin"" ]; then + echo ""Miniconda directory exists."" + else + echo ""Downloading and installing Miniconda..."" + + if [[ ""$($python_to_use -c 'import os; print(os.uname()[0])')"" == ""Darwin"" ]]; then + miniconda_url=https://repo.continuum.io/miniconda/Miniconda3-latest-MacOSX-x86_64.sh + else + miniconda_url=https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh + fi + curl -sSL $miniconda_url > ""$INSTALL_PATH/Miniconda3-latest-x86_64.sh"" + chmod +x ""$INSTALL_PATH/Miniconda3-latest-x86_64.sh"" + ""$INSTALL_PATH/Miniconda3-latest-x86_64.sh"" -b -f -p ""$MINICONDA_PATH"" + + rm ""$INSTALL_PATH/Miniconda3-latest-x86_64.sh"" + fi + + if [ -d ""$MINICONDA_PATH/bin"" ]; then + prepend_miniconda + conda install -q -y -c defaults conda #==4.0.10 + else + echo ""It looks like the Miniconda installation failed"" + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi + fi +} + +function install_viral_ngs_conda(){ + # provide an avenue to specify a package path, or to use a previously-built local package + if [ $# -eq 2 ]; then + if [ ""$2"" == ""--use-local"" ]; then + conda install -q $CONDA_CHANNEL_STRING -y -p ""$VIRAL_CONDA_ENV_PATH"" --use-local $VIRAL_NGS_PACKAGE || exit 1 + echo ""using local...."" + exit 0 + else + conda install -q $CONDA_CHANNEL_STRING -y -p ""$VIRAL_CONDA_ENV_PATH"" $2 || exit 1 + fi + + elif [ $# -eq 3 ]; then + if [ ""$2"" == ""--viral-ngs-version"" ]; then + conda install -q $CONDA_CHANNEL_STRING -y -p ""$VIRAL_CONDA_ENV_PATH"" $VIRAL_NGS_PACKAGE=$3 || exit 1 + else + echo ""--viral-ngs-version specified but no version given"" + fi + elif [ $# -eq 1 ]; then + conda install -q $CONDA_CHANNEL_STRING -y -p ""$VIRAL_CONDA_ENV_PATH"" $VIRAL_NGS_PACKAGE || exit 1 + fi +} + +function install_viral_ngs_git(){ + if [ ! -d ""$VIRAL_NGS_PATH"" ]; then + # First optional argument specifies non-master branch + if [[ $# -eq 1 ]]; then + git clone https://github.com/broadinstitute/viral-ngs.git --branch $1 ""$VIRAL_NGS_PATH"" + else + git clone https://github.com/broadinstitute/viral-ngs.git ""$VIRAL_NGS_PATH"" + fi + else + echo ""$VIRAL_NGS_PATH/ symlink already exists. Skipping link."" + fi +} + +function install_viral_ngs_conda_dependencies() { + if [[ $(absolute_path ""$VIRAL_CONDA_ENV_PATH"") == $(absolute_path ""$MINICONDA_PATH"") ]]; then + conda install -q $CONDA_CHANNEL_STRING -y --file ""$VIRAL_NGS_PATH/requirements-conda.txt"" --file ""$VIRAL_NGS_PATH/requirements-py3.txt"" --file ""$VIRAL_NGS_PATH/requirements-conda-tests.txt"" || exit 1 + else + conda install -q $CONDA_CHANNEL_STRING -y -p $VIRAL_CONDA_ENV_PATH --file ""$VIRAL_NGS_PATH/requirements-conda.txt"" --file ""$VIRAL_NGS_PATH/requirements-py3.txt"" --file ""$VIRAL_NGS_PATH/requirements-conda-tests.txt"" || exit 1 + fi +} + + +function install_tools(){ + # install tools + + # get the version of gatk expected based on the installed conda package + EXPECTED_GATK_VERSION=$(conda list | grep gatk | awk -F"" "" '{print $2}') + if [ -z ""$GATK_JAR_PATH"" ]; then + # if the env var is not set, try to get the jar location using the default Broad path + if [[ ""$(hash dnsdomainname &> /dev/null && dnsdomainname || echo '')"" == *""broadinstitute.org"" || ""$HOSTNAME"" == *"".broadinstitute.org"" || ""$DOMAINNAME"" == ""broadinstitute.org"" ]]; then + echo ""This script is being run on a Broad Institute system."" + echo ""Trying to find GATK..."" + export GATK_JAR_PATH=$(ls /idi/sabeti-scratch/shared-resources/software/gatk &> /dev/null && sleep 5 && find /idi/sabeti-scratch/shared-resources/software/gatk/GenomeAnalysisTK-$EXPECTED_GATK_VERSION-* -maxdepth 0 -type d)/GenomeAnalysisTK.jar + fi + fi + + # if the gatk jar file exists, call gatk3-register + if [ -e ""$GATK_JAR_PATH"" ]; then + echo ""GATK found: $GATK_JAR_PATH"" + gatk3-register $GATK_JAR_PATH + else + echo ""GATK jar could not be found on this system for GATK version $EXPECTED_GATK_VERSION"" + echo ""Please activate the viral-ngs conda environment and 'gatk3-register /path/to/GenomeAnalysisTK.jar'"" + exit 0 + fi + + echo """" + if [ -n ""$NOVOALIGN_PATH"" ]; then + novoalign-license-register ""$NOVOALIGN_PATH/novoalign.lic"" + elif [ -n ""$NOVOALIGN_LICENSE_PATH"" ]; then + novoalign-license-register ""$NOVOALIGN_LICENSE_PATH"" + else + echo ""No Novoalign license found via NOVOALIGN_PATH or NOVOALIGN_LICENSE_PATH"" + echo ""Please activate the viral-ngs conda environment and run 'novoalign-license-register /path/to/novoalign.lic'"" + fi +} + +function create_project(){ + echo ""Checking and populating project directory..."" + # first arg is project folder name + starting_dir=$(pwd) + + mkdir -p $PROJECTS_PATH + PROJECT_PATH=""$PROJECTS_PATH/$1"" + mkdir -p ""$PROJECT_PATH"" + pushd ""$PROJECT_PATH"" > /dev/null + mkdir -p data log reports tmp + pushd data > /dev/null + mkdir -p 00_raw 01_cleaned 01_per_sample 02_align_to_self 02_assembly 03_align_to_ref 03_interhost 04_intrahost + popd > /dev/null + touch samples-metagenomics.txt + touch samples-depletion.txt + touch samples-assembly.txt + touch samples-runs.txt + touch samples-assembly-failures.txt + pushd > /dev/null + + if [ ! -e ""$PROJECT_PATH/config.yaml"" ]; then + cp ""$VIRAL_NGS_PATH/pipes/config.yaml"" ""$PROJECT_PATH"" + fi + if [ ! -L ""$PROJECT_PATH/Snakefile"" ]; then + ln -s ""$VIRAL_NGS_PATH/pipes/Snakefile"" ""$PROJECT_PATH/Snakefile"" + fi + + if [ ! -L ""$PROJECT_PATH/bin"" ]; then + ln -s ""$VIRAL_NGS_PATH"" ""$PROJECT_PATH/bin"" + fi + + if [ ! -L ""$PROJECT_PATH/conda-env"" ]; then + ln -s ""$INSTALL_PATH/$CONDA_ENV_BASENAME"" ""$PROJECT_PATH/conda-env"" + fi + + if [ ! -L ""$PROJECT_PATH/mc3"" ]; then + ln -s ""$MINICONDA_PATH"" ""$PROJECT_PATH/mc3"" + fi + + if [ -z ""$OMIT_UGER_PROJECT_FILES"" ]; then + # environment var JOB_ID is defined on UGER + # if we are not running this on UGER, assume local execution + if [ -z ""$JOB_ID"" ]; then + if [ ! -L ""$PROJECT_PATH/run-pipe_local.sh"" ]; then + ln -s ""$VIRAL_NGS_PATH/pipes/run-pipe.sh"" ""$PROJECT_PATH/run-pipe_local.sh"" + fi + if [ ! -L ""$PROJECT_PATH/run-pipe.sh"" ]; then + ln -s ""$PROJECT_PATH/run-pipe_local.sh"" ""$PROJECT_PATH/run-pipe.sh"" + fi + # if we ARE running this on UGER, link in the UGER run-pipe script + else + if [ ! -L ""$PROJECT_PATH/run-pipe_UGER.sh"" ]; then + ln -s ""$VIRAL_NGS_PATH/pipes/Broad_UGER/run-pipe.sh"" ""$PROJECT_PATH/run-pipe_UGER.sh"" + fi + if [ ! -L ""$PROJECT_PATH/run-pipe.sh"" ]; then + ln -s ""run-pipe_UGER.sh"" ""$PROJECT_PATH/run-pipe.sh"" + fi + fi + fi + + cd ""$starting_dir"" +} + +function activate_env(){ + if [ -d ""$INSTALL_PATH"" ]; then + echo ""viral-ngs parent directory found"" >&2 + else + echo ""viral-ngs parent directory not found: $INSTALL_PATH not found."" + echo ""Have you run the setup?"" + echo ""Usage: $0 setup"" + cd ""$STARTING_DIR"" + return 1 + fi + + # Add viral-ngs scripts to PATH for git-based installs + if [[ -d ""$VIRAL_NGS_PATH/.git"" ]]; then + PATH=""$VIRAL_NGS_PATH:$PATH"" + PATH=$(puniq $PATH) + fi + + if [ -d ""$VIRAL_CONDA_ENV_PATH"" ]; then + if [ -z ""$CONDA_DEFAULT_ENV"" ]; then + echo ""Activating viral-ngs environment..."" >&2 + prepend_miniconda + + source activate $(absolute_path ""$VIRAL_CONDA_ENV_PATH"") + + # unset JAVA_HOME if set, so we can use the conda-supplied version + if [ -n ""$JAVA_HOME"" ]; then + unset JAVA_HOME + fi + + # override $PS1 to have a shorter prompt + export PS1=""(\[\033[1m\]viral-ngs\[\033[0m\])\s:\h:\w \! \$ "" + else + if [[ ""$CONDA_DEFAULT_ENV"" != ""$VIRAL_CONDA_ENV_PATH"" ]]; then + echo ""It looks like a conda environment is already active,"" + echo ""however it is not the viral-ngs environment."" + echo ""To use viral-ngs with your project, deactivate the"" + echo ""current environment and then source this file."" + echo ""Example: source deactivate && source $(basename $SCRIPT) load"" + else + echo ""The viral-ngs environment is already active."" + fi + return 0 + fi + else + echo ""$VIRAL_CONDA_ENV_PATH/ does not exist. Exiting."" + cd ""$STARTING_DIR"" + return 1 + fi +} + +function print_usage(){ + echo ""Usage: $(basename $SCRIPT) {load,create-project,setup|setup-py2|setup-git|setup-git-local,upgrade|upgrade-deps,update-easy-deploy}"" +} + +function symlink_viral_ngs(){ + # the conda-installed viral-ngs folder resides within the + # opt/ directory of the conda environment, but it contains + # a version number, so we'll ls and grep for the name + # and assume it's the first one to show up + if [ ! -d ""$VIRAL_NGS_PATH"" ]; then + echo ""Linking to current viral-ngs install..."" + EXPECTED_VIRAL_NGS_VERSION=$(conda list $VIRAL_NGS_PACKAGE | grep $VIRAL_NGS_PACKAGE | grep -v packages | awk -F"" "" '{print $2}') + VIRAL_NGS_CONDA_PATH=""$VIRAL_CONDA_ENV_PATH/opt/""$(ls -1 ""$VIRAL_CONDA_ENV_PATH/opt/"" | grep ""$EXPECTED_VIRAL_NGS_VERSION"" | grep -m 1 ""viral-ngs"") + + if [ -d ""$VIRAL_NGS_CONDA_PATH"" ]; then + ln -s ""$VIRAL_NGS_CONDA_PATH"" ""$VIRAL_NGS_PATH"" + else + echo ""Could not find viral-ngs install in conda env:"" + echo ""$VIRAL_NGS_CONDA_PATH"" + exit 1 + fi + else + echo ""$VIRAL_NGS_DIR/ symlink already exists. Skipping link."" + fi +} + +function check_viral_ngs_version(){ + if [ -z ""$SKIP_VERSION_CHECK"" ]; then + if [ -d ""$VIRAL_NGS_PATH/.git"" ]; then + pushd ""$VIRAL_NGS_PATH"" > /dev/null + git remote update + git status -uno + popd > /dev/null + else + # this must be run within an active conda environment + # so, after a call to ""activate_env"" + echo ""Checking viral-ngs version..."" + CURRENT_VER=""$(conda list --no-pip viral-ngs | grep viral-ngs | grep -v packages | awk -F' ' '{print $2}')"" + # perhaps a better way... + AVAILABLE_VER=""$(conda search -f $CONDA_CHANNEL_STRING viral-ngs --json | grep version | tail -n 1 | awk -F' ' '{print $2}' | perl -lape 's/[\"",]+//g')"" + if [ ""$CURRENT_VER"" != ""$AVAILABLE_VER"" ]; then + echo """" + echo ""============================================================================================================"" + echo ""Your copy of viral-ngs appears to be outdated ($CURRENT_VER). A newer version is available ($AVAILABLE_VER)."" + echo ""Check the release notes and consider upgrading:"" + echo ""https://github.com/broadinstitute/viral-ngs/releases"" + echo ""To upgrade: $(basename $SCRIPT) upgrade"" + echo ""============================================================================================================"" + echo """" + else + echo ""viral-ngs is up to date ($CURRENT_VER)"" + fi + fi + fi +} + +function updateSelf() { + # this function overwrites this script with one downloaded from + # the first argument passed to the funciton, $1 + + echo ""Performing self-update..."" + + cp ""$SCRIPT"" ""$SCRIPT.bak"" + + # Download new version + echo -n ""Downloading latest version..."" + if ! wget --quiet --output-document=""$SCRIPT.tmp"" ""$1"" ; then + echo ""Error while trying to wget new version!"" + echo ""File requested: $SELF_UPDATE_URL"" + exit 1 + fi + echo ""done."" + + # Copy permissions from old version + if [[ ""$OSTYPE"" == ""darwin""* ]]; then + OCTAL_MODE=$(stat -f '%A' $SCRIPT) + else + OCTAL_MODE=$(stat -c '%a' $SCRIPT) + fi + if ! chmod $OCTAL_MODE ""$SCRIPT.tmp"" ; then + echo ""Failed: Error while trying to set mode on $SCRIPT.tmp."" + exit 1 + fi + + # Spawn update script + cat > update-easy-deploy-script.sh << EOF +#!/bin/bash +# Overwrite old file with new +if mv ""$SCRIPT.tmp"" ""$SCRIPT""; then + echo ""done."" + echo ""Self-update complete."" + rm \$0 +else + echo ""Failed!"" +fi +EOF + + echo -n ""Overwriting old script with new one..."" + exec /bin/bash update-easy-deploy-script.sh +} + +if [ $# -eq 0 ]; then + print_usage + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi +else + case ""$1"" in + ""setup""|""setup-py2""|""setup-git""|""setup-git-local"") + if ! [ $# -eq 1 -o $# -eq 2 -o $# -eq 3 ]; then + + echo ""Usage: $(basename $SCRIPT) setup"" + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi + fi + + if [[ $sourced -eq 1 ]]; then + echo ""ABORTING. $(basename $SCRIPT) must not be sourced during setup"" + echo ""Usage: $(basename $SCRIPT) setup"" + return 1 + elif [ ! -z ""$CONDA_DEFAULT_ENV"" ]; then + echo ""The viral-ngs setup cannot be run while a conda environment is active."" + echo ""The current environment must first be disabled via 'source deactivate'"" + exit 1 + fi + + mkdir -p ""$INSTALL_PATH"" + install_miniconda + + if [ ! -d ""$VIRAL_CONDA_ENV_PATH"" ]; then + # provide an option to use Python 2 in the conda environment + if [ ""$1"" == ""setup-py2"" ]; then + conda create -q $CONDA_CHANNEL_STRING -y -p ""$VIRAL_CONDA_ENV_PATH"" python=2 || exit 1 + else + conda create -q $CONDA_CHANNEL_STRING -y -p ""$VIRAL_CONDA_ENV_PATH"" python=3.6 || exit 1 + fi + + if [[ ""$1"" == ""setup-git"" || ""$1"" == ""setup-git-local"" ]]; then + install_viral_ngs_git $2 + install_viral_ngs_conda_dependencies + else + install_viral_ngs_conda $@ + fi + else + echo ""$VIRAL_CONDA_ENV_PATH/ already exists. Skipping conda env setup."" + if [[ ""$1"" == ""setup-git-local"" ]]; then + install_viral_ngs_conda_dependencies + fi + fi + + conda clean -y --all + + activate_env + + if [[ ""$1"" != ""setup-git"" ]]; then + symlink_viral_ngs + fi + + #if [[ ""$1"" != ""setup-git-local"" ]]; then + install_tools + #fi + + echo ""Setup complete. Do you want to start a project? Run:"" + echo ""$0 create-project [/containing/path]"" + echo """" + ;; + ""load"") + if [ $# -eq 1 ]; then + if [[ $sourced -eq 0 ]]; then + echo ""ABORTING. $(basename $SCRIPT) must be sourced."" + echo ""Usage: source $(basename $SCRIPT) load"" + else + activate_env + + check_viral_ngs_version + + return 0 + fi + else + echo ""Usage: source $(basename $SCRIPT) load"" + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi + fi + ;; + ""upgrade-deps"") + if [ ! -d ""$VIRAL_NGS_PATH/.git"" ]; then + echo ""upgrade-deps requires a viral-ngs installation from git"" + echo ""Use 'upgrade' for a versioned install"" + exit 1 + fi + activate_env + install_viral_ngs_conda_dependencies + ;; + ""upgrade"") + if [ $# -eq 1 ]; then + if [[ $sourced -eq 1 ]]; then + echo ""ABORTING. $(basename $SCRIPT) must not be sourced during upgrade"" + echo ""Usage: $(basename $SCRIPT) upgrade"" + return 1 + else + echo ""Upgrading viral-ngs..."" + + if [ -z ""$CONDA_DEFAULT_ENV"" ]; then + activate_env + else + if [ ""$CONDA_DEFAULT_ENV"" != ""$VIRAL_CONDA_ENV_PATH"" ]; then + echo ""A viral-ngs upgrade cannot be run while a conda environment is active."" + echo ""The current environment must first be disabled via 'source deactivate'"" + exit 1 + fi + fi + + if [ ! -z ""$(conda list $VIRAL_NGS_PACKAGE | grep $VIRAL_NGS_PACKAGE | grep -v packages | awk -F"" "" '{print $2}')"" ]; then + if [ -L ""$VIRAL_NGS_PATH"" ]; then + rm $VIRAL_NGS_PATH # remove symlink + fi + conda update -y $CONDA_CHANNEL_STRING viral-ngs + + # recreate symlink to folder for latest viral-ngs in conda-env/opt/ + symlink_viral_ngs + + echo """" + echo ""=================================================================================="" + echo ""Note that if viral-ngs-derived files are present in your project folders,"" + echo ""they may need to be updated. Check the release notes and commit log for more info:"" + echo ""https://github.com/broadinstitute/viral-ngs/releases"" + echo ""=================================================================================="" + echo """" + else + echo ""The viral-ngs package does not appear to be installed. Have you run setup?"" + echo ""Usage: $(basename $SCRIPT) setup"" + exit 1 + fi + #source deactivate + exit 0 + fi + else + echo ""Usage: source $(basename $SCRIPT) upgrade"" + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi + fi + ;; + ""update-easy-deploy"") + if [ $# -eq 1 ]; then + if [[ $sourced -eq 1 ]]; then + echo ""ABORTING. $(basename $SCRIPT) must not be sourced during upgrade"" + echo ""Usage: $(basename $SCRIPT) update-easy-deploy"" + return 1 + else + if [ -z ""$CONDA_DEFAULT_ENV"" ]; then + if [ ! -z ""$SKIP_SELF_UPDATE_CONFIRM"" ] || $(ask ""Are you sure you want to update the easy deploy script to the latest version?"" Y); then + updateSelf ""$SELF_UPDATE_URL"" + fi + else + echo ""It looks like a conda environment is active."" + echo ""To update this script, first deactivate the environment"" + echo ""then call update-easy-deploy. Example:"" + echo "" source deactivate && $(basename $SCRIPT) update-easy-deploy"" + exit 1 + fi + + fi + else + echo ""Usage: source $(basename $SCRIPT) update-easy-deploy"" + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi + fi + ;; + ""create-project"") + if [ $# -ne 2 -a $# -ne 3 ]; then + echo ""Usage: $(basename $SCRIPT) create-project [/containing/path]"" + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi + else + # check for viral-ngs install; abort project creation if missing + if [ ! -d ""$VIRAL_CONDA_ENV_PATH"" ]; then + echo ""It looks like viral-ngs has not yet been installed."" + echo ""Directory does not exist: $VIRAL_CONDA_ENV_PATH"" + echo ""First run $(basename $SCRIPT) setup"" + if [[ $sourced -eq 0 ]]; then + exit 1 + else + return 1 + fi + fi + ORIGINAL_PROJECTS_PATH=$PROJECTS_PATH + PROJECT_NAME=""$2"" + if [ $# -eq 3 ]; then + PROJECTS_PATH=""$3"" + echo ""Creating project in path: $PROJECTS_PATH/$PROJECT_NAME"" + else + echo ""Creating project: $PROJECT_NAME"" + fi + + create_project $PROJECT_NAME && echo ""Project created: $PROJECTS_PATH/$PROJECT_NAME"" && echo ""OK"" + + echo """" + + if [[ ""$CONDA_DEFAULT_ENV"" != ""$VIRAL_CONDA_ENV_PATH"" ]]; then + echo ""It looks like the vial-ngs environment is not active."" + echo ""To use viral-ngs with your project, source this file."" + echo ""Example: source $(basename $SCRIPT) load"" + else + # if the viral-ngs environment is active and we have sourced this file + if [[ $sourced -eq 1 ]]; then + # change to the project directory + if [ -d ""$PROJECTS_PATH/$PROJECT_NAME"" ]; then + cd ""$PROJECTS_PATH/$PROJECT_NAME"" + fi + return 0 + fi + fi + PROJECTS_PATH=$ORIGINAL_PROJECTS_PATH + fi + ;; + *) + print_usage + ;; + esac +fi +","Shell" +"Viral","broadinstitute/viral-ngs","docker/gosu-entrypoint.sh",".sh","1171","31","#!/bin/bash + +# Gosu setup adapted from https://denibertovic.com/posts/handling-permissions-with-docker-volumes/ +USER_ID=${RUN_USER_ID:-1000} +GROUP_ID=${RUN_GROUP_ID:-$USER_ID} +USER_NAME=user +GROUP_NAME=viral-ngs + +echo ""Starting with UID : $USER_ID, GID : $GROUP_ID"" >&2 +groupadd --gid $GROUP_ID $GROUP_NAME +useradd --shell /bin/bash --uid $USER_ID --gid $GROUP_ID -o -c """" -m $USER_NAME + +# Chown to deal with potential problems of creating projects under the path define in the deploy script: +# PROJECTS_PATH=""$SCRIPTPATH/$CONTAINING_DIR/$PROJECTS_DIR"" +export HOME=/home/$USER_NAME +ln -s /user-data $HOME/data +# This is very slow and not really needed unless /opt/viral-ngs is mounted as a volume on the host +#chown -R $USER_NAME:$GROUP_NAME /opt/viral-ngs + +# '-R' is not used here because the user running docker may not have chown -R permission to the whole +# data directory +chown $USER_NAME:$GROUP_NAME /user-data + +cd $HOME/data + +# Chroot does jump to a custom startup directory, so we don't use it. +# More importantly, it allows to escape to root +# chroot --userspec=$USER_NAME / ""/bin/bash"" +# Therefore gosu is a good choice +exec /usr/local/bin/gosu $USER_NAME ""$@"" +","Shell" +"Viral","broadinstitute/viral-ngs","docker/install-viral-ngs.sh",".sh","1467","48","#!/bin/bash +# +# This script requires INSTALL_PATH (typically /opt/viral-ngs), +# VIRAL_NGS_PATH (typically /opt/viral-ngs/source), and +# CONDA_DEFAULT_ENV (typically /opt/miniconda) to be set. +# +# A miniconda install must exist at $CONDA_DEFAULT_ENV +# and $CONDA_DEFAULT_ENV/bin must be in the PATH +# +# Otherwise, this only requires the existence of the following files: +# requirements-minimal.txt +# requirements-conda.txt +# requirements-conda-tests.txt +# requirements-py3.txt + +set -e -o pipefail + +echo ""PATH: ${PATH}"" +echo ""INSTALL_PATH: ${INSTALL_PATH}"" +echo ""CONDA_PREFIX: ${CONDA_PREFIX}"" +echo ""VIRAL_NGS_PATH: ${VIRAL_NGS_PATH}"" +echo ""MINICONDA_PATH: ${MINICONDA_PATH}"" +echo ""CONDA_DEFAULT_ENV: ${CONDA_DEFAULT_ENV}"" + +CONDA_CHANNEL_STRING=""--override-channels -c broad-viral -c conda-forge -c bioconda -c defaults"" + +# setup/install viral-ngs directory tree and conda dependencies +sync + +# manually install it ourselves instead of using easy-deploy +if [[ ""$1"" == ""minimal"" ]]; then + # a more minimal set of tools (smaller docker image?) + conda install -y \ + -q $CONDA_CHANNEL_STRING \ + --file ""$VIRAL_NGS_PATH/requirements-minimal.txt"" \ + -p ""${CONDA_PREFIX}"" +else + conda install -y \ + -q $CONDA_CHANNEL_STRING \ + --file ""$VIRAL_NGS_PATH/requirements-py3.txt"" \ + --file ""$VIRAL_NGS_PATH/requirements-conda.txt"" \ + --file ""$VIRAL_NGS_PATH/requirements-conda-tests.txt"" \ + -p ""${CONDA_PREFIX}"" +fi + +# clean up +conda clean -y --all +","Shell" +"Viral","broadinstitute/viral-ngs","docker/calc_mem.py",".py","1703","46","#!/usr/bin/env python + +""""""Calculate the memory allocated to the process, taking account of cgroups. +Print result to stdout. +"""""" + +import argparse +import sys +import os +import os.path + +parser = argparse.ArgumentParser('Calculated memory allocated to the process') +parser.add_argument('mem_unit', choices=('mb', 'gb'), help='memory units') +parser.add_argument('mem_fraction', type=int, help='what fraction of total memory to report') +args = parser.parse_args() + +if not (1 <= args.mem_fraction <= 100): + raise RuntimeError(""mem_fraction should be in the range [1,100]"") + +unit2factor = {'k': 1024, 'm': 1024*1024, 'g': 1024*1024*1024} + +def mem_from_proc_meminfo(): + """"""Return the total memory, in bytes, as given by /proc/meminfo"""""" + with open('/proc/meminfo') as f: + for line in f: + if line.startswith('MemTotal:'): + parts = line.strip().split() + val, unit = parts[1:3] + unit_factor = unit2factor[unit[0].lower()] + return int(val) * unit_factor + raise RuntimeError('Could not get MemTotal from /proc/meminfo') + +def mem_from_cgroups(): + """"""Return the total memory, in bytes, as given by cgroups (or sys.maxsize if not given)"""""" + cgroups_memlimit_fname = '/sys/fs/cgroup/memory/memory.limit_in_bytes' + if os.path.isfile(cgroups_memlimit_fname): + with open(cgroups_memlimit_fname) as f: + val = f.read().strip() + return int(val) * unit2factor.get(val[-1], 1) + + return sys.maxsize + +mem_in_bytes = min(mem_from_proc_meminfo(), mem_from_cgroups()) +mem_in_units = float(mem_in_bytes) / float(unit2factor[args.mem_unit[0]]) +print(int(mem_in_units * (float(args.mem_fraction) / 100.0))) +","Python" +"Viral","broadinstitute/viral-ngs","docker/rundocker.sh",".sh","718","18","#!/usr/bin/env bash + +# A wrapper script to run viral-ngs docker images +# The following paths have to be modified according to end-user environment +NOVOALIGN_PATH=""/opt/novocraft"" # Directory where novoalign.lic license file can befound +GATK_PATH=""/opt/GenomeAnalysisTK-3.8"" # Directory where the correct GATK jar file can be found +IMAGE_HASH_OR_TAG=""quay.io/broadinstitute/viral-ngs:latest"" # This can be found by running this command 'docker images' +DATA_DIR=""$1""; shift +GID=$(id -g $USER) + +docker run -it \ + --volume $NOVOALIGN_PATH:/novoalign \ + --volume $GATK_PATH:/gatk \ + --volume $DATA_DIR:/user-data \ + -e RUN_USER_ID=$UID -e RUN_GROUP_ID=$GID \ + $IMAGE_HASH_OR_TAG \ + ""$@"" +","Shell" +"Viral","broadinstitute/viral-ngs","docker/run_tile_count.sh",".sh","1271","38","#!/bin/bash +set -e -o pipefail + +if [ $# -eq 0 ]; then + echo ""Usage: $(basename $0) path/to/RunInfo.xml"" + exit 0 +fi + +if [ ! -e ""$1"" ]; then + echo ""The specified file does not exist: $1"" + exit 1 +fi + +# Parse the lane count & run ID from RunInfo.xml file +lane_count=$(xmllint --xpath ""string(//Run/FlowcellLayout/@LaneCount)"" $1) +if [ -z ""$lane_count"" ]; then + echo ""Could not parse LaneCount from RunInfo.xml. Please check RunInfo.xml is properly formatted"" +fi + +surface_count=$(xmllint --xpath ""string(//Run/FlowcellLayout/@SurfaceCount)"" $1) +if [ -z ""$surface_count"" ]; then + echo ""Could not parse SurfaceCount from RunInfo.xml. Please check RunInfo.xml is properly formatted"" +fi + +swath_count=$(xmllint --xpath ""string(//Run/FlowcellLayout/@SwathCount)"" $1) +if [ -z ""$swath_count"" ]; then + echo ""Could not parse SwathCount from RunInfo.xml. Please check RunInfo.xml is properly formatted"" +fi + +tile_count=$(xmllint --xpath ""string(//Run/FlowcellLayout/@TileCount)"" $1) +if [ -z ""$tile_count"" ]; then + echo ""Could not parse TileCount from RunInfo.xml. Please check RunInfo.xml is properly formatted"" +fi + +# total data size more roughly tracks total tile count +total_tile_count=$((lane_count*surface_count*swath_count*tile_count)) + +echo $total_tile_count","Shell" +"Viral","broadinstitute/viral-ngs","util/misc.py",".py","24578","637","'''A few miscellaneous tools. ''' +from __future__ import print_function, division # Division of integers with / should never round! +import collections +import contextlib +import itertools, functools, operator +import logging +import os, os.path +import re +import subprocess +import threading +import multiprocessing +import sys +import copy +import yaml, json +import time + +import util.file + +log = logging.getLogger(__name__) + +__author__ = ""dpark@broadinstitute.org"" + +MAX_INT32 = (2 ** 31)-1 + +@contextlib.contextmanager +def timer(prefix): + start = time.time() + yield + finish = time.time() + elapsed = '{:.2f}'.format(finish - start) + print(prefix + ' - ' + elapsed, file=sys.stderr) + + +def memoize(obj): + cache = obj.cache = {} + + @functools.wraps(obj) + def memoizer(*args, **kwargs): + key = """".join([str(args),str(kwargs)]) + if key not in cache: + cache[key] = obj(*args, **kwargs) + return cache[key] + return memoizer + +def unique(items): + ''' Return unique items in the same order as seen in the input. ''' + seen = set() + for i in items: + if i not in seen: + seen.add(i) + yield i + + +def histogram(items): + ''' I count the number of times I see stuff and return a dict of counts. ''' + out = {} + for i in items: + out.setdefault(i, 0) + out[i] += 1 + return out + + +def freqs(items, zero_checks=None): + ''' Given a list of comparable, non-unique items, produce an iterator of + (item, count, freq) tuples. + item is a unique instance of one of the items seen on input + count is a positive integer describing the number of times this item was observed + freq is count / sum(count) for all outputs. + If zero_checks is specified, then the output iterator will emit tuples for the + items in zero_checks even if they do not appear in the input. If they are not in + the input, they will be emitted with a zero count and freq. + See histogram(items) + ''' + zero_checks = zero_checks or set() + + tot = 0 + out = {} + for i in items: + out.setdefault(i, 0) + out[i] += 1 + tot += 1 + for k, v in out.items(): + yield (k, v, float(v) / tot) + for i in zero_checks: + if i not in out: + yield (i, 0, 0.0) + + +def intervals(i, n, l): + ''' Divide something of length l into n equally sized parts and return the + start-stop values of the i'th part. Values are 1-based. Each part + will be adjacent and non-overlapping with the next part. i must be a + number from 1 to n. + ''' + assert 1 <= i <= n and l >= n + part_size = l // n + start = 1 + part_size * (i - 1) + stop = part_size * i + if i == n: + stop = l + return (start, stop) + +# from http://stackoverflow.com/a/312467 + + +def pairwise(iterable): + """""" from itertools recipes + s -> (s0,s1), (s1,s2), (s2, s3), ..."""""" + a, b = itertools.tee(iterable) + next(b, None) + return zip(a, b) + + +def batch_iterator(iterator, batch_size): + """"""Returns lists of length batch_size. + + This can be used on any iterator, for example to batch up + SeqRecord objects from Bio.SeqIO.parse(...), or to batch + Alignment objects from Bio.AlignIO.parse(...), or simply + lines from a file handle. + + This is a generator function, and it returns lists of the + entries from the supplied iterator. Each list will have + batch_size entries, although the final list may be shorter. + """""" + it = iter(iterator) + item = list(itertools.islice(it, batch_size)) + while item: + yield item + item = list(itertools.islice(it, batch_size)) + + +def list_contains(sublist, list_): + """"""Tests whether sublist is contained in full list_."""""" + + for i in range(len(list_)-len(sublist)+1): + if sublist == list_[i:i+len(sublist)]: + return True + return False + + +try: + from subprocess import run +except ImportError: + CompletedProcess = collections.namedtuple( + 'CompletedProcess', ['args', 'returncode', 'stdout', 'stderr']) + + def run(args, stdin=None, stdout=None, stderr=None, shell=False, + env=None, cwd=None, timeout=None, check=False, executable=None): + '''A poor man's substitute of python 3.5's subprocess.run(). + + Should only be used for capturing stdout. If stdout is unneeded, a + simple subprocess.call should suffice. + ''' + assert stdout is not None, ( + 'Why are you using this util function if not capturing stdout?') + + stdout_pipe = stdout == subprocess.PIPE + stderr_pipe = stderr == subprocess.PIPE + # A little optimization when we don't need temporary files. + if stdout_pipe and ( + stderr == subprocess.STDOUT or stderr is None): + try: + output = subprocess.check_output( + args, stdin=stdin, stderr=stderr, shell=shell, + env=env, cwd=cwd, executable=executable) + return CompletedProcess(args, 0, output, b'') + # Py3.4 doesn't have stderr attribute + except subprocess.CalledProcessError as e: + if check: + raise + returncode = e.returncode + stderr_text = getattr(e, 'stderr', b'') + return CompletedProcess(args, e.returncode, e.output, stderr_text) + + # Otherwise use temporary files as buffers, since subprocess.call + # cannot use PIPE. + if stdout_pipe: + stdout_fn = util.file.mkstempfname('.stdout') + stdout = open(stdout_fn, 'wb') + if stderr_pipe: + stderr_fn = util.file.mkstempfname('.stderr') + stderr = open(stderr_fn, 'wb') + try: + returncode = subprocess.call( + args, stdin=stdin, stdout=stdout, + stderr=stderr, shell=shell, env=env, cwd=cwd, + executable=executable) + if stdout_pipe: + stdout.close() + with open(stdout_fn, 'rb') as f: + output = f.read() + else: + output = '' + if stderr_pipe: + stderr.close() + with open(stderr_fn, 'rb') as f: + error = f.read() + else: + error = '' + if check and returncode != 0: + print(output.decode(""utf-8"")) + print(error.decode(""utf-8"")) + raise subprocess.CalledProcessError( + returncode, args, output, error) #pylint: disable-msg=E1121 + + return CompletedProcess(args, returncode, output, error) + finally: + if stdout_pipe: + stdout.close() + os.remove(stdout_fn) + if stderr_pipe: + stderr.close() + os.remove(stderr_fn) + + +def run_and_print(args, stdout=None, stderr=subprocess.STDOUT, + stdin=None, shell=False, env=None, cwd=None, + timeout=None, silent=False, buffered=False, check=False, + loglevel=None): + '''Capture stdout+stderr and print. + + This is useful for nose, which has difficulty capturing stdout of + subprocess invocations. + ''' + if not buffered: + if check and not silent: + try: + result = run( + args, + stdin=stdin, + stdout=subprocess.PIPE, + stderr=stderr, + env=env, + cwd=cwd, + timeout=timeout, + check=check + ) + print(result.stdout.decode('utf-8')) + try: + print(result.stderr.decode('utf-8')) + except AttributeError: + pass + except subprocess.CalledProcessError as e: + if loglevel: + try: + log.log(loglevel, result.stdout.decode('utf-8')) + except NameError: + # in some situations, result does not get assigned anything + pass + except AttributeError: + log.log(loglevel, result.output.decode('utf-8')) + else: + print(e.output.decode('utf-8')) + try: + print(e.stderr.decode('utf-8')) + except AttributeError: + pass + sys.stdout.flush() + raise(e) + else: + result = run(args, stdin=stdin, stdout=subprocess.PIPE, + stderr=stderr, env=env, cwd=cwd, + timeout=timeout, check=check) + if not silent and not loglevel: + print(result.stdout.decode('utf-8')) + sys.stdout.flush() + elif loglevel: + log.log(loglevel, result.stdout.decode('utf-8')) + + else: + CompletedProcess = collections.namedtuple( + 'CompletedProcess', ['args', 'returncode', 'stdout', 'stderr']) + + process = subprocess.Popen(args, stdin=stdin, stdout=subprocess.PIPE, + stderr=stderr, env=env, + cwd=cwd) + output = [] + while process.poll() is None: + for c in iter(process.stdout.read, b""""): + output.append(c) + if not silent: + print(c.decode('utf-8'), end="""") # print for py3 / p2 from __future__ + sys.stdout.flush() # flush buffer to stdout + + # in case there are still chars in the pipe buffer + for c in iter(lambda: process.stdout.read(1), b""""): + if not silent: + print(c, end="""") + sys.stdout.flush() # flush buffer to stdout + + if check and process.returncode != 0: + raise subprocess.CalledProcessError(process.returncode, args, + b''.join(output)) + result = CompletedProcess( + args, process.returncode, b''.join(output), b'') + + return result + + +def run_and_save(args, stdout=None, stdin=None, + outf=None, stderr=None, preexec_fn=None, + close_fds=False, shell=False, cwd=None, env=None, check=True): + assert outf is not None + + sp = subprocess.Popen(args, + stdin=stdin, + stdout=outf, + stderr=subprocess.PIPE, + preexec_fn=preexec_fn, + close_fds=close_fds, + shell=shell, + cwd=cwd, + env=env) + out, err = sp.communicate() + + # redirect stderror to stdout so it can be captured by nose + if err: + sys.stdout.write(err.decode(""UTF-8"")) + + if sp.returncode != 0 and check: + raise subprocess.CalledProcessError(sp.returncode, str(args[0])) + + return sp + + +class FeatureSorter(object): + ''' This class helps sort genomic features. It's not terribly optimized + for speed or anything. Slightly inspired by calhoun's MultiSequenceRangeMap. + ''' + def __init__(self, collection=None): + self.seqids = [] + self.seq_to_features = {} + self.seq_to_breakpoints = {} + self.dirty = False + if collection is not None: + for args in collection: + self.add(*args) + + def add(self, c, start, stop, strand='+', other=None): + ''' Add a ""feature"", which is a chrom,start,stop,strand tuple (with + optional other info attached) + ''' + if c not in self.seq_to_features: + self.seqids.append(c) + self.seq_to_features[c] = [] + self.seq_to_breakpoints[c] = set() + #self.seq_to_breakpoints[c].add(1) # do we want the empty interval in front? + self.seq_to_features[c].append((int(start), int(stop), strand, other)) + self.seq_to_breakpoints[c].add(start) + self.seq_to_breakpoints[c].add(stop+1) + self.dirty = True + + def _cleanup(self): + if self.dirty: + self.dirty = False + for c in self.seqids: + self.seq_to_features[c].sort() + + def get_seqids(self): + return tuple(self.seqids) + + def get_features(self, c=None, left=0, right=float('inf')): + ''' Get all features on all chromosomes in sorted order. Chromosomes + are emitted in order of first appearance (via add). Features on + each chromosome are emitted in start, then stop order. If + boundaries are specified, we restrict to features that contain + the specified interval. + ''' + self._cleanup() + if c is not None: + seqlist = [c] + else: + seqlist = self.seqids + for c in seqlist: + for start, stop, strand, other in self.seq_to_features[c]: + if stop>=left and start<=right: + yield (c, start, stop, strand, other) + + def get_intervals(self, c=None): + ''' Get all intervals on the reference where the overlapping feature + set remains the same. Output will be sorted, adjacent intervals + and will describe how many and which features overlap it. + ''' + self._cleanup() + if c is not None: + seqlist = [c] + else: + seqlist = self.seqids + for c in seqlist: + for left, right in pairwise(sorted(self.seq_to_breakpoints[c])): + right = right - 1 + features = list(self.get_features(c, left, right)) + yield (c, left, right, len(features), features) + + +def available_cpu_count(): + """""" + Return the number of available virtual or physical CPUs on this system. + The number of available CPUs can be smaller than the total number of CPUs + when the cpuset(7) mechanism is in use, as is the case on some cluster + systems. + + Adapted from http://stackoverflow.com/a/1006301/715090 + """""" + + cgroup_cpus = MAX_INT32 + try: + def get_cpu_val(name): + return float(util.file.slurp_file('/sys/fs/cgroup/cpu/cpu.'+name).strip()) + cfs_quota = get_cpu_val('cfs_quota_us') + if cfs_quota > 0: + cfs_period = get_cpu_val('cfs_period_us') + log.debug('cfs_quota %s, cfs_period %s', cfs_quota, cfs_period) + cgroup_cpus = max(1, int(cfs_quota / cfs_period)) + except Exception as e: + pass + + proc_cpus = MAX_INT32 + try: + with open('/proc/self/status') as f: + status = f.read() + m = re.search(r'(?m)^Cpus_allowed:\s*(.*)$', status) + if m: + res = bin(int(m.group(1).replace(',', ''), 16)).count('1') + if res > 0: + proc_cpus = res + except IOError: + pass + + log.debug('cgroup_cpus %d, proc_cpus %d, multiprocessing cpus %d', + cgroup_cpus, proc_cpus, multiprocessing.cpu_count()) + return min(cgroup_cpus, proc_cpus, multiprocessing.cpu_count()) + +def sanitize_thread_count(threads=None, tool_max_cores_value=available_cpu_count): + ''' Given a user specified thread count, this function will: + - ensure that 1 <= threads <= available_cpu_count() + - interpret None values to mean max available cpus + unless PYTEST_XDIST_WORKER_COUNT is defined as an environment + variable, in which case we always return 1 + - allow for various, tool-specific ways of specifying + max available cores (tool_max_value) + tool_max_cores_value can be one of: + available_cpu_count - this function will return available_cpu_count() + any other value - this function will return that value. + some commonly used values for tools are -1, 0, and None. + ''' + if 'PYTEST_XDIST_WORKER_COUNT' in os.environ: + threads = 1 + + max_cores = available_cpu_count() + + if threads is None: + threads = max_cores + + assert type(threads) == int + + if threads >= max_cores: + if tool_max_cores_value == available_cpu_count: + threads = max_cores + else: + threads = tool_max_cores_value + else: + if threads < 1: + threads = 1 + return threads + +def which(application_binary_name): + """""" + Similar to the *nix ""which"" command, + this function finds the first executable binary present + in the system PATH for the binary specified. + It differs in that it resolves symlinks. + """""" + path=os.getenv('PATH') + for path in path.split(os.path.pathsep): + full_path=os.path.join(path, application_binary_name) + if os.path.exists(full_path) and os.access(full_path, os.X_OK): + link_resolved_path = os.path.realpath(full_path) + return link_resolved_path + +def is_nonstr_iterable(x, str_types=str): + '''Tests whether `x` is an Iterable other than a string. `str_types` gives the type(s) to treat as strings.''' + return isinstance(x, collections.Iterable) and not isinstance(x, str_types) + +def make_seq(x, str_types=str): + '''Return a tuple containing the items in `x`, or containing just `x` if `x` is a non-string iterable. Convenient + for uniformly writing iterations over parameters that may be passed in as either an item or a tuple/list of items. + Note that if `x` is an iterator, it will be concretized. `str_types` gives the type(s) to treat as strings.' + ''' + return tuple(x) if is_nonstr_iterable(x, str_types) else (x,) + +def load_yaml_or_json(fname): + '''Load a dictionary from either a yaml or a json file''' + with open(fname) as f: + if fname.upper().endswith('.YAML'): return yaml.safe_load(f) or {} + if fname.upper().endswith('.JSON'): return json.load(f) or {} + raise TypeError('Unsupported dict file format: ' + fname) + + +def load_config(cfg, include_directive='include', std_includes=(), param_renamings=None): + '''Load a configuration, with support for some extra functionality that lets project configurations evolve + without breaking backwards compatibility. + + The configuration `cfg` is either a dict (possibly including nested dicts) or a yaml/json file containing one. + A configuration parameter or config param is a sequence of one or more keys; the value of the corresponding + parameter is accessed as ""cfg[k1][k2]...[kN]"". Note, by ""parameter"" we denote the entire sequence of keys. + + This function implements extensions to the standard way of specifying configuration parameters via (possibly nested) + dictionaries. These extensions make it easier to add or rename config params without breaking backwards + compatibility. + + One extension lets config files include other config files, and lets you specify ""standard"" config file(s) to + be included before all others. If the ""default"" config file from the project distribution is made a standard + include, new parameters can be added to it (and referenced from project code) without breaking compatibility + with old config files that omit these parameters. + + Another extension lets you, when loading a config file, recognize parameters specified under old or legacy names. + This lets you change parameter names in new program versions while still accepting legacy config files that + use older names. + + Args: + cfg: either a config mapping, or the name of a file containing one (in yaml or json format). + A config mapping is just a dict, possibly including nested dicts, specifying config params. + The mapping can include an entry pointing to other config files to include. + The key of the entry is `include_directive`, and the value is a filename or list of filenames of config files. + Relative filenames are interpreted relative to the directory containing `cfg`, if `cfg` is a filename, + else relative to the current directory. Any files from `std_includes` are prepended to the list of + included config files. Parameter values from `cfg` override ones from any included files, and parameter values + from included files listed later in the include list override parameter values from included files listed + earlier. + + include_directive: key used to specify included config files + std_includes: config file(s) implicitly included before all others and before `cfg` + param_renamings: optional map of old/legacy config param names to new ones. 'Param names' here are + either keys or sequences of keys. Example value: {'trinity_kmer_size': ('de_novo_assembly', 'kmer_size')}; + new code can access the parameter as cfg[""de_novo_assembly""][""kmer_size""] while legacy users can keep + specifying it as ""trinity_kmer_size: 31"". + ''' + + param_renamings = param_renamings or {} + + result = dict() + + base_dir_for_includes = None + if isinstance(cfg, str): + cfg_fname = os.path.realpath(cfg) + base_dir_for_includes = os.path.dirname(cfg_fname) + cfg = load_yaml_or_json(cfg_fname) + + def _update_config(config, overwrite_config): + """"""Recursively update dictionary config with overwrite_config. + + Adapted from snakemake.utils. + See + http://stackoverflow.com/questions/3232943/update-value-of-a-nested-dictionary-of-varying-depth + for details. + + Args: + config (dict): dictionary to update + overwrite_config (dict): dictionary whose items will overwrite those in config + + """""" + + def _update(d, u): + def fix_None(v): return {} if v is None else v + for (key, value) in u.items(): + if (isinstance(value, collections.Mapping)): + d[key] = _update(fix_None(d.get(key, {})), value) + else: + d[key] = fix_None(value) + return d + + _update(config, overwrite_config) + + + includes = make_seq(std_includes) + make_seq(cfg.get(include_directive, [])) + for included_cfg_fname in includes: + if (not os.path.isabs(included_cfg_fname)) and base_dir_for_includes: + included_cfg_fname = os.path.join(base_dir_for_includes, included_cfg_fname) + _update_config(result, load_config(cfg=included_cfg_fname, + include_directive=include_directive, + param_renamings=param_renamings)) + + # mappings in the current (top-level) config override any mappings from included configs + _update_config(result, cfg) + + # load any params specified under legacy names, for backwards compatibility + param_renamings_seq = dict(map(lambda kv: map(make_seq, kv), param_renamings.items())) + + for old_param, new_param in param_renamings_seq.items(): + + # handle chains of param renamings + while new_param in param_renamings_seq: + new_param = param_renamings_seq[new_param] + + old_val = functools.reduce(lambda d, k: d.get(k, {}), old_param, result) + new_val = functools.reduce(lambda d, k: d.get(k, {}), new_param, result) + + if old_val != {} and new_val == {}: + _update_config(result, functools.reduce(lambda d, k: {k: d}, new_param[::-1], old_val)) + log.warning('Config param {} has been renamed to {}; old name accepted for now'.format(old_param, new_param)) + + return result + +def as_type(val, types): + """"""Try converting `val`to each of `types` in turn, returning the first one that succeeds."""""" + errs = [] + for type in make_seq(types): + try: + return type(val) + except Exception as e: + errs.append(e) + pass + raise TypeError('Could not convert {} to any of {}: {}'.format(val, types, errs)) + +def subdict(d, keys): + """"""Return a newly allocated shallow copy of a mapping `d` restricted to keys in `keys`."""""" + d = dict(d) + keys = set(keys) + return {k: v for k, v in d.items() if k in keys} + +def chk(condition, message='Check failed', exc=RuntimeError): + """"""Check a condition, raise an exception if condition is False."""""" + if not condition: + raise exc(message) + +def wraps(f): + """"""Like functools.wraps but sets __wrapped__ even on Python 2.7"""""" + wrapper = functools.wraps(f) + wrapper.__wrapped__ = f + return wrapper + +def unwrap(f): + """"""Find the original function under layers of wrappers"""""" + return f if not hasattr(f, '__wrapped__') else unwrap(f.__wrapped__) +","Python" +"Viral","broadinstitute/viral-ngs","util/annot.py",".py","6922","170","'''A few methods for dealing with gene annotation from snpEff.''' + +__author__ = ""dpark@broadinstitute.org"" +__version__ = ""PLACEHOLDER"" +__date__ = ""PLACEHOLDER"" + +import sqlite3 +import itertools +import urllib +import logging +import re +import os +import util.file +import util.misc + +log = logging.getLogger(__name__) + + +class SnpAnnotater(object): + ''' Add annotations to snps based on a snpEff-annotated VCF file. + ''' + + def __init__(self, snpEffVcf=None, snpIterator=None): + self.snpIterator = snpIterator + self.dbFile = util.file.mkstempfname(prefix='SnpAnnotater-', suffix='.db') + self.conn = sqlite3.connect(self.dbFile, isolation_level='DEFERRED') + self.cur = self.conn.cursor() + self.cur.execute(""""""create table annot ( + chr not null, + pos integer not null, + allele_ref not null, + allele_alt not null, + effect not null, + impact not null, + gene_id, + gene_name, + protein_pos integer, + residue_ref, + residue_alt + )"""""") + self.cur.execute(""create index idx_annot on annot(chr,pos)"") + if snpEffVcf: + self.loadVcf(snpEffVcf) + + def loadVcf(self, snpEffVcf): + #log.info(""reading in snpEff VCF file: %s"" % snpEffVcf) + with util.file.open_or_gzopen(snpEffVcf, 'rt') as inf: + ffp = util.file.FlatFileParser(inf) + try: + self.cur.executemany(""""""insert into annot (chr,pos,allele_ref,allele_alt, + effect,impact,gene_id,gene_name,protein_pos,residue_ref,residue_alt) + values (?,?,?,?,?,?,?,?,?,?,?)"""""", map( + lambda row: [row['CHROM'], int(row['POS']), row['REF'], row['ALT']] + parse_eff(row['CHROM'], row['POS'], row['INFO']), + filter(lambda r: r['ALT'] != '.', ffp))) + except Exception: + log.exception(""exception processing file %s line %s"", snpEffVcf, ffp.line_num) + raise + self.cur.execute(""select chr,pos from annot group by chr,pos having count(*)>1"") + dupes = [(c, p) for c, p in self.cur] + if dupes: + log.info(""deleting annotation for %d duplicate positions: %s"", len(dupes), + ', '.join(['%s:%s' % (c, p) for c, p in dupes])) + self.cur.executemany(""delete from annot where chr=? and pos=?"", dupes) + self.conn.commit() + + def __iter__(self): + assert self.snpIterator + for snp in self.snpIterator: + yield self.annotate(snp) + + def annotate(self, row): + self.cur.execute(""""""select effect,impact,gene_id,gene_name,protein_pos, + allele_ref,allele_alt,residue_ref,residue_alt + from annot where chr=? and pos=?"""""", [row['chr'], int(row['pos'])]) + x = self.cur.fetchone() + if x is not None: + row['effect'], row['impact'], row['gene_id'], row['gene_name'], row['protein_pos'], row[ + 'allele_ref' + ], row['allele_alt'], row['residue_ref'], row['residue_alt'] = x + row['alleles'] = '/'.join((row['allele_ref'], row['allele_alt'])) + if row['residue_alt']: + row['residues'] = '/'.join((row['residue_ref'], row['residue_alt'])) + else: + row['residues'] = row['residue_ref'] + else: + row['effect'] = 'UNKNOWN' + row['impact'] = 'UNKNOWN' + return row + + def new_fields(self): + return ('effect', 'impact', 'gene_id', 'gene_name', 'protein_pos', 'alleles', 'residues') + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + return 0 + + def close(self): + self.cur.close() + self.conn.close() + os.unlink(self.dbFile) + + +def parse_eff(chrom, pos, info, required=True): + try: + impact_rank = {'HIGH': 0, 'MODERATE': 1, 'LOW': 2, 'MODIFIER': 3} + infos = [x for x in info.split(';') if x.startswith('EFF=')] + assert len(infos) <= 1 + if not infos: + assert not required + return ['', '', '', '', '', '', ''] + info = infos[0] + effs = info[4:].split(',') + out = [] + for eff in effs: + assert eff.endswith(')') + effect, other = eff[:-1].split('(') + other = other.split('|') + assert len(other) >= 10 + impact = other[0] + gene_id = other[8] + assert not gene_id or (gene_id.endswith('-1') and gene_id.startswith('rna_')) + if gene_id: + gene_id = gene_id[4:-2] + if gene_id == 'PF14_0620' or gene_id == 'PF3D7_1465300': + gene_name = 'tRNA 3-trailer sequence RNase, putative' + else: + try: + gene_name = urllib.unquote_plus(other[5]).encode('ascii') + except UnicodeDecodeError: + log.error(""error at %s:%s decoding the string '%s'"", chrom, pos, other[5]) + raise + aa_chg = other[3] + if aa_chg: + if effect.startswith('SYNON'): + aas = (aa_chg[0], '') + codon = int(aa_chg[1:]) + elif effect.startswith('NON_SYNON') or effect.startswith('START_') or effect.startswith( + 'STOP_') or effect.startswith('CODON_'): + mo = re.match(r'^(\D+)(\d+)(\D+)$', aa_chg) + assert mo, ""unrecognized coding change format for %s (%s)"" % (effect, aa_chg) + aas = (mo.group(1), mo.group(3)) + codon = int(mo.group(2)) + elif effect == 'FRAME_SHIFT': + mo = re.match(r'^(\D*)(\d+)(\D*)$', aa_chg) + assert mo, ""unrecognized coding change format for %s (%s)"" % (effect, aa_chg) + aas = ('', '') + codon = int(mo.group(2)) + else: + assert 0, ""unrecognized effect type (%s) for variant with coding change (%s)"" % (effect, aa_chg) + else: + aas = ('', '') + codon = '' + out.append([impact_rank[impact], effect, impact, gene_id, gene_name, codon, aas[0], aas[1]]) + + if len(out) > 1: + out.sort() + if out[0][0] == out[1][0]: + #log.debug(""SNP found with multiple effects of the same impact level: %s:%s - %s"" % (chrom, pos, info)) + #assert out[0][2] in ('MODIFIER','LOW'), ""Error: SNP found with multiple effects of the same impact level"" + out = [[';'.join(util.misc.unique([str(o[i]) for o in out])) for i in range(len(out[0]))]] + eff = out[0][1:] + return eff + + except Exception: + log.exception(""exception parsing snpEff on row %s:%s - %s"", chrom, pos, info) + raise +","Python" +"Viral","broadinstitute/viral-ngs","util/vcf.py",".py","17566","428","'''This gives a number of useful quick methods for dealing with VCF files. +''' + +__author__ = ""dpark@broadinstitute.org"" +__version__ = ""PLACEHOLDER"" +__date__ = ""PLACEHOLDER"" + +import logging +import pysam +import util.file +import util.misc + +log = logging.getLogger(__name__) + + +def make_intervals(i, n, fasta, chr_prefix='', verbose=False): + ''' Divide a sorted genome into n equally sized parts and return the i'th + part. We will return a list of intervals: chr, start, stop. It may + contain multiple chromosomes in order to fill out a total length equal + to the other parts. Each part will be adjacent and non-overlapping with + the next part. i must be a number from 1 to n. + ''' + assert 1 <= i <= n + + # read genome dict file + tot = 0 + chrlens = [] + for c, c_len in get_chrlens(fasta): + if c.startswith(chr_prefix): + chrlens.append((c, c_len, tot)) + tot += c_len + + # define our chunk by gpos: + part_size = tot // n + g_start = 1 + part_size * (i - 1) + g_stop = part_size * i + if i == n: + g_stop = tot + + # find the genomic intervals that correspond to our gpos window + out = [] + for c, c_len, c_g_start in chrlens: + c_g_stop = c_g_start + c_len + c_g_start += 1 + if c_g_stop >= g_start and c_g_start <= g_stop: + start = max(g_start, c_g_start) - c_g_start + 1 + stop = min(g_stop, c_g_stop) - c_g_start + 1 + out.append((c, start, stop)) + + if verbose: + log.info( + ""Dividing the %d bp genome into %d chunks of %d bp each. The %dth chunk contains the following %d intervals: %s"", + tot, n, part_size, i, len(out), ', '.join([""%s:%d-%d"" % x for x in out])) + return out + + +def sliding_windows(fasta, width, offset, chr_prefix=''): + ''' Divide a genome into sliding windows and return as an iterator of + intervals (chr, start, stop). The windows are of fixed width + (except maybe the last window on each chromosome) and may overlap + (offsetwidth). + ''' + assert width > 0 and offset > 0 + for c, c_len in get_chrlens(fasta): + if c.startswith(chr_prefix): + start = 1 + while start <= c_len: + stop = min(c_len, start + width - 1) + yield (c, start, stop) + start += offset + + +class GenomePosition(object): + ''' Provide a mapping from chr:pos to genomic position. + Read chromosome lengths and order from either a Picard/GATK-index for + a FASTA file (a .dict file) or from a VCF header. + ''' + + def __init__(self, seqDb): + self.gpos_map = {} + self.clen_map = {} + self.chrs = [] + totlen = 0 + for c, clen in get_chrlens(seqDb): + self.chrs.append((c, clen)) + self.gpos_map[c] = totlen + self.clen_map[c] = clen + totlen += clen + self.total = totlen + + def get_gpos(self, c, p): + assert isinstance(p, int) + assert c in self.gpos_map + assert 1 <= p <= self.clen_map[c] + return p + self.gpos_map[c] + + def get_chr_pos(self, gpos): + assert isinstance(gpos, int) + assert 1 <= gpos <= self.total + totlen = 0 + for c, clen in self.chrs: + if gpos <= totlen + clen: + break + totlen += clen + return (c, gpos - totlen) + + +def get_chrlens(inFile): + ''' Read chromosome lengths and order from either a Picard/GATK-index for + a FASTA file (a .dict file) or from ""contig"" rows in the VCF header. + ''' + chrlens = [] + if hasattr(inFile, 'chrlens'): + chrlens = inFile.chrlens() + else: + if inFile.endswith('.fasta'): + inFile = inFile[:-len('.fasta')] + '.dict' + elif inFile.endswith('.fa'): + inFile = inFile[:-len('.fa')] + '.dict' + if inFile.endswith('.dict'): + with open(inFile, 'rt') as inf: + for line in inf: + row = line.rstrip('\n').split('\t') + if row[0] == '@SQ': + assert row[1].startswith('SN:') and row[2].startswith('LN:') + c = row[1][3:] + c_len = int(row[2][3:]) + chrlens.append((c, c_len)) + elif inFile.endswith('.vcf') or inFile.endswith('.vcf.gz'): + with util.file.open_or_gzopen(inFile, 'rt') as inf: + for line in inf: + line = line.rstrip('\n') + if line.startswith('##contig='): + line = line[13:-1] + c = line.split(',')[0] + clen = int(line.split('=')[1]) + chrlens.append((c, clen)) + elif line.startswith('#CHROM'): + break + else: + raise AssertionError(""unrecognized file type %s"" % inFile) + assert chrlens, ""no sequence data found in %s % inFile"" + return chrlens + + +def calc_maf(genos, ancestral=None, ploidy=1): + # get list of alleles + if ploidy == 1: + alleles = genos + else: + alleles = [] + for g in genos: + g = g.split('/') + assert len(g) == ploidy + alleles += g + + # count up + out = {'n_tot': len(alleles)} + acounts = util.misc.histogram(alleles) + alist = sorted([(n, a) for a, n in acounts.items()]) + + # daf + if ancestral is not None: + out['a_ancestral'] = ancestral + derived = list(sorted([a for a in acounts.keys() if a != ancestral])) + out['a_derived'] = ','.join(derived) + out['dac'] = sum(acounts[a] for a in derived) + out['daf'] = out['n_tot'] and float(out['dac']) / out['n_tot'] or None + + # maf + if out['n_tot']: + out['a_major'] = alist[-1][1] + out['a_minor'] = ','.join([a for n, a in alist[:-1]]) + out['mac'] = out['n_tot'] - alist[-1][0] + out['maf'] = float(out['mac']) / out['n_tot'] + else: + out['a_major'] = None + out['a_minor'] = None + out['mac'] = None + out['maf'] = None + + return out + +class TabixReader(pysam.TabixFile): + ''' A wrapper around pysam.TabixFile that provides a context and + allows us to query using 1-based coordinates. + + We should request upstream to the Pysam people to implement + methods __reversed__() and __len__() in pysam.TabixIterator. + __getitem__ could be a bonus, but prob unnecessary. + ''' + + def __init__(self, inFile, parser=pysam.asTuple()): + # inFile is passed in but is never used, and yet the TabixReader works. How?! + # This inFile magic is because Tabixfile is a Cython object that uses def __cinit__ + # rather than def __init__; the former is called automatically exactly once for the + # base class prior to any use of __init__. Use of subsequent __init__ should obey + # normal inheritance rules (assuming inheritance from object and it's not an old-style class). + # So __cinit__ sets the input file, and then our __init__ (which doesn't override a base method) + # is called and sets the parser. + # This could all break in the future if pysam moves away from __cinit__, but doing so would + # reduce performance and so it seems unlikely. + # See: + # https://github.com/cython/cython/blob/master/docs/src/userguide/special_methods.rst#id19 + # https://github.com/pysam-developers/pysam/blob/master/pysam/libctabix.pyx#L331 + #super(TabixReader, self).__init__(inFile, parser=parser) + self.parser = parser + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() # pylint: disable=E1101 + return 0 + + # close() is being inherited from pysam.Tabixfile, why call it ourselves? + # def close(self): + # super(TabixReader, self).close() + + def chroms(self): + return self.contigs # pylint: disable=E1101 + + def get(self, chrom=None, start=None, stop=None, region=None): + if start is not None: + start -= 1 + return self.fetch(reference=chrom, start=start, end=stop, region=region, parser=self.parser) # pylint: disable=E1101 + + +def get_pos_from_vcf_record(vcfrec): + # new versions of pysam return a zero-based position here + return vcfrec.pos + 1 + + +def bytes_to_string(o): + if isinstance(o, bytes): + o = o.decode('utf-8') + return o + + +class VcfReader(TabixReader): + ''' Same as TabixReader with a few more perks for VCF files: + - emit results parsed as pysam VCF rows + - provide self.chrlens(), a dict mapping chrom name to chrom length + - provide self.samples(), a list of sample names in order of appearance + - provide get_range(c,start,stop) and get_snp_genos(c,pos) + ''' + + def __init__(self, inFile, ploidy=1, parser=pysam.asVCF()): + # using old-style class superclass calling here + # since TabixReader is derived from pysam.TabixFile + # which is itself an old-style class (due to Cython version?) + TabixReader.__init__(self, inFile, parser=parser) + # when pysam uses new-style classes, we can replace with: + #super(VcfReader, self).__init__(inFile, parser=parser) + assert ploidy in (1, 2) + self.ploidy = ploidy + self.clens = [] + self.sample_names = None + for line in self.header: # pylint: disable=E1101 + line = bytes_to_string(line) + if line.startswith('##contig='): + line = line[13:-1] + c = line.split(',')[0] + clen = int(line.split('=')[1]) + self.clens.append((c, clen)) + elif line.startswith('#CHROM'): + row = line.split('\t') + self.sample_names = row[9:] + self.clens = dict(self.clens) + assert self.sample_names + + def samples(self): + return self.sample_names + + def chrlens(self): + return self.clens + + def get_positions(self, c=None, start=None, stop=None, region=None): + for snp in self.get(c, start, stop, region): + yield (bytes_to_string(snp.contig), get_pos_from_vcf_record(snp), + get_pos_from_vcf_record(snp) + len(snp.ref) - 1) + + def get_range(self, c=None, start=None, stop=None, region=None, as_strings=True, more=False): + ''' Read a VCF file (optionally just a piece of it) and return contents + as an iterator with parsed contents. Each row is returned as + a 4-tuple: + 1: chr + 2: pos (int) + 3: list of allele strings (in order) + 4: list of genotypes as 2-tuples: + haploid: (sample, allele) + diploid: (sample, [allele, allele]) + If as_strings, the alleles will be actual alleles. Otherwise, + alleles will be integers. + If more is true, a fifth column will be emitted with the pysam VCF object. + ''' + for snp in self.get(c, start, stop, region): + alleles = [bytes_to_string(snp.ref)] + bytes_to_string(snp.alt).split(',') + alleles = [a for a in alleles if a != '.'] + if self.ploidy == 1: + genos = [(self.sample_names[i], int(bytes_to_string(snp[i])[0])) for i in range(len(self.sample_names)) + if bytes_to_string(snp[i])[0] != '.'] + if as_strings: + genos = [(s, alleles[a]) for s, a in genos] + else: + genos = [(self.sample_names[i], [int(bytes_to_string(snp[i])[j * 2]) for j in range(self.ploidy)]) + for i in range(len(self.sample_names)) if bytes_to_string(snp[i])[0] != '.'] + if as_strings: + genos = [(s, [alleles[a] for a in g]) for s, g in genos] + if more: + yield (bytes_to_string(snp.contig), get_pos_from_vcf_record(snp), alleles, genos, snp) + else: + yield (bytes_to_string(snp.contig), get_pos_from_vcf_record(snp), alleles, genos) + + def get_snp_genos(self, c, p, as_strings=True): + ''' Read a single position from a VCF file and return the genotypes + as a sample -> allele map. If there is not exactly one matching + row in the VCF file at this position (if there are none or multiple) + then we return an empty map: {}. + ''' + snps = [x for x in self.get_range(c, p, p, as_strings=as_strings)] + return len(snps) == 1 and dict(snps[0][3]) or {} + + def getFullSequences(self, c, start, stop, samples, + na='-', refSeq=None, refInvariantsOnly=False, ignoreIndels=False): + ''' chr - chromosome name + start - start position + stop - default = start + samples is a list of samples. None can be used for the ref sample. + if refSeq is a string with length = stop-start+1, then use this as the + base sequence for missing data, otherwise, use the na string. + if refInvariantsOnly is True, refSeq is only used for invariant + sites or sites with no entries for any samples. if False, refSeq + is used for all missing data. + ''' + assert 1 <= start <= stop + assert len(na) == 1 + + # get all the VCF records + vcf_records = [(p - start, alleles, dict(genos)) + for _, p, alleles, genos in self.get_range(c, + start, + stop, + as_strings=True) + if not ignoreIndels or set(map(len, alleles)) == set([1])] + + # Construct a list called ""seq"" into which we will replace alleles as + # we discover them. This is a list, not a string, because each position + # might be replaced with an arbitrary length string (deletions will be + # empty strings, insertions will be strings > length 1). This all gets + # converted to a string at the end. + if refSeq: + # assume refSeq alleles as a baseline for missing data + assert len(refSeq) == (stop - start + 1) + seq = list(refSeq) + if refInvariantsOnly: + # but don't assume refSeq alleles for any known variant sites + for i, alleles, genos in vcf_records: + if len(set(genos[s] for s in samples if s in genos)) > 1: + for j in range(len(alleles[0])): + if i + j < len(seq): + seq[i + j] = na + else: + # assume nothing when data is missing + seq = list(na * (stop - start + 1)) + + for sample in samples: + assert sample is None or sample in self.samples() + + # Make copy of reference sequence + newseq = [s for s in seq] + + # Replace alleles, one site at a time. + replaceAlleles(sample, newseq, vcf_records) + + # Convert list back to string. This string may or may not be the same + # length as the original (if ignoreIndels is True, it must be the same + # length as the original). + newseq = ''.join(newseq) + assert len(newseq) == (stop - start + 1) or not ignoreIndels + yield (sample, newseq) + + +def replaceAlleles(sample, seq, vcf_records): + ''' Replace alleles, one site at a time. ''' + for i, alleles, genos in vcf_records: + + # set allele to the DNA sequence we will replace at positions i through i+len(refallele)-1 + if sample is None: + # caller is asking for the reference sample's sequence + allele = alleles[0] + alleles = [allele] + else: + # caller is asking for a normal sample + samp_geno = genos.get(sample) + if not samp_geno: + continue + if isinstance(samp_geno, list): + log.warning( + ""TO DO: add code to turn hets into IUPAC ambiguity codes (%s %s = %s)."", + i, sample, '/'.join(samp_geno)) + continue + allele = samp_geno + + # replace portion of sequence with allele + # NEED BUGFIXES HERE for overlapping VCF records + if allele is None: + # nothing here ... is this even possible anymore? + pass + elif len(alleles[0]) == 1: + # the most common cases: SNP, novar, or indel replacing one ref base (with zero or more bases) + seq[i] = allele + else: + # most complicated case: something replacing multiple ref bases + # TODO: beware--this is all untested! + for j in range(max(len(alleles[0]), len(allele))): + if i + j < len(seq): + if j < len(allele): + if j == len(alleles[0]) - 1: + # new allele is >= ref length, fill out the rest of the bases + seq[i + j] = allele[j:] + else: + seq[i + j] = allele[j] + else: + # new allele is shorter than ref, so delete extra bases + seq[i + j] = '' + return seq +","Python" +"Viral","broadinstitute/viral-ngs","util/illumina_indices.py",".py","225358","1895","#!/usr/bin/env python + +"""""" + Related only to sequence data within this file: + ""Oligonucleotide sequences Copyright 2016 Illumina, Inc. All rights reserved."" + See: https://support.illumina.com/content/dam/illumina-support/documents/documentation/chemistry_documentation/experiment-design/illumina-adapter-sequences_1000000002694-01.pdf + Python code below is under the license of this repository: + https://raw.githubusercontent.com/broadinstitute/viral-ngs/master/LICENSE +"""""" + +import re, functools +import csv +import copy +import math +import logging +from collections import OrderedDict, defaultdict + +import util.file + +log = logging.getLogger(__name__) + +def memoize(obj): + cache = obj.cache = {} + + @functools.wraps(obj) + def memoizer(*args, **kwargs): + key = """".join([str(args),str(kwargs)]) + if key not in cache: + cache[key] = obj(*args, **kwargs) + return cache[key] + return memoizer + +class IlluminaIndexReference(object): + + def __init__(self, kit=None, instrument=None): + self.kit = kit + self.instrument = instrument + + _kits = { + ""TruSight Amplicon Panels"":{ + ""_short_name"":""trusight_amp"", + ""i7"":{ + ""A701"":[{""seq"":""ATCACGAC"",""instruments"":[]}], + ""A702"":[{""seq"":""ACAGTGGT"",""instruments"":[]}], + ""A703"":[{""seq"":""CAGATCCA"",""instruments"":[]}], + ""A704"":[{""seq"":""ACAAACGG"",""instruments"":[]}], + ""A705"":[{""seq"":""ACCCAGCA"",""instruments"":[]}], + ""A706"":[{""seq"":""AACCCCTC"",""instruments"":[]}], + ""A707"":[{""seq"":""CCCAACCT"",""instruments"":[]}], + ""A708"":[{""seq"":""CACCACAC"",""instruments"":[]}], + ""A709"":[{""seq"":""GAAACCCA"",""instruments"":[]}], + ""A710"":[{""seq"":""TGTGACCA"",""instruments"":[]}], + ""A711"":[{""seq"":""AGGGTCAA"",""instruments"":[]}], + ""A712"":[{""seq"":""AGGAGTGG"",""instruments"":[]}] + }, + ""i5"":{ + ""A501"": [{""seq"":""TGAACCTT"", ""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AAGGTTCA"", ""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A502"": [{""seq"":""TGCTAAGT"", ""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""ACTTAGCA"", ""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A503"": [{""seq"":""TGTTCTCT"", ""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AGAGAACA"", ""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A504"": [{""seq"":""TAAGACAC"", ""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""GTGTCTTA"", ""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A505"": [{""seq"":""CTAATCGA"", ""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TCGATTAG"", ""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A506"": [{""seq"":""CTAGAACA"", ""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TGTTCTAG"", ""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A507"": [{""seq"":""TAAGTTCC"", ""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""GGAACTTA"", ""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A508"": [{""seq"":""TAGACCTA"", ""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TAGGTCTA"", ""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}] + } + }, + ""TruSight Cardio"":{ + ""_short_name"":""trusight_cardio"", + ""i7"":{ + ""N701"": [{""seq"":""TAAGGCGA"",""instruments"":[]}], + ""N702"": [{""seq"":""CGTACTAG"",""instruments"":[]}], + ""N703"": [{""seq"":""AGGCAGAA"",""instruments"":[]}], + ""N704"": [{""seq"":""TCCTGAGC"",""instruments"":[]}], + ""N705"": [{""seq"":""GGACTCCT"",""instruments"":[]}], + ""N706"": [{""seq"":""TAGGCATG"",""instruments"":[]}], + ""N707"": [{""seq"":""CTCTCTAC"",""instruments"":[]}], + ""N708"": [{""seq"":""CAGAGAGG"",""instruments"":[]}], + ""N709"": [{""seq"":""GCTACGCT"",""instruments"":[]}], + ""N710"": [{""seq"":""CGAGGCTG"",""instruments"":[]}], + ""N711"": [{""seq"":""AAGAGGCA"",""instruments"":[]}], + ""N712"": [{""seq"":""GTAGAGGA"",""instruments"":[]}] + } , + ""i5"":{ + ""E505"": [{""seq"":""GTAAGGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""CTCCTTAC"",""instruments"":[""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}] + } + }, + ""TruSight One"":{ + ""_short_name"":""trusight_one"", + ""i7"":{ + ""N701"":[{""seq"":""TAAGGCGA"",""instruments"":[]}], + ""N702"":[{""seq"":""CGTACTAG"",""instruments"":[]}], + ""N703"":[{""seq"":""AGGCAGAA"",""instruments"":[]}], + ""N704"":[{""seq"":""TCCTGAGC"",""instruments"":[]}], + ""N705"":[{""seq"":""GGACTCCT"",""instruments"":[]}], + ""N706"":[{""seq"":""TAGGCATG"",""instruments"":[]}], + ""N707"":[{""seq"":""CTCTCTAC"",""instruments"":[]}], + ""N708"":[{""seq"":""CAGAGAGG"",""instruments"":[]}], + ""N709"":[{""seq"":""GCTACGCT"",""instruments"":[]}], + ""N710"":[{""seq"":""CGAGGCTG"",""instruments"":[]}], + ""N711"":[{""seq"":""AAGAGGCA"",""instruments"":[]}], + ""N712"":[{""seq"":""GTAGAGGA"",""instruments"":[]}] + }, + ""i5"":{ + ""E502"": [{""seq"":""CTCTCTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""ATAGAGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""E503"": [{""seq"":""TATCCTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AGAGGATA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""E504"": [{""seq"":""AGAGTAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TCTACTCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""E505"": [{""seq"":""GTAAGGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""CTCCTTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}] + } + }, + ""TruSight Rapid Capture"":{ + ""_short_name"":""trusight_rapid_capture"", + ""i7"":{ + ""N701"":[{""seq"":""TAAGGCGA"",""instruments"":[]}], + ""N702"":[{""seq"":""CGTACTAG"",""instruments"":[]}], + ""N703"":[{""seq"":""AGGCAGAA"",""instruments"":[]}], + ""N704"":[{""seq"":""TCCTGAGC"",""instruments"":[]}], + ""N705"":[{""seq"":""GGACTCCT"",""instruments"":[]}], + ""N706"":[{""seq"":""TAGGCATG"",""instruments"":[]}], + ""N707"":[{""seq"":""CTCTCTAC"",""instruments"":[]}], + ""N708"":[{""seq"":""CAGAGAGG"",""instruments"":[]}], + ""N709"":[{""seq"":""GCTACGCT"",""instruments"":[]}], + ""N710"":[{""seq"":""CGAGGCTG"",""instruments"":[]}], + ""N711"":[{""seq"":""AAGAGGCA"",""instruments"":[]}], + ""N712"":[{""seq"":""GTAGAGGA"",""instruments"":[]}] + }, + ""i5"":{ + ""E502"": [{""seq"":""CTCTCTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""ATAGAGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""E505"": [{""seq"":""GTAAGGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""CTCCTTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""E506"": [{""seq"":""ACTGCATA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TATGCAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""E517"": [{""seq"":""GCGTAAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TCTTACGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}] + } + }, + ""TruSight Tumor 15"":{ + ""_short_name"":""trusight_tumor_15"", + ""i7"":{ + ""R701"": [{""seq"":""ATCACG"",""instruments"":[]}], + ""R702"": [{""seq"":""CGATGT"",""instruments"":[]}], + ""R703"": [{""seq"":""TTAGGC"",""instruments"":[]}], + ""R704"": [{""seq"":""TGACCA"",""instruments"":[]}], + ""R705"": [{""seq"":""ACAGTG"",""instruments"":[]}], + ""R706"": [{""seq"":""GCCAAT"",""instruments"":[]}], + ""R707"": [{""seq"":""CAGATC"",""instruments"":[]}], + ""R708"": [{""seq"":""ACTTGA"",""instruments"":[]}], + ""R709"": [{""seq"":""GATCAG"",""instruments"":[]}], + ""R711"": [{""seq"":""GGCTAC"",""instruments"":[]}], + ""R712"": [{""seq"":""CTTGTA"",""instruments"":[]}], + ""R725"": [{""seq"":""ACTGAT"",""instruments"":[]}], + ""R726"": [{""seq"":""ATGAGC"",""instruments"":[]}], + ""R727"": [{""seq"":""ATTCCT"",""instruments"":[]}], + ""R728"": [{""seq"":""CAAAAG"",""instruments"":[]}], + ""R729"": [{""seq"":""CAACTA"",""instruments"":[]}], + ""R730"": [{""seq"":""CACCGG"",""instruments"":[]}], + ""R731"": [{""seq"":""CACGAT"",""instruments"":[]}], + ""R732"": [{""seq"":""CACTCA"",""instruments"":[]}], + ""R733"": [{""seq"":""CAGGCG"",""instruments"":[]}], + ""R734"": [{""seq"":""CATGGC"",""instruments"":[]}], + ""R735"": [{""seq"":""CATTTT"",""instruments"":[]}], + ""R736"": [{""seq"":""CCAACA"",""instruments"":[]}], + ""R749"": [{""seq"":""GATGCT"",""instruments"":[]}] + }, + ""i5"":{ + ""A501"": [{""seq"":""TGAACCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AAGGTTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A502"": [{""seq"":""TGCTAAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""ACTTAGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}] + } + }, + ""TruSight RNA Pan-Cancer Panel"":{ + ""_short_name"":""trusight_rna_pan_cancer"", + ""indices"":{ + ""AR001"": [{""seq"":""ATCACG"", ""instruments"":[], ""LT_set"":""B""}], + ""AR002"": [{""seq"":""CGATGT"", ""instruments"":[], ""LT_set"":""A""}], + ""AR003"": [{""seq"":""TTAGGC"", ""instruments"":[], ""LT_set"":""B""}], + ""AR004"": [{""seq"":""TGACCA"", ""instruments"":[], ""LT_set"":""A""}], + ""AR005"": [{""seq"":""ACAGTG"", ""instruments"":[], ""LT_set"":""A""}], + ""AR006"": [{""seq"":""GCCAAT"", ""instruments"":[], ""LT_set"":""A""}], + ""AR007"": [{""seq"":""CAGATC"", ""instruments"":[], ""LT_set"":""A""}], + ""AR008"": [{""seq"":""ACTTGA"", ""instruments"":[], ""LT_set"":""B""}], + ""AR009"": [{""seq"":""GATCAG"", ""instruments"":[], ""LT_set"":""B""}], + ""AR010"": [{""seq"":""TAGCTT"", ""instruments"":[], ""LT_set"":""B""}], + ""AR011"": [{""seq"":""GGCTAC"", ""instruments"":[], ""LT_set"":""B""}], + ""AR012"": [{""seq"":""CTTGTA"", ""instruments"":[], ""LT_set"":""A""}], + ""AR013"": [{""seq"":""AGTCAA"", ""instruments"":[], ""LT_set"":""A""}], + ""AR014"": [{""seq"":""AGTTCC"", ""instruments"":[], ""LT_set"":""A""}], + ""AR015"": [{""seq"":""ATGTCA"", ""instruments"":[], ""LT_set"":""A""}], + ""AR016"": [{""seq"":""CCGTCC"", ""instruments"":[], ""LT_set"":""A""}], + ""AR018"": [{""seq"":""GTCCGC"", ""instruments"":[], ""LT_set"":""A""}], + ""AR019"": [{""seq"":""GTGAAA"", ""instruments"":[], ""LT_set"":""A""}], + ""AR020"": [{""seq"":""GTGGCC"", ""instruments"":[], ""LT_set"":""B""}], + ""AR021"": [{""seq"":""GTTTCG"", ""instruments"":[], ""LT_set"":""B""}], + ""AR022"": [{""seq"":""CGTACG"", ""instruments"":[], ""LT_set"":""B""}], + ""AR023"": [{""seq"":""GAGTGG"", ""instruments"":[], ""LT_set"":""B""}], + ""AR025"": [{""seq"":""ACTGAT"", ""instruments"":[], ""LT_set"":""B""}], + ""AR027"": [{""seq"":""ATTCCT"", ""instruments"":[], ""LT_set"":""B""}] + }, + }, + ""Nextera Index Kit"":{ + ""_short_name"":""nextera"", + ""i7"":{ + ""N701"": [{""seq"":""TAAGGCGA"",""instruments"":[],""seq_in_adapter"":""TCGCCTTA""}], + ""N702"": [{""seq"":""CGTACTAG"",""instruments"":[],""seq_in_adapter"":""CTAGTACG""}], + ""N703"": [{""seq"":""AGGCAGAA"",""instruments"":[],""seq_in_adapter"":""TTCTGCCT""}], + ""N704"": [{""seq"":""TCCTGAGC"",""instruments"":[],""seq_in_adapter"":""GCTCAGGA""}], + ""N705"": [{""seq"":""GGACTCCT"",""instruments"":[],""seq_in_adapter"":""AGGAGTCC""}], + ""N706"": [{""seq"":""TAGGCATG"",""instruments"":[],""seq_in_adapter"":""CATGCCTA""}], + ""N707"": [{""seq"":""CTCTCTAC"",""instruments"":[],""seq_in_adapter"":""GTAGAGAG""}], + ""N708"": [{""seq"":""CAGAGAGG"",""instruments"":[],""seq_in_adapter"":""CCTCTCTG""}], + ""N709"": [{""seq"":""GCTACGCT"",""instruments"":[],""seq_in_adapter"":""AGCGTAGC""}], + ""N710"": [{""seq"":""CGAGGCTG"",""instruments"":[],""seq_in_adapter"":""AAGAGGCA""}], + ""N711"": [{""seq"":""AAGAGGCA"",""instruments"":[],""seq_in_adapter"":""TGCCTCTT""}], + ""N712"": [{""seq"":""GTAGAGGA"",""instruments"":[],""seq_in_adapter"":""TCCTCTAC""}] + }, + ""i5"":{ + ""[N|S|E]501"":[{""seq"":""TAGATCGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGATCGC""}, {""seq"":""GCGATCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGATCGC""}], + ""[N|S|E]502"":[{""seq"":""CTCTCTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCTCTAT""}, {""seq"":""ATAGAGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCTCTAT""}], + ""[N|S|E]503"":[{""seq"":""TATCCTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TATCCTCT""}, {""seq"":""AGAGGATA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TATCCTCT""}], + ""[N|S|E]504"":[{""seq"":""AGAGTAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGAGTAGA""}, {""seq"":""TCTACTCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGAGTAGA""}], + ""[N|S|E]505"":[{""seq"":""GTAAGGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTAAGGAG""}, {""seq"":""CTCCTTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTAAGGAG""}], + ""[N|S|E]506"":[{""seq"":""ACTGCATA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTGCATA""}, {""seq"":""TATGCAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTGCATA""}], + ""[N|S|E]507"":[{""seq"":""AAGGAGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGGAGTA""}, {""seq"":""TACTCCTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGGAGTA""}], + ""[N|S|E]508"":[{""seq"":""CTAAGCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTAAGCCT""}, {""seq"":""AGGCTTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTAAGCCT""}], + ""[N|S|E]517"":[{""seq"":""GCGTAAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCGTAAGA""}, {""seq"":""TCTTACGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCGTAAGA""}], + } + }, + ""Nextera XT Index Kit v2"":{ + ""_short_name"":""nextera_v2"", + ""i7"":{ + ""N701"": [{""seq"":""TAAGGCGA"",""instruments"":[],""seq_in_adapter"":""TCGCCTTA""}], + ""N702"": [{""seq"":""CGTACTAG"",""instruments"":[],""seq_in_adapter"":""CTAGTACG""}], + ""N703"": [{""seq"":""AGGCAGAA"",""instruments"":[],""seq_in_adapter"":""TTCTGCCT""}], + ""N704"": [{""seq"":""TCCTGAGC"",""instruments"":[],""seq_in_adapter"":""GCTCAGGA""}], + ""N705"": [{""seq"":""GGACTCCT"",""instruments"":[],""seq_in_adapter"":""AGGAGTCC""}], + ""N706"": [{""seq"":""TAGGCATG"",""instruments"":[],""seq_in_adapter"":""CATGCCTA""}], + ""N707"": [{""seq"":""CTCTCTAC"",""instruments"":[],""seq_in_adapter"":""GTAGAGAG""}], + ""N710"": [{""seq"":""CGAGGCTG"",""instruments"":[],""seq_in_adapter"":""CAGCCTCG""}], + ""N711"": [{""seq"":""AAGAGGCA"",""instruments"":[],""seq_in_adapter"":""TGCCTCTT""}], + ""N712"": [{""seq"":""GTAGAGGA"",""instruments"":[],""seq_in_adapter"":""TCCTCTAC""}], + ""N714"": [{""seq"":""GCTCATGA"",""instruments"":[],""seq_in_adapter"":""TCATGAGC""}], + ""N715"": [{""seq"":""ATCTCAGG"",""instruments"":[],""seq_in_adapter"":""CCTGAGAT""}], + ""N716"": [{""seq"":""ACTCGCTA"",""instruments"":[],""seq_in_adapter"":""TAGCGAGT""}], + ""N718"": [{""seq"":""GGAGCTAC"",""instruments"":[],""seq_in_adapter"":""GTAGCTCC""}], + ""N719"": [{""seq"":""GCGTAGTA"",""instruments"":[],""seq_in_adapter"":""TACTACGC""}], + ""N720"": [{""seq"":""CGGAGCCT"",""instruments"":[],""seq_in_adapter"":""AGGCTCCG""}], + ""N721"": [{""seq"":""TACGCTGC"",""instruments"":[],""seq_in_adapter"":""GCAGCGTA""}], + ""N722"": [{""seq"":""ATGCGCAG"",""instruments"":[],""seq_in_adapter"":""CTGCGCAT""}], + ""N723"": [{""seq"":""TAGCGCTC"",""instruments"":[],""seq_in_adapter"":""GAGCGCTA""}], + ""N724"": [{""seq"":""ACTGAGCG"",""instruments"":[],""seq_in_adapter"":""CGCTCAGT""}], + ""N726"": [{""seq"":""CCTAAGAC"",""instruments"":[],""seq_in_adapter"":""GTCTTAGG""}], + ""N727"": [{""seq"":""CGATCAGT"",""instruments"":[],""seq_in_adapter"":""ACTGATCG""}], + ""N728"": [{""seq"":""TGCAGCTA"",""instruments"":[],""seq_in_adapter"":""TAGCTGCA""}], + ""N729"": [{""seq"":""TCGACGTC"",""instruments"":[],""seq_in_adapter"":""GACGTCGA""}] + }, + ""i5"":{ + ""S502"":[{""seq"":""CTCTCTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCTCTAT""}, {""seq"":""ATAGAGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCTCTAT""}], + ""S503"":[{""seq"":""TATCCTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TATCCTCT""}, {""seq"":""AGAGGATA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TATCCTCT""}], + ""S505"":[{""seq"":""GTAAGGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTAAGGAG""}, {""seq"":""CTCCTTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTAAGGAG""}], + ""S506"":[{""seq"":""ACTGCATA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTGCATA""}, {""seq"":""TATGCAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTGCATA""}], + ""S507"":[{""seq"":""AAGGAGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGGAGTA""}, {""seq"":""TACTCCTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGGAGTA""}], + ""S508"":[{""seq"":""CTAAGCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTAAGCCT""}, {""seq"":""AGGCTTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTAAGCCT""}], + ""S510"":[{""seq"":""CGTCTAAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGTCTAAT""}, {""seq"":""ATTAGACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGTCTAAT""}], + ""S511"":[{""seq"":""TCTCTCCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCTCTCCG""}, {""seq"":""CGGAGAGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCTCTCCG""}], + ""S513"":[{""seq"":""TCGACTAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCGACTAG""}, {""seq"":""CTAGTCGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCGACTAG""}], + ""S515"":[{""seq"":""TTCTAGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCTAGCT""}, {""seq"":""AGCTAGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCTAGCT""}], + ""S516"":[{""seq"":""CCTAGAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTAGAGT""}, {""seq"":""ACTCTAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTAGAGT""}], + ""S517"":[{""seq"":""GCGTAAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCGTAAGA""}, {""seq"":""TCTTACGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCGTAAGA""}], + ""S518"":[{""seq"":""CTATTAAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTATTAAG""}, {""seq"":""CTTAATAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTATTAAG""}], + ""S520"":[{""seq"":""AAGGCTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGGCTAT""}, {""seq"":""ATAGCCTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGGCTAT""}], + ""S521"":[{""seq"":""GAGCCTTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAGCCTTA""}, {""seq"":""TAAGGCTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAGCCTTA""}], + ""S522"":[{""seq"":""TTATGCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTATGCGA""}, {""seq"":""TCGCATAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTATGCGA""}], + } + }, + ""TruSeq Amplicon Kits"":{ + ""_short_name"":""truseq_amplicon"", + ""i7"":{ + ""A701"":[{""seq"":""ATCACGAC"",""instruments"":[]}], + ""A702"":[{""seq"":""ACAGTGGT"",""instruments"":[]}], + ""A703"":[{""seq"":""CAGATCCA"",""instruments"":[]}], + ""A704"":[{""seq"":""ACAAACGG"",""instruments"":[]}], + ""A705"":[{""seq"":""ACCCAGCA"",""instruments"":[]}], + ""A706"":[{""seq"":""AACCCCTC"",""instruments"":[]}], + ""A707"":[{""seq"":""CCCAACCT"",""instruments"":[]}], + ""A708"":[{""seq"":""CACCACAC"",""instruments"":[]}], + ""A709"":[{""seq"":""GAAACCCA"",""instruments"":[]}], + ""A710"":[{""seq"":""TGTGACCA"",""instruments"":[]}], + ""A711"":[{""seq"":""AGGGTCAA"",""instruments"":[]}], + ""A712"":[{""seq"":""AGGAGTGG"",""instruments"":[]}], + }, + ""i5"":{ + ""A501"":[{""seq"":""TGAACCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AAGGTTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A502"":[{""seq"":""TGCTAAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""ACTTAGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A503"":[{""seq"":""TGTTCTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AGAGAACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A504"":[{""seq"":""TAAGACAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""GTGTCTTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A505"":[{""seq"":""CTAATCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TCGATTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A506"":[{""seq"":""CTAGAACA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TGTTCTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A507"":[{""seq"":""TAAGTTCC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""GGAACTTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A508"":[{""seq"":""TAGACCTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TAGGTCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + } + }, + ""TruSeq DNA Methylation"":{ + ""_short_name"":""truseq_methylation"", + ""indices"":{ + ""Index 1"": [{""seq"":""ATCACG"",""instruments"":[]}], + ""Index 2"": [{""seq"":""CGATGT"",""instruments"":[]}], + ""Index 3"": [{""seq"":""TTAGGC"",""instruments"":[]}], + ""Index 4"": [{""seq"":""TGACCA"",""instruments"":[]}], + ""Index 5"": [{""seq"":""ACAGTG"",""instruments"":[]}], + ""Index 6"": [{""seq"":""GCCAAT"",""instruments"":[]}], + ""Index 7"": [{""seq"":""CAGATC"",""instruments"":[]}], + ""Index 8"": [{""seq"":""ACTTGA"",""instruments"":[]}], + ""Index 9"": [{""seq"":""GATCAG"",""instruments"":[]}], + ""Index 10"": [{""seq"":""TAGCTT"",""instruments"":[]}], + ""Index 11"": [{""seq"":""GGCTAC"",""instruments"":[]}], + ""Index 12"": [{""seq"":""CTTGTA"",""instruments"":[]}], + }, + }, + ""TruSeq HT Kits"":{ + ""_short_name"":""truseq_ht"", + ""i7"":{ + ""D701"":[{""seq"":""ATTACTCG"",""instruments"":[]}], + ""D702"":[{""seq"":""TCCGGAGA"",""instruments"":[]}], + ""D703"":[{""seq"":""CGCTCATT"",""instruments"":[]}], + ""D704"":[{""seq"":""GAGATTCC"",""instruments"":[]}], + ""D705"":[{""seq"":""ATTCAGAA"",""instruments"":[]}], + ""D706"":[{""seq"":""GAATTCGT"",""instruments"":[]}], + ""D707"":[{""seq"":""CTGAAGCT"",""instruments"":[]}], + ""D708"":[{""seq"":""TAATGCGC"",""instruments"":[]}], + ""D709"":[{""seq"":""CGGCTATG"",""instruments"":[]}], + ""D710"":[{""seq"":""TCCGCGAA"",""instruments"":[]}], + ""D711"":[{""seq"":""TCTCGCGC"",""instruments"":[]}], + ""D712"":[{""seq"":""AGCGATAG"",""instruments"":[]}], + }, + ""i5"":{ + ""D501"":[{""seq"":""TATAGCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AGGCTATA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""D502"":[{""seq"":""ATAGAGGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""GCCTCTAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""D503"":[{""seq"":""CCTATCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AGGATAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""D504"":[{""seq"":""GGCTCTGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TCAGAGCC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""D505"":[{""seq"":""AGGCGAAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""CTTCGCCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""D506"":[{""seq"":""TAATCTTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TAAGATTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""D507"":[{""seq"":""CAGGACGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""ACGTCCTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""D508"":[{""seq"":""GTACTGAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""GTCAGTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + } + }, + # ""TruSeq LT Kits"":{ + # ""_short_name"":"""", + # }, + # ""TruSeq v1/v2 Kits"":{ + # ""_short_name"":"""", + # }, + ""TruSeq Ribo Profile"":{ + ""_short_name"":""truseq_ribo"", + ""indices"":{ + ""A001"": [{""seq"":""ATCACG"",""instruments"":[]}], + ""A002"": [{""seq"":""CGATGT"",""instruments"":[]}], + ""A003"": [{""seq"":""TTAGGC"",""instruments"":[]}], + ""A004"": [{""seq"":""TGACCA"",""instruments"":[]}], + ""A005"": [{""seq"":""ACAGTG"",""instruments"":[]}], + ""A006"": [{""seq"":""GCCAAT"",""instruments"":[]}], + ""A007"": [{""seq"":""CAGATC"",""instruments"":[]}], + ""A008"": [{""seq"":""ACTTGA"",""instruments"":[]}], + ""A009"": [{""seq"":""GATCAG"",""instruments"":[]}], + ""A010"": [{""seq"":""TAGCTT"",""instruments"":[]}], + ""A011"": [{""seq"":""GGCTAC"",""instruments"":[]}], + ""A012"": [{""seq"":""CTTGTA"",""instruments"":[]}], + }, + }, + # ""TruSeq Synthetic Long-Read DNA"":{ + # ""_short_name"":"""", + # }, + # ""TruSeq Small RNA"":{ + # ""_short_name"":"""", + # }, + ""TruSeq Targeted RNA Expression"":{ + ""_short_name"":""truseq_rna_expression"", + ""i7"":{ + ""R701"": [{""seq"":""ATCACG"",""instruments"":[]}], + ""R702"": [{""seq"":""CGATGT"",""instruments"":[]}], + ""R703"": [{""seq"":""TTAGGC"",""instruments"":[]}], + ""R704"": [{""seq"":""TGACCA"",""instruments"":[]}], + ""R705"": [{""seq"":""ACAGTG"",""instruments"":[]}], + ""R706"": [{""seq"":""GCCAAT"",""instruments"":[]}], + ""R707"": [{""seq"":""CAGATC"",""instruments"":[]}], + ""R708"": [{""seq"":""ACTTGA"",""instruments"":[]}], + ""R709"": [{""seq"":""GATCAG"",""instruments"":[]}], + ""R710"": [{""seq"":""TAGCTT"",""instruments"":[]}], + ""R711"": [{""seq"":""GGCTAC"",""instruments"":[]}], + ""R712"": [{""seq"":""CTTGTA"",""instruments"":[]}], + ""R713"": [{""seq"":""AGTCAA"",""instruments"":[]}], + ""R714"": [{""seq"":""AGTTCC"",""instruments"":[]}], + ""R715"": [{""seq"":""ATGTCA"",""instruments"":[]}], + ""R716"": [{""seq"":""CCGTCC"",""instruments"":[]}], + ""R717"": [{""seq"":""GTAGAG"",""instruments"":[]}], + ""R718"": [{""seq"":""GTCCGC"",""instruments"":[]}], + ""R719"": [{""seq"":""GTGAAA"",""instruments"":[]}], + ""R720"": [{""seq"":""GTGGCC"",""instruments"":[]}], + ""R721"": [{""seq"":""GTTTCG"",""instruments"":[]}], + ""R722"": [{""seq"":""CGTACG"",""instruments"":[]}], + ""R723"": [{""seq"":""GAGTGG"",""instruments"":[]}], + ""R724"": [{""seq"":""GGTAGC"",""instruments"":[]}], + ""R725"": [{""seq"":""ACTGAT"",""instruments"":[]}], + ""R726"": [{""seq"":""ATGAGC"",""instruments"":[]}], + ""R727"": [{""seq"":""ATTCCT"",""instruments"":[]}], + ""R728"": [{""seq"":""CAAAAG"",""instruments"":[]}], + ""R729"": [{""seq"":""CAACTA"",""instruments"":[]}], + ""R730"": [{""seq"":""CACCGG"",""instruments"":[]}], + ""R731"": [{""seq"":""CACGAT"",""instruments"":[]}], + ""R732"": [{""seq"":""CACTCA"",""instruments"":[]}], + ""R733"": [{""seq"":""CAGGCG"",""instruments"":[]}], + ""R734"": [{""seq"":""CATGGC"",""instruments"":[]}], + ""R735"": [{""seq"":""CATTTT"",""instruments"":[]}], + ""R736"": [{""seq"":""CCAACA"",""instruments"":[]}], + ""R737"": [{""seq"":""CGGAAT"",""instruments"":[]}], + ""R738"": [{""seq"":""CTAGCT"",""instruments"":[]}], + ""R739"": [{""seq"":""CTATAC"",""instruments"":[]}], + ""R740"": [{""seq"":""CTCAGA"",""instruments"":[]}], + ""R741"": [{""seq"":""GACGAC"",""instruments"":[]}], + ""R742"": [{""seq"":""TAATCG"",""instruments"":[]}], + ""R743"": [{""seq"":""TACAGC"",""instruments"":[]}], + ""R744"": [{""seq"":""TATAAT"",""instruments"":[]}], + ""R745"": [{""seq"":""TCATTC"",""instruments"":[]}], + ""R746"": [{""seq"":""TCCCGA"",""instruments"":[]}], + ""R747"": [{""seq"":""TCGAAG"",""instruments"":[]}], + ""R748"": [{""seq"":""TCGGCA"",""instruments"":[]}], + }, + ""i5"":{ + ""A501"":[{""seq"":""TGAACCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AAGGTTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A502"":[{""seq"":""TGCTAAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""ACTTAGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A503"":[{""seq"":""TGTTCTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""AGAGAACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A504"":[{""seq"":""TAAGACAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""GTGTCTTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A505"":[{""seq"":""CTAATCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TCGATTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A506"":[{""seq"":""CTAGAACA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TGTTCTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A507"":[{""seq"":""TAAGTTCC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""GGAACTTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + ""A508"":[{""seq"":""TAGACCTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""]}, {""seq"":""TAGGTCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""]}], + } + }, + # ""Process Controls for TruSeq Kits"":{ + # ""_short_name"":"""", + # }, + # ""Nextera DNA Sample Prep Kit"":{ + # ""_short_name"":"""", + # }, + # ""Oligonucleotide Sequences for Genomic DNA"":{ + # ""_short_name"":"""", + # }, + # ""Oligonucleotide Sequences for Paired End DNA"":{ + # ""_short_name"":"""", + # }, + # ""Oligonucleotide Sequences for the Multiplexing Sample Prep Oligo Only Kit"":{ + # ""_short_name"":"""", + # }, + # ""Oligonucleotide Sequences for the v1 and v1.5 Small RNA Kits"":{ + # ""_short_name"":"""", + # } + ""Broad Institute NEXTERAINDEXPL"":{ + ""_short_name"":""BI_nextera"", + ""i7"":{ + ""BI7A01"":[{""seq"":""AAGTAGAG"",""instruments"":[],""seq_in_adapter"":""CTCTACTT""}], + ""BI7A02"":[{""seq"":""ACACGATC"",""instruments"":[],""seq_in_adapter"":""GATCGTGT""}], + ""BI7A03"":[{""seq"":""TGTTCCGA"",""instruments"":[],""seq_in_adapter"":""TCGGAACA""}], + ""BI7A04"":[{""seq"":""CATGATCG"",""instruments"":[],""seq_in_adapter"":""CGATCATG""}], + ""BI7A05"":[{""seq"":""CGTTACCA"",""instruments"":[],""seq_in_adapter"":""TGGTAACG""}], + ""BI7A06"":[{""seq"":""CAGAGAGG"",""instruments"":[],""seq_in_adapter"":""CCTCTCTG""}], + ""BI7A07"":[{""seq"":""AACGCATT"",""instruments"":[],""seq_in_adapter"":""AATGCGTT""}], + ""BI7A08"":[{""seq"":""ACAGGTAT"",""instruments"":[],""seq_in_adapter"":""ATACCTGT""}], + ""BI7A09"":[{""seq"":""AGGTAAGG"",""instruments"":[],""seq_in_adapter"":""CCTTACCT""}], + ""BI7A10"":[{""seq"":""AACAATGG"",""instruments"":[],""seq_in_adapter"":""CCATTGTT""}], + ""BI7A11"":[{""seq"":""ACTGTATC"",""instruments"":[],""seq_in_adapter"":""GATACAGT""}], + ""BI7A12"":[{""seq"":""AGGTCGCA"",""instruments"":[],""seq_in_adapter"":""TGCGACCT""}], + ""BI7B01"":[{""seq"":""GGTCCAGA"",""instruments"":[],""seq_in_adapter"":""TCTGGACC""}], + ""BI7B02"":[{""seq"":""CATGCTTA"",""instruments"":[],""seq_in_adapter"":""TAAGCATG""}], + ""BI7B03"":[{""seq"":""AGGATCTA"",""instruments"":[],""seq_in_adapter"":""TAGATCCT""}], + ""BI7B04"":[{""seq"":""TCTGGCGA"",""instruments"":[],""seq_in_adapter"":""TCGCCAGA""}], + ""BI7B05"":[{""seq"":""AGGTTATC"",""instruments"":[],""seq_in_adapter"":""GATAACCT""}], + ""BI7B06"":[{""seq"":""GTCTGATG"",""instruments"":[],""seq_in_adapter"":""CATCAGAC""}], + ""BI7B07"":[{""seq"":""CCAACATT"",""instruments"":[],""seq_in_adapter"":""AATGTTGG""}], + ""BI7B08"":[{""seq"":""CAACTCTC"",""instruments"":[],""seq_in_adapter"":""GAGAGTTG""}], + ""BI7B09"":[{""seq"":""ATTCCTCT"",""instruments"":[],""seq_in_adapter"":""AGAGGAAT""}], + ""BI7B10"":[{""seq"":""CTAACTCG"",""instruments"":[],""seq_in_adapter"":""CGAGTTAG""}], + ""BI7B11"":[{""seq"":""CTGCGGAT"",""instruments"":[],""seq_in_adapter"":""ATCCGCAG""}], + ""BI7B12"":[{""seq"":""CTACCAGG"",""instruments"":[],""seq_in_adapter"":""CCTGGTAG""}], + ""BI7C01"":[{""seq"":""GCACATCT"",""instruments"":[],""seq_in_adapter"":""AGATGTGC""}], + ""BI7C02"":[{""seq"":""GTATAACA"",""instruments"":[],""seq_in_adapter"":""TGTTATAC""}], + ""BI7C03"":[{""seq"":""CATAGCGA"",""instruments"":[],""seq_in_adapter"":""TCGCTATG""}], + ""BI7C04"":[{""seq"":""GACAGTAA"",""instruments"":[],""seq_in_adapter"":""TTACTGTC""}], + ""BI7C05"":[{""seq"":""TTACGCAC"",""instruments"":[],""seq_in_adapter"":""GTGCGTAA""}], + ""BI7C06"":[{""seq"":""GTCATCTA"",""instruments"":[],""seq_in_adapter"":""TAGATGAC""}], + ""BI7C07"":[{""seq"":""CTGTAATC"",""instruments"":[],""seq_in_adapter"":""GATTACAG""}], + ""BI7C08"":[{""seq"":""GCCGTCGA"",""instruments"":[],""seq_in_adapter"":""TCGACGGC""}], + ""BI7C09"":[{""seq"":""GTAACATC"",""instruments"":[],""seq_in_adapter"":""GATGTTAC""}], + ""BI7C10"":[{""seq"":""GAAGGAAG"",""instruments"":[],""seq_in_adapter"":""CTTCCTTC""}], + ""BI7C11"":[{""seq"":""GACCTAAC"",""instruments"":[],""seq_in_adapter"":""GTTAGGTC""}], + ""BI7C12"":[{""seq"":""ACCAACTG"",""instruments"":[],""seq_in_adapter"":""CAGTTGGT""}], + ""BI7D01"":[{""seq"":""TTCGCTGA"",""instruments"":[],""seq_in_adapter"":""TCAGCGAA""}], + ""BI7D02"":[{""seq"":""TGCTCGAC"",""instruments"":[],""seq_in_adapter"":""GTCGAGCA""}], + ""BI7D03"":[{""seq"":""GGACTCCT"",""instruments"":[],""seq_in_adapter"":""AGGAGTCC""}], + ""BI7D04"":[{""seq"":""CAGGAGCC"",""instruments"":[],""seq_in_adapter"":""GGCTCCTG""}], + ""BI7D05"":[{""seq"":""CCTTCGCA"",""instruments"":[],""seq_in_adapter"":""TGCGAAGG""}], + ""BI7D06"":[{""seq"":""TTGAATAG"",""instruments"":[],""seq_in_adapter"":""CTATTCAA""}], + ""BI7D07"":[{""seq"":""TATCTGCC"",""instruments"":[],""seq_in_adapter"":""GGCAGATA""}], + ""BI7D08"":[{""seq"":""TAAGCACA"",""instruments"":[],""seq_in_adapter"":""TGTGCTTA""}], + ""BI7D09"":[{""seq"":""TCGCTAGA"",""instruments"":[],""seq_in_adapter"":""TCTAGCGA""}], + ""BI7D10"":[{""seq"":""TGTAATCA"",""instruments"":[],""seq_in_adapter"":""TGATTACA""}], + ""BI7D11"":[{""seq"":""TTAATCAG"",""instruments"":[],""seq_in_adapter"":""CTGATTAA""}], + ""BI7D12"":[{""seq"":""TGCAAGTA"",""instruments"":[],""seq_in_adapter"":""TACTTGCA""}], + ""BI7E01"":[{""seq"":""AGCAATTC"",""instruments"":[],""seq_in_adapter"":""GAATTGCT""}], + ""BI7E02"":[{""seq"":""AACTTGAC"",""instruments"":[],""seq_in_adapter"":""GTCAAGTT""}], + ""BI7E03"":[{""seq"":""TGTCGGAT"",""instruments"":[],""seq_in_adapter"":""ATCCGACA""}], + ""BI7E04"":[{""seq"":""TCGCCTTG"",""instruments"":[],""seq_in_adapter"":""CAAGGCGA""}], + ""BI7E05"":[{""seq"":""AAGACACT"",""instruments"":[],""seq_in_adapter"":""AGTGTCTT""}], + ""BI7E06"":[{""seq"":""TCTCGGTC"",""instruments"":[],""seq_in_adapter"":""GACCGAGA""}], + ""BI7E07"":[{""seq"":""AATGTTCT"",""instruments"":[],""seq_in_adapter"":""AGAACATT""}], + ""BI7E08"":[{""seq"":""ACTAAGAC"",""instruments"":[],""seq_in_adapter"":""GTCTTAGT""}], + ""BI7E09"":[{""seq"":""ATTATCAA"",""instruments"":[],""seq_in_adapter"":""TTGATAAT""}], + ""BI7E10"":[{""seq"":""ACAGTTGA"",""instruments"":[],""seq_in_adapter"":""TCAACTGT""}], + ""BI7E11"":[{""seq"":""AGCATGGA"",""instruments"":[],""seq_in_adapter"":""TCCATGCT""}], + ""BI7E12"":[{""seq"":""AGGTGCGA"",""instruments"":[],""seq_in_adapter"":""TCGCACCT""}], + ""BI7F01"":[{""seq"":""CACATCCT"",""instruments"":[],""seq_in_adapter"":""AGGATGTG""}], + ""BI7F02"":[{""seq"":""AGTTGCTT"",""instruments"":[],""seq_in_adapter"":""AAGCAACT""}], + ""BI7F03"":[{""seq"":""ATAGCGTC"",""instruments"":[],""seq_in_adapter"":""GACGCTAT""}], + ""BI7F04"":[{""seq"":""ATTATGTT"",""instruments"":[],""seq_in_adapter"":""AACATAAT""}], + ""BI7F05"":[{""seq"":""ATTGTCTG"",""instruments"":[],""seq_in_adapter"":""CAGACAAT""}], + ""BI7F06"":[{""seq"":""CAGCAAGG"",""instruments"":[],""seq_in_adapter"":""CCTTGCTG""}], + ""BI7F07"":[{""seq"":""CGCCTTCC"",""instruments"":[],""seq_in_adapter"":""GGAAGGCG""}], + ""BI7F08"":[{""seq"":""CAGCGGTA"",""instruments"":[],""seq_in_adapter"":""TACCGCTG""}], + ""BI7F09"":[{""seq"":""CAATAGTC"",""instruments"":[],""seq_in_adapter"":""GACTATTG""}], + ""BI7F10"":[{""seq"":""CTATGCGT"",""instruments"":[],""seq_in_adapter"":""ACGCATAG""}], + ""BI7F11"":[{""seq"":""CTGTGGCG"",""instruments"":[],""seq_in_adapter"":""CGCCACAG""}], + ""BI7F12"":[{""seq"":""CGCTATGT"",""instruments"":[],""seq_in_adapter"":""ACATAGCG""}], + ""BI7G01"":[{""seq"":""CCAGTTAG"",""instruments"":[],""seq_in_adapter"":""CTAACTGG""}], + ""BI7G02"":[{""seq"":""CTCTCTAC"",""instruments"":[],""seq_in_adapter"":""GTAGAGAG""}], + ""BI7G03"":[{""seq"":""CCTACCAT"",""instruments"":[],""seq_in_adapter"":""ATGGTAGG""}], + ""BI7G04"":[{""seq"":""GAAGAAGT"",""instruments"":[],""seq_in_adapter"":""ACTTCTTC""}], + ""BI7G05"":[{""seq"":""TCCAGCAA"",""instruments"":[],""seq_in_adapter"":""TTGCTGGA""}], + ""BI7G06"":[{""seq"":""AAGAGGCA"",""instruments"":[],""seq_in_adapter"":""TGCCTCTT""}], + ""BI7G07"":[{""seq"":""GACCAGGA"",""instruments"":[],""seq_in_adapter"":""TCCTGGTC""}], + ""BI7G08"":[{""seq"":""GCCTAGCC"",""instruments"":[],""seq_in_adapter"":""GGCTAGGC""}], + ""BI7G09"":[{""seq"":""GTCCACAG"",""instruments"":[],""seq_in_adapter"":""CTGTGGAC""}], + ""BI7G10"":[{""seq"":""GACCGTTG"",""instruments"":[],""seq_in_adapter"":""CAACGGTC""}], + ""BI7G11"":[{""seq"":""GATATCCA"",""instruments"":[],""seq_in_adapter"":""TGGATATC""}], + ""BI7G12"":[{""seq"":""GCCGCAAC"",""instruments"":[],""seq_in_adapter"":""GTTGCGGC""}], + ""BI7H01"":[{""seq"":""AAGGATGT"",""instruments"":[],""seq_in_adapter"":""ACATCCTT""}], + ""BI7H02"":[{""seq"":""AGGCAGAA"",""instruments"":[],""seq_in_adapter"":""TTCTGCCT""}], + ""BI7H03"":[{""seq"":""ATTCTAGG"",""instruments"":[],""seq_in_adapter"":""CCTAGAAT""}], + ""BI7H04"":[{""seq"":""TCCTGAGC"",""instruments"":[],""seq_in_adapter"":""GCTCAGGA""}], + ""BI7H05"":[{""seq"":""TAATGAAC"",""instruments"":[],""seq_in_adapter"":""GTTCATTA""}], + ""BI7H06"":[{""seq"":""CCAGAGCT"",""instruments"":[],""seq_in_adapter"":""AGCTCTGG""}], + ""BI7H07"":[{""seq"":""CGTACTAG"",""instruments"":[],""seq_in_adapter"":""CTAGTACG""}], + ""BI7H08"":[{""seq"":""TATCCAGG"",""instruments"":[],""seq_in_adapter"":""CCTGGATA""}], + ""BI7H09"":[{""seq"":""TCTGCAAG"",""instruments"":[],""seq_in_adapter"":""CTTGCAGA""}], + ""BI7H10"":[{""seq"":""TTGTCTAT"",""instruments"":[],""seq_in_adapter"":""ATAGACAA""}], + ""BI7H11"":[{""seq"":""TTATATCT"",""instruments"":[],""seq_in_adapter"":""AGATATAA""}], + ""BI7H12"":[{""seq"":""TAGGCATG"",""instruments"":[],""seq_in_adapter"":""CATGCCTA""}], + }, + ""i5"":{ + ""BI5A01"":[{""seq"":""ATCGACTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCGACTG""}, {""seq"":""CAGTCGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCGACTG""}], + ""BI5A02"":[{""seq"":""CGGTTCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGGTTCTT""}, {""seq"":""AAGAACCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGGTTCTT""}], + ""BI5A03"":[{""seq"":""AACCTCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACCTCTT""}, {""seq"":""AAGAGGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACCTCTT""}], + ""BI5A04"":[{""seq"":""CGCATATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGCATATT""}, {""seq"":""AATATGCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGCATATT""}], + ""BI5A05"":[{""seq"":""CTGCTCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTGCTCCT""}, {""seq"":""AGGAGCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTGCTCCT""}], + ""BI5A06"":[{""seq"":""TAGATCGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGATCGC""}, {""seq"":""GCGATCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGATCGC""}], + ""BI5A07"":[{""seq"":""CCTGTCAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTGTCAT""}, {""seq"":""ATGACAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTGTCAT""}], + ""BI5A08"":[{""seq"":""CACTTCAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACTTCAT""}, {""seq"":""ATGAAGTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACTTCAT""}], + ""BI5A09"":[{""seq"":""AATACCAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AATACCAT""}, {""seq"":""ATGGTATT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AATACCAT""}], + ""BI5A10"":[{""seq"":""ATGAATTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATGAATTA""}, {""seq"":""TAATTCAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATGAATTA""}], + ""BI5A11"":[{""seq"":""TGCTTCAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGCTTCAC""}, {""seq"":""GTGAAGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGCTTCAC""}], + ""BI5A12"":[{""seq"":""ATCCTTAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCCTTAA""}, {""seq"":""TTAAGGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCCTTAA""}], + ""BI5B01"":[{""seq"":""GCTAGCAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTAGCAG""}, {""seq"":""CTGCTAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTAGCAG""}], + ""BI5B02"":[{""seq"":""TAGCATTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGCATTG""}, {""seq"":""CAATGCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGCATTG""}], + ""BI5B03"":[{""seq"":""CTACATTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTACATTG""}, {""seq"":""CAATGTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTACATTG""}], + ""BI5B04"":[{""seq"":""TCATTCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCATTCGA""}, {""seq"":""TCGAATGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCATTCGA""}], + ""BI5B05"":[{""seq"":""TTAGCCAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTAGCCAG""}, {""seq"":""CTGGCTAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTAGCCAG""}], + ""BI5B06"":[{""seq"":""GAACTTCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAACTTCG""}, {""seq"":""CGAAGTTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAACTTCG""}], + ""BI5B07"":[{""seq"":""GACGGTTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACGGTTA""}, {""seq"":""TAACCGTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACGGTTA""}], + ""BI5B08"":[{""seq"":""CAAGCTTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAAGCTTA""}, {""seq"":""TAAGCTTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAAGCTTA""}], + ""BI5B09"":[{""seq"":""TCAGGCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCAGGCTT""}, {""seq"":""AAGCCTGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCAGGCTT""}], + ""BI5B10"":[{""seq"":""TACTCCAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACTCCAG""}, {""seq"":""CTGGAGTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACTCCAG""}], + ""BI5B11"":[{""seq"":""GCTTCCTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTTCCTA""}, {""seq"":""TAGGAAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTTCCTA""}], + ""BI5B12"":[{""seq"":""TTCTTGGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCTTGGC""}, {""seq"":""GCCAAGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCTTGGC""}], + ""BI5C01"":[{""seq"":""TACTCTCC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACTCTCC""}, {""seq"":""GGAGAGTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACTCTCC""}], + ""BI5C02"":[{""seq"":""AATTCAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AATTCAAC""}, {""seq"":""GTTGAATT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AATTCAAC""}], + ""BI5C03"":[{""seq"":""GCGATTAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCGATTAC""}, {""seq"":""GTAATCGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCGATTAC""}], + ""BI5C04"":[{""seq"":""GTCCAATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTCCAATC""}, {""seq"":""GATTGGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTCCAATC""}], + ""BI5C05"":[{""seq"":""GCTGATTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTGATTC""}, {""seq"":""GAATCAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTGATTC""}], + ""BI5C06"":[{""seq"":""CTGTATTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTGTATTC""}, {""seq"":""GAATACAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTGTATTC""}], + ""BI5C07"":[{""seq"":""CTATTAGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTATTAGC""}, {""seq"":""GCTAATAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTATTAGC""}], + ""BI5C08"":[{""seq"":""AGGTACCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGTACCA""}, {""seq"":""TGGTACCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGTACCA""}], + ""BI5C09"":[{""seq"":""GAACGCTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAACGCTA""}, {""seq"":""TAGCGTTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAACGCTA""}], + ""BI5C10"":[{""seq"":""ATCATACC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCATACC""}, {""seq"":""GGTATGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCATACC""}], + ""BI5C11"":[{""seq"":""GACCATCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACCATCT""}, {""seq"":""AGATGGTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACCATCT""}], + ""BI5C12"":[{""seq"":""CATCACTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATCACTT""}, {""seq"":""AAGTGATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATCACTT""}], + ""BI5D01"":[{""seq"":""TGACAGCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGACAGCA""}, {""seq"":""TGCTGTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGACAGCA""}], + ""BI5D02"":[{""seq"":""TTCACAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCACAGA""}, {""seq"":""TCTGTGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCACAGA""}], + ""BI5D03"":[{""seq"":""CTCTCTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCTCTAT""}, {""seq"":""ATAGAGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCTCTAT""}], + ""BI5D04"":[{""seq"":""CTTGGCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTTGGCTT""}, {""seq"":""AAGCCAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTTGGCTT""}], + ""BI5D05"":[{""seq"":""GAATCGAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAATCGAC""}, {""seq"":""GTCGATTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAATCGAC""}], + ""BI5D06"":[{""seq"":""ATATCCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATATCCGA""}, {""seq"":""TCGGATAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATATCCGA""}], + ""BI5D07"":[{""seq"":""TCCAACCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCCAACCA""}, {""seq"":""TGGTTGGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCCAACCA""}], + ""BI5D08"":[{""seq"":""TCCATAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCCATAAC""}, {""seq"":""GTTATGGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCCATAAC""}], + ""BI5D09"":[{""seq"":""CTGACATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTGACATC""}, {""seq"":""GATGTCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTGACATC""}], + ""BI5D10"":[{""seq"":""CCTCTAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTCTAAC""}, {""seq"":""GTTAGAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTCTAAC""}], + ""BI5D11"":[{""seq"":""CTGGTATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTGGTATT""}, {""seq"":""AATACCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTGGTATT""}], + ""BI5D12"":[{""seq"":""CGAACTTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGAACTTC""}, {""seq"":""GAAGTTCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGAACTTC""}], + ""BI5E01"":[{""seq"":""GCAGGTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCAGGTTG""}, {""seq"":""CAACCTGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCAGGTTG""}], + ""BI5E02"":[{""seq"":""GCTCTCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTCTCTT""}, {""seq"":""AAGAGAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTCTCTT""}], + ""BI5E03"":[{""seq"":""AATTGCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AATTGCTT""}, {""seq"":""AAGCAATT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AATTGCTT""}], + ""BI5E04"":[{""seq"":""CCAACGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAACGCT""}, {""seq"":""AGCGTTGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAACGCT""}], + ""BI5E05"":[{""seq"":""AGTCACCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTCACCT""}, {""seq"":""AGGTGACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTCACCT""}], + ""BI5E06"":[{""seq"":""GCGGACTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCGGACTT""}, {""seq"":""AAGTCCGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCGGACTT""}], + ""BI5E07"":[{""seq"":""CTGGCTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTGGCTAT""}, {""seq"":""ATAGCCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTGGCTAT""}], + ""BI5E08"":[{""seq"":""GTCCTCAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTCCTCAT""}, {""seq"":""ATGAGGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTCCTCAT""}], + ""BI5E09"":[{""seq"":""GCCACCAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCCACCAT""}, {""seq"":""ATGGTGGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCCACCAT""}], + ""BI5E10"":[{""seq"":""ATCTTCTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCTTCTC""}, {""seq"":""GAGAAGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCTTCTC""}], + ""BI5E11"":[{""seq"":""TTAATCAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTAATCAC""}, {""seq"":""GTGATTAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTAATCAC""}], + ""BI5E12"":[{""seq"":""GACATTAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACATTAA""}, {""seq"":""TTAATGTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACATTAA""}], + ""BI5F01"":[{""seq"":""TTCCAGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCCAGCT""}, {""seq"":""AGCTGGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCCAGCT""}], + ""BI5F02"":[{""seq"":""TGACTTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGACTTGG""}, {""seq"":""CCAAGTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGACTTGG""}], + ""BI5F03"":[{""seq"":""TTGGTCTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTGGTCTG""}, {""seq"":""CAGACCAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTGGTCTG""}], + ""BI5F04"":[{""seq"":""TCCACTTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCCACTTC""}, {""seq"":""GAAGTGGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCCACTTC""}], + ""BI5F05"":[{""seq"":""CACGATTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACGATTC""}, {""seq"":""GAATCGTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACGATTC""}], + ""BI5F06"":[{""seq"":""GCGATATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCGATATT""}, {""seq"":""AATATCGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCGATATT""}], + ""BI5F07"":[{""seq"":""CAGCGATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGCGATT""}, {""seq"":""AATCGCTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGCGATT""}], + ""BI5F08"":[{""seq"":""AGTACTGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTACTGC""}, {""seq"":""GCAGTACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTACTGC""}], + ""BI5F09"":[{""seq"":""CGACTCTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGACTCTC""}, {""seq"":""GAGAGTCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGACTCTC""}], + ""BI5F10"":[{""seq"":""CAGCTCAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGCTCAC""}, {""seq"":""GTGAGCTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGCTCAC""}], + ""BI5F11"":[{""seq"":""CGCGAATA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGCGAATA""}, {""seq"":""TATTCGCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGCGAATA""}], + ""BI5F12"":[{""seq"":""TTCACCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCACCTT""}, {""seq"":""AAGGTGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCACCTT""}], + ""BI5G01"":[{""seq"":""TAGTTAGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGTTAGC""}, {""seq"":""GCTAACTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGTTAGC""}], + ""BI5G02"":[{""seq"":""TATCCTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TATCCTCT""}, {""seq"":""AGAGGATA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TATCCTCT""}], + ""BI5G03"":[{""seq"":""CATCCTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATCCTGG""}, {""seq"":""CCAGGATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATCCTGG""}], + ""BI5G04"":[{""seq"":""AATCTCCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AATCTCCA""}, {""seq"":""TGGAGATT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AATCTCCA""}], + ""BI5G05"":[{""seq"":""GCTCCGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTCCGAT""}, {""seq"":""ATCGGAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTCCGAT""}], + ""BI5G06"":[{""seq"":""AGAGTAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGAGTAGA""}, {""seq"":""TCTACTCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGAGTAGA""}], + ""BI5G07"":[{""seq"":""CCATCACA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCATCACA""}, {""seq"":""TGTGATGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCATCACA""}], + ""BI5G08"":[{""seq"":""CTTGAATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTTGAATC""}, {""seq"":""GATTCAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTTGAATC""}], + ""BI5G09"":[{""seq"":""TGCTATTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGCTATTA""}, {""seq"":""TAATAGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGCTATTA""}], + ""BI5G10"":[{""seq"":""GGTTATCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GGTTATCT""}, {""seq"":""AGATAACC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GGTTATCT""}], + ""BI5G11"":[{""seq"":""GCTCACCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTCACCA""}, {""seq"":""TGGTGAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTCACCA""}], + ""BI5G12"":[{""seq"":""CCAATCTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAATCTG""}, {""seq"":""CAGATTGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAATCTG""}], + ""BI5H01"":[{""seq"":""AGCGCTAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCGCTAA""}, {""seq"":""TTAGCGCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCGCTAA""}], + ""BI5H02"":[{""seq"":""GTAAGGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTAAGGAG""}, {""seq"":""CTCCTTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTAAGGAG""}], + ""BI5H03"":[{""seq"":""GGATTAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GGATTAAC""}, {""seq"":""GTTAATCC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GGATTAAC""}], + ""BI5H04"":[{""seq"":""ACTGCATA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTGCATA""}, {""seq"":""TATGCAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTGCATA""}], + ""BI5H05"":[{""seq"":""GCACAATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCACAATT""}, {""seq"":""AATTGTGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCACAATT""}], + ""BI5H06"":[{""seq"":""CAACTGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAACTGAT""}, {""seq"":""ATCAGTTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAACTGAT""}], + ""BI5H07"":[{""seq"":""AAGGAGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGGAGTA""}, {""seq"":""TACTCCTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGGAGTA""}], + ""BI5H08"":[{""seq"":""CCAACTAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAACTAA""}, {""seq"":""TTAGTTGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAACTAA""}], + ""BI5H09"":[{""seq"":""CTTCTGGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTTCTGGC""}, {""seq"":""GCCAGAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTTCTGGC""}], + ""BI5H10"":[{""seq"":""TCCGCATA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCCGCATA""}, {""seq"":""TATGCGGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCCGCATA""}], + ""BI5H11"":[{""seq"":""TCATGTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCATGTCT""}, {""seq"":""AGACATGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCATGTCT""}], + ""BI5H12"":[{""seq"":""CTAAGCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTAAGCCT""}, {""seq"":""AGGCTTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTAAGCCT""}], + } + }, + ""Additional Pardis Sabeti Lab NEXTERAINDEXPL"":{ + ""_short_name"":""PS_nextera"", + ""i7"":{ + ""PS7A01"":[{""seq"":""CTCTACTT"",""instruments"":[],""seq_in_adapter"":""AAGTAGAG""}], + ""PS7A02"":[{""seq"":""GATCGTGT"",""instruments"":[],""seq_in_adapter"":""ACACGATC""}], + ""PS7B01"":[{""seq"":""TCTGGACC"",""instruments"":[],""seq_in_adapter"":""GGTCCAGA""}], + ""PS7B02"":[{""seq"":""TAAGCATG"",""instruments"":[],""seq_in_adapter"":""CATGCTTA""}], + ""PS7C01"":[{""seq"":""AGATGTGC"",""instruments"":[],""seq_in_adapter"":""GCACATCT""}], + ""PS7C02"":[{""seq"":""TGTTATAC"",""instruments"":[],""seq_in_adapter"":""GTATAACA""}], + ""PS7D01"":[{""seq"":""TCAGCGAA"",""instruments"":[],""seq_in_adapter"":""TTCGCTGA""}], + ""PS7D02"":[{""seq"":""GTCGAGCA"",""instruments"":[],""seq_in_adapter"":""TGCTCGAC""}], + ""PS7E01"":[{""seq"":""GAATTGCT"",""instruments"":[],""seq_in_adapter"":""AGCAATTC""}], + ""PS7F01"":[{""seq"":""AGGATGTG"",""instruments"":[],""seq_in_adapter"":""CACATCCT""}], + ""PS7G01"":[{""seq"":""CTAACTGG"",""instruments"":[],""seq_in_adapter"":""CCAGTTAG""}], + ""PS7H01"":[{""seq"":""ACATCCTT"",""instruments"":[],""seq_in_adapter"":""AAGGATGT""}], + } + }, + ""IDT xGen UDI-UMI"":{ + ""_short_name"":""xGen_UDI-UMI"", + ""i7"":{ + ""X7001"":[{""seq"":""CTGATCGT"",""instruments"":[],""seq_in_adapter"":""ACGATCAG""}], + ""X7002"":[{""seq"":""ACTCTCGA"",""instruments"":[],""seq_in_adapter"":""TCGAGAGT""}], + ""X7003"":[{""seq"":""TGAGCTAG"",""instruments"":[],""seq_in_adapter"":""CTAGCTCA""}], + ""X7004"":[{""seq"":""GAGACGAT"",""instruments"":[],""seq_in_adapter"":""ATCGTCTC""}], + ""X7005"":[{""seq"":""CTTGTCGA"",""instruments"":[],""seq_in_adapter"":""TCGACAAG""}], + ""X7006"":[{""seq"":""TTCCAAGG"",""instruments"":[],""seq_in_adapter"":""CCTTGGAA""}], + ""X7007"":[{""seq"":""CGCATGAT"",""instruments"":[],""seq_in_adapter"":""ATCATGCG""}], + ""X7008"":[{""seq"":""ACGGAACA"",""instruments"":[],""seq_in_adapter"":""TGTTCCGT""}], + ""X7009"":[{""seq"":""CGGCTAAT"",""instruments"":[],""seq_in_adapter"":""ATTAGCCG""}], + ""X7010"":[{""seq"":""ATCGATCG"",""instruments"":[],""seq_in_adapter"":""CGATCGAT""}], + ""X7011"":[{""seq"":""GCAAGATC"",""instruments"":[],""seq_in_adapter"":""GATCTTGC""}], + ""X7012"":[{""seq"":""GCTATCCT"",""instruments"":[],""seq_in_adapter"":""AGGATAGC""}], + ""X7013"":[{""seq"":""TACGCTAC"",""instruments"":[],""seq_in_adapter"":""GTAGCGTA""}], + ""X7014"":[{""seq"":""TGGACTCT"",""instruments"":[],""seq_in_adapter"":""AGAGTCCA""}], + ""X7015"":[{""seq"":""AGAGTAGC"",""instruments"":[],""seq_in_adapter"":""GCTACTCT""}], + ""X7016"":[{""seq"":""ATCCAGAG"",""instruments"":[],""seq_in_adapter"":""CTCTGGAT""}], + ""X7017"":[{""seq"":""GACGATCT"",""instruments"":[],""seq_in_adapter"":""AGATCGTC""}], + ""X7018"":[{""seq"":""AACTGAGC"",""instruments"":[],""seq_in_adapter"":""GCTCAGTT""}], + ""X7019"":[{""seq"":""CTTAGGAC"",""instruments"":[],""seq_in_adapter"":""GTCCTAAG""}], + ""X7020"":[{""seq"":""GTGCCATA"",""instruments"":[],""seq_in_adapter"":""TATGGCAC""}], + ""X7021"":[{""seq"":""GAATCCGA"",""instruments"":[],""seq_in_adapter"":""TCGGATTC""}], + ""X7022"":[{""seq"":""TCGCTGTT"",""instruments"":[],""seq_in_adapter"":""AACAGCGA""}], + ""X7023"":[{""seq"":""TTCGTTGG"",""instruments"":[],""seq_in_adapter"":""CCAACGAA""}], + ""X7024"":[{""seq"":""AAGCACTG"",""instruments"":[],""seq_in_adapter"":""CAGTGCTT""}], + ""X7025"":[{""seq"":""CCTTGATC"",""instruments"":[],""seq_in_adapter"":""GATCAAGG""}], + ""X7026"":[{""seq"":""GTCGAAGA"",""instruments"":[],""seq_in_adapter"":""TCTTCGAC""}], + ""X7027"":[{""seq"":""ACCACGAT"",""instruments"":[],""seq_in_adapter"":""ATCGTGGT""}], + ""X7028"":[{""seq"":""GATTACCG"",""instruments"":[],""seq_in_adapter"":""CGGTAATC""}], + ""X7029"":[{""seq"":""GCACAACT"",""instruments"":[],""seq_in_adapter"":""AGTTGTGC""}], + ""X7030"":[{""seq"":""GCGTCATT"",""instruments"":[],""seq_in_adapter"":""AATGACGC""}], + ""X7031"":[{""seq"":""ATCCGGTA"",""instruments"":[],""seq_in_adapter"":""TACCGGAT""}], + ""X7032"":[{""seq"":""CGTTGCAA"",""instruments"":[],""seq_in_adapter"":""TTGCAACG""}], + ""X7033"":[{""seq"":""GTGAAGTG"",""instruments"":[],""seq_in_adapter"":""CACTTCAC""}], + ""X7034"":[{""seq"":""CATGGCTA"",""instruments"":[],""seq_in_adapter"":""TAGCCATG""}], + ""X7035"":[{""seq"":""ATGCCTGT"",""instruments"":[],""seq_in_adapter"":""ACAGGCAT""}], + ""X7036"":[{""seq"":""CAACACCT"",""instruments"":[],""seq_in_adapter"":""AGGTGTTG""}], + ""X7037"":[{""seq"":""TGTGACTG"",""instruments"":[],""seq_in_adapter"":""CAGTCACA""}], + ""X7038"":[{""seq"":""GTCATCGA"",""instruments"":[],""seq_in_adapter"":""TCGATGAC""}], + ""X7039"":[{""seq"":""AGCACTTC"",""instruments"":[],""seq_in_adapter"":""GAAGTGCT""}], + ""X7040"":[{""seq"":""GAAGGAAG"",""instruments"":[],""seq_in_adapter"":""CTTCCTTC""}], + ""X7041"":[{""seq"":""GTTGTTCG"",""instruments"":[],""seq_in_adapter"":""CGAACAAC""}], + ""X7042"":[{""seq"":""CGGTTGTT"",""instruments"":[],""seq_in_adapter"":""AACAACCG""}], + ""X7043"":[{""seq"":""ACTGAGGT"",""instruments"":[],""seq_in_adapter"":""ACCTCAGT""}], + ""X7044"":[{""seq"":""TGAAGACG"",""instruments"":[],""seq_in_adapter"":""CGTCTTCA""}], + ""X7045"":[{""seq"":""GTTACGCA"",""instruments"":[],""seq_in_adapter"":""TGCGTAAC""}], + ""X7046"":[{""seq"":""AGCGTGTT"",""instruments"":[],""seq_in_adapter"":""AACACGCT""}], + ""X7047"":[{""seq"":""GATCGAGT"",""instruments"":[],""seq_in_adapter"":""ACTCGATC""}], + ""X7048"":[{""seq"":""ACAGCTCA"",""instruments"":[],""seq_in_adapter"":""TGAGCTGT""}], + ""X7049"":[{""seq"":""GAGCAGTA"",""instruments"":[],""seq_in_adapter"":""TACTGCTC""}], + ""X7050"":[{""seq"":""AGTTCGTC"",""instruments"":[],""seq_in_adapter"":""GACGAACT""}], + ""X7051"":[{""seq"":""TTGCGAAG"",""instruments"":[],""seq_in_adapter"":""CTTCGCAA""}], + ""X7052"":[{""seq"":""ATCGCCAT"",""instruments"":[],""seq_in_adapter"":""ATGGCGAT""}], + ""X7053"":[{""seq"":""TGGCATGT"",""instruments"":[],""seq_in_adapter"":""ACATGCCA""}], + ""X7054"":[{""seq"":""CTGTTGAC"",""instruments"":[],""seq_in_adapter"":""GTCAACAG""}], + ""X7055"":[{""seq"":""CATACCAC"",""instruments"":[],""seq_in_adapter"":""GTGGTATG""}], + ""X7056"":[{""seq"":""GAAGTTGG"",""instruments"":[],""seq_in_adapter"":""CCAACTTC""}], + ""X7057"":[{""seq"":""ATGACGTC"",""instruments"":[],""seq_in_adapter"":""GACGTCAT""}], + ""X7058"":[{""seq"":""TTGGACGT"",""instruments"":[],""seq_in_adapter"":""ACGTCCAA""}], + ""X7059"":[{""seq"":""AGTGGATC"",""instruments"":[],""seq_in_adapter"":""GATCCACT""}], + ""X7060"":[{""seq"":""GATAGGCT"",""instruments"":[],""seq_in_adapter"":""AGCCTATC""}], + ""X7061"":[{""seq"":""TGGTAGCT"",""instruments"":[],""seq_in_adapter"":""AGCTACCA""}], + ""X7062"":[{""seq"":""CGCAATCT"",""instruments"":[],""seq_in_adapter"":""AGATTGCG""}], + ""X7063"":[{""seq"":""GATGTGTG"",""instruments"":[],""seq_in_adapter"":""CACACATC""}], + ""X7064"":[{""seq"":""GATTGCTC"",""instruments"":[],""seq_in_adapter"":""GAGCAATC""}], + ""X7065"":[{""seq"":""CGCTCTAT"",""instruments"":[],""seq_in_adapter"":""ATAGAGCG""}], + ""X7066"":[{""seq"":""TATCGGTC"",""instruments"":[],""seq_in_adapter"":""GACCGATA""}], + ""X7067"":[{""seq"":""AACGTCTG"",""instruments"":[],""seq_in_adapter"":""CAGACGTT""}], + ""X7068"":[{""seq"":""ACGTTCAG"",""instruments"":[],""seq_in_adapter"":""CTGAACGT""}], + ""X7069"":[{""seq"":""CAGTCCAA"",""instruments"":[],""seq_in_adapter"":""TTGGACTG""}], + ""X7070"":[{""seq"":""TTGCAGAC"",""instruments"":[],""seq_in_adapter"":""GTCTGCAA""}], + ""X7071"":[{""seq"":""CAATGTGG"",""instruments"":[],""seq_in_adapter"":""CCACATTG""}], + ""X7072"":[{""seq"":""ACTCCATC"",""instruments"":[],""seq_in_adapter"":""GATGGAGT""}], + ""X7073"":[{""seq"":""GTTGACCT"",""instruments"":[],""seq_in_adapter"":""AGGTCAAC""}], + ""X7074"":[{""seq"":""CGTGTGTA"",""instruments"":[],""seq_in_adapter"":""TACACACG""}], + ""X7075"":[{""seq"":""ACGACTTG"",""instruments"":[],""seq_in_adapter"":""CAAGTCGT""}], + ""X7076"":[{""seq"":""CACTAGCT"",""instruments"":[],""seq_in_adapter"":""AGCTAGTG""}], + ""X7077"":[{""seq"":""ACTAGGAG"",""instruments"":[],""seq_in_adapter"":""CTCCTAGT""}], + ""X7078"":[{""seq"":""GTAGGAGT"",""instruments"":[],""seq_in_adapter"":""ACTCCTAC""}], + ""X7079"":[{""seq"":""CCTGATTG"",""instruments"":[],""seq_in_adapter"":""CAATCAGG""}], + ""X7080"":[{""seq"":""ATGCACGA"",""instruments"":[],""seq_in_adapter"":""TCGTGCAT""}], + ""X7081"":[{""seq"":""CGACGTTA"",""instruments"":[],""seq_in_adapter"":""TAACGTCG""}], + ""X7082"":[{""seq"":""TACGCCTT"",""instruments"":[],""seq_in_adapter"":""AAGGCGTA""}], + ""X7083"":[{""seq"":""CCGTAAGA"",""instruments"":[],""seq_in_adapter"":""TCTTACGG""}], + ""X7084"":[{""seq"":""ATCACACG"",""instruments"":[],""seq_in_adapter"":""CGTGTGAT""}], + ""X7085"":[{""seq"":""CACCTGTT"",""instruments"":[],""seq_in_adapter"":""AACAGGTG""}], + ""X7086"":[{""seq"":""CTTCGACT"",""instruments"":[],""seq_in_adapter"":""AGTCGAAG""}], + ""X7087"":[{""seq"":""TGCTTCCA"",""instruments"":[],""seq_in_adapter"":""TGGAAGCA""}], + ""X7088"":[{""seq"":""AGAACGAG"",""instruments"":[],""seq_in_adapter"":""CTCGTTCT""}], + ""X7089"":[{""seq"":""GTTCTCGT"",""instruments"":[],""seq_in_adapter"":""ACGAGAAC""}], + ""X7090"":[{""seq"":""TCAGGCTT"",""instruments"":[],""seq_in_adapter"":""AAGCCTGA""}], + ""X7091"":[{""seq"":""CCTTGTAG"",""instruments"":[],""seq_in_adapter"":""CTACAAGG""}], + ""X7092"":[{""seq"":""GAACATCG"",""instruments"":[],""seq_in_adapter"":""CGATGTTC""}], + ""X7093"":[{""seq"":""TAACCGGT"",""instruments"":[],""seq_in_adapter"":""ACCGGTTA""}], + ""X7094"":[{""seq"":""AACCGTTC"",""instruments"":[],""seq_in_adapter"":""GAACGGTT""}], + ""X7095"":[{""seq"":""TGGTACAG"",""instruments"":[],""seq_in_adapter"":""CTGTACCA""}], + ""X7096"":[{""seq"":""ATATGCGC"",""instruments"":[],""seq_in_adapter"":""GCGCATAT""}], + ""X7097"":[{""seq"":""GCCTATCA"",""instruments"":[],""seq_in_adapter"":""TGATAGGC""}], + ""X7098"":[{""seq"":""CTTGGATG"",""instruments"":[],""seq_in_adapter"":""CATCCAAG""}], + ""X7099"":[{""seq"":""AGTCTCAC"",""instruments"":[],""seq_in_adapter"":""GTGAGACT""}], + ""X7100"":[{""seq"":""CTCATCAG"",""instruments"":[],""seq_in_adapter"":""CTGATGAG""}], + ""X7101"":[{""seq"":""TGTACCGT"",""instruments"":[],""seq_in_adapter"":""ACGGTACA""}], + ""X7102"":[{""seq"":""AAGTCGAG"",""instruments"":[],""seq_in_adapter"":""CTCGACTT""}], + ""X7103"":[{""seq"":""CACGTTGT"",""instruments"":[],""seq_in_adapter"":""ACAACGTG""}], + ""X7104"":[{""seq"":""TCACAGCA"",""instruments"":[],""seq_in_adapter"":""TGCTGTGA""}], + ""X7105"":[{""seq"":""CTACTTGG"",""instruments"":[],""seq_in_adapter"":""CCAAGTAG""}], + ""X7106"":[{""seq"":""CCTCAGTT"",""instruments"":[],""seq_in_adapter"":""AACTGAGG""}], + ""X7107"":[{""seq"":""TCCTACCT"",""instruments"":[],""seq_in_adapter"":""AGGTAGGA""}], + ""X7108"":[{""seq"":""ATGGCGAA"",""instruments"":[],""seq_in_adapter"":""TTCGCCAT""}], + ""X7109"":[{""seq"":""CTTACCTG"",""instruments"":[],""seq_in_adapter"":""CAGGTAAG""}], + ""X7110"":[{""seq"":""CTCGATAC"",""instruments"":[],""seq_in_adapter"":""GTATCGAG""}], + ""X7111"":[{""seq"":""TCCGTGAA"",""instruments"":[],""seq_in_adapter"":""TTCACGGA""}], + ""X7112"":[{""seq"":""TAGAGCTC"",""instruments"":[],""seq_in_adapter"":""GAGCTCTA""}], + ""X7113"":[{""seq"":""TGACTGAC"",""instruments"":[],""seq_in_adapter"":""GTCAGTCA""}], + ""X7114"":[{""seq"":""TAGACGTG"",""instruments"":[],""seq_in_adapter"":""CACGTCTA""}], + ""X7115"":[{""seq"":""CCGGAATT"",""instruments"":[],""seq_in_adapter"":""AATTCCGG""}], + ""X7116"":[{""seq"":""CTCCTAGA"",""instruments"":[],""seq_in_adapter"":""TCTAGGAG""}], + ""X7117"":[{""seq"":""CAACGGAT"",""instruments"":[],""seq_in_adapter"":""ATCCGTTG""}], + ""X7118"":[{""seq"":""TGGCTATC"",""instruments"":[],""seq_in_adapter"":""GATAGCCA""}], + ""X7119"":[{""seq"":""CGGTCATA"",""instruments"":[],""seq_in_adapter"":""TATGACCG""}], + ""X7120"":[{""seq"":""TCCAATCG"",""instruments"":[],""seq_in_adapter"":""CGATTGGA""}], + ""X7121"":[{""seq"":""GAGCTTGT"",""instruments"":[],""seq_in_adapter"":""ACAAGCTC""}], + ""X7122"":[{""seq"":""GAAGGTTC"",""instruments"":[],""seq_in_adapter"":""GAACCTTC""}], + ""X7123"":[{""seq"":""ATCTCGCT"",""instruments"":[],""seq_in_adapter"":""AGCGAGAT""}], + ""X7124"":[{""seq"":""AGTTACGG"",""instruments"":[],""seq_in_adapter"":""CCGTAACT""}], + ""X7125"":[{""seq"":""GTGTCTGA"",""instruments"":[],""seq_in_adapter"":""TCAGACAC""}], + ""X7126"":[{""seq"":""TGACTTCG"",""instruments"":[],""seq_in_adapter"":""CGAAGTCA""}], + ""X7127"":[{""seq"":""TGGATCAC"",""instruments"":[],""seq_in_adapter"":""GTGATCCA""}], + ""X7128"":[{""seq"":""ACACCAGT"",""instruments"":[],""seq_in_adapter"":""ACTGGTGT""}], + ""X7129"":[{""seq"":""CAGGTTAG"",""instruments"":[],""seq_in_adapter"":""CTAACCTG""}], + ""X7130"":[{""seq"":""AGTTGGCT"",""instruments"":[],""seq_in_adapter"":""AGCCAACT""}], + ""X7131"":[{""seq"":""TCAACTGG"",""instruments"":[],""seq_in_adapter"":""CCAGTTGA""}], + ""X7132"":[{""seq"":""CTGCACTT"",""instruments"":[],""seq_in_adapter"":""AAGTGCAG""}], + ""X7133"":[{""seq"":""ACACGGTT"",""instruments"":[],""seq_in_adapter"":""AACCGTGT""}], + ""X7134"":[{""seq"":""AATACGCG"",""instruments"":[],""seq_in_adapter"":""CGCGTATT""}], + ""X7135"":[{""seq"":""TGCGAACT"",""instruments"":[],""seq_in_adapter"":""AGTTCGCA""}], + ""X7136"":[{""seq"":""GCTGACTA"",""instruments"":[],""seq_in_adapter"":""TAGTCAGC""}], + ""X7137"":[{""seq"":""GTGGTGTT"",""instruments"":[],""seq_in_adapter"":""AACACCAC""}], + ""X7138"":[{""seq"":""GTGCTTAC"",""instruments"":[],""seq_in_adapter"":""GTAAGCAC""}], + ""X7139"":[{""seq"":""TCAAGGAC"",""instruments"":[],""seq_in_adapter"":""GTCCTTGA""}], + ""X7140"":[{""seq"":""TGAACCTG"",""instruments"":[],""seq_in_adapter"":""CAGGTTCA""}], + ""X7141"":[{""seq"":""AGTGTTGG"",""instruments"":[],""seq_in_adapter"":""CCAACACT""}], + ""X7142"":[{""seq"":""GTACTCTC"",""instruments"":[],""seq_in_adapter"":""GAGAGTAC""}], + ""X7143"":[{""seq"":""CCGTATCT"",""instruments"":[],""seq_in_adapter"":""AGATACGG""}], + ""X7144"":[{""seq"":""CGAAGAAC"",""instruments"":[],""seq_in_adapter"":""GTTCTTCG""}], + ""X7145"":[{""seq"":""AGCGGAAT"",""instruments"":[],""seq_in_adapter"":""ATTCCGCT""}], + ""X7146"":[{""seq"":""GTGAGCTT"",""instruments"":[],""seq_in_adapter"":""AAGCTCAC""}], + ""X7147"":[{""seq"":""CGTGATCA"",""instruments"":[],""seq_in_adapter"":""TGATCACG""}], + ""X7148"":[{""seq"":""TCGCATTG"",""instruments"":[],""seq_in_adapter"":""CAATGCGA""}], + ""X7149"":[{""seq"":""TGACGCAT"",""instruments"":[],""seq_in_adapter"":""ATGCGTCA""}], + ""X7150"":[{""seq"":""CCGATGTA"",""instruments"":[],""seq_in_adapter"":""TACATCGG""}], + ""X7151"":[{""seq"":""TTCGCAGT"",""instruments"":[],""seq_in_adapter"":""ACTGCGAA""}], + ""X7152"":[{""seq"":""ACGACAGA"",""instruments"":[],""seq_in_adapter"":""TCTGTCGT""}], + ""X7153"":[{""seq"":""AGCTTGAG"",""instruments"":[],""seq_in_adapter"":""CTCAAGCT""}], + ""X7154"":[{""seq"":""GAGTGGTT"",""instruments"":[],""seq_in_adapter"":""AACCACTC""}], + ""X7155"":[{""seq"":""GCTGTAAG"",""instruments"":[],""seq_in_adapter"":""CTTACAGC""}], + ""X7156"":[{""seq"":""CCAAGACT"",""instruments"":[],""seq_in_adapter"":""AGTCTTGG""}], + ""X7157"":[{""seq"":""ATTGCGTG"",""instruments"":[],""seq_in_adapter"":""CACGCAAT""}], + ""X7158"":[{""seq"":""CTGAAGCT"",""instruments"":[],""seq_in_adapter"":""AGCTTCAG""}], + ""X7159"":[{""seq"":""TAACGAGG"",""instruments"":[],""seq_in_adapter"":""CCTCGTTA""}], + ""X7160"":[{""seq"":""TCGTCTCA"",""instruments"":[],""seq_in_adapter"":""TGAGACGA""}], + ""X7161"":[{""seq"":""TTCCTGTG"",""instruments"":[],""seq_in_adapter"":""CACAGGAA""}], + ""X7162"":[{""seq"":""CGTTGAGT"",""instruments"":[],""seq_in_adapter"":""ACTCAACG""}], + ""X7163"":[{""seq"":""AGTCGCTT"",""instruments"":[],""seq_in_adapter"":""AAGCGACT""}], + ""X7164"":[{""seq"":""TAGGTAGG"",""instruments"":[],""seq_in_adapter"":""CCTACCTA""}], + ""X7165"":[{""seq"":""CAGGAGAT"",""instruments"":[],""seq_in_adapter"":""ATCTCCTG""}], + ""X7166"":[{""seq"":""CATCGTGA"",""instruments"":[],""seq_in_adapter"":""TCACGATG""}], + ""X7167"":[{""seq"":""TGTTGTGG"",""instruments"":[],""seq_in_adapter"":""CCACAACA""}], + ""X7168"":[{""seq"":""ACAGACCT"",""instruments"":[],""seq_in_adapter"":""AGGTCTGT""}], + ""X7169"":[{""seq"":""GTCCTTCT"",""instruments"":[],""seq_in_adapter"":""AGAAGGAC""}], + ""X7170"":[{""seq"":""TGATACGC"",""instruments"":[],""seq_in_adapter"":""GCGTATCA""}], + ""X7171"":[{""seq"":""CTGTGTTG"",""instruments"":[],""seq_in_adapter"":""CAACACAG""}], + ""X7172"":[{""seq"":""AACGTGGA"",""instruments"":[],""seq_in_adapter"":""TCCACGTT""}], + ""X7173"":[{""seq"":""GTTGCGAT"",""instruments"":[],""seq_in_adapter"":""ATCGCAAC""}], + ""X7174"":[{""seq"":""AACGACGT"",""instruments"":[],""seq_in_adapter"":""ACGTCGTT""}], + ""X7175"":[{""seq"":""CGTATTCG"",""instruments"":[],""seq_in_adapter"":""CGAATACG""}], + ""X7176"":[{""seq"":""AGCAAGCA"",""instruments"":[],""seq_in_adapter"":""TGCTTGCT""}], + ""X7177"":[{""seq"":""TGTTCGAG"",""instruments"":[],""seq_in_adapter"":""CTCGAACA""}], + ""X7178"":[{""seq"":""CTCCATGT"",""instruments"":[],""seq_in_adapter"":""ACATGGAG""}], + ""X7179"":[{""seq"":""CGTCTTGT"",""instruments"":[],""seq_in_adapter"":""ACAAGACG""}], + ""X7180"":[{""seq"":""ATAAGGCG"",""instruments"":[],""seq_in_adapter"":""CGCCTTAT""}], + ""X7181"":[{""seq"":""TGTCTGCT"",""instruments"":[],""seq_in_adapter"":""AGCAGACA""}], + ""X7182"":[{""seq"":""CGCTTAAC"",""instruments"":[],""seq_in_adapter"":""GTTAAGCG""}], + ""X7183"":[{""seq"":""GATCCATG"",""instruments"":[],""seq_in_adapter"":""CATGGATC""}], + ""X7184"":[{""seq"":""ACCTCTGT"",""instruments"":[],""seq_in_adapter"":""ACAGAGGT""}], + ""X7185"":[{""seq"":""GCCACTTA"",""instruments"":[],""seq_in_adapter"":""TAAGTGGC""}], + ""X7186"":[{""seq"":""ACCTGACT"",""instruments"":[],""seq_in_adapter"":""AGTCAGGT""}], + ""X7187"":[{""seq"":""GTTAAGGC"",""instruments"":[],""seq_in_adapter"":""GCCTTAAC""}], + ""X7188"":[{""seq"":""ATGCCAAC"",""instruments"":[],""seq_in_adapter"":""GTTGGCAT""}], + ""X7189"":[{""seq"":""AGAGGTTG"",""instruments"":[],""seq_in_adapter"":""CAACCTCT""}], + ""X7190"":[{""seq"":""ACCATCCA"",""instruments"":[],""seq_in_adapter"":""TGGATGGT""}], + ""X7191"":[{""seq"":""GTGGATAG"",""instruments"":[],""seq_in_adapter"":""CTATCCAC""}], + ""X7192"":[{""seq"":""CTGAGATC"",""instruments"":[],""seq_in_adapter"":""GATCTCAG""}], + ""X7193"":[{""seq"":""CTTCGTTC"",""instruments"":[],""seq_in_adapter"":""GAACGAAG""}], + ""X7194"":[{""seq"":""GTCTAGGT"",""instruments"":[],""seq_in_adapter"":""ACCTAGAC""}], + ""X7195"":[{""seq"":""ACGTCGTA"",""instruments"":[],""seq_in_adapter"":""TACGACGT""}], + ""X7196"":[{""seq"":""GAGCTCAA"",""instruments"":[],""seq_in_adapter"":""TTGAGCTC""}], + ""X7197"":[{""seq"":""CGTGTACT"",""instruments"":[],""seq_in_adapter"":""AGTACACG""}], + ""X7198"":[{""seq"":""CACTGACA"",""instruments"":[],""seq_in_adapter"":""TGTCAGTG""}], + ""X7199"":[{""seq"":""TCGTAGTC"",""instruments"":[],""seq_in_adapter"":""GACTACGA""}], + ""X7200"":[{""seq"":""GCACGTAA"",""instruments"":[],""seq_in_adapter"":""TTACGTGC""}], + ""X7201"":[{""seq"":""CAAGCAGT"",""instruments"":[],""seq_in_adapter"":""ACTGCTTG""}], + ""X7202"":[{""seq"":""ACATAGGC"",""instruments"":[],""seq_in_adapter"":""GCCTATGT""}], + ""X7203"":[{""seq"":""TGTGGTAC"",""instruments"":[],""seq_in_adapter"":""GTACCACA""}], + ""X7204"":[{""seq"":""CACCACTA"",""instruments"":[],""seq_in_adapter"":""TAGTGGTG""}], + ""X7205"":[{""seq"":""CTGCGTAT"",""instruments"":[],""seq_in_adapter"":""ATACGCAG""}], + ""X7206"":[{""seq"":""ACGGTCTT"",""instruments"":[],""seq_in_adapter"":""AAGACCGT""}], + ""X7207"":[{""seq"":""GATTGGAG"",""instruments"":[],""seq_in_adapter"":""CTCCAATC""}], + ""X7208"":[{""seq"":""TGTCCAGA"",""instruments"":[],""seq_in_adapter"":""TCTGGACA""}], + ""X7209"":[{""seq"":""CCAGTGTT"",""instruments"":[],""seq_in_adapter"":""AACACTGG""}], + ""X7210"":[{""seq"":""TGCACCAA"",""instruments"":[],""seq_in_adapter"":""TTGGTGCA""}], + ""X7211"":[{""seq"":""TTGACAGG"",""instruments"":[],""seq_in_adapter"":""CCTGTCAA""}], + ""X7212"":[{""seq"":""AGGCATAG"",""instruments"":[],""seq_in_adapter"":""CTATGCCT""}], + ""X7213"":[{""seq"":""TAGCCGAA"",""instruments"":[],""seq_in_adapter"":""TTCGGCTA""}], + ""X7214"":[{""seq"":""TTGTCGGT"",""instruments"":[],""seq_in_adapter"":""ACCGACAA""}], + ""X7215"":[{""seq"":""CATCTACG"",""instruments"":[],""seq_in_adapter"":""CGTAGATG""}], + ""X7216"":[{""seq"":""GCATACAG"",""instruments"":[],""seq_in_adapter"":""CTGTATGC""}], + ""X7217"":[{""seq"":""ACAGCAAC"",""instruments"":[],""seq_in_adapter"":""GTTGCTGT""}], + ""X7218"":[{""seq"":""CTGGTTCT"",""instruments"":[],""seq_in_adapter"":""AGAACCAG""}], + ""X7219"":[{""seq"":""TCGACATC"",""instruments"":[],""seq_in_adapter"":""GATGTCGA""}], + ""X7220"":[{""seq"":""AACCTCCT"",""instruments"":[],""seq_in_adapter"":""AGGAGGTT""}], + ""X7221"":[{""seq"":""CAGCGATT"",""instruments"":[],""seq_in_adapter"":""AATCGCTG""}], + ""X7222"":[{""seq"":""AGGTCACT"",""instruments"":[],""seq_in_adapter"":""AGTGACCT""}], + ""X7223"":[{""seq"":""GCAATTCG"",""instruments"":[],""seq_in_adapter"":""CGAATTGC""}], + ""X7224"":[{""seq"":""GCTTCTTG"",""instruments"":[],""seq_in_adapter"":""CAAGAAGC""}], + ""X7225"":[{""seq"":""AACTGGTG"",""instruments"":[],""seq_in_adapter"":""CACCAGTT""}], + ""X7226"":[{""seq"":""CGGAATAC"",""instruments"":[],""seq_in_adapter"":""GTATTCCG""}], + ""X7227"":[{""seq"":""GCTTCGAA"",""instruments"":[],""seq_in_adapter"":""TTCGAAGC""}], + ""X7228"":[{""seq"":""CAAGGTCT"",""instruments"":[],""seq_in_adapter"":""AGACCTTG""}], + ""X7229"":[{""seq"":""AACCTTGG"",""instruments"":[],""seq_in_adapter"":""CCAAGGTT""}], + ""X7230"":[{""seq"":""CCATACGT"",""instruments"":[],""seq_in_adapter"":""ACGTATGG""}], + ""X7231"":[{""seq"":""TGGTCCTT"",""instruments"":[],""seq_in_adapter"":""AAGGACCA""}], + ""X7232"":[{""seq"":""ACCGCATA"",""instruments"":[],""seq_in_adapter"":""TATGCGGT""}], + ""X7233"":[{""seq"":""CCTTCCTT"",""instruments"":[],""seq_in_adapter"":""AAGGAAGG""}], + ""X7234"":[{""seq"":""TACACGCT"",""instruments"":[],""seq_in_adapter"":""AGCGTGTA""}], + ""X7235"":[{""seq"":""TGCGTAGA"",""instruments"":[],""seq_in_adapter"":""TCTACGCA""}], + ""X7236"":[{""seq"":""AAGAGCCA"",""instruments"":[],""seq_in_adapter"":""TGGCTCTT""}], + ""X7237"":[{""seq"":""ATGGAAGG"",""instruments"":[],""seq_in_adapter"":""CCTTCCAT""}], + ""X7238"":[{""seq"":""GCCAGTAT"",""instruments"":[],""seq_in_adapter"":""ATACTGGC""}], + ""X7239"":[{""seq"":""CGTAGGTT"",""instruments"":[],""seq_in_adapter"":""AACCTACG""}], + ""X7240"":[{""seq"":""CGAGTATG"",""instruments"":[],""seq_in_adapter"":""CATACTCG""}], + ""X7241"":[{""seq"":""CAAGTGCA"",""instruments"":[],""seq_in_adapter"":""TGCACTTG""}], + ""X7242"":[{""seq"":""TCGAGTGA"",""instruments"":[],""seq_in_adapter"":""TCACTCGA""}], + ""X7243"":[{""seq"":""CTACAGTG"",""instruments"":[],""seq_in_adapter"":""CACTGTAG""}], + ""X7244"":[{""seq"":""GATCGTAC"",""instruments"":[],""seq_in_adapter"":""GTACGATC""}], + ""X7245"":[{""seq"":""CTTCACCA"",""instruments"":[],""seq_in_adapter"":""TGGTGAAG""}], + ""X7246"":[{""seq"":""CTCAGCTA"",""instruments"":[],""seq_in_adapter"":""TAGCTGAG""}], + ""X7247"":[{""seq"":""TCTGCTCT"",""instruments"":[],""seq_in_adapter"":""AGAGCAGA""}], + ""X7248"":[{""seq"":""AACCGAAG"",""instruments"":[],""seq_in_adapter"":""CTTCGGTT""}], + ""X7249"":[{""seq"":""GCTGTTGT"",""instruments"":[],""seq_in_adapter"":""ACAACAGC""}], + ""X7250"":[{""seq"":""TTACGGCT"",""instruments"":[],""seq_in_adapter"":""AGCCGTAA""}], + ""X7251"":[{""seq"":""GACAAGAG"",""instruments"":[],""seq_in_adapter"":""CTCTTGTC""}], + ""X7252"":[{""seq"":""AGGATCTG"",""instruments"":[],""seq_in_adapter"":""CAGATCCT""}], + ""X7253"":[{""seq"":""GTAGCATC"",""instruments"":[],""seq_in_adapter"":""GATGCTAC""}], + ""X7254"":[{""seq"":""GTGTTCCT"",""instruments"":[],""seq_in_adapter"":""AGGAACAC""}], + ""X7255"":[{""seq"":""AGGATGGT"",""instruments"":[],""seq_in_adapter"":""ACCATCCT""}], + ""X7256"":[{""seq"":""TCACGTTC"",""instruments"":[],""seq_in_adapter"":""GAACGTGA""}], + ""X7257"":[{""seq"":""GCGTTCTA"",""instruments"":[],""seq_in_adapter"":""TAGAACGC""}], + ""X7258"":[{""seq"":""CTCTGGTT"",""instruments"":[],""seq_in_adapter"":""AACCAGAG""}], + ""X7259"":[{""seq"":""TTAGGTCG"",""instruments"":[],""seq_in_adapter"":""CGACCTAA""}], + ""X7260"":[{""seq"":""TCTGAGAG"",""instruments"":[],""seq_in_adapter"":""CTCTCAGA""}], + ""X7261"":[{""seq"":""TTCAGCCT"",""instruments"":[],""seq_in_adapter"":""AGGCTGAA""}], + ""X7262"":[{""seq"":""TCTCCGAT"",""instruments"":[],""seq_in_adapter"":""ATCGGAGA""}], + ""X7263"":[{""seq"":""CAGGTATC"",""instruments"":[],""seq_in_adapter"":""GATACCTG""}], + ""X7264"":[{""seq"":""AGTCAGGA"",""instruments"":[],""seq_in_adapter"":""TCCTGACT""}], + ""X7265"":[{""seq"":""AAGGCTGA"",""instruments"":[],""seq_in_adapter"":""TCAGCCTT""}], + ""X7266"":[{""seq"":""CGATGCTT"",""instruments"":[],""seq_in_adapter"":""AAGCATCG""}], + ""X7267"":[{""seq"":""GTATTGGC"",""instruments"":[],""seq_in_adapter"":""GCCAATAC""}], + ""X7268"":[{""seq"":""ACTGTGTC"",""instruments"":[],""seq_in_adapter"":""GACACAGT""}], + ""X7269"":[{""seq"":""TGCCTCTT"",""instruments"":[],""seq_in_adapter"":""AAGAGGCA""}], + ""X7270"":[{""seq"":""CAGTCTTC"",""instruments"":[],""seq_in_adapter"":""GAAGACTG""}], + ""X7271"":[{""seq"":""CATAACGG"",""instruments"":[],""seq_in_adapter"":""CCGTTATG""}], + ""X7272"":[{""seq"":""ACTGCTAG"",""instruments"":[],""seq_in_adapter"":""CTAGCAGT""}], + ""X7273"":[{""seq"":""ATTCTGGC"",""instruments"":[],""seq_in_adapter"":""GCCAGAAT""}], + ""X7274"":[{""seq"":""TTCTCTCG"",""instruments"":[],""seq_in_adapter"":""CGAGAGAA""}], + ""X7275"":[{""seq"":""TCCGAGTT"",""instruments"":[],""seq_in_adapter"":""AACTCGGA""}], + ""X7276"":[{""seq"":""CGAACTGT"",""instruments"":[],""seq_in_adapter"":""ACAGTTCG""}], + ""X7277"":[{""seq"":""AACGGTCA"",""instruments"":[],""seq_in_adapter"":""TGACCGTT""}], + ""X7278"":[{""seq"":""AGCAGATG"",""instruments"":[],""seq_in_adapter"":""CATCTGCT""}], + ""X7279"":[{""seq"":""TATCAGCG"",""instruments"":[],""seq_in_adapter"":""CGCTGATA""}], + ""X7280"":[{""seq"":""TCAGACGA"",""instruments"":[],""seq_in_adapter"":""TCGTCTGA""}], + ""X7281"":[{""seq"":""ACCATGTG"",""instruments"":[],""seq_in_adapter"":""CACATGGT""}], + ""X7282"":[{""seq"":""CTAACTCG"",""instruments"":[],""seq_in_adapter"":""CGAGTTAG""}], + ""X7283"":[{""seq"":""GCTTAGCT"",""instruments"":[],""seq_in_adapter"":""AGCTAAGC""}], + ""X7284"":[{""seq"":""CATGGAAC"",""instruments"":[],""seq_in_adapter"":""GTTCCATG""}], + ""X7285"":[{""seq"":""TAGGATGC"",""instruments"":[],""seq_in_adapter"":""GCATCCTA""}], + ""X7286"":[{""seq"":""GTTCATGG"",""instruments"":[],""seq_in_adapter"":""CCATGAAC""}], + ""X7287"":[{""seq"":""TCGTGGAT"",""instruments"":[],""seq_in_adapter"":""ATCCACGA""}], + ""X7288"":[{""seq"":""ACCTTCTC"",""instruments"":[],""seq_in_adapter"":""GAGAAGGT""}], + ""X7289"":[{""seq"":""CATTGCCT"",""instruments"":[],""seq_in_adapter"":""AGGCAATG""}], + ""X7290"":[{""seq"":""CTAGGTGA"",""instruments"":[],""seq_in_adapter"":""TCACCTAG""}], + ""X7291"":[{""seq"":""TCCGTATG"",""instruments"":[],""seq_in_adapter"":""CATACGGA""}], + ""X7292"":[{""seq"":""ACGATGAC"",""instruments"":[],""seq_in_adapter"":""GTCATCGT""}], + ""X7293"":[{""seq"":""GTCGGTAA"",""instruments"":[],""seq_in_adapter"":""TTACCGAC""}], + ""X7294"":[{""seq"":""TCGAAGGT"",""instruments"":[],""seq_in_adapter"":""ACCTTCGA""}], + ""X7295"":[{""seq"":""AGAAGCGT"",""instruments"":[],""seq_in_adapter"":""ACGCTTCT""}], + ""X7296"":[{""seq"":""CTCTACTC"",""instruments"":[],""seq_in_adapter"":""GAGTAGAG""}], + ""X7297"":[{""seq"":""CTAGGCAT"",""instruments"":[],""seq_in_adapter"":""ATGCCTAG""}], + ""X7298"":[{""seq"":""TGGAGTTG"",""instruments"":[],""seq_in_adapter"":""CAACTCCA""}], + ""X7299"":[{""seq"":""GAGGACTT"",""instruments"":[],""seq_in_adapter"":""AAGTCCTC""}], + ""X7300"":[{""seq"":""CAATCGAC"",""instruments"":[],""seq_in_adapter"":""GTCGATTG""}], + ""X7301"":[{""seq"":""TCTAACGC"",""instruments"":[],""seq_in_adapter"":""GCGTTAGA""}], + ""X7302"":[{""seq"":""TCTCGCAA"",""instruments"":[],""seq_in_adapter"":""TTGCGAGA""}], + ""X7303"":[{""seq"":""ATCGGTGT"",""instruments"":[],""seq_in_adapter"":""ACACCGAT""}], + ""X7304"":[{""seq"":""GAGATACG"",""instruments"":[],""seq_in_adapter"":""CGTATCTC""}], + ""X7305"":[{""seq"":""GTCTCCTT"",""instruments"":[],""seq_in_adapter"":""AAGGAGAC""}], + ""X7306"":[{""seq"":""AGTCGACA"",""instruments"":[],""seq_in_adapter"":""TGTCGACT""}], + ""X7307"":[{""seq"":""CGGATTGA"",""instruments"":[],""seq_in_adapter"":""TCAATCCG""}], + ""X7308"":[{""seq"":""CACAAGTC"",""instruments"":[],""seq_in_adapter"":""GACTTGTG""}], + ""X7309"":[{""seq"":""TACATCGG"",""instruments"":[],""seq_in_adapter"":""CCGATGTA""}], + ""X7310"":[{""seq"":""AGCTCCTA"",""instruments"":[],""seq_in_adapter"":""TAGGAGCT""}], + ""X7311"":[{""seq"":""ACTCGTTG"",""instruments"":[],""seq_in_adapter"":""CAACGAGT""}], + ""X7312"":[{""seq"":""CTGACACA"",""instruments"":[],""seq_in_adapter"":""TGTGTCAG""}], + ""X7313"":[{""seq"":""CAACCTAG"",""instruments"":[],""seq_in_adapter"":""CTAGGTTG""}], + ""X7314"":[{""seq"":""AAGGACAC"",""instruments"":[],""seq_in_adapter"":""GTGTCCTT""}], + ""X7315"":[{""seq"":""TGCAGGTA"",""instruments"":[],""seq_in_adapter"":""TACCTGCA""}], + ""X7316"":[{""seq"":""ACCTAAGG"",""instruments"":[],""seq_in_adapter"":""CCTTAGGT""}], + ""X7317"":[{""seq"":""AGTCTGTG"",""instruments"":[],""seq_in_adapter"":""CACAGACT""}], + ""X7318"":[{""seq"":""AGGTTCGA"",""instruments"":[],""seq_in_adapter"":""TCGAACCT""}], + ""X7319"":[{""seq"":""GACTATGC"",""instruments"":[],""seq_in_adapter"":""GCATAGTC""}], + ""X7320"":[{""seq"":""TTCAGGAG"",""instruments"":[],""seq_in_adapter"":""CTCCTGAA""}], + ""X7321"":[{""seq"":""TGTGCGTT"",""instruments"":[],""seq_in_adapter"":""AACGCACA""}], + ""X7322"":[{""seq"":""CGAGACTA"",""instruments"":[],""seq_in_adapter"":""TAGTCTCG""}], + ""X7323"":[{""seq"":""CTCAGAGT"",""instruments"":[],""seq_in_adapter"":""ACTCTGAG""}], + ""X7324"":[{""seq"":""GCCATAAC"",""instruments"":[],""seq_in_adapter"":""GTTATGGC""}], + ""X7325"":[{""seq"":""TTACCGAG"",""instruments"":[],""seq_in_adapter"":""CTCGGTAA""}], + ""X7326"":[{""seq"":""GCTCTGTA"",""instruments"":[],""seq_in_adapter"":""TACAGAGC""}], + ""X7327"":[{""seq"":""CGTTATGC"",""instruments"":[],""seq_in_adapter"":""GCATAACG""}], + ""X7328"":[{""seq"":""GTCTGATC"",""instruments"":[],""seq_in_adapter"":""GATCAGAC""}], + ""X7329"":[{""seq"":""TAGTTGCG"",""instruments"":[],""seq_in_adapter"":""CGCAACTA""}], + ""X7330"":[{""seq"":""TGATCGGA"",""instruments"":[],""seq_in_adapter"":""TCCGATCA""}], + ""X7331"":[{""seq"":""CCAAGTTG"",""instruments"":[],""seq_in_adapter"":""CAACTTGG""}], + ""X7332"":[{""seq"":""CCTACTGA"",""instruments"":[],""seq_in_adapter"":""TCAGTAGG""}], + ""X7333"":[{""seq"":""CTTGCTGT"",""instruments"":[],""seq_in_adapter"":""ACAGCAAG""}], + ""X7334"":[{""seq"":""TGCCATTC"",""instruments"":[],""seq_in_adapter"":""GAATGGCA""}], + ""X7335"":[{""seq"":""TTGATCCG"",""instruments"":[],""seq_in_adapter"":""CGGATCAA""}], + ""X7336"":[{""seq"":""AGTGCAGT"",""instruments"":[],""seq_in_adapter"":""ACTGCACT""}], + ""X7337"":[{""seq"":""GACTTAGG"",""instruments"":[],""seq_in_adapter"":""CCTAAGTC""}], + ""X7338"":[{""seq"":""CGTACGAA"",""instruments"":[],""seq_in_adapter"":""TTCGTACG""}], + ""X7339"":[{""seq"":""TACCAGGA"",""instruments"":[],""seq_in_adapter"":""TCCTGGTA""}], + ""X7340"":[{""seq"":""CGTCAATG"",""instruments"":[],""seq_in_adapter"":""CATTGACG""}], + ""X7341"":[{""seq"":""GAAGAGGT"",""instruments"":[],""seq_in_adapter"":""ACCTCTTC""}], + ""X7342"":[{""seq"":""GACGAATG"",""instruments"":[],""seq_in_adapter"":""CATTCGTC""}], + ""X7343"":[{""seq"":""AGGAGGAA"",""instruments"":[],""seq_in_adapter"":""TTCCTCCT""}], + ""X7344"":[{""seq"":""CTTACAGC"",""instruments"":[],""seq_in_adapter"":""GCTGTAAG""}], + ""X7345"":[{""seq"":""GAGATGTC"",""instruments"":[],""seq_in_adapter"":""GACATCTC""}], + ""X7346"":[{""seq"":""TACGGTTG"",""instruments"":[],""seq_in_adapter"":""CAACCGTA""}], + ""X7347"":[{""seq"":""CTATCGCA"",""instruments"":[],""seq_in_adapter"":""TGCGATAG""}], + ""X7348"":[{""seq"":""TCGAACCA"",""instruments"":[],""seq_in_adapter"":""TGGTTCGA""}], + ""X7349"":[{""seq"":""GAACGCTT"",""instruments"":[],""seq_in_adapter"":""AAGCGTTC""}], + ""X7350"":[{""seq"":""CAGAATCG"",""instruments"":[],""seq_in_adapter"":""CGATTCTG""}], + ""X7351"":[{""seq"":""ATGGTTGC"",""instruments"":[],""seq_in_adapter"":""GCAACCAT""}], + ""X7352"":[{""seq"":""GCTGGATT"",""instruments"":[],""seq_in_adapter"":""AATCCAGC""}], + ""X7353"":[{""seq"":""GATGCACT"",""instruments"":[],""seq_in_adapter"":""AGTGCATC""}], + ""X7354"":[{""seq"":""ACCAATGC"",""instruments"":[],""seq_in_adapter"":""GCATTGGT""}], + ""X7355"":[{""seq"":""GTCCTAAG"",""instruments"":[],""seq_in_adapter"":""CTTAGGAC""}], + ""X7356"":[{""seq"":""CCGACTAT"",""instruments"":[],""seq_in_adapter"":""ATAGTCGG""}], + ""X7357"":[{""seq"":""TTGGTCTC"",""instruments"":[],""seq_in_adapter"":""GAGACCAA""}], + ""X7358"":[{""seq"":""GCCTTGTT"",""instruments"":[],""seq_in_adapter"":""AACAAGGC""}], + ""X7359"":[{""seq"":""GATACTGG"",""instruments"":[],""seq_in_adapter"":""CCAGTATC""}], + ""X7360"":[{""seq"":""ATTCGAGG"",""instruments"":[],""seq_in_adapter"":""CCTCGAAT""}], + ""X7361"":[{""seq"":""GTCAGTTG"",""instruments"":[],""seq_in_adapter"":""CAACTGAC""}], + ""X7362"":[{""seq"":""GTAGAGCA"",""instruments"":[],""seq_in_adapter"":""TGCTCTAC""}], + ""X7363"":[{""seq"":""ACGTGATG"",""instruments"":[],""seq_in_adapter"":""CATCACGT""}], + ""X7364"":[{""seq"":""TAAGTGGC"",""instruments"":[],""seq_in_adapter"":""GCCACTTA""}], + ""X7365"":[{""seq"":""TGTGAAGC"",""instruments"":[],""seq_in_adapter"":""GCTTCACA""}], + ""X7366"":[{""seq"":""CATTCGGT"",""instruments"":[],""seq_in_adapter"":""ACCGAATG""}], + ""X7367"":[{""seq"":""TTGGTGAG"",""instruments"":[],""seq_in_adapter"":""CTCACCAA""}], + ""X7368"":[{""seq"":""CAGTTCTG"",""instruments"":[],""seq_in_adapter"":""CAGAACTG""}], + ""X7369"":[{""seq"":""AGGCTTCT"",""instruments"":[],""seq_in_adapter"":""AGAAGCCT""}], + ""X7370"":[{""seq"":""GAATCGTG"",""instruments"":[],""seq_in_adapter"":""CACGATTC""}], + ""X7371"":[{""seq"":""ACCAGCTT"",""instruments"":[],""seq_in_adapter"":""AAGCTGGT""}], + ""X7372"":[{""seq"":""CTCATTGC"",""instruments"":[],""seq_in_adapter"":""GCAATGAG""}], + ""X7373"":[{""seq"":""CGATAGAG"",""instruments"":[],""seq_in_adapter"":""CTCTATCG""}], + ""X7374"":[{""seq"":""TGGAGAGT"",""instruments"":[],""seq_in_adapter"":""ACTCTCCA""}], + ""X7375"":[{""seq"":""GTATGCTG"",""instruments"":[],""seq_in_adapter"":""CAGCATAC""}], + ""X7376"":[{""seq"":""CTGGAGTA"",""instruments"":[],""seq_in_adapter"":""TACTCCAG""}], + ""X7377"":[{""seq"":""AATGCCTC"",""instruments"":[],""seq_in_adapter"":""GAGGCATT""}], + ""X7378"":[{""seq"":""TGAGGTGT"",""instruments"":[],""seq_in_adapter"":""ACACCTCA""}], + ""X7379"":[{""seq"":""ACATTGCG"",""instruments"":[],""seq_in_adapter"":""CGCAATGT""}], + ""X7380"":[{""seq"":""TCTCTAGG"",""instruments"":[],""seq_in_adapter"":""CCTAGAGA""}], + ""X7381"":[{""seq"":""CGCTAGTA"",""instruments"":[],""seq_in_adapter"":""TACTAGCG""}], + ""X7382"":[{""seq"":""AATGGACG"",""instruments"":[],""seq_in_adapter"":""CGTCCATT""}], + ""X7383"":[{""seq"":""GATAGCGA"",""instruments"":[],""seq_in_adapter"":""TCGCTATC""}], + ""X7384"":[{""seq"":""CGACCATT"",""instruments"":[],""seq_in_adapter"":""AATGGTCG""}], + }, + ""i5"":{ + ""X5001"":[{""seq"":""ATATGCGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCGCATAT""}, {""seq"":""GCGCATAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCGCATAT""}], + ""X5002"":[{""seq"":""TGGTACAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTGTACCA""}, {""seq"":""CTGTACCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTGTACCA""}], + ""X5003"":[{""seq"":""AACCGTTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAACGGTT""}, {""seq"":""GAACGGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAACGGTT""}], + ""X5004"":[{""seq"":""TAACCGGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACCGGTTA""}, {""seq"":""ACCGGTTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACCGGTTA""}], + ""X5005"":[{""seq"":""GAACATCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGATGTTC""}, {""seq"":""CGATGTTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGATGTTC""}], + ""X5006"":[{""seq"":""CCTTGTAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTACAAGG""}, {""seq"":""CTACAAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTACAAGG""}], + ""X5007"":[{""seq"":""TCAGGCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGCCTGA""}, {""seq"":""AAGCCTGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGCCTGA""}], + ""X5008"":[{""seq"":""GTTCTCGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACGAGAAC""}, {""seq"":""ACGAGAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACGAGAAC""}], + ""X5009"":[{""seq"":""AGAACGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCGTTCT""}, {""seq"":""CTCGTTCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCGTTCT""}], + ""X5010"":[{""seq"":""TGCTTCCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGGAAGCA""}, {""seq"":""TGGAAGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGGAAGCA""}], + ""X5011"":[{""seq"":""CTTCGACT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTCGAAG""}, {""seq"":""AGTCGAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTCGAAG""}], + ""X5012"":[{""seq"":""CACCTGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACAGGTG""}, {""seq"":""AACAGGTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACAGGTG""}], + ""X5013"":[{""seq"":""ATCACACG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGTGTGAT""}, {""seq"":""CGTGTGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGTGTGAT""}], + ""X5014"":[{""seq"":""CCGTAAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCTTACGG""}, {""seq"":""TCTTACGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCTTACGG""}], + ""X5015"":[{""seq"":""TACGCCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGGCGTA""}, {""seq"":""AAGGCGTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGGCGTA""}], + ""X5016"":[{""seq"":""CGACGTTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAACGTCG""}, {""seq"":""TAACGTCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAACGTCG""}], + ""X5017"":[{""seq"":""ATGCACGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCGTGCAT""}, {""seq"":""TCGTGCAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCGTGCAT""}], + ""X5018"":[{""seq"":""CCTGATTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAATCAGG""}, {""seq"":""CAATCAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAATCAGG""}], + ""X5019"":[{""seq"":""GTAGGAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTCCTAC""}, {""seq"":""ACTCCTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTCCTAC""}], + ""X5020"":[{""seq"":""ACTAGGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCCTAGT""}, {""seq"":""CTCCTAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCCTAGT""}], + ""X5021"":[{""seq"":""CACTAGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCTAGTG""}, {""seq"":""AGCTAGTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCTAGTG""}], + ""X5022"":[{""seq"":""ACGACTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAAGTCGT""}, {""seq"":""CAAGTCGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAAGTCGT""}], + ""X5023"":[{""seq"":""CGTGTGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACACACG""}, {""seq"":""TACACACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACACACG""}], + ""X5024"":[{""seq"":""GTTGACCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGTCAAC""}, {""seq"":""AGGTCAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGTCAAC""}], + ""X5025"":[{""seq"":""ACTCCATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATGGAGT""}, {""seq"":""GATGGAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATGGAGT""}], + ""X5026"":[{""seq"":""CAATGTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCACATTG""}, {""seq"":""CCACATTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCACATTG""}], + ""X5027"":[{""seq"":""TTGCAGAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTCTGCAA""}, {""seq"":""GTCTGCAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTCTGCAA""}], + ""X5028"":[{""seq"":""CAGTCCAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTGGACTG""}, {""seq"":""TTGGACTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTGGACTG""}], + ""X5029"":[{""seq"":""ACGTTCAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTGAACGT""}, {""seq"":""CTGAACGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTGAACGT""}], + ""X5030"":[{""seq"":""AACGTCTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGACGTT""}, {""seq"":""CAGACGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGACGTT""}], + ""X5031"":[{""seq"":""TATCGGTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACCGATA""}, {""seq"":""GACCGATA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACCGATA""}], + ""X5032"":[{""seq"":""CGCTCTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATAGAGCG""}, {""seq"":""ATAGAGCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATAGAGCG""}], + ""X5033"":[{""seq"":""GATTGCTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAGCAATC""}, {""seq"":""GAGCAATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAGCAATC""}], + ""X5034"":[{""seq"":""GATGTGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACACATC""}, {""seq"":""CACACATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACACATC""}], + ""X5035"":[{""seq"":""CGCAATCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGATTGCG""}, {""seq"":""AGATTGCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGATTGCG""}], + ""X5036"":[{""seq"":""TGGTAGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCTACCA""}, {""seq"":""AGCTACCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCTACCA""}], + ""X5037"":[{""seq"":""GATAGGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCCTATC""}, {""seq"":""AGCCTATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCCTATC""}], + ""X5038"":[{""seq"":""AGTGGATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATCCACT""}, {""seq"":""GATCCACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATCCACT""}], + ""X5039"":[{""seq"":""TTGGACGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACGTCCAA""}, {""seq"":""ACGTCCAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACGTCCAA""}], + ""X5040"":[{""seq"":""ATGACGTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACGTCAT""}, {""seq"":""GACGTCAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACGTCAT""}], + ""X5041"":[{""seq"":""GAAGTTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAACTTC""}, {""seq"":""CCAACTTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAACTTC""}], + ""X5042"":[{""seq"":""CATACCAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTGGTATG""}, {""seq"":""GTGGTATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTGGTATG""}], + ""X5043"":[{""seq"":""CTGTTGAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTCAACAG""}, {""seq"":""GTCAACAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTCAACAG""}], + ""X5044"":[{""seq"":""TGGCATGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACATGCCA""}, {""seq"":""ACATGCCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACATGCCA""}], + ""X5045"":[{""seq"":""ATCGCCAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATGGCGAT""}, {""seq"":""ATGGCGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATGGCGAT""}], + ""X5046"":[{""seq"":""TTGCGAAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTTCGCAA""}, {""seq"":""CTTCGCAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTTCGCAA""}], + ""X5047"":[{""seq"":""AGTTCGTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACGAACT""}, {""seq"":""GACGAACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACGAACT""}], + ""X5048"":[{""seq"":""GAGCAGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACTGCTC""}, {""seq"":""TACTGCTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACTGCTC""}], + ""X5049"":[{""seq"":""ACAGCTCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGAGCTGT""}, {""seq"":""TGAGCTGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGAGCTGT""}], + ""X5050"":[{""seq"":""GATCGAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTCGATC""}, {""seq"":""ACTCGATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTCGATC""}], + ""X5051"":[{""seq"":""AGCGTGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACACGCT""}, {""seq"":""AACACGCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACACGCT""}], + ""X5052"":[{""seq"":""GTTACGCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGCGTAAC""}, {""seq"":""TGCGTAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGCGTAAC""}], + ""X5053"":[{""seq"":""TGAAGACG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGTCTTCA""}, {""seq"":""CGTCTTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGTCTTCA""}], + ""X5054"":[{""seq"":""ACTGAGGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACCTCAGT""}, {""seq"":""ACCTCAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACCTCAGT""}], + ""X5055"":[{""seq"":""CGGTTGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACAACCG""}, {""seq"":""AACAACCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACAACCG""}], + ""X5056"":[{""seq"":""GTTGTTCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGAACAAC""}, {""seq"":""CGAACAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGAACAAC""}], + ""X5057"":[{""seq"":""GAAGGAAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTTCCTTC""}, {""seq"":""CTTCCTTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTTCCTTC""}], + ""X5058"":[{""seq"":""AGCACTTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAAGTGCT""}, {""seq"":""GAAGTGCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAAGTGCT""}], + ""X5059"":[{""seq"":""GTCATCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCGATGAC""}, {""seq"":""TCGATGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCGATGAC""}], + ""X5060"":[{""seq"":""TGTGACTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGTCACA""}, {""seq"":""CAGTCACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGTCACA""}], + ""X5061"":[{""seq"":""CAACACCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGTGTTG""}, {""seq"":""AGGTGTTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGTGTTG""}], + ""X5062"":[{""seq"":""ATGCCTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACAGGCAT""}, {""seq"":""ACAGGCAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACAGGCAT""}], + ""X5063"":[{""seq"":""CATGGCTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGCCATG""}, {""seq"":""TAGCCATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGCCATG""}], + ""X5064"":[{""seq"":""GTGAAGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACTTCAC""}, {""seq"":""CACTTCAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACTTCAC""}], + ""X5065"":[{""seq"":""CGTTGCAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTGCAACG""}, {""seq"":""TTGCAACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTGCAACG""}], + ""X5066"":[{""seq"":""ATCCGGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACCGGAT""}, {""seq"":""TACCGGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACCGGAT""}], + ""X5067"":[{""seq"":""GCGTCATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AATGACGC""}, {""seq"":""AATGACGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AATGACGC""}], + ""X5068"":[{""seq"":""GCACAACT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTTGTGC""}, {""seq"":""AGTTGTGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTTGTGC""}], + ""X5069"":[{""seq"":""GATTACCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGGTAATC""}, {""seq"":""CGGTAATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGGTAATC""}], + ""X5070"":[{""seq"":""ACCACGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCGTGGT""}, {""seq"":""ATCGTGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCGTGGT""}], + ""X5071"":[{""seq"":""GTCGAAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCTTCGAC""}, {""seq"":""TCTTCGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCTTCGAC""}], + ""X5072"":[{""seq"":""CCTTGATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATCAAGG""}, {""seq"":""GATCAAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATCAAGG""}], + ""X5073"":[{""seq"":""AAGCACTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGTGCTT""}, {""seq"":""CAGTGCTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGTGCTT""}], + ""X5074"":[{""seq"":""TTCGTTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAACGAA""}, {""seq"":""CCAACGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAACGAA""}], + ""X5075"":[{""seq"":""TCGCTGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACAGCGA""}, {""seq"":""AACAGCGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACAGCGA""}], + ""X5076"":[{""seq"":""GAATCCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCGGATTC""}, {""seq"":""TCGGATTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCGGATTC""}], + ""X5077"":[{""seq"":""GTGCCATA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TATGGCAC""}, {""seq"":""TATGGCAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TATGGCAC""}], + ""X5078"":[{""seq"":""CTTAGGAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTCCTAAG""}, {""seq"":""GTCCTAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTCCTAAG""}], + ""X5079"":[{""seq"":""AACTGAGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTCAGTT""}, {""seq"":""GCTCAGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTCAGTT""}], + ""X5080"":[{""seq"":""GACGATCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGATCGTC""}, {""seq"":""AGATCGTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGATCGTC""}], + ""X5081"":[{""seq"":""ATCCAGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCTGGAT""}, {""seq"":""CTCTGGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCTGGAT""}], + ""X5082"":[{""seq"":""AGAGTAGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTACTCT""}, {""seq"":""GCTACTCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTACTCT""}], + ""X5083"":[{""seq"":""TGGACTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGAGTCCA""}, {""seq"":""AGAGTCCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGAGTCCA""}], + ""X5084"":[{""seq"":""TACGCTAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTAGCGTA""}, {""seq"":""GTAGCGTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTAGCGTA""}], + ""X5085"":[{""seq"":""GCTATCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGATAGC""}, {""seq"":""AGGATAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGATAGC""}], + ""X5086"":[{""seq"":""GCAAGATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATCTTGC""}, {""seq"":""GATCTTGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATCTTGC""}], + ""X5087"":[{""seq"":""ATCGATCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGATCGAT""}, {""seq"":""CGATCGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGATCGAT""}], + ""X5088"":[{""seq"":""CGGCTAAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATTAGCCG""}, {""seq"":""ATTAGCCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATTAGCCG""}], + ""X5089"":[{""seq"":""ACGGAACA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGTTCCGT""}, {""seq"":""TGTTCCGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGTTCCGT""}], + ""X5090"":[{""seq"":""CGCATGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCATGCG""}, {""seq"":""ATCATGCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCATGCG""}], + ""X5091"":[{""seq"":""TTCCAAGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTTGGAA""}, {""seq"":""CCTTGGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTTGGAA""}], + ""X5092"":[{""seq"":""CTTGTCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCGACAAG""}, {""seq"":""TCGACAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCGACAAG""}], + ""X5093"":[{""seq"":""GAGACGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCGTCTC""}, {""seq"":""ATCGTCTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCGTCTC""}], + ""X5094"":[{""seq"":""TGAGCTAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTAGCTCA""}, {""seq"":""CTAGCTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTAGCTCA""}], + ""X5095"":[{""seq"":""ACTCTCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCGAGAGT""}, {""seq"":""TCGAGAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCGAGAGT""}], + ""X5096"":[{""seq"":""CTGATCGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACGATCAG""}, {""seq"":""ACGATCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACGATCAG""}], + ""X5097"":[{""seq"":""CGACCATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AATGGTCG""}, {""seq"":""AATGGTCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AATGGTCG""}], + ""X5098"":[{""seq"":""GATAGCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCGCTATC""}, {""seq"":""TCGCTATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCGCTATC""}], + ""X5099"":[{""seq"":""AATGGACG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGTCCATT""}, {""seq"":""CGTCCATT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGTCCATT""}], + ""X5100"":[{""seq"":""CGCTAGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACTAGCG""}, {""seq"":""TACTAGCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACTAGCG""}], + ""X5101"":[{""seq"":""TCTCTAGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTAGAGA""}, {""seq"":""CCTAGAGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTAGAGA""}], + ""X5102"":[{""seq"":""ACATTGCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGCAATGT""}, {""seq"":""CGCAATGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGCAATGT""}], + ""X5103"":[{""seq"":""TGAGGTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACACCTCA""}, {""seq"":""ACACCTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACACCTCA""}], + ""X5104"":[{""seq"":""AATGCCTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAGGCATT""}, {""seq"":""GAGGCATT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAGGCATT""}], + ""X5105"":[{""seq"":""CTGGAGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACTCCAG""}, {""seq"":""TACTCCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACTCCAG""}], + ""X5106"":[{""seq"":""GTATGCTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGCATAC""}, {""seq"":""CAGCATAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGCATAC""}], + ""X5107"":[{""seq"":""TGGAGAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTCTCCA""}, {""seq"":""ACTCTCCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTCTCCA""}], + ""X5108"":[{""seq"":""CGATAGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCTATCG""}, {""seq"":""CTCTATCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCTATCG""}], + ""X5109"":[{""seq"":""CTCATTGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCAATGAG""}, {""seq"":""GCAATGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCAATGAG""}], + ""X5110"":[{""seq"":""ACCAGCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGCTGGT""}, {""seq"":""AAGCTGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGCTGGT""}], + ""X5111"":[{""seq"":""GAATCGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACGATTC""}, {""seq"":""CACGATTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACGATTC""}], + ""X5112"":[{""seq"":""AGGCTTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGAAGCCT""}, {""seq"":""AGAAGCCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGAAGCCT""}], + ""X5113"":[{""seq"":""CAGTTCTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGAACTG""}, {""seq"":""CAGAACTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGAACTG""}], + ""X5114"":[{""seq"":""TTGGTGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCACCAA""}, {""seq"":""CTCACCAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCACCAA""}], + ""X5115"":[{""seq"":""CATTCGGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACCGAATG""}, {""seq"":""ACCGAATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACCGAATG""}], + ""X5116"":[{""seq"":""TGTGAAGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTTCACA""}, {""seq"":""GCTTCACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTTCACA""}], + ""X5117"":[{""seq"":""TAAGTGGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCCACTTA""}, {""seq"":""GCCACTTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCCACTTA""}], + ""X5118"":[{""seq"":""ACGTGATG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATCACGT""}, {""seq"":""CATCACGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATCACGT""}], + ""X5119"":[{""seq"":""GTAGAGCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGCTCTAC""}, {""seq"":""TGCTCTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGCTCTAC""}], + ""X5120"":[{""seq"":""GTCAGTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAACTGAC""}, {""seq"":""CAACTGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAACTGAC""}], + ""X5121"":[{""seq"":""ATTCGAGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTCGAAT""}, {""seq"":""CCTCGAAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTCGAAT""}], + ""X5122"":[{""seq"":""GATACTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAGTATC""}, {""seq"":""CCAGTATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAGTATC""}], + ""X5123"":[{""seq"":""GCCTTGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACAAGGC""}, {""seq"":""AACAAGGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACAAGGC""}], + ""X5124"":[{""seq"":""TTGGTCTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAGACCAA""}, {""seq"":""GAGACCAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAGACCAA""}], + ""X5125"":[{""seq"":""CCGACTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATAGTCGG""}, {""seq"":""ATAGTCGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATAGTCGG""}], + ""X5126"":[{""seq"":""GTCCTAAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTTAGGAC""}, {""seq"":""CTTAGGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTTAGGAC""}], + ""X5127"":[{""seq"":""ACCAATGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCATTGGT""}, {""seq"":""GCATTGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCATTGGT""}], + ""X5128"":[{""seq"":""GATGCACT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTGCATC""}, {""seq"":""AGTGCATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTGCATC""}], + ""X5129"":[{""seq"":""GCTGGATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AATCCAGC""}, {""seq"":""AATCCAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AATCCAGC""}], + ""X5130"":[{""seq"":""ATGGTTGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCAACCAT""}, {""seq"":""GCAACCAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCAACCAT""}], + ""X5131"":[{""seq"":""CAGAATCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGATTCTG""}, {""seq"":""CGATTCTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGATTCTG""}], + ""X5132"":[{""seq"":""GAACGCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGCGTTC""}, {""seq"":""AAGCGTTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGCGTTC""}], + ""X5133"":[{""seq"":""TCGAACCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGGTTCGA""}, {""seq"":""TGGTTCGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGGTTCGA""}], + ""X5134"":[{""seq"":""CTATCGCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGCGATAG""}, {""seq"":""TGCGATAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGCGATAG""}], + ""X5135"":[{""seq"":""TACGGTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAACCGTA""}, {""seq"":""CAACCGTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAACCGTA""}], + ""X5136"":[{""seq"":""GAGATGTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACATCTC""}, {""seq"":""GACATCTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACATCTC""}], + ""X5137"":[{""seq"":""CTTACAGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCTGTAAG""}, {""seq"":""GCTGTAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCTGTAAG""}], + ""X5138"":[{""seq"":""AGGAGGAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCCTCCT""}, {""seq"":""TTCCTCCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCCTCCT""}], + ""X5139"":[{""seq"":""GACGAATG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATTCGTC""}, {""seq"":""CATTCGTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATTCGTC""}], + ""X5140"":[{""seq"":""GAAGAGGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACCTCTTC""}, {""seq"":""ACCTCTTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACCTCTTC""}], + ""X5141"":[{""seq"":""CGTCAATG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATTGACG""}, {""seq"":""CATTGACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATTGACG""}], + ""X5142"":[{""seq"":""TACCAGGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCCTGGTA""}, {""seq"":""TCCTGGTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCCTGGTA""}], + ""X5143"":[{""seq"":""CGTACGAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCGTACG""}, {""seq"":""TTCGTACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCGTACG""}], + ""X5144"":[{""seq"":""GACTTAGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTAAGTC""}, {""seq"":""CCTAAGTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTAAGTC""}], + ""X5145"":[{""seq"":""AGTGCAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTGCACT""}, {""seq"":""ACTGCACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTGCACT""}], + ""X5146"":[{""seq"":""TTGATCCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGGATCAA""}, {""seq"":""CGGATCAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGGATCAA""}], + ""X5147"":[{""seq"":""TGCCATTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAATGGCA""}, {""seq"":""GAATGGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAATGGCA""}], + ""X5148"":[{""seq"":""CTTGCTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACAGCAAG""}, {""seq"":""ACAGCAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACAGCAAG""}], + ""X5149"":[{""seq"":""CCTACTGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCAGTAGG""}, {""seq"":""TCAGTAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCAGTAGG""}], + ""X5150"":[{""seq"":""CCAAGTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAACTTGG""}, {""seq"":""CAACTTGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAACTTGG""}], + ""X5151"":[{""seq"":""TGATCGGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCCGATCA""}, {""seq"":""TCCGATCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCCGATCA""}], + ""X5152"":[{""seq"":""TAGTTGCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGCAACTA""}, {""seq"":""CGCAACTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGCAACTA""}], + ""X5153"":[{""seq"":""GTCTGATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATCAGAC""}, {""seq"":""GATCAGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATCAGAC""}], + ""X5154"":[{""seq"":""CGTTATGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCATAACG""}, {""seq"":""GCATAACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCATAACG""}], + ""X5155"":[{""seq"":""GCTCTGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACAGAGC""}, {""seq"":""TACAGAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACAGAGC""}], + ""X5156"":[{""seq"":""TTACCGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCGGTAA""}, {""seq"":""CTCGGTAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCGGTAA""}], + ""X5157"":[{""seq"":""GCCATAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTTATGGC""}, {""seq"":""GTTATGGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTTATGGC""}], + ""X5158"":[{""seq"":""CTCAGAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTCTGAG""}, {""seq"":""ACTCTGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTCTGAG""}], + ""X5159"":[{""seq"":""CGAGACTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGTCTCG""}, {""seq"":""TAGTCTCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGTCTCG""}], + ""X5160"":[{""seq"":""TGTGCGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACGCACA""}, {""seq"":""AACGCACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACGCACA""}], + ""X5161"":[{""seq"":""TTCAGGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCCTGAA""}, {""seq"":""CTCCTGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCCTGAA""}], + ""X5162"":[{""seq"":""GACTATGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCATAGTC""}, {""seq"":""GCATAGTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCATAGTC""}], + ""X5163"":[{""seq"":""AGGTTCGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCGAACCT""}, {""seq"":""TCGAACCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCGAACCT""}], + ""X5164"":[{""seq"":""AGTCTGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACAGACT""}, {""seq"":""CACAGACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACAGACT""}], + ""X5165"":[{""seq"":""ACCTAAGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTTAGGT""}, {""seq"":""CCTTAGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTTAGGT""}], + ""X5166"":[{""seq"":""TGCAGGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACCTGCA""}, {""seq"":""TACCTGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACCTGCA""}], + ""X5167"":[{""seq"":""AAGGACAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTGTCCTT""}, {""seq"":""GTGTCCTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTGTCCTT""}], + ""X5168"":[{""seq"":""CAACCTAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTAGGTTG""}, {""seq"":""CTAGGTTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTAGGTTG""}], + ""X5169"":[{""seq"":""CTGACACA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGTGTCAG""}, {""seq"":""TGTGTCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGTGTCAG""}], + ""X5170"":[{""seq"":""ACTCGTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAACGAGT""}, {""seq"":""CAACGAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAACGAGT""}], + ""X5171"":[{""seq"":""AGCTCCTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGGAGCT""}, {""seq"":""TAGGAGCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGGAGCT""}], + ""X5172"":[{""seq"":""TACATCGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCGATGTA""}, {""seq"":""CCGATGTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCGATGTA""}], + ""X5173"":[{""seq"":""CACAAGTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACTTGTG""}, {""seq"":""GACTTGTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACTTGTG""}], + ""X5174"":[{""seq"":""CGGATTGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCAATCCG""}, {""seq"":""TCAATCCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCAATCCG""}], + ""X5175"":[{""seq"":""AGTCGACA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGTCGACT""}, {""seq"":""TGTCGACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGTCGACT""}], + ""X5176"":[{""seq"":""GTCTCCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGGAGAC""}, {""seq"":""AAGGAGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGGAGAC""}], + ""X5177"":[{""seq"":""GAGATACG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGTATCTC""}, {""seq"":""CGTATCTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGTATCTC""}], + ""X5178"":[{""seq"":""ATCGGTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACACCGAT""}, {""seq"":""ACACCGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACACCGAT""}], + ""X5179"":[{""seq"":""TCTCGCAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTGCGAGA""}, {""seq"":""TTGCGAGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTGCGAGA""}], + ""X5180"":[{""seq"":""TCTAACGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCGTTAGA""}, {""seq"":""GCGTTAGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCGTTAGA""}], + ""X5181"":[{""seq"":""CAATCGAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTCGATTG""}, {""seq"":""GTCGATTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTCGATTG""}], + ""X5182"":[{""seq"":""GAGGACTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGTCCTC""}, {""seq"":""AAGTCCTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGTCCTC""}], + ""X5183"":[{""seq"":""TGGAGTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAACTCCA""}, {""seq"":""CAACTCCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAACTCCA""}], + ""X5184"":[{""seq"":""CTAGGCAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATGCCTAG""}, {""seq"":""ATGCCTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATGCCTAG""}], + ""X5185"":[{""seq"":""CTCTACTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAGTAGAG""}, {""seq"":""GAGTAGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAGTAGAG""}], + ""X5186"":[{""seq"":""AGAAGCGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACGCTTCT""}, {""seq"":""ACGCTTCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACGCTTCT""}], + ""X5187"":[{""seq"":""TCGAAGGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACCTTCGA""}, {""seq"":""ACCTTCGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACCTTCGA""}], + ""X5188"":[{""seq"":""GTCGGTAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTACCGAC""}, {""seq"":""TTACCGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTACCGAC""}], + ""X5189"":[{""seq"":""ACGATGAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTCATCGT""}, {""seq"":""GTCATCGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTCATCGT""}], + ""X5190"":[{""seq"":""TCCGTATG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATACGGA""}, {""seq"":""CATACGGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATACGGA""}], + ""X5191"":[{""seq"":""CTAGGTGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCACCTAG""}, {""seq"":""TCACCTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCACCTAG""}], + ""X5192"":[{""seq"":""CATTGCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGCAATG""}, {""seq"":""AGGCAATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGCAATG""}], + ""X5193"":[{""seq"":""ACCTTCTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAGAAGGT""}, {""seq"":""GAGAAGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAGAAGGT""}], + ""X5194"":[{""seq"":""TCGTGGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCCACGA""}, {""seq"":""ATCCACGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCCACGA""}], + ""X5195"":[{""seq"":""GTTCATGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCATGAAC""}, {""seq"":""CCATGAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCATGAAC""}], + ""X5196"":[{""seq"":""TAGGATGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCATCCTA""}, {""seq"":""GCATCCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCATCCTA""}], + ""X5197"":[{""seq"":""CATGGAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTTCCATG""}, {""seq"":""GTTCCATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTTCCATG""}], + ""X5198"":[{""seq"":""GCTTAGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCTAAGC""}, {""seq"":""AGCTAAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCTAAGC""}], + ""X5199"":[{""seq"":""CTAACTCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGAGTTAG""}, {""seq"":""CGAGTTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGAGTTAG""}], + ""X5200"":[{""seq"":""ACCATGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACATGGT""}, {""seq"":""CACATGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACATGGT""}], + ""X5201"":[{""seq"":""TCAGACGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCGTCTGA""}, {""seq"":""TCGTCTGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCGTCTGA""}], + ""X5202"":[{""seq"":""TATCAGCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGCTGATA""}, {""seq"":""CGCTGATA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGCTGATA""}], + ""X5203"":[{""seq"":""AGCAGATG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATCTGCT""}, {""seq"":""CATCTGCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATCTGCT""}], + ""X5204"":[{""seq"":""AACGGTCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGACCGTT""}, {""seq"":""TGACCGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGACCGTT""}], + ""X5205"":[{""seq"":""CGAACTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACAGTTCG""}, {""seq"":""ACAGTTCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACAGTTCG""}], + ""X5206"":[{""seq"":""TCCGAGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACTCGGA""}, {""seq"":""AACTCGGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACTCGGA""}], + ""X5207"":[{""seq"":""TTCTCTCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGAGAGAA""}, {""seq"":""CGAGAGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGAGAGAA""}], + ""X5208"":[{""seq"":""ATTCTGGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCCAGAAT""}, {""seq"":""GCCAGAAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCCAGAAT""}], + ""X5209"":[{""seq"":""ACTGCTAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTAGCAGT""}, {""seq"":""CTAGCAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTAGCAGT""}], + ""X5210"":[{""seq"":""CATAACGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCGTTATG""}, {""seq"":""CCGTTATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCGTTATG""}], + ""X5211"":[{""seq"":""CAGTCTTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAAGACTG""}, {""seq"":""GAAGACTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAAGACTG""}], + ""X5212"":[{""seq"":""TGCCTCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGAGGCA""}, {""seq"":""AAGAGGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGAGGCA""}], + ""X5213"":[{""seq"":""ACTGTGTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACACAGT""}, {""seq"":""GACACAGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACACAGT""}], + ""X5214"":[{""seq"":""GTATTGGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCCAATAC""}, {""seq"":""GCCAATAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCCAATAC""}], + ""X5215"":[{""seq"":""CGATGCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGCATCG""}, {""seq"":""AAGCATCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGCATCG""}], + ""X5216"":[{""seq"":""AAGGCTGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCAGCCTT""}, {""seq"":""TCAGCCTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCAGCCTT""}], + ""X5217"":[{""seq"":""AGTCAGGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCCTGACT""}, {""seq"":""TCCTGACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCCTGACT""}], + ""X5218"":[{""seq"":""CAGGTATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATACCTG""}, {""seq"":""GATACCTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATACCTG""}], + ""X5219"":[{""seq"":""TCTCCGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCGGAGA""}, {""seq"":""ATCGGAGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCGGAGA""}], + ""X5220"":[{""seq"":""TTCAGCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGCTGAA""}, {""seq"":""AGGCTGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGCTGAA""}], + ""X5221"":[{""seq"":""TCTGAGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCTCAGA""}, {""seq"":""CTCTCAGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCTCAGA""}], + ""X5222"":[{""seq"":""TTAGGTCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGACCTAA""}, {""seq"":""CGACCTAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGACCTAA""}], + ""X5223"":[{""seq"":""CTCTGGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACCAGAG""}, {""seq"":""AACCAGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACCAGAG""}], + ""X5224"":[{""seq"":""GCGTTCTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGAACGC""}, {""seq"":""TAGAACGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGAACGC""}], + ""X5225"":[{""seq"":""TCACGTTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAACGTGA""}, {""seq"":""GAACGTGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAACGTGA""}], + ""X5226"":[{""seq"":""AGGATGGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACCATCCT""}, {""seq"":""ACCATCCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACCATCCT""}], + ""X5227"":[{""seq"":""GTGTTCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGAACAC""}, {""seq"":""AGGAACAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGAACAC""}], + ""X5228"":[{""seq"":""GTAGCATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATGCTAC""}, {""seq"":""GATGCTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATGCTAC""}], + ""X5229"":[{""seq"":""AGGATCTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGATCCT""}, {""seq"":""CAGATCCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGATCCT""}], + ""X5230"":[{""seq"":""GACAAGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCTTGTC""}, {""seq"":""CTCTTGTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCTTGTC""}], + ""X5231"":[{""seq"":""TTACGGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCCGTAA""}, {""seq"":""AGCCGTAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCCGTAA""}], + ""X5232"":[{""seq"":""GCTGTTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACAACAGC""}, {""seq"":""ACAACAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACAACAGC""}], + ""X5233"":[{""seq"":""AACCGAAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTTCGGTT""}, {""seq"":""CTTCGGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTTCGGTT""}], + ""X5234"":[{""seq"":""TCTGCTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGAGCAGA""}, {""seq"":""AGAGCAGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGAGCAGA""}], + ""X5235"":[{""seq"":""CTCAGCTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGCTGAG""}, {""seq"":""TAGCTGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGCTGAG""}], + ""X5236"":[{""seq"":""CTTCACCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGGTGAAG""}, {""seq"":""TGGTGAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGGTGAAG""}], + ""X5237"":[{""seq"":""GATCGTAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTACGATC""}, {""seq"":""GTACGATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTACGATC""}], + ""X5238"":[{""seq"":""CTACAGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACTGTAG""}, {""seq"":""CACTGTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACTGTAG""}], + ""X5239"":[{""seq"":""TCGAGTGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCACTCGA""}, {""seq"":""TCACTCGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCACTCGA""}], + ""X5240"":[{""seq"":""CAAGTGCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGCACTTG""}, {""seq"":""TGCACTTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGCACTTG""}], + ""X5241"":[{""seq"":""CGAGTATG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATACTCG""}, {""seq"":""CATACTCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATACTCG""}], + ""X5242"":[{""seq"":""CGTAGGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACCTACG""}, {""seq"":""AACCTACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACCTACG""}], + ""X5243"":[{""seq"":""GCCAGTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATACTGGC""}, {""seq"":""ATACTGGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATACTGGC""}], + ""X5244"":[{""seq"":""ATGGAAGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTTCCAT""}, {""seq"":""CCTTCCAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTTCCAT""}], + ""X5245"":[{""seq"":""AAGAGCCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGGCTCTT""}, {""seq"":""TGGCTCTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGGCTCTT""}], + ""X5246"":[{""seq"":""TGCGTAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCTACGCA""}, {""seq"":""TCTACGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCTACGCA""}], + ""X5247"":[{""seq"":""TACACGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCGTGTA""}, {""seq"":""AGCGTGTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCGTGTA""}], + ""X5248"":[{""seq"":""CCTTCCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGGAAGG""}, {""seq"":""AAGGAAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGGAAGG""}], + ""X5249"":[{""seq"":""ACCGCATA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TATGCGGT""}, {""seq"":""TATGCGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TATGCGGT""}], + ""X5250"":[{""seq"":""TGGTCCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGGACCA""}, {""seq"":""AAGGACCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGGACCA""}], + ""X5251"":[{""seq"":""CCATACGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACGTATGG""}, {""seq"":""ACGTATGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACGTATGG""}], + ""X5252"":[{""seq"":""AACCTTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAAGGTT""}, {""seq"":""CCAAGGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAAGGTT""}], + ""X5253"":[{""seq"":""CAAGGTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGACCTTG""}, {""seq"":""AGACCTTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGACCTTG""}], + ""X5254"":[{""seq"":""GCTTCGAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCGAAGC""}, {""seq"":""TTCGAAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCGAAGC""}], + ""X5255"":[{""seq"":""CGGAATAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTATTCCG""}, {""seq"":""GTATTCCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTATTCCG""}], + ""X5256"":[{""seq"":""AACTGGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACCAGTT""}, {""seq"":""CACCAGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACCAGTT""}], + ""X5257"":[{""seq"":""GCTTCTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAAGAAGC""}, {""seq"":""CAAGAAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAAGAAGC""}], + ""X5258"":[{""seq"":""GCAATTCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGAATTGC""}, {""seq"":""CGAATTGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGAATTGC""}], + ""X5259"":[{""seq"":""AGGTCACT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTGACCT""}, {""seq"":""AGTGACCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTGACCT""}], + ""X5260"":[{""seq"":""CAGCGATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AATCGCTG""}, {""seq"":""AATCGCTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AATCGCTG""}], + ""X5261"":[{""seq"":""AACCTCCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGAGGTT""}, {""seq"":""AGGAGGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGAGGTT""}], + ""X5262"":[{""seq"":""TCGACATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATGTCGA""}, {""seq"":""GATGTCGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATGTCGA""}], + ""X5263"":[{""seq"":""CTGGTTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGAACCAG""}, {""seq"":""AGAACCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGAACCAG""}], + ""X5264"":[{""seq"":""ACAGCAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTTGCTGT""}, {""seq"":""GTTGCTGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTTGCTGT""}], + ""X5265"":[{""seq"":""GCATACAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTGTATGC""}, {""seq"":""CTGTATGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTGTATGC""}], + ""X5266"":[{""seq"":""CATCTACG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGTAGATG""}, {""seq"":""CGTAGATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGTAGATG""}], + ""X5267"":[{""seq"":""TTGTCGGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACCGACAA""}, {""seq"":""ACCGACAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACCGACAA""}], + ""X5268"":[{""seq"":""TAGCCGAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCGGCTA""}, {""seq"":""TTCGGCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCGGCTA""}], + ""X5269"":[{""seq"":""AGGCATAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTATGCCT""}, {""seq"":""CTATGCCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTATGCCT""}], + ""X5270"":[{""seq"":""TTGACAGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTGTCAA""}, {""seq"":""CCTGTCAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTGTCAA""}], + ""X5271"":[{""seq"":""TGCACCAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTGGTGCA""}, {""seq"":""TTGGTGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTGGTGCA""}], + ""X5272"":[{""seq"":""CCAGTGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACACTGG""}, {""seq"":""AACACTGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACACTGG""}], + ""X5273"":[{""seq"":""TGTCCAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCTGGACA""}, {""seq"":""TCTGGACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCTGGACA""}], + ""X5274"":[{""seq"":""GATTGGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCCAATC""}, {""seq"":""CTCCAATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCCAATC""}], + ""X5275"":[{""seq"":""ACGGTCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGACCGT""}, {""seq"":""AAGACCGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGACCGT""}], + ""X5276"":[{""seq"":""CTGCGTAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATACGCAG""}, {""seq"":""ATACGCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATACGCAG""}], + ""X5277"":[{""seq"":""CACCACTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGTGGTG""}, {""seq"":""TAGTGGTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGTGGTG""}], + ""X5278"":[{""seq"":""TGTGGTAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTACCACA""}, {""seq"":""GTACCACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTACCACA""}], + ""X5279"":[{""seq"":""ACATAGGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCCTATGT""}, {""seq"":""GCCTATGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCCTATGT""}], + ""X5280"":[{""seq"":""CAAGCAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTGCTTG""}, {""seq"":""ACTGCTTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTGCTTG""}], + ""X5281"":[{""seq"":""GCACGTAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTACGTGC""}, {""seq"":""TTACGTGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTACGTGC""}], + ""X5282"":[{""seq"":""TCGTAGTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GACTACGA""}, {""seq"":""GACTACGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GACTACGA""}], + ""X5283"":[{""seq"":""CACTGACA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGTCAGTG""}, {""seq"":""TGTCAGTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGTCAGTG""}], + ""X5284"":[{""seq"":""CGTGTACT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTACACG""}, {""seq"":""AGTACACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTACACG""}], + ""X5285"":[{""seq"":""GAGCTCAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTGAGCTC""}, {""seq"":""TTGAGCTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTGAGCTC""}], + ""X5286"":[{""seq"":""ACGTCGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACGACGT""}, {""seq"":""TACGACGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACGACGT""}], + ""X5287"":[{""seq"":""GTCTAGGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACCTAGAC""}, {""seq"":""ACCTAGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACCTAGAC""}], + ""X5288"":[{""seq"":""CTTCGTTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAACGAAG""}, {""seq"":""GAACGAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAACGAAG""}], + ""X5289"":[{""seq"":""CTGAGATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATCTCAG""}, {""seq"":""GATCTCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATCTCAG""}], + ""X5290"":[{""seq"":""GTGGATAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTATCCAC""}, {""seq"":""CTATCCAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTATCCAC""}], + ""X5291"":[{""seq"":""ACCATCCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGGATGGT""}, {""seq"":""TGGATGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGGATGGT""}], + ""X5292"":[{""seq"":""AGAGGTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAACCTCT""}, {""seq"":""CAACCTCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAACCTCT""}], + ""X5293"":[{""seq"":""ATGCCAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTTGGCAT""}, {""seq"":""GTTGGCAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTTGGCAT""}], + ""X5294"":[{""seq"":""GTTAAGGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCCTTAAC""}, {""seq"":""GCCTTAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCCTTAAC""}], + ""X5295"":[{""seq"":""ACCTGACT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTCAGGT""}, {""seq"":""AGTCAGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTCAGGT""}], + ""X5296"":[{""seq"":""GCCACTTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAAGTGGC""}, {""seq"":""TAAGTGGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAAGTGGC""}], + ""X5297"":[{""seq"":""ACCTCTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACAGAGGT""}, {""seq"":""ACAGAGGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACAGAGGT""}], + ""X5298"":[{""seq"":""GATCCATG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATGGATC""}, {""seq"":""CATGGATC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATGGATC""}], + ""X5299"":[{""seq"":""CGCTTAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTTAAGCG""}, {""seq"":""GTTAAGCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTTAAGCG""}], + ""X5300"":[{""seq"":""TGTCTGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCAGACA""}, {""seq"":""AGCAGACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCAGACA""}], + ""X5301"":[{""seq"":""ATAAGGCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGCCTTAT""}, {""seq"":""CGCCTTAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGCCTTAT""}], + ""X5302"":[{""seq"":""CGTCTTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACAAGACG""}, {""seq"":""ACAAGACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACAAGACG""}], + ""X5303"":[{""seq"":""CTCCATGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACATGGAG""}, {""seq"":""ACATGGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACATGGAG""}], + ""X5304"":[{""seq"":""TGTTCGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCGAACA""}, {""seq"":""CTCGAACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCGAACA""}], + ""X5305"":[{""seq"":""AGCAAGCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGCTTGCT""}, {""seq"":""TGCTTGCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGCTTGCT""}], + ""X5306"":[{""seq"":""CGTATTCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGAATACG""}, {""seq"":""CGAATACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGAATACG""}], + ""X5307"":[{""seq"":""AACGACGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACGTCGTT""}, {""seq"":""ACGTCGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACGTCGTT""}], + ""X5308"":[{""seq"":""GTTGCGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCGCAAC""}, {""seq"":""ATCGCAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCGCAAC""}], + ""X5309"":[{""seq"":""AACGTGGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCCACGTT""}, {""seq"":""TCCACGTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCCACGTT""}], + ""X5310"":[{""seq"":""CTGTGTTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAACACAG""}, {""seq"":""CAACACAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAACACAG""}], + ""X5311"":[{""seq"":""TGATACGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GCGTATCA""}, {""seq"":""GCGTATCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GCGTATCA""}], + ""X5312"":[{""seq"":""GTCCTTCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGAAGGAC""}, {""seq"":""AGAAGGAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGAAGGAC""}], + ""X5313"":[{""seq"":""ACAGACCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGTCTGT""}, {""seq"":""AGGTCTGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGTCTGT""}], + ""X5314"":[{""seq"":""TGTTGTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCACAACA""}, {""seq"":""CCACAACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCACAACA""}], + ""X5315"":[{""seq"":""CATCGTGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCACGATG""}, {""seq"":""TCACGATG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCACGATG""}], + ""X5316"":[{""seq"":""CAGGAGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCTCCTG""}, {""seq"":""ATCTCCTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCTCCTG""}], + ""X5317"":[{""seq"":""TAGGTAGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTACCTA""}, {""seq"":""CCTACCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTACCTA""}], + ""X5318"":[{""seq"":""AGTCGCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGCGACT""}, {""seq"":""AAGCGACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGCGACT""}], + ""X5319"":[{""seq"":""CGTTGAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTCAACG""}, {""seq"":""ACTCAACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTCAACG""}], + ""X5320"":[{""seq"":""TTCCTGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACAGGAA""}, {""seq"":""CACAGGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACAGGAA""}], + ""X5321"":[{""seq"":""TCGTCTCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGAGACGA""}, {""seq"":""TGAGACGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGAGACGA""}], + ""X5322"":[{""seq"":""TAACGAGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCTCGTTA""}, {""seq"":""CCTCGTTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCTCGTTA""}], + ""X5323"":[{""seq"":""CTGAAGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCTTCAG""}, {""seq"":""AGCTTCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCTTCAG""}], + ""X5324"":[{""seq"":""ATTGCGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACGCAAT""}, {""seq"":""CACGCAAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACGCAAT""}], + ""X5325"":[{""seq"":""CCAAGACT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTCTTGG""}, {""seq"":""AGTCTTGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTCTTGG""}], + ""X5326"":[{""seq"":""GCTGTAAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTTACAGC""}, {""seq"":""CTTACAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTTACAGC""}], + ""X5327"":[{""seq"":""GAGTGGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACCACTC""}, {""seq"":""AACCACTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACCACTC""}], + ""X5328"":[{""seq"":""AGCTTGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCAAGCT""}, {""seq"":""CTCAAGCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCAAGCT""}], + ""X5329"":[{""seq"":""ACGACAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCTGTCGT""}, {""seq"":""TCTGTCGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCTGTCGT""}], + ""X5330"":[{""seq"":""TTCGCAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTGCGAA""}, {""seq"":""ACTGCGAA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTGCGAA""}], + ""X5331"":[{""seq"":""CCGATGTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TACATCGG""}, {""seq"":""TACATCGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TACATCGG""}], + ""X5332"":[{""seq"":""TGACGCAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATGCGTCA""}, {""seq"":""ATGCGTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATGCGTCA""}], + ""X5333"":[{""seq"":""TCGCATTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAATGCGA""}, {""seq"":""CAATGCGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAATGCGA""}], + ""X5334"":[{""seq"":""CGTGATCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGATCACG""}, {""seq"":""TGATCACG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGATCACG""}], + ""X5335"":[{""seq"":""GTGAGCTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGCTCAC""}, {""seq"":""AAGCTCAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGCTCAC""}], + ""X5336"":[{""seq"":""AGCGGAAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATTCCGCT""}, {""seq"":""ATTCCGCT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATTCCGCT""}], + ""X5337"":[{""seq"":""CGAAGAAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTTCTTCG""}, {""seq"":""GTTCTTCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTTCTTCG""}], + ""X5338"":[{""seq"":""CCGTATCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGATACGG""}, {""seq"":""AGATACGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGATACGG""}], + ""X5339"":[{""seq"":""GTACTCTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAGAGTAC""}, {""seq"":""GAGAGTAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAGAGTAC""}], + ""X5340"":[{""seq"":""AGTGTTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAACACT""}, {""seq"":""CCAACACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAACACT""}], + ""X5341"":[{""seq"":""TGAACCTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGGTTCA""}, {""seq"":""CAGGTTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGGTTCA""}], + ""X5342"":[{""seq"":""TCAAGGAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTCCTTGA""}, {""seq"":""GTCCTTGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTCCTTGA""}], + ""X5343"":[{""seq"":""GTGCTTAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTAAGCAC""}, {""seq"":""GTAAGCAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTAAGCAC""}], + ""X5344"":[{""seq"":""GTGGTGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACACCAC""}, {""seq"":""AACACCAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACACCAC""}], + ""X5345"":[{""seq"":""GCTGACTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TAGTCAGC""}, {""seq"":""TAGTCAGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TAGTCAGC""}], + ""X5346"":[{""seq"":""TGCGAACT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGTTCGCA""}, {""seq"":""AGTTCGCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGTTCGCA""}], + ""X5347"":[{""seq"":""AATACGCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGCGTATT""}, {""seq"":""CGCGTATT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGCGTATT""}], + ""X5348"":[{""seq"":""ACACGGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACCGTGT""}, {""seq"":""AACCGTGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACCGTGT""}], + ""X5349"":[{""seq"":""CTGCACTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGTGCAG""}, {""seq"":""AAGTGCAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGTGCAG""}], + ""X5350"":[{""seq"":""TCAACTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAGTTGA""}, {""seq"":""CCAGTTGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAGTTGA""}], + ""X5351"":[{""seq"":""AGTTGGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCCAACT""}, {""seq"":""AGCCAACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCCAACT""}], + ""X5352"":[{""seq"":""CAGGTTAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTAACCTG""}, {""seq"":""CTAACCTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTAACCTG""}], + ""X5353"":[{""seq"":""ACACCAGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACTGGTGT""}, {""seq"":""ACTGGTGT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACTGGTGT""}], + ""X5354"":[{""seq"":""TGGATCAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTGATCCA""}, {""seq"":""GTGATCCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTGATCCA""}], + ""X5355"":[{""seq"":""TGACTTCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGAAGTCA""}, {""seq"":""CGAAGTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGAAGTCA""}], + ""X5356"":[{""seq"":""GTGTCTGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCAGACAC""}, {""seq"":""TCAGACAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCAGACAC""}], + ""X5357"":[{""seq"":""AGTTACGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCGTAACT""}, {""seq"":""CCGTAACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCGTAACT""}], + ""X5358"":[{""seq"":""ATCTCGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGCGAGAT""}, {""seq"":""AGCGAGAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGCGAGAT""}], + ""X5359"":[{""seq"":""GAAGGTTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAACCTTC""}, {""seq"":""GAACCTTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAACCTTC""}], + ""X5360"":[{""seq"":""GAGCTTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACAAGCTC""}, {""seq"":""ACAAGCTC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACAAGCTC""}], + ""X5361"":[{""seq"":""TCCAATCG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CGATTGGA""}, {""seq"":""CGATTGGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CGATTGGA""}], + ""X5362"":[{""seq"":""CGGTCATA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TATGACCG""}, {""seq"":""TATGACCG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TATGACCG""}], + ""X5363"":[{""seq"":""TGGCTATC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GATAGCCA""}, {""seq"":""GATAGCCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GATAGCCA""}], + ""X5364"":[{""seq"":""CAACGGAT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ATCCGTTG""}, {""seq"":""ATCCGTTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ATCCGTTG""}], + ""X5365"":[{""seq"":""CTCCTAGA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCTAGGAG""}, {""seq"":""TCTAGGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCTAGGAG""}], + ""X5366"":[{""seq"":""CCGGAATT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AATTCCGG""}, {""seq"":""AATTCCGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AATTCCGG""}], + ""X5367"":[{""seq"":""TAGACGTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CACGTCTA""}, {""seq"":""CACGTCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CACGTCTA""}], + ""X5368"":[{""seq"":""TGACTGAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTCAGTCA""}, {""seq"":""GTCAGTCA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTCAGTCA""}], + ""X5369"":[{""seq"":""TAGAGCTC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GAGCTCTA""}, {""seq"":""GAGCTCTA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GAGCTCTA""}], + ""X5370"":[{""seq"":""TCCGTGAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCACGGA""}, {""seq"":""TTCACGGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCACGGA""}], + ""X5371"":[{""seq"":""CTCGATAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTATCGAG""}, {""seq"":""GTATCGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTATCGAG""}], + ""X5372"":[{""seq"":""CTTACCTG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CAGGTAAG""}, {""seq"":""CAGGTAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CAGGTAAG""}], + ""X5373"":[{""seq"":""ATGGCGAA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TTCGCCAT""}, {""seq"":""TTCGCCAT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TTCGCCAT""}], + ""X5374"":[{""seq"":""TCCTACCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AGGTAGGA""}, {""seq"":""AGGTAGGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AGGTAGGA""}], + ""X5375"":[{""seq"":""CCTCAGTT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AACTGAGG""}, {""seq"":""AACTGAGG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AACTGAGG""}], + ""X5376"":[{""seq"":""CTACTTGG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CCAAGTAG""}, {""seq"":""CCAAGTAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CCAAGTAG""}], + ""X5377"":[{""seq"":""TCACAGCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGCTGTGA""}, {""seq"":""TGCTGTGA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGCTGTGA""}], + ""X5378"":[{""seq"":""CACGTTGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACAACGTG""}, {""seq"":""ACAACGTG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACAACGTG""}], + ""X5379"":[{""seq"":""AAGTCGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCGACTT""}, {""seq"":""CTCGACTT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCGACTT""}], + ""X5380"":[{""seq"":""TGTACCGT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""ACGGTACA""}, {""seq"":""ACGGTACA"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""ACGGTACA""}], + ""X5381"":[{""seq"":""CTCATCAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTGATGAG""}, {""seq"":""CTGATGAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTGATGAG""}], + ""X5382"":[{""seq"":""AGTCTCAC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTGAGACT""}, {""seq"":""GTGAGACT"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTGAGACT""}], + ""X5383"":[{""seq"":""CTTGGATG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CATCCAAG""}, {""seq"":""CATCCAAG"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CATCCAAG""}], + ""X5384"":[{""seq"":""GCCTATCA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TGATAGGC""}, {""seq"":""TGATAGGC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TGATAGGC""}], + } + }, + ""Sabeti Lab Custom RNA-seq v5"":{ + ""_short_name"":""nextera"", + ""i7"":{ + ""RPI1"":[{""seq"":""ATCACGAT"",""instruments"":[],""seq_in_adapter"":""ATCGTGAT""}], + ""RPI2"":[{""seq"":""CGATGTAT"",""instruments"":[],""seq_in_adapter"":""ATACATCG""}], + ""RPI3"":[{""seq"":""TTAGGCAT"",""instruments"":[],""seq_in_adapter"":""ATGCCTAA""}], + ""RPI4"":[{""seq"":""TGACCAAT"",""instruments"":[],""seq_in_adapter"":""ATTGGTCA""}], + ""RPI5"":[{""seq"":""ACAGTGAT"",""instruments"":[],""seq_in_adapter"":""ATCACTGT""}], + ""RPI6"":[{""seq"":""GCCAATAT"",""instruments"":[],""seq_in_adapter"":""ATATTGGC""}], + ""RPI7"":[{""seq"":""CAGATCAT"",""instruments"":[],""seq_in_adapter"":""ATGATCTG""}], + ""RPI8"":[{""seq"":""ACTTGAAT"",""instruments"":[],""seq_in_adapter"":""ATTCAAGT""}], + ""RPI9"":[{""seq"":""GATCAGAT"",""instruments"":[],""seq_in_adapter"":""ATCTGATC""}], + ""RPI10"":[{""seq"":""TAGCTTAT"",""instruments"":[],""seq_in_adapter"":""ATAAGCTA""}], + ""RPI11"":[{""seq"":""GGCTACAT"",""instruments"":[],""seq_in_adapter"":""ATGTAGCC""}], + ""RPI12"":[{""seq"":""CTTGTAAT"",""instruments"":[],""seq_in_adapter"":""ATTACAAG""}], + ""RPI13"":[{""seq"":""AGTCAAAT"",""instruments"":[],""seq_in_adapter"":""ATTTGACT""}], + ""RPI14"":[{""seq"":""AGTTCCAT"",""instruments"":[],""seq_in_adapter"":""ATGGAACT""}], + ""RPI15"":[{""seq"":""ATGTCAAT"",""instruments"":[],""seq_in_adapter"":""ATTGACAT""}], + ""RPI16"":[{""seq"":""CCGTCCAT"",""instruments"":[],""seq_in_adapter"":""ATGGACGG""}], + ""RPI17"":[{""seq"":""GTAGAGAT"",""instruments"":[],""seq_in_adapter"":""ATCTCTAC""}], + ""RPI18"":[{""seq"":""GTCCGCAT"",""instruments"":[],""seq_in_adapter"":""ATGCGGAC""}], + ""RPI19"":[{""seq"":""GTGAAAAT"",""instruments"":[],""seq_in_adapter"":""ATTTTCAC""}], + ""RPI20"":[{""seq"":""GTGGCCAT"",""instruments"":[],""seq_in_adapter"":""ATGGCCAC""}], + ""RPI21"":[{""seq"":""GTTTCGAT"",""instruments"":[],""seq_in_adapter"":""ATCGAAAC""}], + ""RPI22"":[{""seq"":""CGTACGAT"",""instruments"":[],""seq_in_adapter"":""ATCGTACG""}], + ""RPI23"":[{""seq"":""GAGTGGAT"",""instruments"":[],""seq_in_adapter"":""ATCCACTC""}], + ""RPI24"":[{""seq"":""GGTAGCAT"",""instruments"":[],""seq_in_adapter"":""ATGCTACC""}], + ""RPI25"":[{""seq"":""ACTGATAT"",""instruments"":[],""seq_in_adapter"":""ATATCAGT""}], + ""RPI26"":[{""seq"":""ATGAGCAT"",""instruments"":[],""seq_in_adapter"":""ATGCTCAT""}], + ""RPI27"":[{""seq"":""ATTCCTAT"",""instruments"":[],""seq_in_adapter"":""ATAGGAAT""}], + ""RPI28"":[{""seq"":""CAAAAGAT"",""instruments"":[],""seq_in_adapter"":""ATCTTTTG""}], + ""RPI29"":[{""seq"":""CAACTAAT"",""instruments"":[],""seq_in_adapter"":""ATTAGTTG""}], + ""RPI30"":[{""seq"":""CACCGGAT"",""instruments"":[],""seq_in_adapter"":""ATCCGGTG""}], + ""RPI31"":[{""seq"":""CACGATAT"",""instruments"":[],""seq_in_adapter"":""ATATCGTG""}], + ""RPI32"":[{""seq"":""CACTCAAT"",""instruments"":[],""seq_in_adapter"":""ATTGAGTG""}], + ""RPI33"":[{""seq"":""CAGGCGAT"",""instruments"":[],""seq_in_adapter"":""ATCGCCTG""}], + ""RPI34"":[{""seq"":""CATGGCAT"",""instruments"":[],""seq_in_adapter"":""ATGCCATG""}], + ""RPI35"":[{""seq"":""CATTTTAT"",""instruments"":[],""seq_in_adapter"":""ATAAAATG""}], + ""RPI36"":[{""seq"":""CCAACAAT"",""instruments"":[],""seq_in_adapter"":""ATTGTTGG""}], + ""RPI37"":[{""seq"":""CGGAATAT"",""instruments"":[],""seq_in_adapter"":""ATATTCCG""}], + ""RPI38"":[{""seq"":""CTAGCTAT"",""instruments"":[],""seq_in_adapter"":""ATAGCTAG""}], + ""RPI39"":[{""seq"":""CTATACAT"",""instruments"":[],""seq_in_adapter"":""ATGTATAG""}], + ""RPI40"":[{""seq"":""CTCAGAAT"",""instruments"":[],""seq_in_adapter"":""ATTCTGAG""}], + ""RPI41"":[{""seq"":""GACGACAT"",""instruments"":[],""seq_in_adapter"":""ATGTCGTC""}], + ""RPI42"":[{""seq"":""TAATCGAT"",""instruments"":[],""seq_in_adapter"":""ATCGATTA""}], + ""RPI43"":[{""seq"":""TACAGCAT"",""instruments"":[],""seq_in_adapter"":""ATGCTGTA""}], + ""RPI44"":[{""seq"":""TATAATAT"",""instruments"":[],""seq_in_adapter"":""ATATTATA""}], + ""RPI45"":[{""seq"":""TCATTCAT"",""instruments"":[],""seq_in_adapter"":""ATGAATGA""}], + ""RPI46"":[{""seq"":""TCCCGAAT"",""instruments"":[],""seq_in_adapter"":""ATTCGGGA""}], + ""RPI47"":[{""seq"":""TCGAAGAT"",""instruments"":[],""seq_in_adapter"":""ATCTTCGA""}], + ""RPI48"":[{""seq"":""TCGGCAAT"",""instruments"":[],""seq_in_adapter"":""ATTGCCGA""}], + }, + ""i5"":{ + ""RP1"":[{""seq"":""GTTCAGAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GTTCAGAG""}, {""seq"":""CTCTGAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GTTCAGAG""}], + ""RP1-v4"":[{""seq"":""AAGTGCTA"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""AAGTGCTA""}, {""seq"":""CTCTGAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""AAGTGCTA""}], + ""RP2-v4"":[{""seq"":""CTCGAAGC"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""CTCGAAGC""}, {""seq"":""CTCTGAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""CTCGAAGC""}], + ""RP3-v4"":[{""seq"":""TCACTGCT"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""TCACTGCT""}, {""seq"":""CTCTGAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""TCACTGCT""}], + ""RP4-v4"":[{""seq"":""GGTACTAG"",""instruments"":[""MiSeq"",""HiSeq 2000"",""HiSeq 2500"",""NovaSeq""],""seq_in_adapter"":""GGTACTAG""}, {""seq"":""CTCTGAAC"",""instruments"":[""iSeq"",""MiniSeq"",""NextSeq"",""HiSeq 3000"",""HiSeq 4000""],""seq_in_adapter"":""GGTACTAG""}], + } + }, + } + + @classmethod + @memoize + def neighbors(cls, seq, distance=1): + ''' Returns a list Hamming-distance of 1 from the input seq''' + neighbor_list = [] + + seq = seq.rstrip() + for i in range(0, len(seq.rstrip())): + for j in [""A"", ""C"", ""G"", ""T"", ""N""]: + if j == seq[i].upper(): + continue # Do not include the seq itself + q = seq[0:i] + j + seq[i+1:] + neighbor_list.append(q) + + if distance==1: + return sorted(neighbor_list) + else: + return sorted(list(set([item for sublist in (cls.neighbors(s, distance=distance-1) for s in neighbor_list) for item in sublist if item!=seq]))) + + @staticmethod + def reverse_complement(seq): + """""" + Returns the reverse complement using string.maketrans + """""" + table = bytearray.maketrans(b""ACTGN"",b""TGACN"") + return bytearray(seq.encode(""UTF8"")).translate(table)[::-1].decode(""UTF8"") + + @property + @memoize + def _barcodes_meta_all(self): + barcodes = [] + for kit_name,kit_value in self._kits.items(): + for item_key,item_value in kit_value.items(): + + if type(item_value) == dict: + for index_name,index_value in item_value.items(): + for barcode_meta in index_value: + barcodes.append(barcode_meta) + return barcodes + + @classmethod + @memoize + def kits(cls): + return sorted(list(cls._kits.keys())) + + @property + def instruments(self): + instruments = set() + for barcode_meta in self._barcodes_meta_all: + ins_for_barcode = barcode_meta.get(""instruments"","""") + if len(ins_for_barcode): + + instruments |= set(ins_for_barcode) + return sorted(list(instruments)) + + @memoize + def index_for_seq(self, seq, kit=None, instrument=None): + # use kit/instrument passed in if present + # value forinstrument, if present, if neither return list of options + possible_indices = set() + for kit_name,kit_value in self._kits.items(): + if not kit or (kit_name == kit) or (kit_value[""_short_name""]==kit): + for item_key,item_value in kit_value.items(): + if type(item_value) == dict: + for index_name,index_value in item_value.items(): + for barcode_meta in index_value: + if barcode_meta[""seq""] == seq: + if not instrument or instrument in barcode_meta[""instruments""]: + possible_indices |= set([index_name]) + return sorted(list(possible_indices)) + + @memoize + def seq_for_index(self, index, kit=None, instrument=None): + # use kit/instrument passed in if present + # value forinstrument, if present, if neither return list of options + possible_seqs = set() + for kit_name,kit_value in self._kits.items(): + if not kit or (kit_name == kit) or (kit_value[""_short_name""]==kit): + for item_key,item_value in kit_value.items(): + if type(item_value) == dict: + for index_name,index_value in item_value.items(): + matches = re.match(""(?P""+index_name+"")"", index) + if matches: + for barcode_meta in index_value: + if not instrument or instrument in barcode_meta[""instruments""]: + possible_seqs |= set([barcode_meta[""seq""]]) + return sorted(list(possible_seqs)) + + @memoize + def guess_index(self, seq, distance=1, kit=None, instrument=None): + # using neighbors()... + # use kit/instrument if present + possible_indices = set() + # first include exact matches + exact_matches = self.index_for_seq(seq, kit=kit, instrument=instrument) + if len(exact_matches): + possible_indices |= set(exact_matches) + else: + # then include barcodes _distance_ away + for neighbor_seq in self.neighbors(seq, distance=distance): + possible_indices |= set(self.index_for_seq(neighbor_seq, kit=kit, instrument=instrument)) + return sorted(list(possible_indices)) + +class UncertainSamplesheetError(Exception): + pass + +class IlluminaBarcodeHelper(object): + index_reference = IlluminaIndexReference() + def __init__(self, barcode_counts, picard_metrics, sample_name, rows_limit=1000): + # (barcode1,barcode2): count + self.barcodes_seen = OrderedDict() + # barcode: illumina index name (N507, etc.) + self.barcode_name_map = OrderedDict() + # sample_name: (barcode1,barcode2) + self.sample_to_barcodes = OrderedDict() + # list of all sample names (barcode_name from Picard metrics file) + self.samples = [] + # sample_name: count + self.sample_to_read_counts = OrderedDict() + # unresolved barcode pair count + self.unassigned_read_count = 0 + + # read Picard demux metrics file + for row in util.file.read_tabfile_dict(picard_metrics, skip_prefix=""#""): + barcodes = tuple(row[""BARCODE""].split(""-"")) + if ""BARCODE_NAME"" in row: + self.sample_to_barcodes[row[""BARCODE_NAME""]] = barcodes + self.samples.append(row[""BARCODE_NAME""]) + self.sample_to_read_counts[row[""BARCODE_NAME""]] = int(row[""READS""]) + elif all(re.match(r'^N+$',barcode) for barcode in barcodes): + self.unassigned_read_count = int(row[""READS""]) + continue + + # read barcodes seen in the file, in the format: + #Barcode1 Likely_Index_Names1 Barcode2 Likely_Index_Names2 Count + #CTCTCTAC N707 AAGGAGTA S507,[N|S|E]507 40324834 + for row in util.file.read_tabfile_dict(barcode_counts, rowcount_limit=rows_limit): + if (row[""Barcode1""],row.get(""Barcode2"",None)) not in self.barcodes_seen: + self.barcodes_seen[(row[""Barcode1""],row.get(""Barcode2"",None))] = int(row[""Count""]) + self.barcode_name_map[row[""Barcode1""]] = row[""Likely_Index_Names1""] + if ""Barcode2"" in row and row[""Barcode2""]: + self.barcode_name_map[row[""Barcode2""]] = row[""Likely_Index_Names2""] + + def outlier_barcodes(self, outlier_threshold=0.675, expected_assigned_fraction=0.7, number_of_negative_controls=1): + """""" + This identifies samples listed in the Picard metrics (derived from + the sample sheet) that are believed to have an anomalously low + number of reads after demultiplexing, based on the following assumptions: + - The pool of samples will have (at least) one negative control that should yield zero reads + - The total number of reads should be evenly distributed among the rest of the samples + since the nucleic acid concentration should be roughly balanced in the pool + - The variation among what should be evenly distributed is gaussian + + + A warning is raised if <70% of the total reads are assigned (likely indicating + multiple problems with the samplesheet). + + Loosely based on the method for outlier detection specified in + Boris Iglewicz and David Hoaglin (1993), + ""Volume 16: How to Detect and Handle Outliers"", + The ASQC Basic References in Quality Control: Statistical Techniques + + Params: + outlier_threshold (float): 0.675 corresponds to 75th percentile + expected_assigned_fraction (float): fraction of reads assigned to samples + number_of_negative_controls (int): the number of samples in the pool expected to have zero reads + """""" + assigned_read_count = sum(self.sample_to_read_counts.values()) + total_read_count = assigned_read_count+self.unassigned_read_count + fraction_assigned = float(assigned_read_count)/float(total_read_count) + log.info(""fraction_assigned %s"", fraction_assigned) + if fraction_assigned < expected_assigned_fraction: + raise UncertainSamplesheetError(""Only {:.0%} of reads were assigned to barcode pairs listed in the samplesheet. Check the sample sheet for errors."".format(fraction_assigned)) + + num_samples = len(self.sample_to_read_counts) + log_obs_fractions_of_pool = [ -math.log(float(x)/float(total_read_count),10) if x>0 + else 0 + for x in + list(self.sample_to_read_counts.values())+[self.unassigned_read_count] + ] + + log_exp_fractions_of_pool = [-math.log(1.0/float(num_samples-number_of_negative_controls),10)]*num_samples + [0] + + residuals = [obs-exp for (obs,exp) in zip(log_obs_fractions_of_pool,log_exp_fractions_of_pool)] + resid_stdev = self.stddevp(residuals) #essentially RMSE + resid_mean = self.mean(residuals) # mean error + resid_median = self.median(residuals) # median error + + # modifed zscore using median to reduce influence of outliers + zscores_residual_relative_to_median = [float(1.0 * (x-resid_median))/resid_stdev for x in residuals] + # only consider LOW variance + indices_of_outliers = [i for i,v in enumerate(zscores_residual_relative_to_median[:-1]) if v > outlier_threshold] + indices_of_outliers += [i for i,v in enumerate(list(self.sample_to_read_counts.values())[:-1]) if v==0] + names_of_outlier_samples = [(list(self.sample_to_read_counts.keys()))[i] for i in indices_of_outliers] + log.warning(""outlier samples"") + for s in names_of_outlier_samples: + log.warning(""\t%s (%s reads)"", s,self.sample_to_read_counts[s]) + + return names_of_outlier_samples + + @classmethod + def mean(cls, nums): + return sum(nums) / len(nums) + + @classmethod + def stddevp(cls, nums): + """"""population standard deviation of nums"""""" + mn = cls.mean(nums) + variance = sum([(e-mn)**2 for e in nums]) / len(nums) + return math.sqrt(variance) + + @classmethod + def median(cls, nums): + length = len(nums) + if length < 1: + return None + if length % 2 == 1: + # if this is a list with an odd number of elements, + # return the middle element from a sorted version of the list + return sorted(nums)[length//2] + else: + # otherwise if the list has an even number of elements + # return the interpolated mean of the middle two numbers + return sum(sorted(nums)[length//2-1:length//2+1])/2.0 + + + def guess_barcodes_for_sample(self, sample_name): + """""" + This guesses the barcode value for a sample name, + based on the following: + - a list is made of novel barcode pairs seen in the data, but not in the picard metrics + - for the sample in question, get the most abundant novel barcode pair where one of the + barcodes seen in the data matches one of the barcodes in the picard metrics (partial match) + - if there are no partial matches, get the most abundant novel barcode pair + + Limitations: + - If multiple samples share a barcode with multiple novel barcodes, disentangling them + is difficult or impossible + """""" + # output_header = [""sample_name"", + # ""expected_barcode_1"",""expected_barcode_1_name"", + # ""expected_barcode_2"",""expected_barcode_2_name"" + # ""expected_barcodes_read_count"", + # ""guessed_barcode_1"",""guessed_barcode_1_name"", + # ""guessed_barcode_2"",""guessed_barcode_2_name"" + # ""guessed_barcodes_read_count"", + # ""match_type"" + # ] + + out_dict = OrderedDict() + out_dict[""sample_name""] = sample_name + + barcodes_seen_novel = copy.deepcopy(self.barcodes_seen) + + # From barcodes seen in data, collect barcode pairs not expected based on sample sheet + novel_barcode_pairs = [] + + for barcode_pair in self.barcodes_seen.keys(): + if barcode_pair not in self.sample_to_barcodes.values(): + novel_barcode_pairs.append(barcode_pair) + else: + del barcodes_seen_novel[barcode_pair] + + is_dual_index = len(self.sample_to_barcodes[sample_name]) > 1 + + out_dict[""expected_barcode_1""] = self.sample_to_barcodes[sample_name][0] + out_dict[""expected_barcode_1_name""] = "","".join(self.index_reference.guess_index(self.sample_to_barcodes[sample_name][0])) + if is_dual_index: + out_dict[""expected_barcode_2""] = self.sample_to_barcodes[sample_name][1] + out_dict[""expected_barcode_2_name""] = "","".join(self.index_reference.guess_index(self.sample_to_barcodes[sample_name][1])) + out_dict[""expected_barcodes_read_count""] = self.sample_to_read_counts[sample_name] + + claimed_barcodes = self.sample_to_barcodes[sample_name] + + found_partial_match = False + putative_match = None + + if is_dual_index: + # barcodes_seen_novel is sorted by read count, desc + for (barcode_pair,count) in barcodes_seen_novel.items(): + if barcode_pair[0]==claimed_barcodes[0] or barcode_pair[1]==claimed_barcodes[1]: + found_partial_match=True + putative_match = barcode_pair + out_dict[""match_type""] = ""one_barcode_match"" + break + + # find index of match to help determine if it is a reasonable guess + idx_of_match = -1 + for (idx,(barcode_pair,count)) in enumerate(self.barcodes_seen.items()): + if barcode_pair==putative_match: + idx_of_match=idx + break + + # if the one-barcode match is too far down the list of barcode pairs seen + # (farther down than 1.5x the number of samples) + if not found_partial_match or idx_of_match>(len(self.sample_to_read_counts)*1.5): + for (barcode_pair,count) in barcodes_seen_novel.items(): + # return the most pair with greatest count + putative_match = barcode_pair + out_dict[""match_type""] = ""high_count_novel_pair"" + break + + if putative_match[0]!=None: + out_dict[""guessed_barcode_1""] = putative_match[0] + out_dict[""guessed_barcode_1_name""] = self.barcode_name_map[putative_match[0]] + if is_dual_index and putative_match[1] != None: + out_dict[""guessed_barcode_2""] = putative_match[1] + out_dict[""guessed_barcode_2_name""] = self.barcode_name_map[putative_match[1]] + out_dict[""guessed_barcodes_read_count""] = self.barcodes_seen[(putative_match[0],putative_match[1])] + + return out_dict + + + def find_uncertain_barcodes(self, sample_names=None, outlier_threshold=0.675, expected_assigned_fraction=0.7, number_of_negative_controls=1, readcount_threshold=None): + """""" + If sample_names is specified, barcodes for the named samples + will be re-examined. + + If readcount_threshold is specified, this will be used as the + cutoff above which sample barcodes will not be re-examined. + If this is not specified, outliers will be detected automatically. + """""" + samples_to_examine = sample_names or [] + + guessed_barcodes = [] + + if not samples_to_examine: + if readcount_threshold: + for sample_name,count in self.sample_to_read_counts.values(): + if count < readcount_threshold: + samples_to_examine.append(sample_name) + else: + samples_to_examine = self.outlier_barcodes(outlier_threshold=outlier_threshold, expected_assigned_fraction=expected_assigned_fraction, number_of_negative_controls=number_of_negative_controls) + + for s in samples_to_examine: + guessed_barcodes.append(self.guess_barcodes_for_sample(s)) + + consolidated_guesses = defaultdict(list) + + for row in guessed_barcodes: + consolidated_guesses[(row[""guessed_barcode_1""],row.get(""guessed_barcode_2"",None))].append(row) + + final_guesses = [] + + def clear_guessed_fields(sample,match_reason,fields_to_clear=None): + fields_to_clear = fields_to_clear or [""guessed_barcode_1"", ""guessed_barcode_2"", + ""guessed_barcode_1_name"", ""guessed_barcode_2_name"", + ""guessed_barcodes_read_count""] + for field in fields_to_clear: + if field in sample: + sample[field] = None + sample[""match_type""] = match_reason + return sample + + for barcode_pair,samples in consolidated_guesses.items(): + if len(samples) > 1: + log.warning(""Ambiguous! Multiple samples corresponding to guessed barcodes %s:"", barcode_pair) + for sample in samples: + log.warning(""\t%s expected (%s,%s); -> Guessed (%s,%s); match type: %s"", sample[""sample_name""], sample[""expected_barcode_1""],sample.get(""expected_barcode_2"",""""),sample[""guessed_barcode_1""],sample.get(""guessed_barcode_2"",""""),sample[""match_type""]) + + final_guesses.append(clear_guessed_fields(sample, ""alternative_indices_uncertain"")) + else: + for sample in samples: + if sample[""guessed_barcodes_read_count""] < sample[""expected_barcodes_read_count""]: + final_guesses.append(clear_guessed_fields(sample, ""alternatives_have_lower_read_counts"")) + else: + final_guesses.append(sample) + return final_guesses + + def write_guessed_barcodes(self, out_tsv, guessed_barcodes): + possible_header_cols = [""sample_name"", + ""expected_barcode_1"",""expected_barcode_2"", + ""expected_barcode_1_name"",""expected_barcode_2_name"", + ""expected_barcodes_read_count"", + ""guessed_barcode_1"", ""guessed_barcode_2"", + ""guessed_barcode_1_name"", ""guessed_barcode_2_name"", + ""guessed_barcodes_read_count"", + ""match_type"" + ] + output_header_columns = [] + for header_key in possible_header_cols: + for row in guessed_barcodes: + if header_key in row.keys() and header_key not in output_header_columns: + output_header_columns.append(header_key) + + with open(out_tsv, 'w') as tsvfile: + csv.register_dialect('dict_tsv', quoting=csv.QUOTE_MINIMAL, delimiter=""\t"") + writer = csv.DictWriter(tsvfile, fieldnames=output_header_columns, dialect=""dict_tsv"") + + writer.writeheader() + writer.writerows(guessed_barcodes) +","Python" +"Viral","broadinstitute/viral-ngs","util/version.py",".py","4146","131","#!/usr/bin/python +''' This gets the git version into python-land +''' + +__author__ = ""dpark@broadinstitute.org"" +__version__ = None + +import subprocess +import os +import re +import time, datetime +import os.path +import util.misc + + +def get_project_path(): + '''Return the absolute path of the top-level project, assumed to be the + parent of the directory containing this script.''' + # abspath converts relative to absolute path; expanduser interprets ~ + path = __file__ # path to this script + path = os.path.expanduser(path) # interpret ~ + path = os.path.abspath(path) # convert to absolute path + path = os.path.dirname(path) # containing directory: util + path = os.path.dirname(path) # containing directory: main project dir + return path + + +def call_git_describe(): + cwd = os.getcwd() + try: + os.chdir(get_project_path()) + cmd = ['git', 'describe', '--tags', '--always', '--dirty'] + result = util.misc.run_and_print(cmd, silent=True) + ver = None + if result.returncode == 0: + out = result.stdout + if not isinstance(out, str): + out = out.decode('utf-8') + ver = out.strip() + except Exception: + ver = None + os.chdir(cwd) + return ver + + +def release_file(): + return os.path.join(get_project_path(), 'VERSION') + + +def read_release_version(): + try: + with open(release_file(), 'rt') as inf: + version = inf.readlines()[0].strip() + except Exception: + version = None + return version + + +def write_release_version(version): + with open(release_file(), 'wt') as outf: + outf.write(version + '\n') + + +def approx_version_number(): + """""" + In the event that git is unavailable and the VERSION file is not present + this returns a ""version number"" in the following precedence: + - version number from path + downloads of viral-ngs from GitHub tagged releases + are likely to be extracted into directories containing + the version number. If they contain a version number + in the form d.d.d, we can use it + - modification time of this file (unix timestamp) + file modification time for github releases corresponds to + when the release archives were created, a rough way to ballpark + the release date. If we can't get the version number from the path + we can at least use the modification time of this file as a proxy + for the true version number + - the current time (unix timestamp) + the current time is better than not having any version number + """""" + version = """" + + version_re = re.compile(r""(?:(\d+)\.)?(?:(\d+)\.)?(?:(\d+))"") + # path relative to version.py + viral_ngs_path = os.path.basename(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + + # for tagged releases, it is likely the version number is part of + # the viral-ngs root directory name + matches = version_re.search(viral_ngs_path) + + if matches and len([n for n in matches.groups() if n]) == 3: + version = ""."".join( map(str,matches.groups()) ) + else: + try: + mtime = os.path.getmtime(__file__) + except OSError: + mtime = 0 + + if mtime > 0: + # if we could get the modification time of the current file, use it + version = str(int(mtime)) + else: + # just use the current time + version = str(int(time.time())) + + return version + +def get_version(): + global __version__ + if __version__ is None: + from_git = call_git_describe() + from_file = read_release_version() + + if from_git: + if from_file != from_git: + write_release_version(from_git) + __version__ = from_git + else: + __version__ = from_file + + if __version__ is None: + __version__ = approx_version_number() + #raise ValueError(""Cannot find the version number!"") + + return __version__ + + +if __name__ == ""__main__"": + print(get_version()) +","Python" +"Viral","broadinstitute/viral-ngs","util/__init__.py",".py","1","2"," +","Python" +"Viral","broadinstitute/viral-ngs","util/cmd.py",".py","11749","288","'''This gives a main() function that serves as a nice wrapper +around other commands and presents the ability to serve up multiple +command-line functions from a single python script. +''' + +import os +import os.path +import tempfile +import textwrap +import sys +import shutil +import logging +import argparse +import importlib +import inspect +import collections + +import util.version +import util.file + +__author__ = ""dpark@broadinstitute.org"" +__version__ = util.version.get_version() + +log = logging.getLogger() +tmp_dir = None + +class color(object): + """""" *nix terminal control characters for altering text display + """""" + PURPLE = '\033[95m' + CYAN = '\033[96m' + DARKCYAN = '\033[36m' + BLUE = '\033[94m' + GREEN = '\033[92m' + YELLOW = '\033[93m' + RED = '\033[91m' + BOLD = '\033[1m' + UNDERLINE = '\033[4m' + END = '\033[0m' + +def setup_logger(log_level): + loglevel = getattr(logging, log_level.upper(), None) + assert loglevel, ""unrecognized log level: %s"" % log_level + log.setLevel(loglevel) + h = logging.StreamHandler() + h.setFormatter(logging.Formatter(""%(asctime)s - %(module)s:%(lineno)d:%(funcName)s - %(levelname)s - %(message)s"")) + log.addHandler(h) + + +def script_name(): + return os.path.basename(sys.argv[0]).rsplit('.', 1)[0] + + +def common_args(parser, arglist=(('tmp_dir', None), ('loglevel', None))): + for k, v in arglist: + if k == 'loglevel': + if not v: + v = 'INFO' + parser.add_argument(""--loglevel"", + dest=""loglevel"", + help=""Verboseness of output. [default: %(default)s]"", + default=v, + choices=('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', 'EXCEPTION')) + elif k == 'tmp_dir': + if not v: + v = find_tmp_dir() + parser.add_argument(""--tmp_dir"", + dest=""tmp_dir"", + help=""Base directory for temp files. [default: %(default)s]"", + default=v) + parser.add_argument(""--tmp_dirKeep"", + action=""store_true"", + dest=""tmp_dirKeep"", + help=""""""Keep the tmp_dir if an exception occurs while + running. Default is to delete all temp files at + the end, even if there's a failure."""""", + default=False) + elif k == 'threads': + if v is None: + text_default = ""all available cores"" + else: + text_default = v + parser.add_argument('--threads', + dest=""threads"", + type=int, + help=""Number of threads (default: {})"".format(text_default), + default=v) + elif k == 'version': + if not v: + v = __version__ + parser.add_argument('--version', '-V', action='version', version=v) + else: + raise Exception(""unrecognized argument %s"" % k) + return parser + + +def main_command(mainfunc): + ''' This wraps a python method in another method that can be called + with an argparse.Namespace object. When called, it will pass all + the values of the object on as parameters to the function call. + ''' + + def _main(args): + args2 = dict((k, v) for k, v in vars(args).items() if k not in ( + 'loglevel', 'tmp_dir', 'tmp_dirKeep', 'version', 'func_main', 'command')) + mainfunc(**args2) + + _main.__doc__ = mainfunc.__doc__ + return _main + + +def attach_main(parser, cmd_main, split_args=False): + ''' This attaches the main function call to a parser object. + ''' + if split_args: + cmd_main = main_command(cmd_main) + parser.description = cmd_main.__doc__ + parser.set_defaults(func_main=cmd_main) + return parser + +class _HelpAction(argparse._HelpAction): + + def __call__(self, parser, namespace, values, option_string=None): + + print(""\nEnter a subcommand to view additional information:"") + + # retrieve subparser actions from parser + subparsers_actions = [ + action for action in parser._actions + if isinstance(action, argparse._SubParsersAction)] + + indent_space = "" "" * 5 + for subparsers_action in subparsers_actions: + # get all subparsers and print descriptions for each + for choice, subparser in subparsers_action.choices.items(): + print(""\n{indent}{filename} {cmd} [...]"".format(indent=indent_space, filename=os.path.basename(sys.argv[0]), cmd=color.BOLD+choice+color.END)) + + # if the subparser has a description string, format and print it + if subparser.description: + # clean up line breaks and spaces in the triple-quoted string + help_description = subparser.description.replace(""\n"","""").replace("". "","". "").replace("" "","""").replace(""\t"","""") + help_description = help_description.strip() + # wrap text to a set width + help_description = textwrap.fill(help_description, 60) + # indent each line + help_description = help_description.replace(""\n"",""\n{}"".format(indent_space*2)) + print(""{}{}"".format(indent_space*2, help_description)) + + print() + parser.print_help() + + parser.exit() + + +def make_parser(commands, description): + ''' commands: a list of pairs containing the following: + 1. name of command (string, no whitespace) + 2. method to call (no arguments) that returns an argparse parser. + If commands contains exactly one member and the name of the + only command is None, then we get rid of the whole multi-command + thing and just present the options for that one function. + description: a long string to present as a description of your script + as a whole if the script is run with no arguments + ''' + if len(commands) == 1 and commands[0][0] == None: + # only one (nameless) command in this script, simplify + parser = commands[0][1]() + parser.set_defaults(command='') + else: + # multiple commands available + parser = argparse.ArgumentParser(description=description, usage='%(prog)s subcommand', add_help=False) + parser.add_argument('--help', '-h', action=_HelpAction, help=argparse.SUPPRESS) + parser.add_argument('--version', '-V', action='version', version=__version__, help=argparse.SUPPRESS) + subparsers = parser.add_subparsers(title='subcommands', dest='command', metavar='\033[F') # \033[F moves cursor up + for cmd_name, cmd_parser in commands: + help_str = cmd_parser.__doc__ if cmd_parser.__doc__ and len(cmd_parser.__doc__) else None + # give a blank string for help if the parser docstring is null + # so sphinx-argparse doesnt't render ""Undocumented"" + if (not help_str) and os.environ.get('READTHEDOCS') or 'sphinx' in sys.modules: + help_str = "" "" + p = subparsers.add_parser(cmd_name, help=help_str, formatter_class=argparse.ArgumentDefaultsHelpFormatter) + cmd_parser(p) + return parser + + +def main_argparse(commands, description): + parser = make_parser(commands, description) + + # if called with no arguments, print help + if len(sys.argv) == 1: + parser.parse_args(['--help']) + elif len(sys.argv) == 2 and (len(commands) > 1 or commands[0][0] != None): + parser.parse_args([sys.argv[1], '--help']) + args = parser.parse_args() + + setup_logger(not hasattr(args, 'loglevel') and 'DEBUG' or args.loglevel) + log.info(""software version: %s, python version: %s"", __version__, sys.version) + log.info(""command: %s %s %s"", sys.argv[0], sys.argv[1], + ' '.join([""%s=%s"" % (k, v) for k, v in vars(args).items() if k not in ('command', 'func_main')])) + + if hasattr(args, 'tmp_dir'): + # If this command has a tmp_dir option, use that as a base directory + # and create a subdirectory within it which we will then destroy at + # the end of execution. + + proposed_dir = 'tmp-%s-%s' % (script_name(), args.command) + for e in ('LSB_JOBID', 'JOB_ID'): # LSB_JOBID is for LSF, JOB_ID is for UGER/GridEngine + if e in os.environ: + proposed_dir = 'tmp-%s-%s-%s-%s' % (script_name(), args.command, os.environ[e], + os.environ.get('LSB_JOBINDEX','0')) + break + tempfile.tempdir = tempfile.mkdtemp(prefix='%s-' % proposed_dir, dir=args.tmp_dir) + log.debug(""using tempDir: %s"", tempfile.tempdir) + os.environ['TMPDIR'] = tempfile.tempdir # this is for running R + try: + ret = args.func_main(args) + finally: + if (hasattr(args, 'tmp_dirKeep') and args.tmp_dirKeep) or util.file.keep_tmp(): + log.debug(""After running %s, saving tmp_dir at %s"", args.command, tempfile.tempdir) + else: + shutil.rmtree(tempfile.tempdir) + else: + # otherwise just run the command + ret = args.func_main(args) + if ret is None: + ret = 0 + return ret + + +def find_tmp_dir(): + ''' This provides a suggested base directory for a temp dir for use in your + argparse-based tmp_dir option. + ''' + tmpdir = '/tmp' + if os.access('/local/scratch', os.X_OK | os.W_OK | os.R_OK) and os.path.isdir('/local/scratch'): + tmpdir = '/local/scratch' + # LSB_JOBID is for LSF, JOB_ID is for UGER/GridEngine + for e in ('LSB_JOBID', 'JOB_ID'): + if e in os.environ: + # this directory often exists for LSF jobs, but not always. + # for example, if the job is part of a job array, this directory is called + # something unpredictable and unfindable, so just use /local/scratch + proposed_dir = '/local/scratch/%s.tmpdir' % os.environ[e] + if os.access(proposed_dir, os.X_OK | os.W_OK | os.R_OK): + tmpdir = proposed_dir + break + if 'TMPDIR' in os.environ and os.path.isdir(os.environ['TMPDIR']): + tmpdir = os.environ['TMPDIR'] + return tmpdir + +class BadInputError(RuntimeError): + + '''Indicates that an invalid input was given to a command''' + + def __init__(self, reason): + super(BadInputError, self).__init__(reason) + +def check_input(condition, error_msg): + '''Check input to a command''' + if not condition: + raise BadInputError(error_msg) + +def parse_cmd(module, cmd, args): + """"""Parse arguments `args` to command `cmd` from module `module`."""""" + if isinstance(module, str): + module = importlib.import_module(module) + assert inspect.ismodule(module) + parser_fn = dict(getattr(module, '__commands__'))[cmd] + return parser_fn(argparse.ArgumentParser()).parse_args(list(map(str, args))) + +CmdRunInfo = collections.namedtuple('CmdRunInfo', ['result', 'args_parsed']) + +def run_cmd(module, cmd, args): + """"""Run command after parsing its arguments with the command's parser. + + Args: + module: the module object for the script containing the command + cmd: the command name + args: list of args to the command + + Returns: + a CmdRunInfo namedtuple with info about the run + """""" + log.info('Calling command {} with args {}'.format(cmd, args)) + args_parsed = parse_cmd(module, cmd, args) + result = args_parsed.func_main(args_parsed) + return CmdRunInfo(result=result, args_parsed=args_parsed) +","Python" +"Viral","broadinstitute/viral-ngs","util/genbank.py",".py","8487","225","#!/usr/bin/python + +# built-ins +import time +import os +import re +import logging + +# third-party +from Bio import Entrez + +log = logging.getLogger(__name__) + + +def parse_accession_str(chr_ref): + ''' + This tries to match an NCBI accession as defined here: + http://www.ncbi.nlm.nih.gov/Sequin/acc.html + ''' + m = re.search(r""(?P(?:[a-zA-Z]{1,6}|NC_)\d{1,10})(?:\.(?P\d+))?.*"", chr_ref) + if m: + chr_ref = m.group(""accession"") + return chr_ref + +def get_feature_table_id(featureTableFile): + with open(featureTableFile, 'rt') as inf: + for line in inf: + line = line.rstrip('\r\n') + if not line: + pass + elif line.startswith('>'): + # sequence identifier + if not line.startswith('>Feature '): + raise Exception(""not sure how to handle a non-Feature record"") + seqid = line[len('>Feature '):].strip() + if not ( + (seqid.startswith('gb|') or seqid.startswith('ref|'))): + raise Exception(""reference annotation ID does not appear to refer to a GenBank or RefSeq accession: %s"" % seqid) + m = re.search(r""(?P(?:gb|ref|dbj))\|(?:(?P[a-zA-Z0-9\._]+))+.*"", seqid) + if m: + seqid = m.group(""accession"") + else: + raise Exception(""Error parsing accession: %s"" % seqid) + return seqid + +def _seq_chunks(seq, n): + # http://stackoverflow.com/a/312464/190597 (Ned Batchelder) + """""" Yield successive n-sized chunks from seq."""""" + for i in range(0, len(seq), n): + yield seq[i:i + n] + +def _fetch_from_nuccore(accessionList, destinationDir, emailAddress, + forceOverwrite=False, rettype=""fasta"", retmode=""text"", + fileExt=None, combinedFilePrefix=None, removeSeparateFiles=False, + chunkSize=1, api_key=None): + """""" + This function downloads and saves files from NCBI nuccore. + """""" + db = ""nuccore"" + Entrez.email = emailAddress + if api_key is not None: + Entrez.api_key = api_key + Entrez.tool = ""https://github.com/broadinstitute/viral-ngs"" + + maxChunkSize = 500 + + # Conform to NCBI retreival guidelines by chunking into 500-accession chunks if + # >500 accessions are specified and chunkSize is set to 1 + # Also clamp chunk size to 500 if the user specified a larger value. + if chunkSize > maxChunkSize or (len(accessionList) > maxChunkSize and chunkSize == 1): + chunkSize = maxChunkSize + + outEx = {""fasta"": ""fasta"", ""ft"": ""tbl"", ""gb"": ""gbk""} + + assert rettype in outEx.keys( + ), ""The return type requested, %s, is not compatible with the nuccore fetch."" % rettype + + outputDirectory = os.path.abspath(os.path.expanduser(destinationDir)) + + if not os.path.exists(outputDirectory): + os.makedirs(outputDirectory) + + # if the file extension to use is specified as the fileExt arg, use it + # otherwise, use the default for the rettype according to the outEx dict, + # falling back to the retmode if there is no match + if not fileExt: + outputExtension = outEx.get(rettype, retmode) + else: + outputExtension = str(fileExt) + + # ensure the extension starts with a ""."", also allowing for passed-in + # extensions that already have it + if outputExtension[:1] != ""."": + outputExtension = ""."" + outputExtension + + log.info(""Fetching %s entries from GenBank: %s\n"", str(len(accessionList)), "", "".join(accessionList[:10])) + outputFiles = [] + + for chunkNum, chunk in enumerate(_seq_chunks(accessionList, chunkSize)): + + accString = "","".join(chunk) + + # if the filename would be longer than Linux allows, simply say ""chunk-chunkNum"" + if len(accString) + len(outputExtension) <= 254: + outputFilePath = os.path.join(outputDirectory, accString + outputExtension) + else: + outputFilePath = os.path.join(outputDirectory, ""chunk-{}"".format(chunkNum) + outputExtension) + + if not forceOverwrite: + log.info(""not overwriting, checking for existence"") + assert not os.path.exists(outputFilePath), """"""File %s already exists. Consider removing + this file or specifying a different output directory. The files for the accessions specified + can be overwritten if you add --forceOverwrite flag. Processing aborted."""""" % outputFilePath + + tryCount = 1 + while True: + try: + log.info(""Fetching file %s: %s, try #%s"", chunkNum + 1, accString, tryCount) + handle = Entrez.efetch(db=db, rettype=rettype, id=accString) + + with open(outputFilePath, ""w"") as outf: + for line in handle: + outf.write(line) + outputFiles.append(outputFilePath) + except IOError: + + log.warning( + ""Error fetching file %s: %s, try #%s probably because NCBI is too busy."", chunkNum + 1, accString, + tryCount) + + tryCount += 1 + if tryCount > 4: + log.warning(""Tried too many times. Aborting."") + raise + + # if the fetch failed, wait a few seconds and try again. + log.info(""Waiting and retrying..."") + time.sleep(2) + + continue + break + + # assert that we are not trying to remove the intermediate files without writing a combined file + if removeSeparateFiles: + assert combinedFilePrefix, """"""The intermediate files + can only be removed if a combined file is written via --combinedFilePrefix"""""" + + # build a path to the combined genome file + if combinedFilePrefix: + concatenatedGenomeFilepath = os.path.join(outputDirectory, combinedFilePrefix + outputExtension) + + if not forceOverwrite: + assert not os.path.exists(concatenatedGenomeFilepath), """"""File %s already exists. Consider removing + this file or specifying a different output directory. The files for the accessions specified + can be overwritten if you add --forceOverwrite flag. Processing aborted."""""" % outputFilePath + + # concatenate the files together into one genome file + with open(concatenatedGenomeFilepath, 'w') as outfile: + for filePath in outputFiles: + with open(filePath) as infile: + for line in infile: + outfile.write(line) + + # if the option is specified, remove the intermediate fasta files + if removeSeparateFiles: + while len(outputFiles) > 0: + os.unlink(outputFiles.pop()) + + # add the combined file to the list of files returned + outputFiles.append(concatenatedGenomeFilepath) + + # return list of files + return outputFiles + + +def fetch_fastas_from_genbank( + accessionList, + destinationDir, + emailAddress, + forceOverwrite, + combinedFilePrefix, + removeSeparateFiles, + fileExt=None, + rettype=""fasta"", + retmode=""text"", + chunkSize=1, + api_key=None): + return _fetch_from_nuccore( + accessionList, destinationDir, emailAddress, forceOverwrite, rettype, retmode, fileExt, combinedFilePrefix, + removeSeparateFiles, chunkSize, api_key=api_key) + + +def fetch_feature_tables_from_genbank( + accessionList, + destinationDir, + emailAddress, + forceOverwrite, + combinedFilePrefix, + removeSeparateFiles, + fileExt=None, + rettype=""ft"", + retmode=""text"", + chunkSize=1, + api_key=None): + return _fetch_from_nuccore( + accessionList, destinationDir, emailAddress, forceOverwrite, rettype, retmode, fileExt, combinedFilePrefix, + removeSeparateFiles, chunkSize, api_key=api_key) + + +def fetch_full_records_from_genbank( + accessionList, + destinationDir, + emailAddress, + forceOverwrite, + combinedFilePrefix, + removeSeparateFiles, + fileExt=None, + rettype=""gb"", + retmode=""text"", + chunkSize=1, + api_key=None): + return _fetch_from_nuccore( + accessionList, destinationDir, emailAddress, forceOverwrite, rettype, retmode, fileExt, combinedFilePrefix, + removeSeparateFiles, chunkSize, api_key=api_key) +","Python" +"Viral","broadinstitute/viral-ngs","util/feature_table.py",".py","10201","256","#!/usr/bin/env python + +import re +import os + +import util.feature_table_types + +class SeqPosition(object): + def __init__(self, position, location_operator=None, allow_fuzzy=True): + self.position = int(position) + self.location_operator = location_operator + self.allow_fuzzy = allow_fuzzy + + def __str__(self): + if self.allow_fuzzy: + return ""{op}{pos}"".format(op=self.location_operator if self.location_operator else """", pos=str(self.position)) + else: + return str(self.position) + + def __int__(self): + return self.position + + def is_fuzzy(self): + return self.locaton_operator + + def __eq__(self, other): + return self.position == other.position + + def __ne__(self, other): + return self.position != other.position + + def __lt__(self, other): + return self.position < other.position + + def __le__(self, other): + return self.position <= other.position + + def __gt__(self, other): + return self.position > other.position + + def __ge__(self, other): + return self.position >= other.position + +class SeqQualifier(object): + def __init__(self, qualifier_key, qualifier_value): + self.qualifier_key = qualifier_key + self.qualifier_value = qualifier_value + + def __str__(self): + if self.qualifier_value: + return ""\t\t\t{k}\t{v}"".format(k=self.qualifier_key,v=self.qualifier_value) + else: + return ""\t\t\t{k}"".format(k=self.qualifier_key) + +class SeqLocation(object): + def __init__(self, start_pos, end_pos, feature_type=None): + self.start = start_pos + self.end = end_pos + self.feature_type = feature_type + + def __str__(self): + return ""{start}\t{end}\t{type}"".format(start=self.start,end=self.end,type=self.feature_type if self.feature_type else """") + + def __eq__(self, other): + return ((self.start, self.end) == (other.start, other.end)) + + def __ne__(self, other): + return ((self.start, self.end) != (other.start, other.end)) + + def __lt__(self, other): + return self.start < other.start or (self.start==other.start and self.end < other.end) + + def __le__(self, other): + return self.start <= other.start or (self.start==other.start and self.end <= other.end) + + def __gt__(self, other): + return self.start > other.start or (self.start==other.start and self.end > other.end) + + def __ge__(self, other): + return self.start >= other.start or (self.start==other.start and self.end >= other.end) + +class SeqFeature(object): + def __init__(self, locations=None, feature_type=None): + self.locations = locations or [] + self.type = feature_type + self.qualifiers = [] + + def add_location(self, location): + self.locations.append(location) + + def add_location(self, start, location_operator_start, end, location_operator_end, allow_fuzzy=True, *args, **kwargs): + self.locations.append(SeqLocation(SeqPosition(start, location_operator_start, allow_fuzzy=allow_fuzzy), SeqPosition(end, location_operator_end, allow_fuzzy=allow_fuzzy))) + # sort with each insertion + self.sort() + + def sort(self): + #pass + self.locations = sorted(self.locations) + + def add_qualifier(self, qualifier_key, qualifier_value, *args, **kwargs): + self.qualifiers.append(SeqQualifier(qualifier_key, qualifier_value)) + + def add_note(self, note_text): + self.add_qualifier(""note"", note_text) + + @property + def lines(self): + if len(self.locations): + first_loc = self.locations.pop(0) + first_loc.feature_type = self.type + yield first_loc + for l in self.locations: + yield l + # yield notes first + for q in self.qualifiers: + if q.qualifier_key == ""note"": + yield q + for q in self.qualifiers: + if q.qualifier_key != ""note"": + yield q + +class AttrDict(dict): + """""" + Expose (string) dictionary keys as attributes. + Danger: can cause collisions between dict item keys + and dict built-ins (the former will override). + Only to be used with trusted input for dict keys + Note: memory leak Python < 2.7.4 / Python3 < 3.2.3 + see: https://bugs.python.org/issue1469629 + """""" + def __init__(self, *args, **kwargs): + super(AttrDict, self).__init__(*args, **kwargs) + self.__dict__ = self + +class FeatureTable(object): + # get feature table keys from extensive map + _default_feature_types = sorted(util.feature_table_types.ft_types.keys()) + + def __init__(self, filepath=None, valid_feature_types=None): + self.refID = None + self._features = [] + self.valid_feature_types = valid_feature_types or self._default_feature_types + + self.feature_line_regex_map = { + ""feature_table_header"" : re.compile(r""^>Feature (gb\||ref\|)(?P.*)\|.*$""), + ""feature_first_location_line"" : re.compile(r""^(?P[<>])?(?P\d+)\t(?P[<>])?(?P\d+)\t(?P"" + ""|"".join(self.valid_feature_types) + "")$""), + ""feature_subsequent_location_line"" : re.compile(r""^(?P[<>])?(?P\d+)\t(?P[<>])?(?P\d+)\t*$""), + ""offset_line"" : re.compile(r""^(?:\[offset=(?P-?\d+)\])$""), + ""feature_qualifier_line"" : re.compile(r""^\t{3}(?P[^\t]*)(?:\t(?P[^\t]*))?$"") + } + + if filepath: + self.read_feature_table(filepath) + + def _parse_line(self, line): + for k,r in self.feature_line_regex_map.items(): + m = r.match(line) + if m: + return_dict = AttrDict(m.groupdict()) + return_dict[""line_type""] = k + #return_dict[""raw_line""] = line + return return_dict + raise LookupError(r""Error parsing feature table line: '%s'"" % line) + + @property + def features(self): + return self._features + + @property + def default_feature_types(self): + return self._default_feature_values.keys() + + + def add_feature(self, feature): + self._features.append(feature) + + def read_feature_table(self, filepath, map_function=None, allow_fuzzy=True): + """""" + Read a Genbank-style feature table in tsv/Sequin format + This applies any offsets present in the input to the positions seen (no offsets in output). + The map_function accepts two ints: a position interval, and returns two ints + representing remapped feature coordinates. + """""" + with open(os.path.realpath(os.path.normpath(filepath)), 'rt') as inf: + feature_in_progress = None + offset = 0 + for line in inf: + line = line.rstrip('\r\n') + if not line: + continue + + l = self._parse_line(line) + if not self.refID and l.line_type == ""feature_table_header"": + self.refID = l.refID + elif l.line_type == ""feature_first_location_line"": + if feature_in_progress: + self.features.append(feature_in_progress) + feature_in_progress = None + + feature_in_progress = SeqFeature(feature_type=l.feature_type) + l.start = int(l.start) + int(offset) + l.end = int(l.end) + int(offset) + + if map_function: + l.start, l.end = map_function(l.start, l.end) + + feature_in_progress.add_location(allow_fuzzy=allow_fuzzy,**l) + elif l.line_type == ""feature_subsequent_location_line"": + l.start = int(l.start) + int(offset) + l.end = int(l.end) + int(offset) + + if map_function: + l.start, l.end = map_function(l.start, l.end) + + feature_in_progress.add_location(allow_fuzzy=allow_fuzzy,**l) + elif l.line_type == ""feature_qualifier_line"": + feature_in_progress.add_qualifier(**l) + elif l.line_type == ""offset_line"": + offset = int(l.offset) + + if feature_in_progress: + self.features.append(feature_in_progress) + feature_in_progress = None + + if not self.refID: + raise Exception(""The feature table file did not have a header line in the format '%s'"" % self.feature_line_regex_map[""feature_table_header""].pattern) + + def remap_locations(self, map_function=None): + """""" + map_function should accept two SeqLocation objects and the containing feature, and return two (mapped) SeqLocation objects + if (None,None) is returned, the location will not be included in the remapped location list + """""" + if map_function: + for feature in self.features: + remapped_locations = [] + for location in feature.locations: + + location.start, location.end = map_function(location.start,location.end, feature) + # only include locations that are not totally null + if location.start is not None and location.end is not None: + remapped_locations.append(location) + else: + feature.add_note(""sequencing did not capture all intervals comprising CDS"") + feature.locations = remapped_locations + + + def lines(self, exclude_patterns=None): + yield "">Feature {refID}"".format(refID=self.refID) + for feature in self.features: + for l in feature.lines: + if not exclude_patterns: + yield l + else: + if not any(re.search(pattern, str(l)) for pattern in exclude_patterns): + yield l +","Python" +"Viral","broadinstitute/viral-ngs","util/feature_table_types.py",".py","46591","1298","#!/usr/bin/env python + +# This is intended to assist with parsing Sequin-format feature tables. +# +# Note: Molecule scope, Organism scope, and qualifier conditions are not currently included here +# Definitions and comments adapted from INSDC documentation. +# +# see the feature table key reference: +# https://www.insdc.org/documents/feature-table#7.2 +# https://www.ncbi.nlm.nih.gov/Sequin/table.html +ft_types = { + ""assembly_gap"":{ + # Definition gap between two components of a genome or transcriptome assembly; + ""mandatory_qualifiers"":[""estimated_length"",""gap_type"",""linkage_evidence""] + # Comment the location span of the assembly_gap feature for an unknown gap has + # to be specified by the submitter; the specified gap length has to be + # reasonable (less or = 1000) and will be indicated as ""n""'s in sequence. + # However, the value for the estimated_length of assembly_gap features + # within a single (non-CON) transcriptome record must be an integer + # and can not be ""unknown""; + }, + ""C_region"":{ + # Definition constant region of immunoglobulin light and heavy + # chains, and T-cell receptor alpha, beta, and gamma + # chains; includes one or more exons depending on the + # particular chain + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""CDS"":{ + # Definition coding sequence; sequence of nucleotides that + # corresponds with the sequence of amino acids in a + # protein (location includes stop codon); + # feature includes amino acid conceptual translation. + ""optional_qualifiers"":[ + ""allele"", + ""artificial_location"", + ""citation"", + ""codon_start"", + ""db_xref"", + ""EC_number"", + ""exception"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""number=unquoted text (single token)"", + ""old_locus_tag"", + ""operon"", + ""product"", + ""protein_id"", + ""pseudo"", + ""pseudogene"", + ""ribosomal_slippage"", + ""standard_name"", + ""translation"", + ""transl_except=(pos:,aa:)"", + ""transl_table "", + ""trans_splicing"" + ] + # Comment codon_start has valid value of 1 or 2 or 3, indicating + # the offset at which the first complete codon of a coding + # feature can be found, relative to the first base of + # that feature; + # ""transl_table defines the genetic code table used if"", + # other than the universal genetic code table; + # genetic code exceptions outside the range of the specified + # tables is reported in /transl_except qualifier; + # ""protein_id consists of a stable ID portion (3+5 format"", + # with 3 position letters and 5 numbers) plus a version + # number after the decimal point; when the protein + # sequence encoded by the CDS changes, only the version + # number of the /protein_id value is incremented; the + # stable part of the /protein_id remains unchanged and as + # a result will permanently be associated with a given + # protein; + }, + ""centromere"":{ + # Definition region of biological interest identified as a centromere and + # which has been experimentally characterized; + ""optional_qualifiers"":[ + ""citation"", + ""db_xref"", + ""experiment"", + ""inference"", + ""note"", + ""standard_name"" + ] + # Comment the centromere feature describes the interval of DNA + # that corresponds to a region where chromatids are held + # and a kinetochore is formed + }, + ""D-loop"":{ + # Definition displacement loop; a region within mitochondrial DNA in + # which a short stretch of RNA is paired with one strand + # of DNA, displacing the original partner DNA strand in + # this region; also used to describe the displacement of a + # region of one strand of duplex DNA by a single stranded + # invader in the reaction catalyzed by RecA protein + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"" + ] + }, + ""D_segment"":{ + # Definition Diversity segment of immunoglobulin heavy chain, and + # T-cell receptor beta chain; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""exon"":{ + # Definition region of genome that codes for portion of spliced mRNA, + # rRNA and tRNA; may contain 5'UTR, all CDSs and 3' UTR; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""EC_number"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""number=unquoted text (single token)"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"", + ""trans_splicing"" + ] + }, + ""gap"":{ + # Definition gap in the sequence + ""mandatory_qualifiers"":[ + ""estimated_length"" + ], + ""optional_qualifiers"":[ + ""experiment"", + ""inference"", + ""map"", + ""note"" + ] + # Comment the location span of the gap feature for an unknown + # gap is 100 bp, with the 100 bp indicated as 100 ""n""'s in + # the sequence. Where estimated length is indicated by + # an integer, this is indicated by the same number of + # ""n""'s in the sequence. + # No upper or lower limit is set on the size of the gap. + }, + ""gene"":{ + # Definition region of biological interest identified as a gene + # and for which a name has been assigned; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""phenotype"", + ""standard_name"", + ""trans_splicing"" + ] + # Comment the gene feature describes the interval of DNA that + # corresponds to a genetic trait or phenotype; the feature is, + # by definition, not strictly bound to it's positions at the + # ends; it is meant to represent a region where the gene is + # located. + }, + ""iDNA"":{ + # Definition intervening DNA; DNA which is eliminated through any of + # several kinds of recombination; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""number=unquoted text (single token)"", + ""old_locus_tag"", + ""standard_name"" + ] + # Comment e.g., in the somatic processing of immunoglobulin genes. + }, + ""intron"":{ + # Definition a segment of DNA that is transcribed, but removed from + # within the transcript by splicing together the sequences + # (exons) on either side of it; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""number=unquoted text (single token)"", + ""old_locus_tag"", + ""pseudo"", + ""pseudogene"", + ""standard_name"", + ""trans_splicing"" + ] + }, + ""J_segment"":{ + # Definition joining segment of immunoglobulin light and heavy + # chains, and T-cell receptor alpha, beta, and gamma + # chains; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""mat_peptide"":{ + # Definition mature peptide or protein coding sequence; coding + # sequence for the mature or final peptide or protein + # product following post-translational modification; the + # location does not include the stop codon (unlike the + # corresponding CDS); + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""EC_number"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""misc_binding"":{ + # Definition site in nucleic acid which covalently or non-covalently + # binds another moiety that cannot be described by any + # other binding key (primer_bind or protein_bind); + ""mandatory_qualifiers"":[""bound_moiety""], + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"" + ] + # Comment note that feature key regulatory with /regulatory_class + # should be used for ribosome binding sites. + }, + ""misc_difference"":{ + # Definition feature sequence is different from that presented + # in the entry and cannot be described by any other + # difference key (old_sequence, variation, or modified_base); + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""clone"", + ""compare"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map="", + ""note"", + ""old_locus_tag"", + ""phenotype"", + ""replace"", + ""standard_name"" + ] + # Comment the misc_difference feature key should be used to + # describe variability that arises as a result of + # genetic manipulation (e.g. site directed mutagenesis); + # use /replace="""" to annotate deletion, e.g. + # misc_difference 412..433 + # ""replace="""" "", + }, + ""misc_feature"":{ + # Definition region of biological interest which cannot be described + # by any other feature key; a new or rare feature; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""number=unquoted text (single token)"", + ""old_locus_tag"", + ""phenotype"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + # Comment this key should not be used when the need is merely to + # mark a region in order to comment on it or to use it in + # another feature's location + }, + ""misc_recomb"":{ + # Definition site of any generalized, site-specific or replicative + # recombination event where there is a breakage and + # reunion of duplex DNA that cannot be described by other + # recombination keys or qualifiers of source key + # (/proviral); + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""recombination_class"", + ""standard_name"" + ] + }, + ""misc_RNA"":{ + # Definition any transcript or RNA product that cannot be defined by + # other RNA keys (prim_transcript, precursor_RNA, mRNA, + # 5'UTR, 3'UTR, exon, CDS, sig_peptide, transit_peptide, + # mat_peptide, intron, polyA_site, ncRNA, rRNA and tRNA); + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"", + ""trans_splicing"" + ] + }, + ""misc_structure"":{ + # Definition any secondary or tertiary nucleotide structure or + # conformation that cannot be described by other Structure + # keys (stem_loop and D-loop); + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""standard_name"" + ] + }, + ""mobile_element"":{ + # Definition region of genome containing mobile elements; + ""mandatory_qualifiers"":[""mobile_element_type""], + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""rpt_family"", + ""rpt_type"", + ""standard_name"" + ] + }, + ""modified_base"":{ + # Definition the indicated nucleotide is a modified nucleotide and + # should be substituted for by the indicated molecule + # (given in the mod_base qualifier value) + ""mandatory_qualifiers"":[""mod_base""], + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""frequency"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"" + ] + # Comment value is limited to the restricted vocabulary for + # modified base abbreviations; + }, + ""mRNA"":{ + # Definition messenger RNA; includes 5'untranslated region (5'UTR), + # coding sequences (CDS, exon) and 3'untranslated region + # (3'UTR); + ""optional_qualifiers"":[ + ""allele"", + ""artificial_location"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"", + ""trans_splicing"" + ] + }, + ""ncRNA"":{ + # Definition a non-protein-coding gene, other than ribosomal RNA and + # transfer RNA, the functional molecule of which is the RNA + # transcript; + ""mandatory_qualifiers"":[""ncRNA_class""], + + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"", + ""trans_splicing"" + ] + # Comment the ncRNA feature is not used for ribosomal and transfer + # RNA annotation, for which the rRNA and tRNA feature keys + # should be used, respectively; + }, + ""N_region"":{ + # Definition extra nucleotides inserted between rearranged + # immunoglobulin segments. + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""old_sequence"":{ + # Definition the presented sequence revises a previous version of the + # sequence at this location; + ""mandatory_qualifiers"":[""citation"", ""compare""], + ""optional_qualifiers"":[ + ""allele"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""replace"" + ] + # Comment /replace="""" is used to annotate deletion, e.g. + # old_sequence 12..15 ""replace="""" "", + # NOTE: This feature key is not valid in entries/records + # created from 15-Oct-2007. + }, + ""operon"":{ + # Definition region containing polycistronic transcript including a cluster of + # genes that are under the control of the same regulatory sequences/promoter + # and in the same biological pathway + ""mandatory_qualifiers"":[""operon""], + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""inference"", + ""map"", + ""note"", + ""phenotype"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""oriT"":{ + # Definition origin of transfer; region of a DNA molecule where transfer is + # initiated during the process of conjugation or mobilization + ""optional_qualifiers"":[ + ""allele"", + ""bound_moiety"", + ""citation"", + ""db_xref"", + ""direction=value"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""rpt_family"", + ""rpt_type"", + ""rpt_unit_range"", + ""rpt_unit_seq"", + ""standard_name"" + ] + # Comment rep_origin should be used for origins of replication; + # ""direction has legal values RIGHT, LEFT and BOTH, however only "", + # RIGHT and LEFT are valid when used in conjunction with the oriT + # feature; + # origins of transfer can be present in the chromosome; + # plasmids can contain multiple origins of transfer + }, + ""polyA_site"":{ + # Definition site on an RNA transcript to which will be added adenine + # residues by post-transcriptional polyadenylation; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"" + ] + }, + ""precursor_RNA"":{ + # Definition any RNA species that is not yet the mature RNA product; + # may include ncRNA, rRNA, tRNA, 5' untranslated region + # (5'UTR), coding sequences (CDS, exon), intervening + # sequences (intron) and 3' untranslated region (3'UTR); + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""product"", + ""standard_name"", + ""trans_splicing"" + ] + # Comment used for RNA which may be the result of + # post-transcriptional processing; if the RNA in question + # is known not to have been processed, use the + # prim_transcript key. + }, + ""prim_transcript"":{ + # Definition primary (initial, unprocessed) transcript; + # may include ncRNA, rRNA, tRNA, 5' untranslated region + # (5'UTR), coding sequences (CDS, exon), intervening + # sequences (intron) and 3' untranslated region (3'UTR); + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""standard_name"" + ] + }, + ""primer_bind"":{ + # Definition non-covalent primer binding site for initiation of + # replication, transcription, or reverse transcription; + # includes site(s) for synthetic e.g., PCR primer elements; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""standard_name"", + ""PCR_conditions"" + ] + # Comment used to annotate the site on a given sequence to which a primer + # molecule binds - not intended to represent the sequence of the + # primer molecule itself; PCR components and reaction times may + # be stored under the ""/PCR_conditions"" qualifier; + # since PCR reactions most often involve pairs of primers, + # a single primer_bind key may use the order() operator + # with two locations, or a pair of primer_bind keys may be + # used. + }, + ""propeptide"":{ + # Definition propeptide coding sequence; coding sequence for the domain of a + # proprotein that is cleaved to form the mature protein product. + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""protein_bind"":{ + # Definition non-covalent protein binding site on nucleic acid; + ""mandatory_qualifiers"":[""bound_moiety""], + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""standard_name"" + ] + # Comment note that feature key regulatory with /regulatory_class + # should be used for ribosome binding sites. + }, + ""regulatory"":{ + # Definition any region of sequence that functions in the regulation of + # transcription, translation, replication or chromatin structure; + ""mandatory_qualifiers"":[""regulatory_class""], + ""optional_qualifiers"":[ + ""allele"", + ""bound_moiety"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""phenotype"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + # Comment This feature has replaced the following Feature Keys on 15-DEC-2014: + # enhancer, promoter, CAAT_signal, TATA_signal, -35_signal, -10_signal, + # RBS, GC_signal, polyA_signal, attenuator, terminator, misc_signal. + }, + ""repeat_region"":{ + # Definition region of genome containing repeating units; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""rpt_family"", + ""rpt_type"", + ""rpt_unit_range"", + ""rpt_unit_seq"", + ""satellite"", + ""standard_name"" + ] + }, + ""rep_origin"":{ + # Definition origin of replication; starting site for duplication of + # nucleic acid to give two identical copies; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""direction=value"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""standard_name"" + ] + # Comment /direction has valid values: RIGHT, LEFT, or BOTH. + }, + ""rRNA"":{ + # Definition mature ribosomal RNA; RNA component of the + # ribonucleoprotein particle (ribosome) which assembles + # amino acids into proteins. + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + # Comment rRNA sizes should be annotated with the /product + # qualifier. + }, + ""S_region"":{ + # Definition switch region of immunoglobulin heavy chains; + # involved in the rearrangement of heavy chain DNA leading + # to the expression of a different immunoglobulin class + # from the same B-cell; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""sig_peptide"":{ + # Definition signal peptide coding sequence; coding sequence for an + # N-terminal domain of a secreted protein; this domain is + # involved in attaching nascent polypeptide to the + # membrane leader sequence; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""source"":{ + # Definition identifies the biological source of the specified span of + # the sequence; this key is mandatory; more than one source + # key per sequence is allowed; every entry/record will have, as a + # minimum, either a single source key spanning the entire + # sequence or multiple source keys, which together, span the + # entire sequence. + ""mandatory_qualifiers"":[""organism"",""mol_type""], + ""optional_qualifiers"":[ + ""altitude"", + ""bio_material"", + ""cell_line"", + ""cell_type"", + ""chromosome"", + ""citation"", + ""clone"", + ""clone_lib"", + ""collected_by"", + ""collection_date"", + ""country"", + ""cultivar"", + ""culture_collection"", + ""db_xref"", + ""dev_stage"", + ""ecotype"", + ""environmental_sample"", + ""focus"", + ""germline"", + ""haplogroup"", + ""haplotype"", + ""host"", + ""identified_by"", + ""isolate"", + ""isolation_source"", + ""lab_host"", + ""lat_lon"", + ""macronuclear"", + ""map"", + ""mating_type"", + ""note"", + ""organelle"", + ""PCR_primers"", + ""plasmid"", + ""pop_variant"", + ""proviral"", + ""rearranged"", + ""segment"", + ""serotype"", + ""serovar"", + ""sex"", + ""specimen_voucher"", + ""strain"", + ""sub_clone"", + ""submitter_seqid"", + ""sub_species"", + ""sub_strain"", + ""tissue_lib"", + ""tissue_type"", + ""transgenic"", + ""type_material"", + ""variety"" + ] + # Comment transgenic sequences must have at least two source feature + # keys; in a transgenic sequence the source feature key + # describing the organism that is the recipient of the DNA + # must span the entire sequence; + # see Appendix III /organelle for a list of + }, + ""stem_loop"":{ + # Definition hairpin; a double-helical region formed by base-pairing + # between adjacent (inverted) complementary sequences in a + # single strand of RNA or DNA. + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""standard_name"" + ] + }, + ""STS"":{ + # Definition sequence tagged site; short, single-copy DNA sequence + # that characterizes a mapping landmark on the genome and + # can be detected by PCR; a region of the genome can be + # mapped by determining the order of a series of STSs; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""standard_name"", + ] + # Comment STS location to include primer(s) in primer_bind key or + # primers. + }, + ""telomere"":{ + # Definition region of biological interest identified as a telomere + # and which has been experimentally characterized; + ""optional_qualifiers"":[ + ""citation"", + ""db_xref"", + ""experiment"", + ""inference"", + ""note"", + ""rpt_type"", + ""rpt_unit_range"", + ""rpt_unit_seq"", + ""standard_name"" + ] + # Comment the telomere feature describes the interval of DNA + # that corresponds to a specific structure at the end of + # the linear eukaryotic chromosome which is required for + # the integrity and maintenance of the end; this region + # is unique compared to the rest of the chromosome and + # represent the physical end of the chromosome; + }, + ""tmRNA"":{ + # Definition transfer messenger RNA; tmRNA acts as a tRNA first, + # and then as an mRNA that encodes a peptide tag; the + # ribosome translates this mRNA region of tmRNA and attaches + # the encoded peptide tag to the C-terminus of the + # unfinished protein; this attached tag targets the protein for + # destruction or proteolysis; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"", + ""tag_peptide"" + ] + }, + ""transit_peptide"":{ + # Definition transit peptide coding sequence; coding sequence for an + # N-terminal domain of a nuclear-encoded organellar + # protein; this domain is involved in post-translational + # import of the protein into the organelle; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""tRNA"":{ + # Definition mature transfer RNA, a small RNA molecule (75-85 bases + # long) that mediates the translation of a nucleic acid + # sequence into an amino acid sequence; + ""optional_qualifiers"":[ + ""allele"", + ""anticodon=(pos:,aa:,seq:)"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""operon"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"", + ""trans_splicing"" + ] + }, + ""unsure"":{ + # Definition a small region of sequenced bases, generally 10 or fewer in its length, which + # could not be confidently identified. Such a region might contain called bases + # (A, T, G, or C), or a mixture of called-bases and uncalled-bases ('N'). + # The unsure feature should not be used when annotating gaps in genome assemblies. + # Please refer to assembly_gap feature for gaps within the sequence of an assembled + # genome. For annotation of gaps in other sequences than assembled genomes use the + # gap feature. + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""compare"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""replace"" + ] + # Comment use /replace="""" to annotate deletion, e.g. + # unsure 11..15 ""replace="""" "", + }, + ""V_region"":{ + # Definition variable region of immunoglobulin light and heavy + # chains, and T-cell receptor alpha, beta, and gamma + # chains; codes for the variable amino terminal portion; + # can be composed of V_segments, D_segments, N_regions, + # and J_segments; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"", + ] + }, + ""V_segment"":{ + # Definition variable segment of immunoglobulin light and heavy + # chains, and T-cell receptor alpha, beta, and gamma + # chains; codes for most of the variable region (V_region) + # and the last few amino acids of the leader peptide; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""product"", + ""pseudo"", + ""pseudogene"", + ""standard_name"" + ] + }, + ""variation"":{ + # Definition a related strain contains stable mutations from the same + # gene (e.g., RFLPs, polymorphisms, etc.) which differ + # from the presented sequence at this location (and + # possibly others); + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""compare"", + ""db_xref"", + ""experiment"", + ""frequency"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""phenotype"", + ""product"", + ""replace"", + ""standard_name"" + ] + # Comment used to describe alleles, RFLP's,and other naturally occurring + # mutations and polymorphisms; variability arising as a result + # of genetic manipulation (e.g. site directed mutagenesis) should + # be described with the misc_difference feature; + # use /replace="""" to annotate deletion, e.g. + }, + ""3'UTR"":{ + # Definition 1) region at the 3' end of a mature transcript (following + # the stop codon) that is not translated into a protein; + # 2) region at the 3' end of an RNA virus (following the last stop + # codon) that is not translated into a protein; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""standard_name"", + ""trans_splicing"" + ] + }, + ""5'UTR"":{ + # Definition 1) region at the 5' end of a mature transcript (preceding + # the initiation codon) that is not translated into a protein; + # 2) region at the 5' end of an RNA virus genome (preceding the first + # initiation codon) that is not translated into a protein; + ""optional_qualifiers"":[ + ""allele"", + ""citation"", + ""db_xref"", + ""experiment"", + ""function"", + ""gene"", + ""gene_synonym"", + ""inference"", + ""locus_tag"", + ""map"", + ""note"", + ""old_locus_tag"", + ""standard_name"", + ""trans_splicing"" + ] + } + }","Python" +"Viral","broadinstitute/viral-ngs","util/stats.py",".py","7200","183","'''A few pure-python statistical tools to avoid the need to install scipy. ''' +from __future__ import division # Division of integers with / should never round! +from math import exp, log, sqrt, gamma, lgamma, erf +import itertools + +__author__ = ""dpark@broadinstitute.org, irwin@broadinstitute.org"" + +# available in Python >=3.4 +from statistics import mean, median + +def product(iterable): + prod = 1 + for x in iterable: + prod *= x + return prod + + +def chi2_contingency(contingencyTable, correction=True): + """""" contingencyTable is a sequence of m sequences, each of length n. + Return an estimate using the chi-square distribution of the two-tailed + p-value for an m x n contingency table against the null hypothesis + that the row and column criteria are independent. This is not as + accurate as fisher_exact, but is faster (and is implemented for all + m and n). + If correction is True and there is 1 degree of freedom, apply Yates's + correction for continuity, i.e., adjust each observed value + by 0.5 towards the corresponding expected value, which brings + the result closer to the Fisher exact test result. + Not recommended if any of the counts or expected counts are + less than 5. + """""" + # scipy equivalent: scipy.stats.chi2_contingency(contingencyTable)[1] + + if len(contingencyTable) == 0: + return 1.0 + if len(set(map(len, contingencyTable))) != 1: + raise ValueError('Not all rows have the same length') + + # Eliminate rows and columns with 0 sum + colSums = [sum(row[col] for row in contingencyTable) for col in range(len(contingencyTable[0]))] + table = [[x for x, colSum in zip(row, colSums) if colSum != 0] for row in contingencyTable if sum(row) != 0] + + if len(table) < 2 or len(table[0]) < 2: + return 1.0 + + m = len(table) + n = len(table[0]) + rowSums = [sum(row) for row in table] + colSums = [sum(row[col] for row in table) for col in range(n)] + N = sum(rowSums) + expect = [[rowSums[i] * colSums[j] / N for j in range(n)] for i in range(m)] + if correction and m == n == 2: + + def corr(i, j): + if expect[i][j] > table[i][j]: + return min(table[i][j] + 0.5, expect[i][j]) + else: + return max(table[i][j] - 0.5, expect[i][j]) + + table = [[corr(i, j) for j in range(n)] for i in range(m)] + chisq = sum((table[i][j] - expect[i][j]) ** 2 / expect[i][j] for j in range(n) for i in range(m)) + pval = 1 - pchisq(chisq, (m - 1) * (n - 1)) + return pval + + +def fisher_exact(contingencyTable): + """""" Fisher exact test for the 2 x n case. + contingencyTable is a sequence of 2 length-n sequences of integers. + Return the two-tailed p-value against the null hypothesis that the row + and column criteria are independent, using Fisher's exact test. + For n larger than 2, this is very slow, O(S^(n-1)), where S is the + smaller of the two row sums. Better to use chi2_contingency unless + one of the row sums is small. + Handles m x n contingencyTable with m > 2 if it can be reduced to the + 2 x n case by transposing or by removing rows that are all 0s. Also + handles degenerate cases of 0 or 1 row by returning 1.0. + """""" + if len(contingencyTable) == 0: + return 1.0 + if len(set(map(len, contingencyTable))) != 1: + raise ValueError('Not all rows have the same length') + if any(x != int(x) for row in contingencyTable for x in row): + raise ValueError('Some table entry is not an integer') + if any(x < 0 for row in contingencyTable for x in row): + raise ValueError('Some table entry is negative') + + # Eliminate rows and columns with 0 sum + colSums = [sum(row[col] for row in contingencyTable) for col in range(len(contingencyTable[0]))] + table = [[x for x, colSum in zip(row, colSums) if colSum != 0] for row in contingencyTable if sum(row) != 0] + + if len(table) < 2 or len(table[0]) < 2: + return 1.0 + + if len(table) > len(table[0]): + table = list(zip(*table)) # Transpose + + m = len(table) + n = len(table[0]) + if m != 2: + raise NotImplementedError('More than 2 non-zero rows and columns.') + + # Put row with smaller sum first. Makes the loop iterations simpler. + table.sort(key=sum) + # Put column with largest sum last. Makes loop quick rejection faster. + table = list(zip(*table)) # Transpose + table.sort(key=sum) + table = list(zip(*table)) # Transpose back + + # There are many optimizations possible for the following code, but it would + # still be O(S^(n-1)) so it would still be too slow for anything + # sizeable, and it's usable as it for small things. + + rowSums = [sum(row) for row in table] + colSums = [sum(row[col] for row in table) for col in range(n)] + + logChooseNrowSum = log_choose(sum(rowSums), rowSums[0]) + + def prob_of_table(firstRow): + return exp(sum(log_choose(cs, a) for cs, a in zip(colSums, firstRow)) - logChooseNrowSum) + + p0 = prob_of_table(table[0]) + result = 0 + for firstRowM1 in itertools.product(*[range(min(rowSums[0], colSums[i]) + 1) for i in range(n - 1)]): + lastElmt = rowSums[0] - sum(firstRowM1) + if lastElmt < 0 or lastElmt > colSums[-1]: + continue + prob = prob_of_table(firstRowM1 + (lastElmt,)) + if prob <= p0 + 1e-9: # (1e-9 handles floating point round off) + result += prob + + return result + + +def log_choose(n, k): + # Return log(n choose k). Compute using lgamma(x + 1) = log(x!) + if not (0 <= k <= n): + raise ValueError('%d is negative or more than %d' % (k, n)) + return lgamma(n + 1) - lgamma(k + 1) - lgamma(n - k + 1) + + +def gammainc_halfint(s, x): + """""" Lower incomplete gamma function = + integral from 0 to x of t ** (s-1) exp(-t) dt divided by gamma(s), + i.e., the fraction of gamma that you get if you integrate only until + x instead of all the way to infinity. + Implemented here only if s is a positive multiple of 0.5. + """""" + # scipy equivalent: scipy.special.gammainc(s,x) + + if s <= 0: + raise ValueError('%s is not positive' % s) + if x < 0: + raise ValueError('%s < 0' % x) + if s * 2 != int(s * 2): + raise NotImplementedError('%s is not a multiple of 0.5' % s) + + # Handle integers analytically + if s == int(s): + term = 1 + total = 1 + for k in range(1, int(s)): + term *= x / k + total += term + return 1 - exp(-x) * total + + # Otherwise s is integer + 0.5. Decrease to 0.5 using recursion formula: + result = 0.0 + while s > 1: + result -= x ** (s - 1) * exp(-x) / gamma(s) + s = s - 1 + # Then use gammainc(0.5, x) = erf(sqrt(x)) + result += erf(sqrt(x)) + return result + + +def pchisq(x, k): + ""Cumulative distribution function of chi squared with k degrees of freedom."" + if k < 1 or k != int(k): + raise ValueError('%s is not a positive integer' % k) + if x < 0: + raise ValueError('%s < 0' % x) + return gammainc_halfint(k / 2, x / 2) +","Python" +"Viral","broadinstitute/viral-ngs","util/file.py",".py","38209","1014","'''This gives a number of useful quick methods for dealing with +tab-text files and gzipped files, as well as fasta files, plus +general file-handling routines. +''' + +__author__ = ""dpark@broadinstitute.org"" + +import codecs +import contextlib +import os +import gzip +import io +import tempfile +import subprocess +import shutil +import errno +import logging +import json +import sys +import io +import csv +import inspect +import tarfile + +import util.cmd +import util.misc + +from Bio import SeqIO +from Bio.Seq import Seq +from Bio.SeqRecord import SeqRecord +from Bio.SeqIO import FastaIO + +# imports needed for download_file() and webfile_readlines() +import re + +from urllib.request import urlopen # pylint: disable=E0611 + +import pysam + +log = logging.getLogger(__name__) + + +class StringNotFoundException(Exception): + """"""When a substring is not found."""""" + pass + + +def get_project_path(): + '''Return the absolute path of the top-level project, assumed to be the + parent of the directory containing this script.''' + # abspath converts relative to absolute path; expanduser interprets ~ + path = __file__ # path to this script + path = os.path.expanduser(path) # interpret ~ + path = os.path.abspath(path) # convert to absolute path + path = os.path.dirname(path) # containing directory: util + path = os.path.dirname(path) # containing directory: main project dir + return path + + +def get_build_path(): + '''Return absolute path of ""build"" directory''' + return os.path.join(get_project_path(), 'tools', 'build') + + +def get_scripts_path(): + '''Return absolute path of ""scripts"" directory''' + return os.path.join(get_project_path(), 'tools', 'scripts') + + +def get_binaries_path(): + '''Return absolute path of ""binaries"" directory''' + return os.path.join(get_project_path(), 'tools', 'binaries') + + +def get_test_path(): + '''Return absolute path of ""test"" directory''' + return os.path.join(get_project_path(), 'test') + + +def get_test_input_path(testClassInstance=None): + '''Return the path to the directory containing input files for the specified + test class + ''' + if testClassInstance is not None: + return os.path.join(get_test_path(), 'input', type(testClassInstance).__name__) + else: + return os.path.join(get_test_path(), 'input') + + +def get_resources(): + ''' Return the project resources dictionary ''' + jsonfile = os.path.join(get_project_path(), 'resources.json') + with open(jsonfile, 'rt') as inf: + resources = json.load(inf) + return resources + +def check_paths(read=(), write=(), read_and_write=()): + '''Check that we can read and write the specified files, throw an exception if not. Useful for checking + error conditions early in the execution of a command. Each arg can be a filename or iterable of filenames. + ''' + read, write, read_and_write = map(util.misc.make_seq, (read, write, read_and_write)) + assert not (set(read) & set(write)) + assert not (set(read) & set(read_and_write)) + assert not (set(write) & set(read_and_write)) + + for fname in read+read_and_write: + with open(fname): + pass + + for fname in write+read_and_write: + if not os.path.exists(fname): + with open(fname, 'w'): + pass + os.unlink(fname) + else: + if not (os.path.isfile(fname) and os.access(fname, os.W_OK)): + raise PermissionError('Cannot write ' + fname) + +def mkstempfname(suffix='', prefix='tmp', directory=None, text=False): + ''' There's no other one-liner way to securely ask for a temp file by + filename only. This calls mkstemp, which does what we want, except + that it returns an open file handle, which causes huge problems on NFS + if we don't close it. So close it first then return the name part only. + ''' + fd, fn = tempfile.mkstemp(prefix=prefix, suffix=suffix, dir=directory, text=text) + os.close(fd) + return fn + + +@contextlib.contextmanager +def tempfname(*args, **kwargs): + '''Create a tempfile name on context entry, delete the file (if it exists) on context exit. + The file is kept for debugging purposes if the environment variable VIRAL_NGS_TMP_DIRKEEP is set. + ''' + fn = mkstempfname(*args, **kwargs) + try: + yield fn + finally: + if os.path.isfile(fn) and not keep_tmp(): + os.unlink(fn) + + +@contextlib.contextmanager +def tempfnames(suffixes, *args, **kwargs): + '''Create a set of tempfile names on context entry, delete the files (if they exist) on context exit. + The files are kept for debugging purposes if the environment variable VIRAL_NGS_TMP_DIRKEEP is set. + ''' + fns = [mkstempfname(sfx, *args, **kwargs) for sfx in suffixes] + try: + yield fns + finally: + if not keep_tmp(): + for fn in fns: + if os.path.isfile(fn): + os.unlink(fn) + +@contextlib.contextmanager +def tmp_dir(*args, **kwargs): + """"""Create and return a temporary directory, which is cleaned up on context exit + unless keep_tmp() is True."""""" + + _args = inspect.getcallargs(tempfile.mkdtemp, *args, **kwargs) + length_margin = 6 + for pfx_sfx in ('prefix', 'suffix'): + if _args[pfx_sfx]: + _args[pfx_sfx] = string_to_file_name(_args[pfx_sfx], file_system_path=_args['dir'], length_margin=length_margin) + length_margin += len(_args[pfx_sfx].encode('utf-8')) + + name = None + try: + name = tempfile.mkdtemp(**_args) + yield name + finally: + if name is not None: + if keep_tmp(): + log.debug('keeping tempdir ' + name) + else: + shutil.rmtree(name, ignore_errors=True) + +@contextlib.contextmanager +def pushd_popd(target_dir): + '''Temporary change to the specified directory, restoring current directory on context exit.''' + save_cwd = os.getcwd() + try: + os.chdir(target_dir) + yield target_dir + finally: + os.chdir(save_cwd) + +def keep_tmp(): + """"""Whether to preserve temporary directories and files (useful during debugging). + Return True if the environment variable VIRAL_NGS_TMP_DIRKEEP is set. + """""" + return 'VIRAL_NGS_TMP_DIRKEEP' in os.environ + +def set_tmp_dir(name): + proposed_prefix = ['tmp'] + if name: + proposed_prefix.append(name) + for e in ('LSB_JOBID', 'LSB_JOBINDEX', 'JOB_ID'): + if e in os.environ: + proposed_prefix.append(os.environ[e]) + break + tempfile.tempdir = tempfile.mkdtemp(prefix='-'.join(proposed_prefix) + '-', dir=util.cmd.find_tmp_dir()) + os.environ['TMPDIR'] = tempfile.tempdir + return tempfile.tempdir + + +def destroy_tmp_dir(tempdir=None): + if not keep_tmp(): + if tempdir: + shutil.rmtree(tempdir) + elif tempfile.tempdir: + shutil.rmtree(tempfile.tempdir) + tempfile.tempdir = None + + +def extract_tarball(tarfile, out_dir=None, threads=None, compression='auto', pipe_hint=None): + if not (tarfile == '-' or (os.path.exists(tarfile) and not os.path.isdir(tarfile))): + raise Exception('file does not exist: %s' % tarfile) + if out_dir is None: + out_dir = tempfile.mkdtemp(prefix='extract_tarball-') + else: + util.file.mkdir_p(out_dir) + assert compression in ('gz', 'bz2', 'lz4', 'zip', 'none', 'auto') + if compression is 'auto': + assert tarfile != '-' or pipe_hint, ""cannot autodetect on stdin input unless pipe_hint provided"" + # auto-detect compression type based on file name + if tarfile=='-': + lower_fname = pipe_hint + else: + lower_fname = os.path.basename(tarfile).lower() + if lower_fname.endswith('.tar'): + compression = 'none' + elif lower_fname.endswith('.zip'): + compression = 'zip' + elif lower_fname.endswith('.tgz') or lower_fname.endswith('.tar.gz'): + compression = 'gz' + elif lower_fname.endswith('.tar.lz4'): + compression = 'lz4' + elif lower_fname.endswith('.tar.bz2'): + compression = 'bz2' + else: + raise Exception(""unsupported file type: %s"" % tarfile) + + if compression == 'zip': + assert tarfile != '-' + cmd = ['unzip', '-q', tarfile, '-d', out_dir] + with open(os.devnull, 'w') as fnull: + subprocess.check_call(cmd, stderr=fnull) + else: + if compression == 'gz': + decompressor = ['pigz', '-dc', '-p', str(util.misc.sanitize_thread_count(threads))] + elif compression == 'bz2': + decompressor = ['lbzip2', '-dc', '-n', str(util.misc.sanitize_thread_count(threads))] + elif compression == 'lz4': + decompressor = ['lz4', '-d'] + elif compression == 'none': + decompressor = ['cat'] + untar_cmd = ['tar', '-C', out_dir, '-x'] + if os.getuid() == 0: + # GNU tar behaves differently when run as root vs normal user + # we want normal user behavior always + if 'GNU' in subprocess.check_output(['tar', '--version']).decode('UTF-8'): + untar_cmd.append('--no-same-owner') + log.debug(""cat {} | {} | {}"".format(tarfile, ' '.join(decompressor), ' '.join(untar_cmd))) + with open(os.devnull, 'w') as fnull: + if tarfile == '-': + inf = None + else: + inf = open(tarfile, 'rb') + decompress_proc = subprocess.Popen(decompressor, + stdin=inf, stdout=subprocess.PIPE) + untar_proc = subprocess.Popen(untar_cmd, + stdin=decompress_proc.stdout) #, stderr=fnull) + if untar_proc.wait(): + raise subprocess.CalledProcessError(untar_proc.returncode, untar_cmd) + if decompress_proc.wait(): + raise subprocess.CalledProcessError(decompress_proc.returncode, decompressor) + if inf is not None: + inf.close() + log.debug(""completed unpacking of {} into {}"".format(tarfile, out_dir)) + + return out_dir + + +@contextlib.contextmanager +def fifo(num_pipes=1, names=None, name=None): + pipe_dir = tempfile.mkdtemp() + pipe_paths = [] + if name is not None: + names = [name] + if names: + num_pipes = len(names) + for i in range(num_pipes): + if names is not None: + fn = names[i] + else: + fn = '{}.pipe'.format(i) + pipe_path = os.path.join(pipe_dir, fn) + os.mkfifo(pipe_path) + pipe_paths.append(pipe_path) + + if num_pipes == 1: + yield pipe_paths[0] + else: + yield pipe_paths + shutil.rmtree(pipe_dir) + + +def mkdir_p(dirpath): + ''' Verify that the directory given exists, and if not, create it. + ''' + try: + os.makedirs(dirpath) + except OSError as exc: # Python >2.5 + if exc.errno == errno.EEXIST and os.path.isdir(dirpath): + pass + else: + raise + + +def touch_p(path, times=None): + '''Touch file, making parent directories if they don't exist.''' + mkdir_p(os.path.dirname(path)) + touch(path, times=times) + + +def open_or_gzopen(fname, *opts, **kwargs): + mode = 'r' + open_opts = list(opts) + assert type(mode) == str, ""open mode must be of type str"" + + # 'U' mode is deprecated in py3 and may be unsupported in future versions, + # so use newline=None when 'U' is specified + if len(open_opts) > 0: + mode = open_opts[0] + if 'U' in mode: + if 'newline' not in kwargs: + kwargs['newline'] = None + open_opts[0] = mode.replace(""U"","""") + + # if this is a gzip file + if fname.endswith('.gz'): + # if 't' for text mode is not explicitly included, + # replace ""U"" with ""t"" since under gzip ""rb"" is the + # default and ""U"" depends on ""rt"" + gz_mode = str(mode).replace(""U"","""" if ""t"" in mode else ""t"") + gz_opts = [gz_mode]+list(opts)[1:] + return gzip.open(fname, *gz_opts, **kwargs) + else: + return open(fname, *open_opts, **kwargs) + + +def read_tabfile_dict(inFile, header_prefix=""#"", skip_prefix=None, rowcount_limit=None): + ''' Read a tab text file (possibly gzipped) and return contents as an + iterator of dicts. + ''' + with open_or_gzopen(inFile, 'rU') as inf: + header = None + lines_read=0 + for line_no,line in enumerate(inf): + if line_no==0: + # remove BOM, if present + line = line.replace('\ufeff','') + lines_read+=1 + row = [item.strip() for item in line.rstrip('\r\n').split('\t')] + # skip empty lines/rows + if len("""".join(row)) == 0 or (skip_prefix and line.startswith(skip_prefix)): + continue + if line.startswith(header_prefix): + row[0] = row[0][1:] + header = [item for item in row if len(item)] + elif header is None: + header = [item for item in row if len(item)] + else: + # if a row is longer than the header + if len(row) > len(header): + # truncate the row to the header length, and only include extra items if they are not spaces + # (takes care of the case where the user may enter an extra space at the end of a row) + row = row[:len(header)] + [item for item in row[len(header):] if len(item)] + assert len(header) == len(row), ""%s != %s"" % (len(header), len(row)) + yield dict((k, v) for k, v in zip(header, row) if v) + + if rowcount_limit and lines_read==rowcount_limit: + break + + +def read_tabfile(inFile): + ''' Read a tab text file (possibly gzipped) and return contents as an + iterator of arrays. + ''' + with open_or_gzopen(inFile, 'rU') as inf: + for line_no,line in enumerate(inf): + if line_no==0: + # remove BOM, if present + line = line.replace('\ufeff','') + if not line.startswith('#'): + yield list(item.strip() for item in line.rstrip('\r\n').split('\t')) + + +def readFlatFileHeader(filename, headerPrefix='#', delim='\t'): + with open_or_gzopen(filename, 'rt') as inf: + header = inf.readline().rstrip('\n').split(delim) + if header and header[0].startswith(headerPrefix): + header[0] = header[0][len(headerPrefix):] + return header + + +class FlatFileParser(object): + ''' Generic flat file parser that parses tabular text input + ''' + + def __init__(self, lineIter=None, name=None, outType='dict', + readHeader=True, headerPrefix='#', delim='\t', + requireUniqueHeader=False): + self.lineIter = lineIter + self.header = None + self.name = name + self.headerPrefix = headerPrefix + self.readHeader = readHeader + self.delim = delim + self.requireUniqueHeader = requireUniqueHeader + self.line_num = 0 + assert outType in ('dict', 'arrayStrict', 'arrayLoose', 'both') + self.outType = outType + assert readHeader or outType in ('arrayStrict', 'arrayLoose') + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + return 0 + + def __iter__(self): + assert self.lineIter + for row in self.lineIter: + out = self.parse(row) + if out is not None: + yield out + + def parse(self, row): + self.line_num += 1 + try: + line = row.rstrip('\n').split(self.delim) + if self.readHeader: + if self.headerPrefix and row.startswith(self.headerPrefix): + line[0] = line[0][len(self.headerPrefix):] + assert not (self.requireUniqueHeader and self.header) + self.parseHeader(line) + return None + elif not self.header: + self.parseHeader(line) + return None + else: + return self.parseRow(line) + else: + return self.parseRow(line) + except Exception: + template = ""Exception parsing file at line {}. Line contents: '{}'"" + message = template.format(self.line_num, row) + if self.name: + log.exception(""%s File: %s"", message, self.name) + else: + log.exception(message) + raise + + def parseHeader(self, row): + assert row + self.header = row + if self.outType != 'arrayLoose': + assert len(row) == len(dict([(x, 0) for x in row])) + + def parseRow(self, row): + assert self.outType == 'arrayLoose' or (self.header and len(self.header) == len(row)) + + if self.outType == 'arrayLoose' or self.outType == 'arrayStrict': + return row + out = {self.header[i]: row[i] for i in range(len(self.header))} + if self.outType == 'both': + for i in range(len(self.header)): + out[i] = row[i] + return out + + +def fastaMaker(seqs, linewidth=60): + assert linewidth > 0 + + for idVal, seq in seqs: + yield "">{}\n"".format(idVal) + + while len(seq) > linewidth: + line = seq[:linewidth] + seq = seq[linewidth:] + yield ""{}\n"".format(line) + + if seq: + yield seq + ""\n"" + + +def makeFastaFile(seqs, outFasta): + with open(outFasta, 'wt') as outf: + for line in fastaMaker(seqs): + outf.write(line) + + return outFasta + + +def bam_is_sorted(bam_file_path): + # Should perhaps be in samtools.py once it moves to pysam + samfile = pysam.AlignmentFile(bam_file_path, ""rb"", check_sq=False) + if ""HD"" in samfile.header and ""SO"" in samfile.header[""HD""]: + return samfile.header[""HD""][""SO""] in (""coordinate"") # also: ""queryname"" + else: + raise KeyError(""Could not locate the SO field in the SAM/BAM file header."") + + +def concat(inputFilePaths, outputFilePath, append=False): + ''' + This function creates an output file containing the + lines present in the input file(s), in the order specified + by the inputFilePaths list. If `append` is True, + appends to the output file instead of overwriting it. + ''' + with open(outputFilePath, 'a' if append else 'w') as outfile: + for filePath in util.misc.make_seq(inputFilePaths): + with open(filePath) as infile: + for line in infile: + outfile.write(line) + + +def download_file(uriToGet, dest, destFileName=None): + destDir = os.path.realpath(os.path.expanduser(dest)) + + req = urlopen(uriToGet) + + if not destFileName: + m = re.search('filename=""(?P.+)""', req.info()['Content-Disposition']) + + if m: + destFileName = m.group(""filename"") + else: + destFileName = ""file"" + + destPath = os.path.join(destDir, destFileName) + + with open(destPath, ""wb"") as outf: + while True: + chunk = req.read(1024) + if not chunk: + break + outf.write(chunk) + + return destPath + + +def webfile_readlines(uriToGet): + + for line in urlopen(uriToGet): # .readlines(): + cleanedLine = line.decode(""utf-8"").strip() + if len(cleanedLine) > 0: + yield cleanedLine + + +def replace_in_file(filename, original, new): + '''Replace the original string with new in file. + + Raises error if the original is not in the file. + ''' + with open(filename) as f: + s = f.read() + if original not in s: + raise StringNotFoundException(""String '%s' not found."" % s) + s = s.replace(original, new) + with open(filename, 'w') as f: + f.write(s) + + +def cat(output_file, input_files): + '''Cat list of input filenames to output filename.''' + with open_or_gzopen(output_file, 'wb') as wfd: + for f in input_files: + with open_or_gzopen(f, 'rb') as fd: + shutil.copyfileobj(fd, wfd, 1024*1024*10) + + +@contextlib.contextmanager +def temp_catted_files(input_files, suffix=None, prefix=None): + '''Create a temporary file holding catted contents of input_files.''' + fn = mkstempfname(suffix=suffix, prefix=prefix) + try: + cat(fn, input_files) + yield fn + finally: + os.remove(fn) + +def _get_pathconf(file_system_path, param_suffix, default): + """"""Return a pathconf parameter value for a filesystem. + """""" + param_str = [s for s in os.pathconf_names if s.endswith(param_suffix)] + if len(param_str) == 1: + try: + return os.pathconf(file_system_path, param_str[0]) + except OSError: + pass + return default + +def max_file_name_length(file_system_path): + """"""Return the maximum valid length of a filename (path component) on the given filesystem."""""" + return _get_pathconf(file_system_path, '_NAME_MAX', 80)-1 + +def max_path_length(file_system_path): + """"""Return the maximum valid length of a path on the given filesystem."""""" + return _get_pathconf(file_system_path, '_PATH_MAX', 255)-1 + +def sanitize_id_for_sam_rname(string_in): + #[0-9A-Za-z!#$%&+./:;?@^_|~-] + # See character set restrictions in SAM/BAM RNAME spec: + # https://samtools.github.io/hts-specs/SAMv1.pdf + # [0-9A-Za-z!#$%&+./:;?@^_|~-][0-9A-Za-z!#$%&*+./:;=?@^_|~-]* + # Here we are being conservative and replacing anything disallowed: + # [^0-9A-Za-z!#$%&+./:;?@^_|~-] + disallowed_char_re = re.compile(r'[^0-9A-Za-z!#$%&+./:;?@^_|~-]') + string_value = disallowed_char_re.sub(""_"", string_in) + + # condense runs of underscores + double_underscore_re = re.compile(r'_{2,}') + string_value = double_underscore_re.sub(""_"", string_value) + + # ensure all the character removals did not make the name empty + string_value = string_value or '_' + print(""sanitizing: %s ====> %s "" % (string_in, string_value)) + return string_value + +def write_fasta_with_sanitized_ids(fasta_in, out_filepath): + with open(out_filepath, ""w"") as handle: + fasta_out = FastaIO.FastaWriter(handle, wrap=None) + fasta_out.write_header() + for record in SeqIO.parse(fasta_in, ""fasta""): + record.id=sanitize_id_for_sam_rname(record.id) + fasta_out.write_record(record) + print(""out_filepath"",out_filepath) + print(""os.path.dirname(out_filepath)"",os.path.dirname(out_filepath)) + print(""ls -lah"") + for line in subprocess.check_output([""ls"",""-lah"",os.path.dirname(out_filepath)]).decode(""utf-8"").split(""\n""): + print(line) + return out_filepath + +@contextlib.contextmanager +def fastas_with_sanitized_ids(input_fasta_paths, use_tmp=False): + """""" Returns a list of file paths for fasta files with + sanitized IDs + ( Suitable for Picard; see: https://github.com/samtools/hts-specs/pull/333 ) + + input_fasta_paths is a list of file paths to fasta files + + if use_tmp==False, companion fasta files will be created with "".sanitized_ids.fasta"" appended + in the same location as the input + if use_tmp==True, temp files will be written instead + """""" + sanitized_fasta_paths=[] + if use_tmp: + with tempfnames([""_{inf_name}"".format(inf_name=os.path.basename(inf_path)) for inf_path in [input_fasta_paths]]) as temp_fasta_paths: + for fasta_in, out_filepath in zip([input_fasta_paths], temp_fasta_paths): + sanitized_fasta_paths.append(write_fasta_with_sanitized_ids(fasta_in, out_filepath)) + yield sanitized_fasta_paths + else: + for fasta_in in [input_fasta_paths]: + in_fasta_basename = os.path.splitext(os.path.basename(fasta_in))[0] + out_basedir = os.path.realpath(os.path.dirname(fasta_in)) + new_basename = in_fasta_basename + if new_basename.lower().endswith('.fa'): + new_basename = new_basename[:-3] + '.sanitized_ids.fa' + elif new_basename.lower().endswith('.fasta'): + new_basename = new_basename[:-6] + '.sanitized_ids.fasta' + else: + new_basename = new_basename + '.sanitized_ids.fasta' + out_filepath = os.path.join(out_basedir,new_basename) + sanitized_fasta_paths.append(write_fasta_with_sanitized_ids(fasta_in, out_filepath)) + yield sanitized_fasta_paths + +def string_to_file_name(string_value, file_system_path=None, length_margin=0): + """"""Constructs a valid file name from a given string, replacing or deleting invalid characters. + If `file_system_path` is given, makes sure the file name is valid on that file system. + If `length_margin` is given, ensure a string that long can be added to filename without breaking length limits. + """""" + replacements_dict = { + ""\\"": ""-"", # win directory separator + ""/"": ""-"", # posix directory separator + os.sep: ""-"", # directory separator + ""^"": ""_"", # caret + ""&"": ""_and_"", # background + ""\"""": """", # double quotes + r""'"": """", # single quotes + r"":"": ""_"", # colon (problem for ntfs) + r"" "": ""_"", # spaces + r""|"": ""-"", # shouldn't confuse a vertical bar for a shell pipe + r""!"": ""."", # not a bash operator + r"";"": ""."", # not a terminator + r""?"": ""_"", # could be mistaken for a wildcard + r""*"": ""_"", # could be mistaken for a wildcard + r""`"": ""_"", # no subshells + r"" -"": ""_-"", # could be mistaken for an argument + r"" --"": ""_--"", # could be mistaken for an argument + r"">"": ""_"", # no redirect chars + r""<"": ""_"", # no redirect chars + r""("": ""__"", # special character + r"")"": ""__"", # special character + r""\\x"": ""_"", # hex char + r""\\o"": ""_"", # octal char + #r""\\u"": """", # unicode char + #"""": """", # other illegal strings to replace + } + + # group of ascii control and non-printable characters + control_chars = ''.join( map(chr, list(range(0,32)) + list(range(127,160)) ) ) + control_char_re = re.compile('[%s]' % re.escape(control_chars)) + string_value = control_char_re.sub(""_"", string_value) + + # replacements from the dictionary above + strs_to_replace_re = re.compile(r'|'.join(re.escape(key) for key in replacements_dict.keys())) + string_value = strs_to_replace_re.sub(lambda x: replacements_dict.get(x.group(), ""_""), string_value) + + # condense runs of underscores + double_underscore_re = re.compile(r'_{2,}') + string_value = double_underscore_re.sub(""_"", string_value) + + # condense runs of dashes + double_dash_re = re.compile(r'-{2,}') + string_value = double_dash_re.sub(""-"", string_value) + + # remove leading or trailing periods (no hidden files (*NIX) or missing file extensions (NTFS)) + string_value = string_value.strip(""."") + + # comply with file name length limits + if file_system_path is not None: + max_len = max(1, max_file_name_length(file_system_path) - length_margin) + string_value = string_value[:max_len] + while len(string_value.encode('utf-8')) > max_len: + string_value = string_value[:-1] + + # ensure all the character removals did not make the name empty + string_value = string_value or '_' + + return string_value + +def grep_count(file_path, to_match, additional_flags=None, fixed_mode=True, starts_with=False): + ''' + This uses grep for fast counting of strings in a file + ''' + if not os.path.isfile(file_path) or os.path.getsize(file_path)==0: + return 0 + + env = os.environ.copy() + env['LC_ALL'] = 'C' #use C locale rather than UTF8 for faster grep + + cmd = [""grep""] + # '-c' returns the match count + cmd.append(""-c"") + if additional_flags: + cmd.extend(additional_flags) + + # fixed mode cannot be used with starts_with, since it does not match regular expressions + # only add the fixed_mode flag if we're not using starts_with + if not starts_with: + if fixed_mode: + cmd.append(""-F"") + cmd.append(to_match) + else: + cmd.append(""^""+to_match) + + cmd.append(file_path) + + number_of_seqs = util.misc.run_and_print(cmd, silent=False, check=True, env=env) + return int(number_of_seqs.stdout.decode(""utf-8"").rstrip(os.linesep)) + +# used by count_and_sort_barcodes +def count_occurrences_in_tsv(filePath, col=0, noise_chr='.', delimiter='\t', include_noise=False): + file_occurrence_counts = {} + with open(filePath) as infile: + for row in csv.reader(infile, delimiter=delimiter): + if noise_chr not in row[col] or include_noise: + file_occurrence_counts[row[col]] = file_occurrence_counts.get(row[col], 0) + 1 + return file_occurrence_counts + +def count_str_in_file(in_file, query_str, starts_with=False): + if not os.path.isfile(in_file) or os.path.getsize(in_file)==0: + return 0 + + if in_file.endswith('.gz'): + n = 0 + with gzip.open(in_file, 'rt') as inf: + if starts_with: + n = sum(1 for line in inf if line.startswith(query_str)) + else: + n = sum(1 for line in inf if query_str in line) + return n + # use grep count for non-gzip files since it seems to be faster than native on Pythons <3.5 + else: + return grep_count(in_file, query_str, starts_with=starts_with) + +def fasta_length(fasta_path): + ''' + Count number of records in fasta file + ''' + return count_str_in_file(fasta_path, '>', starts_with=True) + +def count_fastq_reads(inFastq): + ''' + Count number of reads in fastq file + ''' + n = line_count(inFastq) + if n % 4 != 0: + raise Exception(""cannot count reads in a fastq with wrapped lines"") + return n // 4 + # unfortunately, both @ and + are potential quality characters and cannot be used in a + # fastq counting approach.... + #return count_str_in_file(inFastq, '@', starts_with=True) + +def line_count(infname): + n = 0 + with open_or_gzopen(infname, 'rt') as inf: + for line in inf: + n += 1 + return n + +def touch(fname, times=None): + with open(fname, 'a'): + os.utime(fname, times) + +def make_empty(fname): + '''Make `fname` a zero-length file with the current timestamp.''' + with open(fname, 'w'): + pass + +def dump_file(fname, value): + """"""store string in file"""""" + with open(fname, 'w') as out: + out.write(str(value)) + +def slurp_file(fname, maxSizeMb=50): + """"""Read entire file into one string. If file is gzipped, uncompress it on-the-fly. If file is larger + than `maxSizeMb` megabytes, throw an error; this is to encourage proper use of iterators for reading + large files. If `maxSizeMb` is None or 0, file size is unlimited."""""" + fileSize = os.path.getsize(fname) + if maxSizeMb and fileSize > maxSizeMb*1024*1024: + raise RuntimeError('Tried to slurp large file {} (size={}); are you sure? Increase `maxSizeMb` param if yes'. + format(fname, fileSize)) + with open_or_gzopen(fname) as f: + return f.read() + +def is_broken_link(filename): + # isfile() returns True if a file, or a working link + if os.path.isfile(filename) or os.path.isdir(filename): + return False + # otherwise if this is a link + if os.path.islink(filename): + # os.path.exists() returns false in the case of broken symlinks + return not os.path.exists(filename) + return False + + +def find_broken_symlinks(rootdir, followlinks=False): + """""" + This function removes broken symlinks within a directory, + doing the same in each child directory as well (though not following + functional symlinks, unless they're directories and followlinks=True). + @param followlinks: only applies to directory links as per os.walk + """""" + + broken_links_to_remove = [] + + # first check to see if the input is itself a broken link + if is_broken_link(rootdir): + broken_links_to_remove.append(rootdir.rstrip(""/"")) + else: + # otherwise traverse the directory hierarchy + for rootpath, subfolders, files in os.walk(rootdir, followlinks=followlinks): + for filename in files: + fpath = os.path.join(rootpath, filename) + if is_broken_link(fpath): + broken_links_to_remove.append(fpath.rstrip(""/"")) + + return broken_links_to_remove + + +def uncompressed_file_type(fname): + """"""Return the original file extension of either a compressed or an uncompressed file."""""" + base, ext = os.path.splitext(fname) + if ext in ('.gz', '.bz2'): + base, ext = os.path.splitext(base) + return ext + +def repack_tarballs(out_compressed_tarball, + input_compressed_tarballs, + extract_to_disk_path=None, + extract_numeric_owner=False, + avoid_disk_roundtrip=True, + ignore_zeros=True, + pipe_hint_in=None, + pipe_hint_out=None, + threads=None): + threads = util.misc.sanitize_thread_count(threads) + + def choose_compressor(filepath, threads=8): + return_obj = {} + filepath = filepath.lower() + if re.search(r'(\.?tgz|\.?gz)$', filepath): + compressor = 'pigz {threads}'.format(threads=""-p ""+str(threads) if threads else """").split() + return_obj[""decompress_cmd""] = compressor + [""-dc""] + return_obj[""compress_cmd""] = compressor + [""-c""] + elif re.search(r'\.?bz2$', filepath): + compressor = 'lbzip2 {threads}'.format(threads=""-n ""+str(threads) if threads else """").split() + return_obj[""decompress_cmd""] = compressor + [""-dc""] + return_obj[""compress_cmd""] = compressor + [""-c""] + elif re.search(r'\.?lz4$', filepath): + compressor = ['lz4'] + return_obj[""decompress_cmd""] = compressor + [""-dc""] + return_obj[""compress_cmd""] = compressor + [""-c""] + elif re.search(r'\.?tar$', filepath): + compressor = ['cat'] + return_obj[""decompress_cmd""] = compressor + return_obj[""compress_cmd""] = compressor + else: + raise IOError(""An input file of unknown type was provided: %s"" % filepath) + return return_obj + + class FileDiverter(object): + """""" + This reads bytes from a TarInfo file stream, writes them to a disk file + and returns the buffered bytes as they are read + """""" + def __init__(self, fileinfo, fileobj, written_mirror_file=None, extract_numeric_owner=False): + self.written_mirror_file = open(written_mirror_file,""wb"") + self.fileinfo = fileinfo + self.fileobj = fileobj + self.extract_numeric_owner = extract_numeric_owner + + def __del__(self): + self.written_mirror_file.close() + + tar_in.chown(self.fileinfo, self.written_mirror_file.name, self.extract_numeric_owner) + if not self.fileinfo.issym(): + tar_in.chmod(self.fileinfo, self.written_mirror_file.name) + tar_in.utime(self.fileinfo, self.written_mirror_file.name) + + def read(self, size): + assert size is not None + + buf = self.fileobj.read(size) + self.written_mirror_file.write(buf) + return buf + + if extract_to_disk_path and not os.path.isdir(extract_to_disk_path): + mkdir_p(extract_to_disk_path) + + if out_compressed_tarball == ""-"": + if not pipe_hint_out: + raise IOError(""cannot autodetect compression for stdoud unless pipeOutHint provided"") + compressor = choose_compressor(pipe_hint_out)[""compress_cmd""] + outfile = None + else: + compressor =choose_compressor(out_compressed_tarball)[""compress_cmd""] + outfile = open(out_compressed_tarball, ""w"") + + out_compress_ps = subprocess.Popen(compressor, stdout=sys.stdout if out_compressed_tarball == ""-"" else outfile, stdin=subprocess.PIPE) + + tar_out = tarfile.open(fileobj=out_compress_ps.stdin, mode=""w|"") + + for in_compressed_tarball in input_compressed_tarballs: + if in_compressed_tarball != ""-"": + pigz_ps = subprocess.Popen(choose_compressor(in_compressed_tarball)[""decompress_cmd""] + [in_compressed_tarball], stdout=subprocess.PIPE) + else: + if not pipe_hint_in: + raise IOError(""cannot autodetect compression for stdin unless pipeInHint provided"") + pigz_ps = subprocess.Popen(choose_compressor(pipe_hint_in)[""decompress_cmd""] + [in_compressed_tarball], stdout=subprocess.PIPE, stdin=sys.stdin) + tar_in = tarfile.open(fileobj=pigz_ps.stdout, mode=""r|"", ignore_zeros=True) + + fileinfo = tar_in.next() + while fileinfo is not None: + if extract_to_disk_path: + target_path = os.path.normpath(os.path.join(extract_to_disk_path, fileinfo.name).rstrip(""/"")) + containing_path = os.path.dirname(target_path) + mkdir_p(containing_path) + + if avoid_disk_roundtrip and fileinfo.isreg(): + # avoid disk round trip for regular files (don't re-read from disk to write to new tar) + fileobj = tar_in.extractfile(fileinfo) + tar_out.addfile(fileinfo, fileobj=FileDiverter(fileinfo, fileobj, written_mirror_file=target_path)) + else: + # write to disk, add to new tarball from disk + outfile = tar_in.extract(fileinfo, path=extract_to_disk_path) + with pushd_popd(extract_to_disk_path): + tar_out.add(fileinfo.name) + else: + # if we're not extracting to disk, stream directly between tarballs + fileobj = tar_in.extractfile(fileinfo) + tar_out.addfile(fileinfo, fileobj=fileobj) + + fileinfo = tar_in.next() + pigz_ps.wait() + tar_in.close() + if pigz_ps.returncode != 0: + raise subprocess.CalledProcessError(pigz_ps.returncode, ""Call error %s"" % pigz_ps.returncode) + + tar_out.close() + out_compress_ps.stdin.close() + out_compress_ps.wait() + if out_compress_ps.returncode != 0: + raise subprocess.CalledProcessError(out_compress_ps.returncode, ""Call error %s"" % out_compress_ps.returncode) + + if outfile is not None: + outfile.close() +","Python" +"Viral","broadinstitute/viral-ngs","test/stubs.py",".py","1891","80","import logging +import os +import pytest +import tools + + +class StubCondaPackage(tools.Tool): + + # Skip gathering in all_tool_classes + _skiptest = True + + def __init__( + self, + package, + channel=""bioconda"", + executable=None, + version="""", + verifycmd=None, + verifycode=0, + require_executability=True, + env=None, + env_root_path=None, + conda_cache_path=None, + patches=None, + post_install_command=None, + post_install_ret=0, + post_verify_command=None, + post_verify_ret=0 + ): + self.executable = executable or package + if type(version) == tools.CondaPackageVersion: + self.version = version + else: + self.version = tools.CondaPackageVersion(version) + + self.env_path = None + if 'CONDA_PREFIX' in os.environ and len(os.environ['CONDA_PREFIX']): + last_path_component = os.path.basename(os.path.normpath(os.environ['CONDA_PREFIX'])) + self.env_path = os.path.dirname(os.environ['CONDA_PREFIX']) if last_path_component == ""bin"" else os.environ['CONDA_PREFIX'] + + else: + raise Exception + + def is_attempted(self): + return True + + def is_installed(self): + return True + + @property + def bin_path(self): + return os.path.join(self.env_path, 'bin') + + def executable_path(self): + return os.path.join(self.bin_path, self.executable) + + def apply_patches(self): + pass + + def verify_install(self): + return + + def package_available(self): + return True + + def uninstall_package(self): + return True + + def install_package(self): + return True + + def get_installed_version(self): + return self.version + + def post_install(self): + pass + + def execute(self, cmd, loglevel=logging.DEBUG): + return {} +","Python" +"Viral","broadinstitute/viral-ngs","test/__init__.py",".py","6950","168","'''utilities for tests''' + +__author__ = ""irwin@broadinstitute.org"" + +# built-ins +import filecmp +import os +import re +import unittest +import hashlib +import logging +import copy + +# third-party +import Bio.SeqIO +import pytest +import pysam + +# intra-project +import util.file +from util.misc import available_cpu_count +from tools.samtools import SamtoolsTool + +logging.getLogger('botocore').setLevel(logging.WARNING) +logging.getLogger('boto3').setLevel(logging.WARNING) + + +if 'PYTEST_XDIST_WORKER_COUNT' in os.environ: + _CPUS = 1 +else: + _CPUS = available_cpu_count() + + +def assert_equal_contents(testCase, filename1, filename2): + 'Assert contents of two files are equal for a unittest.TestCase' + testCase.assertTrue(filecmp.cmp(filename1, filename2, shallow=False)) + + +def assert_equal_bam_reads(testCase, bam_filename1, bam_filename2): + ''' Assert that two bam files are equivalent + + This function converts each file to sam (plaintext) format, + without header, since the header can be variable. + + Test data should be stored in bam format rather than sam + to save space, and to ensure the bam->sam conversion + is the same for both files. + ''' + + samtools = SamtoolsTool() + + sam_one = util.file.mkstempfname("".sam"") + sam_two = util.file.mkstempfname("".sam"") + + # write the bam files to sam format, without header (no -h) + samtools.view(args=[], inFile=bam_filename1, outFile=sam_one) + samtools.view(args=[], inFile=bam_filename2, outFile=sam_two) + + try: + testCase.assertTrue(filecmp.cmp(sam_one, sam_two, shallow=False)) + finally: + for fname in [sam_one, sam_two]: + if os.path.exists(fname): + os.unlink(fname) + +def assert_md5_equal_to_line_in_file(testCase, filename, checksum_file, msg=None): + ''' Compare the checksum of a test file with the expected checksum + stored in a second file + compare md5(test_output.bam) with expected_output.bam.md5:1 + ''' + + hash_md5 = hashlib.md5() + with open(filename, ""rb"") as f: + for chunk in iter(lambda: f.read(4096), b""""): + hash_md5.update(chunk) + + expected_checksum = """" + with open(checksum_file, ""rb"") as f: + expected_checksum = str(f.readline().decode(""utf-8"")) + + expected_checksum = expected_checksum.replace(""\r"","""").replace(""\n"","""") + + assert len(expected_checksum) > 0 + + testCase.assertEqual(hash_md5.hexdigest(), expected_checksum, msg=msg) + +@pytest.mark.usefixtures('tmpdir_class') +class TestCaseWithTmp(unittest.TestCase): + 'Base class for tests that use tempDir' + + def assertEqualContents(self, f1, f2): + assert_equal_contents(self, f1, f2) + + def assertEqualFasta(self, f1, f2): + '''Check that two fasta files have the same sequence ids and bases''' + def seqIdPairs(f): + return [(rec.id, rec.seq) for rec in Bio.SeqIO.parse(f, 'fasta')] + self.assertEqual(seqIdPairs(f1), seqIdPairs(f2)) + + def assertEqualFastaSeqs(self, f1, f2): + '''Check that two fasta files have the same sequence bases (sequence ids may differ)''' + def seqs(f): + return [rec.seq for rec in Bio.SeqIO.parse(f, 'fasta')] + self.assertEqual(seqs(f1), seqs(f2)) + + def input(self, fname): + '''Return the full filename for a file in the test input directory for this test class''' + return os.path.join(util.file.get_test_input_path(self), fname) + + def inputs(self, *fnames): + '''Return the full filenames for files in the test input directory for this test class''' + return [self.input(fname) for fname in fnames] + + def assertEqualSamHeaders(self, tested_samfile, expected_samfile, other_allowed_values=None): + ''' + other_allowed_values is a dict that maps a key to a list of other accepted values + ''' + other_allowed_values = other_allowed_values or {} + + test_sam = pysam.AlignmentFile(tested_samfile, ""rb"", check_sq=False) + expected_sam = pysam.AlignmentFile(expected_samfile, ""rb"", check_sq=False) + + # check that the two sams contain the same types of header lines + # note that pysam returns lists of dicts for + # header lines types that appear more than once (ex. multiple 'RG' lines, etc.) + self.assertEqual(sorted(test_sam.header.keys()),sorted(expected_sam.header.keys())) + + lines_tag_to_check = test_sam.header.keys() + + for line_tag in lines_tag_to_check: + line_type = type(test_sam.header[line_tag]) + # for header lines that occur more than once + if line_type == list: # if list of dicts + # compose alterates for each line present, and check to see if exists in list of expected + for test_dict in test_sam.header[line_tag]: + alternate_allowed_test_dicts = [] + for key,val in test_dict.items(): + alterate_test_dict = copy.deepcopy(test_dict) + if key in other_allowed_values.keys(): + for alternate_val in other_allowed_values[key]: + alterate_test_dict[key] = alternate_val + alternate_allowed_test_dicts.append(copy.deepcopy(alterate_test_dict)) + for expected_d in expected_sam.header[line_tag]: + self.assertTrue(any(d==expected_d for d in alternate_allowed_test_dicts+[test_dict]), msg=""{} expected but not seen in {}"".format(expected_d, alternate_allowed_test_dicts+[test_dict])) + # for header lines that occur only once + elif line_type in (dict,): # may need to change object type for pysam >=0.18 + test_dict = dict(test_sam.header[line_tag]) + alternate_allowed_test_dicts = [] + for key,val in test_dict.items(): + alterate_test_dict = copy.deepcopy(test_dict) + if key in other_allowed_values.keys(): + for alternate_val in other_allowed_values[key]: + alterate_test_dict[key] = alternate_val + alternate_allowed_test_dicts.append(copy.deepcopy(alterate_test_dict)) + self.assertTrue(any(d==expected_sam.header[line_tag] for d in alternate_allowed_test_dicts+[test_dict]), msg=""{} expected but not seen in {}"".format(expected_sam.header[line_tag],alternate_allowed_test_dicts+[test_dict])) + +"""""" +When ""nose"" executes python scripts for automated testing, it excludes ones with +the executable bit set (in case they aren't import safe). To prevent any of the +tests in this folder from being silently excluded, assure this bit is not set. +"""""" + + +def assert_none_executable(): + testDir = os.path.dirname(__file__) + assert all(not os.access(os.path.join(testDir, filename), os.X_OK) for filename in os.listdir(testDir) + if filename.endswith('.py')) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_assembly.py",".py","37329","809","# Unit tests for assembly.py + +__author__ = ""dpark@broadinstitute.org"" + +import assembly +import util.cmd +import util.file +import Bio.SeqIO +import Bio.Data.IUPACData +import unittest +import argparse +import os +import os.path +import shutil +import tempfile +import argparse +import itertools +import pytest +import tools.mummer +import tools.novoalign +import tools.picard +from test import TestCaseWithTmp, _CPUS + + +def makeFasta(seqs, outFasta): + with open(outFasta, 'wt') as outf: + for line in util.file.fastaMaker(seqs): + outf.write(line) + + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_fun in assembly.__commands__: + parser = parser_fun(argparse.ArgumentParser()) + helpstring = parser.format_help() + + +class TestRefineAssemble(TestCaseWithTmp): + ''' Test edge cases of the de novo assembly pipeline ''' + + def test_empty_input_bam_assembly(self): + novoalign = tools.novoalign.NovoalignTool() + novoalign.install() + + # prep inputs + orig_ref = os.path.join(util.file.get_test_input_path(), 'ebov-makona.fasta') + inFasta = util.file.mkstempfname('.ref.fasta') + shutil.copyfile(orig_ref, inFasta) + novoalign.index_fasta(inFasta) + + inBam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + + outFasta = util.file.mkstempfname('.refined.fasta') + + # run refine_assembly + args = [inFasta, inBam, outFasta, ""--chr_names"", 'G5012.3', ""--min_coverage"", '3', ""--novo_params"", + ""-r Random -l 30 -g 40 -x 20 -t 502 -c {}"".format(_CPUS)] + args = assembly.parser_refine_assembly(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + + # the expected output is an empty fasta file + self.assertTrue(os.path.isfile(outFasta)) + self.assertTrue(os.path.getsize(outFasta) == 0) + + + def test_empty_input_fasta_assembly(self): + novoalign = tools.novoalign.NovoalignTool() + novoalign.install() + + # make the input fasta empty + inFasta = util.file.mkstempfname('.input.fasta') + util.file.touch(inFasta) + novoalign.index_fasta(inFasta) + + inBam = os.path.join(util.file.get_test_input_path(), 'G5012.3.testreads.bam') + + outFasta = util.file.mkstempfname('.refined.fasta') + + # run refine_assembly + args = [inFasta, inBam, outFasta, ""--chr_names"", 'G5012.3', ""--min_coverage"", '3', ""--novo_params"", + ""-r Random -l 30 -g 40 -x 20 -t 502 -c {}"".format(_CPUS)] + args = assembly.parser_refine_assembly(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + + # the expected output is an empty fasta file + self.assertTrue(os.path.isfile(outFasta)) + self.assertTrue(os.path.getsize(outFasta) == 0) + + + def test_empty_input_succeed(self): + novoalign = tools.novoalign.NovoalignTool() + novoalign.install() + + # make the input fasta empty + inFasta = util.file.mkstempfname('.input.fasta') + util.file.touch(inFasta) + novoalign.index_fasta(inFasta) + + inBam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + + outFasta = util.file.mkstempfname('.refined.fasta') + + # run refine_assembly + args = [inFasta, inBam, outFasta, ""--chr_names"", 'G5012.3', ""--min_coverage"", '3', ""--novo_params"", + ""-r Random -l 30 -g 40 -x 20 -t 502 -c {}"".format(_CPUS)] + args = assembly.parser_refine_assembly(argparse.ArgumentParser()).parse_args(args) + print(args) + args.func_main(args) + + # the expected output is an empty fasta file + self.assertTrue(os.path.isfile(outFasta)) + self.assertTrue(os.path.getsize(outFasta) == 0) + + +class TestAssembleTrinity(TestCaseWithTmp): + ''' Test the assemble_trinity command (no validation of output) ''' + + def test_assembly(self): + inDir = util.file.get_test_input_path(self) + inBam = os.path.join(inDir, '..', 'G5012.3.subset.bam') + clipDb = os.path.join(inDir, 'clipDb.fasta') + outFasta = util.file.mkstempfname('.fasta') + assembly.assemble_trinity(inBam, clipDb, outFasta) + self.assertGreater(os.path.getsize(outFasta), 0) + contig_lens = list(sorted(len(seq.seq) for seq in Bio.SeqIO.parse(outFasta, 'fasta'))) + self.assertEqual(contig_lens, [328, 348, 376, 381]) + os.unlink(outFasta) + + def test_empty_input_succeed(self): + inDir = util.file.get_test_input_path() + inBam = os.path.join(inDir, 'empty.bam') + clipDb = os.path.join(inDir, 'TestAssembleTrinity', 'clipDb.fasta') + outFasta = util.file.mkstempfname('.fasta') + assembly.assemble_trinity(inBam, clipDb, outFasta, always_succeed=True) + self.assertEqual(os.path.getsize(outFasta), 0) + os.unlink(outFasta) + + def test_empty_input_fail(self): + inDir = util.file.get_test_input_path() + inBam = os.path.join(inDir, 'empty.bam') + clipDb = os.path.join(inDir, 'TestAssembleTrinity', 'clipDb.fasta') + outFasta = util.file.mkstempfname('.fasta') + self.assertRaises(assembly.DenovoAssemblyError, + assembly.assemble_trinity, + inBam, clipDb, outFasta, always_succeed=False) + + +class TestAssembleSpades(TestCaseWithTmp): + ''' Test the assemble_spades command (no validation of output) ''' + + def test_assembly(self): + inDir = util.file.get_test_input_path(self) + inBam = os.path.join(inDir, '..', 'G5012.3.subset.bam') + clipDb = os.path.join(inDir, 'clipDb.fasta') + with util.file.tempfname('.fasta') as outFasta: + assembly.assemble_spades(in_bam=inBam, clip_db=clipDb, min_contig_len=180, out_fasta=outFasta) + self.assertGreater(os.path.getsize(outFasta), 0) + contig_lens = list(sorted(len(seq.seq) for seq in Bio.SeqIO.parse(outFasta, 'fasta'))) + #import sys + #print('test_assembly_contigs_lens:', contig_lens, file=sys.stderr) + self.assertEqual(contig_lens, [180, 184, 187, 190, 191, 194, 197, 211, 243, 244, 247, 288, 328, 348, 430]) + + def test_assembly_with_previously_assembled_contigs(self): + inDir = util.file.get_test_input_path(self) + inBam = os.path.join(inDir, '..', 'G5012.3.subset.bam') + clipDb = os.path.join(inDir, 'clipDb.fasta') + previously_assembled_contigs = os.path.join(inDir, 'trinity_contigs.fasta') + with util.file.tempfname('.fasta') as outFasta: + assembly.assemble_spades(in_bam=inBam, clip_db=clipDb, contigs_untrusted=previously_assembled_contigs, + out_fasta=outFasta, mem_limit_gb=1) + self.assertGreater(os.path.getsize(outFasta), 0) + contig_lens = list(sorted(len(seq.seq) for seq in Bio.SeqIO.parse(outFasta, 'fasta'))) + #import sys + #print('test_assembly_with_previously_assembled_contigs_contigs_lens:', contig_lens, file=sys.stderr) + self.assertEqual(contig_lens, [168, 170, 177, 180, 184, 187, 190, 191, 194, 197, 211, 243, 244, 247, 288, 328, 348, 430]) + + def test_empty_input_succeed(self): + inDir = util.file.get_test_input_path() + inBam = os.path.join(inDir, 'empty.bam') + clipDb = os.path.join(inDir, 'clipDb.fasta') + with util.file.tempfname('fasta') as outFasta: + assembly.assemble_spades(in_bam=inBam, clip_db=clipDb, out_fasta=outFasta) + self.assertEqual(os.path.getsize(outFasta), 0) + + def test_always_succeed(self): + inDir = util.file.get_test_input_path(self) + inBam = os.path.join(inDir, '..', 'almost-empty.bam') + clipDb = os.path.join(inDir, 'clipDb.fasta') + with util.file.tempfname('.fasta') as outFasta: + assembly.assemble_spades(in_bam=inBam, clip_db=clipDb, out_fasta=outFasta, spades_opts='--bad-option', + always_succeed=True) + self.assertEqual(os.path.getsize(outFasta), 0) + +class TestTrimRmdupSubsamp(TestCaseWithTmp): + ''' Test the trim_rmdup_subsamp command ''' + + def test_subsamp_empty(self): + inDir = util.file.get_test_input_path() + inBam = os.path.join(inDir, 'empty.bam') + clipDb = os.path.join(inDir, 'TestAssembleTrinity', 'clipDb.fasta') + outBam = util.file.mkstempfname('.out.bam') + read_stats = assembly.trim_rmdup_subsamp_reads(inBam, clipDb, outBam, n_reads=10) + os.unlink(outBam) + self.assertEqual(read_stats, (0, 0, 0, 0, 0, 0)) + + def test_subsamp_small_50(self): + inDir = util.file.get_test_input_path() + inBam = os.path.join(inDir, 'G5012.3.subset.bam') + clipDb = os.path.join(inDir, 'TestAssembleTrinity', 'clipDb.fasta') + outBam = util.file.mkstempfname('.out.bam') + read_stats = assembly.trim_rmdup_subsamp_reads(inBam, clipDb, outBam, n_reads=50) + os.unlink(outBam) + self.assertEqual(read_stats, (200, 172, 172, 50, 50, 0)) + + def test_subsamp_small_90(self): + inDir = util.file.get_test_input_path() + inBam = os.path.join(inDir, 'G5012.3.subset.bam') + clipDb = os.path.join(inDir, 'TestAssembleTrinity', 'clipDb.fasta') + outBam = util.file.mkstempfname('.out.bam') + read_stats = assembly.trim_rmdup_subsamp_reads(inBam, clipDb, outBam, n_reads=90) + os.unlink(outBam) + # counts are individual reads + self.assertEqual(read_stats, (200, 172, 172, 90, 90, 0)) + + def test_subsamp_small_200(self): + inDir = util.file.get_test_input_path() + inBam = os.path.join(inDir, 'G5012.3.subset.bam') + clipDb = os.path.join(inDir, 'TestAssembleTrinity', 'clipDb.fasta') + outBam = util.file.mkstempfname('.out.bam') + read_stats = assembly.trim_rmdup_subsamp_reads(inBam, clipDb, outBam, n_reads=200) + os.unlink(outBam) + self.assertEqual(read_stats, (200, 172, 172, 185, 172, 13)) + + def test_subsamp_big_500(self): + inDir = util.file.get_test_input_path() + inBam = os.path.join(inDir, 'G5012.3.testreads.bam') + clipDb = os.path.join(inDir, 'TestAssembleTrinity', 'clipDb.fasta') + outBam = util.file.mkstempfname('.out.bam') + read_stats = assembly.trim_rmdup_subsamp_reads(inBam, clipDb, outBam, n_reads=500) + os.unlink(outBam) + self.assertEqual(read_stats, (18710, 16310, 16310, 500, 500, 0)) + + +class TestAmbiguityBases(unittest.TestCase): + + def test_non_failure(self): + ''' Make sure that alleles_to_ambiguity runs without errors for every possible + combination of inputs. Check that the output is one-character long and uppercase. + ''' + bases = ('A', 'C', 'T', 'G') + for i in range(1, 5): + for alleles in itertools.permutations(bases, i): + out = assembly.alleles_to_ambiguity(alleles) + self.assertEqual(1, len(out)) + self.assertEqual(out, out.upper()) + + +class TestOrderAndOrient(TestCaseWithTmp): + ''' Test the MUMmer-based order_and_orient command ''' + + def test_varicella_big(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.hhv3.fasta') + assembly.order_and_orient( + os.path.join(inDir, 'contigs.hhv3.fasta'), + os.path.join(inDir, 'ref.hhv3.fasta'), + outFasta) + self.assertEqual( + str(Bio.SeqIO.read(outFasta, 'fasta').seq), + str(Bio.SeqIO.read(expected, 'fasta').seq)) + + def test_lassa_multisegment(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.lasv.fasta') + assembly.order_and_orient( + os.path.join(inDir, 'contigs.lasv.fasta'), + os.path.join(inDir, 'ref.lasv.fasta'), + outFasta) + self.assertEqualContents(outFasta, expected) + os.unlink(outFasta) + + def test_lassa_multisegment_refsel(self): + with util.file.tempfnames(('.out.fasta', '.out_ref.fasta', '.stats.tsv')) \ + as (outFasta, outReference, outStats): + contigs, expected, expectedStats = self.inputs('contigs.lasv.fasta', + 'expected.lasv.fasta', + 'expected.refsel.lasv.stats.tsv') + refs = [self.input('ref.lasv.{}.fasta'.format(strain)) + for strain in ('josiah', 'pinneo', 'KGH_G502', 'BNI_Nig08_A19', 'nomatch')] + assembly.order_and_orient(contigs, refs, outFasta, + outReference=outReference, outStats=outStats) + self.assertEqualContents(outFasta, expected) + self.assertEqualFasta(outReference, refs[0]) + self.assertEqualContents(outStats, expectedStats) + + def test_influenza_multisegment(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.influenza.fasta') + assembly.order_and_orient( + os.path.join(inDir, 'contigs.influenza.fasta'), + os.path.join(inDir, 'ref.influenza.fasta'), + outFasta) + self.assertEqualContents(outFasta, expected) + os.unlink(outFasta) + + def test_ebov_palindrome(self): + # this tests a scenario where show-aligns has more alignments than show-tiling + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.ebov.doublehit.fasta') + assembly.order_and_orient( + os.path.join(inDir, 'contigs.ebov.doublehit.fasta'), + os.path.join(util.file.get_test_input_path(), 'ebov-makona.fasta'), + outFasta) + self.assertEqual( + str(Bio.SeqIO.read(outFasta, 'fasta').seq), + str(Bio.SeqIO.read(expected, 'fasta').seq)) + + def test_ebov_palindrome_refsel(self): + # this tests a scenario where show-aligns has more alignments than show-tiling + with util.file.tempfnames(('.out.fasta', '.stats.tsv')) as (outFasta, outStats): + contigs, refs, expected, expectedStats = self.inputs('contigs.ebov.doublehit.fasta', + 'refs.ebov.fasta', + 'expected.ebov.doublehit.fasta', + 'expected.refsel.ebov.stats.tsv') + assembly.order_and_orient(contigs, refs, outFasta, n_genome_segments=1, outStats=outStats) + self.assertEqualFastaSeqs(outFasta, expected) + self.assertEqualContents(outStats, expectedStats) + + def test_hiv_wraparound(self): + # this tests a misassembly from Trinity and checks that we still use some of the contig + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.hiv.wrapped.fasta') + assembly.order_and_orient( + os.path.join(inDir, 'contigs.hiv.wrapped.fasta'), + os.path.join(inDir, 'ref.hiv.fasta'), + outFasta) + self.assertEqual( + str(Bio.SeqIO.read(outFasta, 'fasta').seq), + str(Bio.SeqIO.read(expected, 'fasta').seq)) + + def test_alternate_contigs(self): + # this tests that --outAlternateContigs works as expected + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + altFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.hiv.big_indel.fasta') + expectedAlt = os.path.join(inDir, 'expected.hiv.big_indel.alternates.fasta') + assembly.order_and_orient( + os.path.join(inDir, 'contigs.hiv.big_indel.fasta'), + os.path.join(inDir, 'ref.hiv.fasta'), + outFasta, + outAlternateContigs=altFasta) + self.assertEqualContents(outFasta, expected) + self.assertEqualContents(altFasta, expectedAlt) + + @unittest.skip('promer alignments not implemented for custom scaffolding step') + def test_lassa_protein(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.lasv.promer.fasta') + assembly.order_and_orient( + os.path.join(inDir, 'contigs.lasv.fasta'), + os.path.join(inDir, 'ref.lasv.fasta'), + outFasta, + aligner='promer') + self.assertEqualContents(outFasta, expected) + os.unlink(outFasta) + + def test_multi_overlap(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.ebov.small.fasta') + assembly.order_and_orient( + os.path.join(inDir, 'contigs.ebov.fasta'), + os.path.join(inDir, 'ref.ebov.small.fasta'), + outFasta) + self.assertEqual( + str(Bio.SeqIO.read(outFasta, 'fasta').seq), + str(Bio.SeqIO.read(expected, 'fasta').seq)) + + def test_ambig_align(self): + inDir = util.file.get_test_input_path(self) + contigs_gz = os.path.join(inDir, 'contigs.lasv.ambig.fasta.gz') + contigs = util.file.mkstempfname('.fasta') + with util.file.open_or_gzopen(contigs_gz, 'rb') as f_in: + with open(contigs, 'wb') as f_out: + shutil.copyfileobj(f_in, f_out) + expected = os.path.join(inDir, 'expected.lasv.ambig.fasta') + outFasta = util.file.mkstempfname('.fasta') + assembly.order_and_orient( + contigs, + os.path.join(inDir, 'ref.lasv.ISTH2376.fasta'), + outFasta) + def get_seqs(fasta): + return [str(s.seq) for s in Bio.SeqIO.parse(fasta, 'fasta')] + self.assertEqual(get_seqs(outFasta), get_seqs(expected)) + + def test_ambig_align_ebov(self): + inDir = util.file.get_test_input_path(self) + contigs_gz = os.path.join(inDir, 'contigs.ebov.ambig.fasta.gz') + contigs = util.file.mkstempfname('.fasta') + with util.file.open_or_gzopen(contigs_gz, 'rb') as f_in: + with open(contigs, 'wb') as f_out: + shutil.copyfileobj(f_in, f_out) + expected = os.path.join(inDir, 'expected.ebov.ambig.fasta') + outFasta = util.file.mkstempfname('.fasta') + assembly.order_and_orient( + contigs, + os.path.join(inDir, 'ref.ebov.makona_C15.fasta'), + outFasta) + def get_seqs(fasta): + return [str(s.seq) for s in Bio.SeqIO.parse(fasta, 'fasta')] + self.assertEqual(get_seqs(outFasta), get_seqs(expected)) + + def test_obscure_mummer3_bug(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.lasv.bug.fasta') + # under mummer3, this fails with a weird error in nucmer, + # causing a CalledProcessError. We want this to succeed + # nucmer, but fail later on due to IncompleteAssemblyError + self.assertRaises(assembly.IncompleteAssemblyError, + assembly.order_and_orient, + os.path.join(inDir, 'contig.mummer3_fail_lasv.fasta'), + os.path.join(inDir, 'ref.lasv.ISTH2376.fasta'), + outFasta) + + +class TestGap2Seq(TestCaseWithTmp): + '''Test gap-filling tool Gap2Seq''' + + def test_gapfill(self): + join = os.path.join + inDir = util.file.get_test_input_path() + in_scaffold = join(inDir, 'TestOrderAndOrient', 'expected.ebov.doublehit.fasta') + with util.file.tempfname(suffix='.filled.fasta') as filled: + assembly.gapfill_gap2seq(in_scaffold=in_scaffold, + in_bam=join(inDir, 'G5012.3.testreads.bam'), + out_scaffold=filled, random_seed=23923937, threads=1) + shutil.copyfile(filled, '/tmp/filled.fasta') + self.assertEqualContents(filled, join(inDir, 'TestGap2Seq', 'expected.ebov.doublehit.gapfill.fasta')) + + +class TestImputeFromReference(TestCaseWithTmp): + ''' Test the impute_from_reference command (align and modify_contig) ''' + + @unittest.skip('requires 10 mins and 16GB RAM') + def test_varicella_big_muscle(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.hhv3.muscle.fasta') + inDirBase = util.file.get_test_input_path() + assembly.impute_from_reference( + os.path.join(inDirBase, 'TestOrderAndOrient', 'expected.hhv3.fasta'), + os.path.join(inDirBase, 'TestOrderAndOrient', 'ref.hhv3.fasta'), + outFasta, + minLengthFraction=0.8, + minUnambig=0.6, + replaceLength=55, + newName='HHV3-test') + self.assertEqual( + str(Bio.SeqIO.read(outFasta, 'fasta').seq), + str(Bio.SeqIO.read(expected, 'fasta').seq)) + + def test_varicella_big_mummer(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.hhv3.mummer.fasta') + inDirBase = util.file.get_test_input_path() + assembly.impute_from_reference( + os.path.join(inDirBase, 'TestOrderAndOrient', 'expected.hhv3.fasta'), + os.path.join(inDirBase, 'TestOrderAndOrient', 'ref.hhv3.fasta'), + outFasta, + minLengthFraction=0.8, + minUnambig=0.6, + replaceLength=55, + aligner='mummer', + newName='HHV3-test') + self.assertEqual( + str(Bio.SeqIO.read(outFasta, 'fasta').seq), + str(Bio.SeqIO.read(expected, 'fasta').seq)) + + def test_small_muscle(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.sub.ebov.impute.fasta') + assembly.impute_from_reference( + os.path.join(inDir, 'test.pseudo.fasta'), + os.path.join(inDir, 'ref.sub.ebov.fasta'), + outFasta, + minLengthFraction=0.8, + minUnambig=0.2, + replaceLength=5, + newName='test_sub-EBOV.genome', + aligner='muscle') + self.assertEqual( + str(Bio.SeqIO.read(outFasta, 'fasta').seq), + str(Bio.SeqIO.read(expected, 'fasta').seq)) + + def test_small_mafft(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.sub.ebov.impute.fasta') + assembly.impute_from_reference( + os.path.join(inDir, 'test.pseudo.fasta'), + os.path.join(inDir, 'ref.sub.ebov.fasta'), + outFasta, + minLengthFraction=0.8, + minUnambig=0.2, + replaceLength=5, + newName='test_sub-EBOV.genome', + aligner='mafft') + self.assertEqual( + str(Bio.SeqIO.read(outFasta, 'fasta').seq), + str(Bio.SeqIO.read(expected, 'fasta').seq)) + + def test_small_mummer(self): + inDir = util.file.get_test_input_path(self) + outFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(inDir, 'expected.sub.ebov.impute.fasta') + assembly.impute_from_reference( + os.path.join(inDir, 'test.pseudo.fasta'), + os.path.join(inDir, 'ref.sub.ebov.fasta'), + outFasta, + minLengthFraction=0.8, + minUnambig=0.2, + replaceLength=5, + newName='test_sub-EBOV.genome', + aligner='mummer') + self.assertEqual( + str(Bio.SeqIO.read(outFasta, 'fasta').seq), + str(Bio.SeqIO.read(expected, 'fasta').seq)) + + +class TestMutableSequence(unittest.TestCase): + ''' Test the MutableSequence class ''' + + def test_bad_coords(self): + self.assertRaises(Exception, assembly.MutableSequence, 'chr', 0, 4) + self.assertRaises(Exception, assembly.MutableSequence, 'chr', 5, 4) + self.assertRaises(Exception, assembly.MutableSequence, 'chr', -2, 4) + self.assertRaises(Exception, assembly.MutableSequence, 'chr', 5, 6, 'G') + + def test_good_coords(self): + x = assembly.MutableSequence('chr', 1, 5) + x = assembly.MutableSequence('chr', 5, 5) + x = assembly.MutableSequence('chr', 100, 2000) + x = assembly.MutableSequence('chr name with spaces 5 @#$ --', 1, 5) + x = assembly.MutableSequence('chr', 5, 5, 'A') + x = assembly.MutableSequence('chr', 5, 6, 'AT') + + def test_modify_one(self): + x = assembly.MutableSequence('chr', 5, 8, 'ATCG') + self.assertRaises(Exception, x.modify, 4, 'G') + self.assertRaises(Exception, x.modify, 9, 'G') + self.assertEqual(x.emit(), ('chr', 'ATCG')) + x.modify(5, 'G') + self.assertEqual(x.emit(), ('chr', 'GTCG')) + x.modify(6, 'G') + self.assertEqual(x.emit(), ('chr', 'GGCG')) + x.modify(7, 'G') + self.assertEqual(x.emit(), ('chr', 'GGGG')) + x.modify(8, 'G') + self.assertEqual(x.emit(), ('chr', 'GGGG')) + x.modify(6, 'j') + self.assertEqual(x.emit(), ('chr', 'GjGG')) + x.modify(8, 'Y') + self.assertEqual(x.emit(), ('chr', 'GjGY')) + + def test_modify_blank(self): + x = assembly.MutableSequence('chr', 5, 8) + self.assertEqual(x.emit(), ('chr', 'NNNN')) + x.modify(6, 'G') + self.assertEqual(x.emit(), ('chr', 'NGNN')) + + def test_modify_insertions(self): + x = assembly.MutableSequence('chr', 5, 8, 'ATCG') + x.modify(6, 'insert') + self.assertEqual(x.emit(), ('chr', 'AinsertCG')) + x.modify(8, 'tail') + self.assertEqual(x.emit(), ('chr', 'AinsertCtail')) + x.modify(5, 'headA') + self.assertEqual(x.emit(), ('chr', 'headAinsertCtail')) + + def test_modify_deletions(self): + x = assembly.MutableSequence('chr', 5, 8, 'ATCG') + self.assertRaises(Exception, x.replace, 6, 9, 'AT') + x.replace(6, 7, 'CT') + self.assertEqual(x.emit(), ('chr', 'ACTG')) + x.replace(6, 7, '') + self.assertEqual(x.emit(), ('chr', 'AG')) + x.modify(7, 'x') + self.assertEqual(x.emit(), ('chr', 'AxG')) + x.modify(6, 'y') + self.assertEqual(x.emit(), ('chr', 'AyxG')) + x.replace(7, 7, '123') + self.assertEqual(x.emit(), ('chr', 'Ay123G')) + x.modify(7, 'z') + self.assertEqual(x.emit(), ('chr', 'AyzG')) + + def test_modify_deletions_simple(self): + x = assembly.MutableSequence('chr', 5, 8, 'ATCG') + x.replace(6, 7, 'T') + self.assertEqual(x.emit(), ('chr', 'ATG')) + + def test_modify_deletions_remember(self): + x = assembly.MutableSequence('chr', 5, 8, 'ATCG') + x.replace(6, 7, 'T') + self.assertEqual(x.emit(), ('chr', 'ATG')) + x.modify(7, 'x') + self.assertEqual(x.emit(), ('chr', 'ATxG')) + x.replay_deletions() + self.assertEqual(x.emit(), ('chr', 'ATG')) + + +class TestManualSnpCaller(unittest.TestCase): + ''' Test the vcfrow_parse_and_call_snps method.. lots of edge cases. ''' + + def test_missing_dp(self): + ''' VCF files might contain rows with no calls or any kind of data and that's okay. ''' + row = ['chr10', '105', '.', 'G', '.', '.', '.', '.', 'GT', './.'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=1)) + self.assertEqual(out, []) + + def test_dp_inaccurate(self): + ''' The DP might not equal the sum of the ADs and that's okay apparently. ''' + row = ['chr10', '105', '.', 'G', 'A', '.', '.', '.', 'GT:DP:AD', '0/1/1:5:2,2'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=1)) + self.assertEqual(set(out[0][4]), set(['G', 'A'])) + row = ['chr10', '105', '.', 'G', 'A', '.', '.', '.', 'GT:DP:AD', '0/1/1:2:3,3'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(set(out[0][4]), set(['G', 'A'])) + row = ['chr10', '105', '.', 'G', 'A', '.', '.', '.', 'GT:DP:AD', '0/1/1:10:2,0'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(out, []) + + def test_invariant_sites(self): + ''' Invariant site handling is slightly different in code, so test it specially. ''' + row = ['LASV.l', '1', '.', 'T', '.', '.', '.', '.', 'GT:DP', '0/0:3'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(out, [('LASV.l', 1, 1, 's1', ['T'])]) + row = ['LASV.l', '1', '.', 'T', '.', '.', '.', '.', 'GT', '0/0'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=0)) + self.assertEqual(out, [('LASV.l', 1, 1, 's1', ['T'])]) + row = ['LASV.l', '1', '.', 'T', '.', '.', '.', '.', 'GT', '0/0'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=1)) + self.assertEqual(out, []) + row = ['LASV.l', '1', '.', 'T', '.', '.', '.', '.', 'GT', './.'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=1)) + self.assertEqual(out, []) + row = ['LASV.l', '1', '.', 'T', '.', '.', '.', '.', 'GT:DP', './.:10'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=1)) + self.assertEqual(out, [('LASV.l', 1, 1, 's1', ['T'])]) + + def test_het_edgecases(self): + ''' The interplay between min_coverage and major_cutoff is not obvious, here's + what I understand from Kristian about the desired behavior. + for min_dp=3: + 3G, 4A, 5C -> G/A/C + 2G, 3A, 3T -> A/T + 2A, 2T -> no call + 2G, 3C -> C + 2A, 3C, 4T -> T + for min_dp=2: + 2A, 2T -> A/T + ''' + row = ['thecontig', '105000', '.', 'G', 'A,C,T', '.', '.', '.', 'GT:AD', '0/1:3,4,5,0'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(set(out[0][4]), set(['G', 'A', 'C'])) + row = ['thecontig', '105000', '.', 'G', 'A,C,T', '.', '.', '.', 'GT:AD', '0/1:2,3,0,3'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(set(out[0][4]), set(['A', 'T'])) + row = ['thecontig', '105000', '.', 'G', 'A,C,T', '.', '.', '.', 'GT:AD', '0/1:0,2,0,2'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(out, []) + row = ['thecontig', '105000', '.', 'G', 'A,C,T', '.', '.', '.', 'GT:AD', '0/1:0,2,0,2'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=2)) + self.assertEqual(set(out[0][4]), set(['A', 'T'])) + row = ['thecontig', '105000', '.', 'G', 'A,C,T', '.', '.', '.', 'GT:AD', '0/1:2,0,3,0'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(out[0][4], ['C']) + row = ['thecontig', '105000', '.', 'G', 'A,C,T', '.', '.', '.', 'GT:AD', '0/1:0,2,3,4'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(out[0][4], ['T']) + + def test_indels(self): + ''' Indel handling ''' + row = ['thecontig', '105000', '.', 'G', 'GA,T', '.', '.', '.', 'GT:AD', '0/1:5,10,1'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(set(out[0][4]), set(['GA'])) + row = ['thecontig', '105000', '.', 'G', 'GA,T', '.', '.', '.', 'GT:AD', '0/1:5,5,2'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(set(out[0][4]), set(['G', 'GA'])) + row = ['thecontig', '105000', '.', 'G', 'GA,T', '.', '.', '.', 'GT:AD', '0/1:5,5,3'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'], min_dp=3)) + self.assertEqual(set(out[0][4]), set(['G', 'GA', 'T'])) + row = ['thecontig', '105000', '.', 'AT', 'A', '.', '.', '.', 'GT:AD', '0/1:2,10'] + out = list(assembly.vcfrow_parse_and_call_snps(row, ['s1'])) + self.assertEqual(out, [('thecontig', 105000, 105001, 's1', ['A'])]) + + def test_vcf_to_seqs_indels1(self): + input = ['thecontig', '5', '.', 'AT', 'A', '.', '.', '.', 'GT:AD', '0/1:2,10'] + actual = assembly.vcf_to_seqs([input], {'thecontig': 10}, ['s1'], min_dp=2) + actual = list(actual)[0][1].strip('N') + self.assertEqual(actual, 'A') + actual = assembly.vcf_to_seqs([input], {'thecontig': 10}, ['s1'], min_dp=2) + actual = list(actual)[0][1] + self.assertEqual(actual, 'NNNNANNNN') + + def test_vcf_to_seqs_indels2(self): + ''' More end-to-end indel handling ''' + myInputDir = util.file.get_test_input_path(self) + input = os.path.join(myInputDir, 'indel.vcf.gz') + expected = os.path.join(myInputDir, 'output.fasta') + chrlens = {'EBOV_2014_G6060.1': 18962} + samples = ['G6060.1'] + expected = str(Bio.SeqIO.read(expected, 'fasta').seq) + actual = assembly.vcf_to_seqs(util.file.read_tabfile(input), chrlens, samples, min_dp=2) + actual = list(actual)[0][1].strip('N') + self.assertEqual(actual, expected) + + +class TestDeambigAndTrimFasta(TestCaseWithTmp): + ''' Test the deambig_fasta and trim_fasta commands. ''' + + def run_method(self, inseqs, parser_fun): + fasta_in = util.file.mkstempfname() + fasta_out = util.file.mkstempfname() + makeFasta([(str(i), inseqs[i]) for i in range(len(inseqs))], fasta_in) + args = parser_fun(argparse.ArgumentParser()).parse_args([fasta_in, fasta_out]) + args.func_main(args) + return (fasta_in, fasta_out) + + def test_trim_fasta(self): + ''' Simple test of the trim_fasta command ''' + inseqs = ['NNnnNNnNaslkdfjasdkfNNNN', 'NNNnnN', 'NNN123', 'ATCG'] + expected = ['aslkdfjasdkf', '', '123', 'ATCG'] + expected = dict((str(i), expected[i]) for i in range(len(expected))) + fasta_in, fasta_out = self.run_method(inseqs, assembly.parser_trim_fasta) + with open(fasta_out, 'rt') as fa: + for record in Bio.SeqIO.parse(fa, 'fasta'): + self.assertIn(record.id, expected) + self.assertEqual(str(record.seq), expected[record.id]) + + def test_deambig_fasta(self): + ''' Simple test of the deambig_fasta command ''' + table = [(k, v) for k, v in Bio.Data.IUPACData.ambiguous_dna_values.items() if k != 'X'] + keys = [k for k, v in table] + vals = [set(v) for k, v in table] + keys = keys + [k.lower() for k in keys] + vals = vals + vals + inseq = ''.join(keys) + fasta_in, fasta_out = self.run_method([inseq], assembly.parser_deambig_fasta) + with open(fasta_out, 'rt') as fa: + for rec in Bio.SeqIO.parse(fa, 'fasta'): + self.assertEqual(rec.id, '0') + outseq = str(rec.seq) + for i in range(len(outseq)): + self.assertIn(outseq[i], vals[i]) + + +class TestContigChooser(unittest.TestCase): + ''' Test the contig_chooser heuristic used by our MUMmer-based custom scaffolder. ''' + + def test_no_seqs(self): + for test_len in (7,2,228,52): + actual = tools.mummer.contig_chooser([], test_len) + self.assertEqual(actual, ['N' * test_len]) + + def test_one_seq(self): + for test_seq in ('A', '', 'GACTGATG', 'non-biological :characters!'): + actual = tools.mummer.contig_chooser([test_seq], 90) + self.assertEqual(actual, [test_seq]) + + def test_most_popular_seq(self): + alt_seqs = ['AA', 'aa', 'GGA', 'T', 'GGA'] + expected_choice = 'GGA' + expected_alts = set(('AA', 'aa', 'T')) + actual = tools.mummer.contig_chooser(alt_seqs, 2) + self.assertEqual(actual[0], expected_choice) + self.assertEqual(set(actual[1:]), expected_alts) + + def test_most_popular_seq_len(self): + alt_seqs = ['AA', 'GGA', 'aa', 'GGA', 'T', 'GGC', 'aa'] + actual = tools.mummer.contig_chooser(alt_seqs, 2) + self.assertEqual(actual[0], 'aa') + self.assertEqual(set(actual[1:]), set(('AA', 'GGA', 'T', 'GGC'))) + actual = tools.mummer.contig_chooser(alt_seqs, 3) + self.assertEqual(actual[0], 'GGA') + self.assertEqual(set(actual[1:]), set(('AA', 'aa', 'T', 'GGC'))) + alt_seqs = ['AA', 'GGA', 'aa', 'GGA', 'T', 'GGC'] + actual = tools.mummer.contig_chooser(alt_seqs, 20) + self.assertEqual(actual[0], 'GGA') + self.assertEqual(set(actual[1:]), set(('AA', 'aa', 'T', 'GGC'))) + actual = tools.mummer.contig_chooser(alt_seqs, 1) + self.assertEqual(actual[0], 'GGA') + self.assertEqual(set(actual[1:]), set(('AA', 'aa', 'T', 'GGC'))) + + def test_same_as_ref_len(self): + alt_seqs = ['AA', 'GGA', 'aa', 'GGA', 'T', 'GGC', 'aa'] + actual = tools.mummer.contig_chooser(alt_seqs, 1) + self.assertEqual(actual[0], 'T') +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_taxon_filter.py",".py","17084","433","# Unit tests for taxon_filter.py + +__author__ = ""dpark@broadinstitute.org, irwin@broadinstitute.org,"" \ + + ""hlevitin@broadinstitute.org"" + +import unittest +import os +import tempfile +import shutil +import filecmp +import subprocess + +import argparse + +import read_utils +import taxon_filter +import util.file +import util.misc +import tools.last +import tools.bmtagger +import tools.blast +from test import assert_equal_bam_reads, assert_equal_contents, assert_equal_bam_reads, assert_md5_equal_to_line_in_file, TestCaseWithTmp + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_fun in taxon_filter.__commands__: + parser = parser_fun(argparse.ArgumentParser()) + helpstring = parser.format_help() + + + +class TestFilterLastal(TestCaseWithTmp): + + def setUp(self): + TestCaseWithTmp.setUp(self) + self.polio_fasta = os.path.join( + util.file.get_test_input_path(), + 'TestMetagenomicsViralMix', 'db', 'library', 'Viruses', 'Enterovirus_C', 'GCF_000861165.1_ViralProj15288_genomic.fna' + ) + dbDir = tempfile.mkdtemp() + self.lastdb_path = tools.last.Lastdb().build_database(self.polio_fasta, os.path.join(dbDir, 'NC_002058')) + + def test_filter_lastal_bam_polio(self): + inBam = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'expected', 'test-reads.blastn.bam') + outBam = util.file.mkstempfname('-out-taxfilt.bam') + args = taxon_filter.parser_filter_lastal_bam(argparse.ArgumentParser()).parse_args([ + inBam, self.lastdb_path, outBam]) + args.func_main(args) + expectedOut = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'expected', 'test-reads.taxfilt.imperfect.bam') + assert_equal_bam_reads(self, outBam, expectedOut) + + def test_lastal_empty_input(self): + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + outBam = util.file.mkstempfname('-out-taxfilt.bam') + taxon_filter.filter_lastal_bam( + empty_bam, + self.lastdb_path, + outBam + ) + assert_equal_bam_reads(self, outBam, empty_bam) + + def test_lastal_empty_output(self): + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + in_bam = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'test-reads-human.bam') + outBam = util.file.mkstempfname('-out-taxfilt.bam') + taxon_filter.filter_lastal_bam( + in_bam, + self.lastdb_path, + outBam + ) + assert_equal_bam_reads(self, outBam, empty_bam) + + def test_lastal_unbuilt_db(self): + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + in_bam = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'test-reads-human.bam') + outBam = util.file.mkstempfname('-out-taxfilt.bam') + taxon_filter.filter_lastal_bam( + in_bam, + self.polio_fasta, + outBam + ) + assert_equal_bam_reads(self, outBam, empty_bam) + + +class TestBmtagger(TestCaseWithTmp): + ''' + How test data was created: + exported 5kb region of chr6 + created pan-viral fasta file from all NCBI viral accessions + used wgsim to create simulated reads + ''' + + def setUp(self): + TestCaseWithTmp.setUp(self) + self.tempDir = tempfile.mkdtemp() + ref_fasta = os.path.join(util.file.get_test_input_path(), '5kb_human_from_chr6.fasta') + self.database_prefix_path = os.path.join(self.tempDir, ""5kb_human_from_chr6"") + taxon_filter.bmtagger_build_db(ref_fasta, self.tempDir, ""5kb_human_from_chr6"", word_size=8) + + def test_deplete_bmtagger_bam(self): + inBam = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'test-reads.bam') + outBam = util.file.mkstempfname('-out.bam') + args = taxon_filter.parser_deplete_bam_bmtagger(argparse.ArgumentParser()).parse_args([ + inBam, self.database_prefix_path, outBam, '--srprismMemory', '1500']) + args.func_main(args) + expectedOut = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'expected', 'test-reads.bmtagger.bam') + assert_equal_bam_reads(self, outBam, expectedOut) + + @unittest.skip(""too slow for real word size of 18bp"") + def test_deplete_bmtagger_fasta_db(self): + inBam = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'test-reads.bam') + ref_fasta = os.path.join(util.file.get_test_input_path(), '5kb_human_from_chr6.fasta') + outBam = util.file.mkstempfname('-out.bam') + args = taxon_filter.parser_deplete_bam_bmtagger(argparse.ArgumentParser()).parse_args([ + inBam, ref_fasta, outBam, '--srprismMemory', '1500']) + args.func_main(args) + expectedOut = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'expected', 'test-reads.bmtagger.bam') + assert_equal_bam_reads(self, outBam, expectedOut) + + def test_deplete_bmtagger_tar_db(self): + inBam = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'test-reads.bam') + outBam = util.file.mkstempfname('-out.bam') + tar_db_tgz = util.file.mkstempfname('.db.tar.gz') + cmd = ['tar', '-C', os.path.dirname(self.database_prefix_path), '-cvzf', tar_db_tgz, '.'] + subprocess.check_call(cmd) + args = taxon_filter.parser_deplete_bam_bmtagger(argparse.ArgumentParser()).parse_args([ + inBam, tar_db_tgz, outBam, '--srprismMemory', '1500']) + args.func_main(args) + expectedOut = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'expected', 'test-reads.bmtagger.bam') + assert_equal_bam_reads(self, outBam, expectedOut) + os.unlink(tar_db_tgz) + + def test_bmtagger_empty_input(self): + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + out_bam = util.file.mkstempfname('-out.bam') + args = taxon_filter.parser_deplete_bam_bmtagger(argparse.ArgumentParser()).parse_args([ + empty_bam, self.database_prefix_path, out_bam, '--srprismMemory', '1500']) + args.func_main(args) + assert_equal_bam_reads(self, out_bam, empty_bam) + + def test_bmtagger_empty_output(self): + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + in_bam = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'test-reads-human.bam') + out_bam = util.file.mkstempfname('-out.bam') + args = taxon_filter.parser_deplete_bam_bmtagger(argparse.ArgumentParser()).parse_args([ + in_bam, self.database_prefix_path, out_bam, '--srprismMemory', '1500']) + args.func_main(args) + assert_equal_bam_reads(self, out_bam, empty_bam) + + +class TestBlastnDbBuild(TestCaseWithTmp): + + def test_blastn_db_build(self): + commonInputDir = util.file.get_test_input_path() + refFasta = os.path.join(commonInputDir, 'ebola.fasta') + + myInputDir = util.file.get_test_input_path(self) + tempDir = tempfile.mkdtemp() + + output_prefix = self.__class__.__name__ + + args = taxon_filter.parser_blastn_build_db(argparse.ArgumentParser()).parse_args( + [ + # input fasta + refFasta, + # output directory + tempDir, + ""--outputFilePrefix"", + output_prefix + ] + ) + args.func_main(args) + + # nhr=header. nin=index, nsq=sequence + for ext in ["".nhr"", "".nsq""]: # "".nin"" can change + assert_equal_contents( + self, os.path.join(tempDir, output_prefix + ext), + os.path.join(myInputDir, ""expected"", output_prefix + ext) + ) + + def test_blastn_db_build_gz(self): + commonInputDir = util.file.get_test_input_path() + refFasta = os.path.join(commonInputDir, 'ebola.fasta.gz') + + myInputDir = util.file.get_test_input_path(self) + tempDir = tempfile.mkdtemp() + + output_prefix = self.__class__.__name__ + + args = taxon_filter.parser_blastn_build_db(argparse.ArgumentParser()).parse_args( + [ + # input fasta + refFasta, + # output directory + tempDir, + ""--outputFilePrefix"", + output_prefix + ] + ) + args.func_main(args) + + # nhr=header. nin=index, nsq=sequence + for ext in ["".nhr"", "".nsq""]: # "".nin"" can change + assert_equal_contents( + self, os.path.join(tempDir, output_prefix + ext), + os.path.join(myInputDir, ""expected"", output_prefix + ext) + ) + + commonInputDir = util.file.get_test_input_path() + + refFasta = os.path.join(commonInputDir, 'ebola.fasta.lz4') + args = taxon_filter.parser_blastn_build_db(argparse.ArgumentParser()).parse_args( + [ + # input fasta + refFasta, + # output directory + tempDir, + ""--outputFilePrefix"", + output_prefix + ] + ) + args.func_main(args) + + +class TestBmtaggerDbBuild(TestCaseWithTmp): + + def test_bmtagger_db_build(self): + os.environ.pop('TMPDIR', None) + util.file.set_tmp_dir(None) + commonInputDir = util.file.get_test_input_path() + refFasta = os.path.join(commonInputDir, 'ebola.fasta') + + myInputDir = util.file.get_test_input_path(self) + tempDir = tempfile.mkdtemp() + + output_prefix = self.__class__.__name__ + + args = taxon_filter.parser_bmtagger_build_db(argparse.ArgumentParser()).parse_args( + [ + # input fasta + refFasta, + # output directory + tempDir, + ""--outputFilePrefix"", + output_prefix, + ""--word_size"", + ""8"", + ] + ) + args.func_main(args) + + for ext in [ + "".bitmask"", "".srprism.amp"", "".srprism.imp"", "".srprism.pmp"", "".srprism.rmp"", + "".srprism.ssa"", "".srprism.ssd"" + ]: + assert_equal_contents( + self, os.path.join(tempDir, output_prefix + ext), + os.path.join(myInputDir, ""expected"", output_prefix + ext) + ) + + for ext in ["".srprism.map"", "".srprism.idx"", "".srprism.ss""]: + assert_md5_equal_to_line_in_file(self, os.path.join(tempDir, output_prefix + ext), os.path.join(myInputDir, ""expected"", output_prefix + ext+"".md5"")) + + def test_bmtagger_db_build_gz(self): + commonInputDir = util.file.get_test_input_path() + refFasta = os.path.join(commonInputDir, 'ebola.fasta.gz') + myInputDir = util.file.get_test_input_path(self) + tempDir = tempfile.mkdtemp() + output_prefix = self.__class__.__name__ + args = taxon_filter.parser_bmtagger_build_db(argparse.ArgumentParser()).parse_args( + [ + # input fasta + refFasta, + # output directory + tempDir, + ""--outputFilePrefix"", + output_prefix, + ""--word_size"", + ""8"", + ] + ) + args.func_main(args) + refFasta = os.path.join(commonInputDir, 'ebola.fasta.lz4') + args = taxon_filter.parser_bmtagger_build_db(argparse.ArgumentParser()).parse_args( + [ + # input fasta + refFasta, + # output directory + tempDir, + ""--outputFilePrefix"", + output_prefix, + ""--word_size"", + ""8"", + ] + ) + args.func_main(args) + + +class TestLastalDbBuild(TestCaseWithTmp): + + def test_lastal_db_build(self): + commonInputDir = util.file.get_test_input_path() + refFasta = os.path.join(commonInputDir, 'ebola.fasta') + + myInputDir = util.file.get_test_input_path(self) + tempDir = tempfile.mkdtemp() + + output_prefix = self.__class__.__name__ + + args = taxon_filter.parser_lastal_build_db(argparse.ArgumentParser()).parse_args( + [ + # input fasta + refFasta, + # output directory + tempDir, + ""--outputFilePrefix"", + output_prefix + ] + ) + args.func_main(args) + + for ext in ["".bck"", "".des"", "".prj"", "".sds"", "".ssp"", "".tis""]: + assert_equal_contents( + self, os.path.join(tempDir, output_prefix + ext), + os.path.join(myInputDir, ""expected"", output_prefix + ext) + ) + + for ext in ["".suf""]: + assert_md5_equal_to_line_in_file(self, os.path.join(tempDir, output_prefix + ext), os.path.join(myInputDir, ""expected"", output_prefix + ext+"".md5"")) + +class TestDepleteBlastnBam(TestCaseWithTmp): + ''' + How test data was created: + humanChr1Subset.fa has 200 bases from human chr1 + humanChr9Subset.fa has 200 bases from human chr9 + in.fastq ""reads"" are from humanChr[19]Subset.fa and ebola genome, + with arbitrary quality scores. + ''' + + def setUp(self): + TestCaseWithTmp.setUp(self) + self.tempDir = tempfile.mkdtemp() + commonInputDir = util.file.get_test_input_path() + ref_fasta = os.path.join(commonInputDir, '5kb_human_from_chr6.fasta') + self.database_prefix_path = os.path.join(self.tempDir, ""5kb_human_from_chr6"") + + # create blast db + self.blastdb_path = tools.blast.MakeblastdbTool().build_database(ref_fasta, self.database_prefix_path) + + # create multiple dbs + self.blastdbs_multi = [] + for db in ['humanChr1Subset.fa', 'humanChr9Subset.fa']: + dbPath = tools.blast.MakeblastdbTool().build_database( + os.path.join(util.file.get_test_input_path(self), db), + os.path.join(self.tempDir, db[:-3])) + self.blastdbs_multi.append(dbPath) + + # tar one db, but not the other + tar_db_tgz = util.file.mkstempfname('-humanChr9Subset.blastn.db.tar.gz') + cmd = ['tar', '-C', self.tempDir, '-cvzf', tar_db_tgz] + for ext in ('nhr', 'nin', 'nsq'): + cmd.append('humanChr9Subset.'+ext) + subprocess.check_call(cmd) + self.blastdbs_multi[1] = tar_db_tgz + for ext in ('nhr', 'nin', 'nsq'): + os.unlink(os.path.join(self.tempDir, 'humanChr9Subset.'+ext)) + + def test_deplete_blastn_bam(self): + tempDir = tempfile.mkdtemp() + myInputDir = util.file.get_test_input_path(self) + + # Run deplete_blastn_bam + inBam = os.path.join(myInputDir, 'in.bam') + outBam = os.path.join(tempDir, 'out.bam') + args = taxon_filter.parser_deplete_blastn_bam(argparse.ArgumentParser()).parse_args( + [inBam] + self.blastdbs_multi + [outBam, ""--chunkSize"", ""0""] + ) + args.func_main(args) + + # samtools view for out.sam and compare to expected + outSam = os.path.join(tempDir, 'out.sam') + samtools = tools.samtools.SamtoolsTool() + samtools.view(['-h'], outBam, outSam) + + assert_equal_bam_reads(self, + outSam, + os.path.join(myInputDir, 'expected.sam')) + + def test_deplete_blastn_bam_chunked(self): + tempDir = tempfile.mkdtemp() + myInputDir = util.file.get_test_input_path(self) + + # Run deplete_blastn_bam + inBam = os.path.join(myInputDir, 'in.bam') + outBam = os.path.join(tempDir, 'out.bam') + args = taxon_filter.parser_deplete_blastn_bam(argparse.ArgumentParser()).parse_args( + [inBam] + self.blastdbs_multi + [outBam, ""--chunkSize"", ""1""] + ) + args.func_main(args) + + # samtools view for out.sam and compare to expected + outSam = os.path.join(tempDir, 'out.sam') + samtools = tools.samtools.SamtoolsTool() + samtools.view(['-h'], outBam, outSam) + + # the header field ordering may be different with Java 1.8 + assert_equal_bam_reads(self, + outSam, + os.path.join(myInputDir, 'expected.sam')) + + def test_blastn_empty_input(self): + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + out_bam = util.file.mkstempfname('-out.bam') + taxon_filter.multi_db_deplete_bam( + empty_bam, + [self.blastdb_path], + taxon_filter.deplete_blastn_bam, + out_bam + ) + self.assertEqual(0, tools.samtools.SamtoolsTool().count(out_bam)) + + def test_blastn_empty_output(self): + in_bam = os.path.join(util.file.get_test_input_path(), 'TestDepleteHuman', 'test-reads-human.bam') + out_bam = util.file.mkstempfname('-out.bam') + taxon_filter.multi_db_deplete_bam( + in_bam, + [self.blastdb_path], + taxon_filter.deplete_blastn_bam, + out_bam + ) + self.assertEqual(0, tools.samtools.SamtoolsTool().count(out_bam)) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_samtools.py",".py","3398","84","# Unit tests for tools.samtools + +__author__ = ""dpark@broadinstitute.org"" + +import unittest +import os, os.path +import tempfile +import shutil +import Bio.SeqIO, Bio.SeqRecord, Bio.Seq +import util +import util.file +import tools +import tools.samtools +from test import TestCaseWithTmp + + +class TestToolSamtools(TestCaseWithTmp): + + def test_count_bam(self): + sam = os.path.join(util.file.get_test_input_path(self), 'simple.sam') + n = tools.samtools.SamtoolsTool().count(sam, ['-S']) + self.assertEqual(n, 2) + + def test_fasta_index(self): + orig_ref = os.path.join(util.file.get_test_input_path(self), 'in.fasta') + expected_fai = os.path.join(util.file.get_test_input_path(self), 'in.fasta.fai') + samtools = tools.samtools.SamtoolsTool() + for ext in ('.fasta', '.fa'): + inRef = util.file.mkstempfname(ext) + shutil.copyfile(orig_ref, inRef) + outFai = inRef + '.fai' + samtools.faidx(inRef) + self.assertEqualContents(outFai, expected_fai) + + def test_isEmpty(self): + samtools = tools.samtools.SamtoolsTool() + self.assertTrue(samtools.isEmpty(os.path.join(util.file.get_test_input_path(), 'empty.bam'))) + self.assertFalse(samtools.isEmpty(os.path.join(util.file.get_test_input_path(), 'almost-empty.bam'))) + self.assertFalse(samtools.isEmpty(os.path.join(util.file.get_test_input_path(), 'G5012.3.subset.bam'))) + self.assertFalse(samtools.isEmpty(os.path.join(util.file.get_test_input_path(), 'G5012.3.testreads.bam'))) + + def test_sam_downsample(self): + desired_count = 100 + tolerance = 0.1 + + in_sam = os.path.join(util.file.get_test_input_path(), 'G5012.3.subset.bam') + out_bam = util.file.mkstempfname('.bam') + + samtools = tools.samtools.SamtoolsTool() + + samtools.downsample_to_approx_count(in_sam, out_bam, desired_count) + + assert samtools.count(out_bam) in range( + int(desired_count - (desired_count * tolerance)), int(desired_count + (desired_count * tolerance))+1 + ), ""Downsampled bam file does not contain the expected number of reads within tolerance: %s"" % tolerance + + def test_filterByCigarString(self): + # The test input contains three reads to remove; one each: + # leading indel, trailing indel, both leading and trailing + # It also has a cigar string with an indel between alignment matches + in_sam = os.path.join(util.file.get_test_input_path(self), 'indel_cigar.sam') + out_bam = util.file.mkstempfname('.bam') + + samtools = tools.samtools.SamtoolsTool() + + # We'll use the default regex, which matches leading or trailing indels. + # It is reproduced here in case the default changes: + # '^((?:[0-9]+[ID]){1}(?:[0-9]+[MNIDSHPX=])+)|((?:[0-9]+[MNIDSHPX=])+(?:[0-9]+[ID]){1})$' + samtools.filterByCigarString(in_sam, out_bam) + + assert samtools.count(out_bam)==39, ""Output read count does not match the expected count."" + + def test_bam2fa(self): + samtools = tools.samtools.SamtoolsTool() + sam = os.path.join(util.file.get_test_input_path(self), 'simple.sam') + + with samtools.bam2fa_tmp(sam) as (fa1, fa2): + for fa in (fa1, fa2): + assert len(list(Bio.SeqIO.parse(fa, 'fasta')))==1 + + assert not os.path.isfile(fa1) and not os.path.isfile(fa2) + + +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_ncbi.py",".py","6585","167","# Unit tests for ncbi.py + +__author__ = ""tomkinsc@broadinstitute.org"" + +# built-ins +import os +import tempfile +import unittest +import argparse + +# module-specific +import ncbi +import util.file +import util.genbank +from test import assert_equal_bam_reads, TestCaseWithTmp, assert_equal_contents, assert_md5_equal_to_line_in_file + + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_fun in ncbi.__commands__: + parser = parser_fun(argparse.ArgumentParser()) + helpstring = parser.format_help() + +class TestFeatureReader(TestCaseWithTmp): + def setUp(self): + super(TestFeatureReader, self).setUp() + self.input_dir = util.file.get_test_input_path(self) + + def test_read_seq_id_simple(self): + accessions = ('GU481072.1', 'GU481073.1', + 'KM821772.1', 'KM821773.1') + for acc in accessions: + self.assertEqual(acc, util.genbank.get_feature_table_id(os.path.join(self.input_dir, acc+'.tbl'))) + + def test_read_seq_id_different_fnames(self): + self.assertEqual('KM821998.1', util.genbank.get_feature_table_id(os.path.join(self.input_dir, + 'test1-S.tbl'))) + self.assertEqual('KM821997.1', util.genbank.get_feature_table_id(os.path.join(self.input_dir, + 'test2-L.tbl'))) + + def test_read_seq_id_refseq(self): + self.assertEqual('NC_026438.1', util.genbank.get_feature_table_id(os.path.join(self.input_dir, + 'NC_026438.1.tbl'))) + +class TestFeatureTransfer(TestCaseWithTmp): + def setUp(self): + super(TestFeatureTransfer, self).setUp() + self.input_dir = util.file.get_test_input_path(self) + + def test_synthetic_feature_table(self): + input_dir = os.path.join(self.input_dir, ""synthetic"", ""input"") + expected_dir = os.path.join(self.input_dir, ""synthetic"", ""expected"") + temp_dir = tempfile.gettempdir() + + in_tbl = os.path.join(input_dir,""ref.tbl"") + out_tbl = os.path.join(temp_dir,""sample.tbl"") + expected = os.path.join(expected_dir, ""mapped.tbl"") + + ncbi.tbl_transfer_prealigned( + os.path.join(input_dir,""aligned_1.fasta""), + os.path.join(input_dir,""ref.fasta""), + [in_tbl], + temp_dir) + + assert_equal_contents(self, out_tbl, expected) + + def test_synthetic_feature_table_oob_clip(self): + input_dir = os.path.join(self.input_dir, ""synthetic_oob_clip"", ""input"") + expected_dir = os.path.join(self.input_dir, ""synthetic_oob_clip"", ""expected"") + temp_dir = tempfile.gettempdir() + + in_tbl = os.path.join(input_dir,""ref.tbl"") + out_tbl = os.path.join(temp_dir,""sample.tbl"") + expected = os.path.join(expected_dir, ""mapped.tbl"") + + ncbi.tbl_transfer_prealigned( + os.path.join(input_dir,""aligned_1.fasta""), + os.path.join(input_dir,""ref.fasta""), + [in_tbl], + temp_dir, + oob_clip=True) + + assert_equal_contents(self, out_tbl, expected) + + def test_synthetic_feature_table_ignore_ambiguous_edges(self): + input_dir = os.path.join(self.input_dir, ""synthetic_ignore_ambig_edges"", ""input"") + expected_dir = os.path.join(self.input_dir, ""synthetic_ignore_ambig_edges"", ""expected"") + temp_dir = tempfile.gettempdir() + + in_tbl = os.path.join(input_dir,""ref.tbl"") + out_tbl = os.path.join(temp_dir,""sample.tbl"") + expected = os.path.join(expected_dir, ""mapped.tbl"") + + ncbi.tbl_transfer_prealigned( + os.path.join(input_dir,""aligned_1.fasta""), + os.path.join(input_dir,""ref.fasta""), + [in_tbl], + temp_dir, + ignore_ambig_feature_edge=True) + + assert_equal_contents(self, out_tbl, expected) + + def test_lasv_oob_clip(self): + input_dir = os.path.join(self.input_dir, ""lasv"", ""input"") + expected_dir = os.path.join(self.input_dir, ""lasv"", ""expected"") + temp_dir = tempfile.gettempdir() + + infastas = [os.path.join(input_dir, f) for f in [ + ""align_mafft-ref-lasv-ISTH2376_1.fasta"", + ""align_mafft-ref-lasv-ISTH2376_2.fasta"" + ] + ] + + intables =[os.path.join(input_dir, f) for f in [ + ""KM821997.1.tbl"", + ""KM821998.1.tbl"" + ] + ] + + out_table_names = [ + ""LASV_NGA_2018_0026-1.tbl"", + ""LASV_NGA_2018_0026-2.tbl"", + ""LASV_NGA_2018_0097-1.tbl"", + ""LASV_NGA_2018_0097-2.tbl"", + ""LASV_NGA_2018_0541-1.tbl"", + ""LASV_NGA_2018_0541-2.tbl"", + ""LASV_NGA_2018_0611-1.tbl"", + ""LASV_NGA_2018_0611-2.tbl"", + ""LASV_NGA_2018_0664-1.tbl"", + ""LASV_NGA_2018_0664-2.tbl"", + ""LASV_NGA_2018_0959-1.tbl"", + ""LASV_NGA_2018_0959-2.tbl"", + ""LASV_NGA_2018_0998-1.tbl"", + ""LASV_NGA_2018_0998-2.tbl"", + ""LASV_NGA_2018_1024-1.tbl"", + ""LASV_NGA_2018_1024-2.tbl"", + ""LASV_NGA_2018_1079-1.tbl"", + ""LASV_NGA_2018_1079-2.tbl"", + ""LASV_NGA_2018_1177-1.tbl"", + ""LASV_NGA_2018_1177-2.tbl"", + ""LASV_NGA_2018_1375-1.tbl"", + ""LASV_NGA_2018_1375-2.tbl"", + ""LASV_NGA_2018_1381-1.tbl"", + ""LASV_NGA_2018_1381-2.tbl"", + ""LASV_NGA_2018_1392-1.tbl"", + ""LASV_NGA_2018_1392-2.tbl"", + ""LASV_NGA_2018_1643-1.tbl"", + ""LASV_NGA_2018_1643-2.tbl"" + ] + out_tbls =[os.path.join(temp_dir, f) for f in out_table_names] + expected_tbls = [os.path.join(expected_dir, f) for f in out_table_names] + + + for i in range(0, len(infastas)): + ncbi.tbl_transfer_prealigned( + infastas[i], + os.path.join(input_dir,""ref-lasv-ISTH2376.fasta""), + intables, + temp_dir, + oob_clip=True) + + for i in range(0,len(out_table_names)): + out_tbl = out_tbls[i] + expected_tbl = expected_tbls[i] + assert_equal_contents(self, out_tbl, expected_tbl) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_bwa.py",".py","1511","49","# Unit tests for bwa aligner + +__author__ = ""tomkinsc@broadinstitute.org"" + +import os.path +import tempfile +import subprocess +import util.file +import tools.bwa +import tools.samtools +from test import TestCaseWithTmp + +class TestToolBwa(TestCaseWithTmp): + + def setUp(self): + super(TestToolBwa, self).setUp() + self.bwa = tools.bwa.Bwa() + self.bwa.install() + self.samtools = tools.samtools.SamtoolsTool() + + self.tempDir = tempfile.mkdtemp() + root_input_dir = util.file.get_test_input_path() + ref_fasta = os.path.join(root_input_dir, '5kb_human_from_chr6.fasta') + + self.database_prefix_path = os.path.join(self.tempDir, ""5kb_human_from_chr6"") + + # create bwa db + self.bwadb_path = self.bwa.index(ref_fasta, output=self.database_prefix_path) + + def test_working_bam(self): + in_bam = os.path.join(util.file.get_test_input_path(), ""TestDepleteHuman"", 'test-reads-human.bam') + + outfile = util.file.mkstempfname('.bam') + self.bwa.mem(in_bam, self.bwadb_path, outfile, options=['-a']) + + self.assertEqual(self.samtools.count(outfile), 20) + + os.unlink(outfile) + + def test_corrupt_bam(self): + in_bam = os.path.join(util.file.get_test_input_path(), 'broken.bam') + + outfile = util.file.mkstempfname('.bam') + + # pipe.poll() should raise an exception + self.assertRaises(subprocess.CalledProcessError, self.bwa.mem, in_bam, self.bwadb_path, outfile, options=['-a']) + + os.unlink(outfile) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_krona.py",".py","2147","57","# Unit tests for krona +from builtins import super +import os.path +import tempfile +import unittest +from mock import patch +import util.file +import util.misc +import tools.krona +from test import TestCaseWithTmp + + +class TestToolKrona(TestCaseWithTmp): + + def setUp(self): + super().setUp() + self.krona = tools.krona.Krona() + self.krona.install() + + patcher = patch('subprocess.check_call', autospec=True) + self.addCleanup(patcher.stop) + self.mock_run = patcher.start() + + self.db = tempfile.mkdtemp('db') + + def test_import_taxonomy(self): + in_tsv = util.file.mkstempfname('.tsv') + output = util.file.mkstempfname('.output') + self.krona.import_taxonomy( + self.db, [in_tsv], output, query_column=3, taxid_column=5, score_column=7, no_hits=True, no_rank=True + ) + args = self.mock_run.call_args[0][0] + self.assertEqual('ktImportTaxonomy', os.path.basename(args[0])) + self.assertTrue(util.misc.list_contains(['-tax', self.db], args)) + self.assertTrue(util.misc.list_contains(['-q', '3'], args)) + self.assertTrue(util.misc.list_contains(['-t', '5'], args)) + self.assertTrue(util.misc.list_contains(['-s', '7'], args)) + self.assertIn('-i', args) + self.assertIn('-k', args) + + self.krona.import_taxonomy(self.db, [in_tsv], output) + args = self.mock_run.call_args[0][0] + self.assertEqual('ktImportTaxonomy', os.path.basename(args[0])) + self.assertTrue(util.misc.list_contains(['-tax', self.db], args)) + self.assertFalse(util.misc.list_contains(['-q', '3'], args)) + self.assertFalse(util.misc.list_contains(['-t', '5'], args)) + self.assertFalse(util.misc.list_contains(['-s', '7'], args)) + self.assertNotIn('-i', args) + self.assertNotIn('-k', args) + + def test_create_db(self): + self.krona.create_db(self.db) + args = self.mock_run.call_args[0][0] + self.assertEqual('updateTaxonomy.sh', os.path.basename(args[0])) + self.assertTrue(util.misc.list_contains(['--only-build', self.db], args)) + self.assertIn(self.db, args) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_intrahost.py",".py","34803","740","# Unit tests for intrahost.py + +__author__ = ""dpark@broadinstitute.org"" + +# built-ins +from collections import OrderedDict +import os +import os.path +import shutil +import tempfile +import itertools +import argparse +import unittest + +# third-party +import Bio +import Bio.SeqRecord +import Bio.Seq + +# module-specific +import intrahost +import util.file +import util.vcf +import test +from intrahost import AlleleFieldParser +import interhost +import tools.mafft + + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_fun in intrahost.__commands__: + parser = parser_fun(argparse.ArgumentParser()) + helpstring = parser.format_help() + + +def makeTempFasta(seqs): + fn = util.file.mkstempfname('.fasta') + with open(fn, 'wt') as outf: + for line in util.file.fastaMaker(seqs): + outf.write(line) + return fn + + +class MockVphaserOutput: + ''' This creates test data that pretends to be the output from + tools.vphaser2.Vphaser2Tool.iterate + ''' + + def __init__(self): + self.isnvs = {} + self.chroms = [] + + def add_snp(self, chrom, pos, acounts, libinfo=None): + # Add an iSNP at this chrom,pos. acounts is a list of triples: + # (allele, fwd count, rev count). + assert isinstance(pos, int) and pos > 0 and len(acounts) > 1 + for a, f, r in acounts: + assert a in ('A', 'C', 'G', 'T') + assert f >= 0 and r >= 0 and f + r > 0 + + # Add libinfo to acounts + if libinfo is None: + acounts = [[a, f, r, 1, [[f, r]]] for a, f, r in acounts] + else: + # ... + raise Exception + + acounts = reversed(sorted((acount[1] + acount[2],) + tuple(acount) for acount in acounts)) + acounts = [tuple(acount[1:]) for acount in acounts] + if chrom not in self.chroms: + self.chroms.append(chrom) + self.isnvs.setdefault(chrom, {}) + self.isnvs[chrom].setdefault(pos, {}) + self.isnvs[chrom][pos]['snp'] = acounts + + def add_indel(self, chrom, pos, acounts, libinfo=None): + ''' Add an iSNP at this chrom,pos. acounts is a list of triples: + (allele, fwd count, rev count). allele is simply a small + sequence with no ""I"" or ""D"" prefixing it (we'll add the I/D). + ''' + assert isinstance(pos, int) and pos > 0 and len(acounts) > 1 + for a, f, r in acounts: + assert isinstance(a, str) + assert f >= 0 and r >= 0 and f + r > 0 + assert '' in set(a for a, f, r in acounts) + + # Add libinfo to acounts + if libinfo is None: + acounts = [[a, f, r, 1, [[f, r]]] for a, f, r in acounts] + else: + # ... + raise Exception + + acounts = reversed(sorted((acount[1] + acount[2],) + tuple(acount) for acount in acounts)) + acounts = [list(acount[1:]) for acount in acounts] + + # vphaser funniness here + if acounts[0][0] == '': + # this is a set of insertions against the consensus + acounts[0][0] = 'd' + for i in range(1, len(acounts)): + acounts[i][0] = 'I' + acounts[i][0] + else: + # this is a deletion against the consensus + for i in range(1, len(acounts)): + n_deleted = len(acounts[0][0]) - len(acounts[i][0]) + assert n_deleted > 0 + assert acounts[0][0][n_deleted:] == acounts[i][0] + acounts[i][0] = 'D' + str(n_deleted) + acounts[0][0] = 'i' + + if chrom not in self.chroms: + self.chroms.append(chrom) + self.isnvs.setdefault(chrom, {}) + self.isnvs[chrom].setdefault(pos, {}) + self.isnvs[chrom][pos]['lp'] = acounts + + def __iter__(self): + for c in self.chroms: + for p in sorted(self.isnvs[c].keys()): + for model in self.isnvs[c][p].keys(): + acounts = self.isnvs[c][p][model] + mac = sum(acount[1] + acount[2] for acount in acounts[1:]) + tot = sum(acount[1] + acount[2] for acount in acounts) + yield [c, str(p), acounts[1][0], acounts[0][0], + '0.5', model, str(float(mac) / tot * 100.0)] \ + + [str(AlleleFieldParser(None, *acount)) + for acount in acounts] + + +class TestIntrahostFilters(unittest.TestCase): + ''' This tests step 1 of the iSNV calling process + (intrahost.vphaser_one_sample), which runs V-Phaser2 on + a single sample, reformats the output slightly, and performs + strand-bias filtering and adds library-bias statistics. + These unit tests mock the vphaser tool output and just test + the filtering/statistics/etc. + ''' + + def test_single_strand_bias_hard_filter(self): + data = MockVphaserOutput() + data.add_snp('c1', 100, [('A', 10, 20), ('T', 5, 2), ('C', 30, 500), ('G', 60, 40)]) + data.add_snp('c2', 100, [('C', 10, 2), ('T', 2, 8)]) + output = list(intrahost.filter_strand_bias(data)) + expected = ['c1', '100', 'A', 'G', None, 'snp', 23.076923076923078, 'G:60:40:60:40:1', 'A:10:20:10:20:1'] + self.assertEqual(len(output), 1) + self.assertEqual(output[0][:4], expected[:4]) + self.assertEqual(output[0][5], expected[5]) + self.assertAlmostEqual(float(output[0][6]), expected[6], places=4) + self.assertEqual(output[0][7:], expected[7:]) + + +#@unittest.skipIf(tools.is_osx(), ""vphaser2 osx binary from bioconda has issues"") +class TestPerSample(test.TestCaseWithTmp): + ''' This tests step 1 of the iSNV calling process + (intrahost.vphaser_one_sample), which runs V-Phaser2 on + a single sample, reformats the output slightly, and performs + strand-bias filtering and adds library-bias statistics. + ''' + + def test_vphaser_one_sample(self): + # Files here were created as follows: + # - in.bam was copied from input directory for TestVPhaser2; see notes + # there on how it was created. + # - ref.fasta was created by making two identical chromosomes, chr1 + # and chr2, with the sequence from West Nile virus isolate + # WNV-1/US/BID-V7821/2011. That genome is a guess for the reference + # of the V-Phaser 2 test file because BLAST matches the reads to + # West Nile virus and that isolate has the size reported in the bam file. + # Note that ref.fasta is not exactly the consensus of the reads in in.bam; + # for example, pos 660 is C in ref.fasta, but more reads have T there + # than C in in.bam. So we are actually testing the case that + # V-Phaser 2 consensus != our consensus. + myInputDir = util.file.get_test_input_path(self) + inBam = os.path.join(myInputDir, 'in.bam') + refFasta = os.path.join(myInputDir, 'ref.fasta') + outTab = util.file.mkstempfname('.txt') + intrahost.vphaser_one_sample(inBam, refFasta, outTab, vphaserNumThreads=test._CPUS, minReadsEach=6, maxBias=3) + expected = os.path.join(myInputDir, 'vphaser_one_sample_expected.txt') + self.assertEqualContents(outTab, expected) + + +class VcfMergeRunner: + ''' This creates test data and feeds it to intrahost.merge_to_vcf + ''' + + def __init__(self, ref_genome=None): + self.genomes = {} # {sample : {chrom : bases, ...}, ...} + self.genomeFastas = OrderedDict() # {sample: fastaFileName, ... + self.alignedFastas = [] # [chr1, chr2, ...] + self.isnvs = {} + self.sample_order = [] + self.sequence_order = OrderedDict() # { sample: [seq1, seq2, ... ], ... } + if ref_genome: + self.set_ref(ref_genome) + + def set_ref(self, genome): + self.ref = makeTempFasta(genome) + + def add_genome(self, sample_name, genome): + self.genomes[sample_name] = dict(genome) + self.genomeFastas[sample_name] = makeTempFasta(genome) + if sample_name not in self.sample_order: + self.sample_order.append(sample_name) + self.isnvs.setdefault(sample_name, MockVphaserOutput()) + + def add_snp(self, sample, chrom, pos, acounts, libinfo=None): + assert sample in self.genomeFastas + assert chrom in self.genomes[sample] + assert 1 <= pos <= len(self.genomes[sample][chrom]) + assert self.genomes[sample][chrom][pos - 1] in [a for a, f, r in acounts] + self.isnvs[sample].add_snp(chrom, pos, acounts, libinfo) + + def add_indel(self, sample, chrom, pos, acounts, libinfo=None): + assert sample in self.genomeFastas + assert sample in self.genomeFastas + assert chrom in self.genomes[sample] + assert 1 <= pos <= len(self.genomes[sample][chrom]) + if acounts[0][0] != '': # deletion + assert self.genomes[sample][chrom][pos - 1:].startswith(acounts[0][0]) + self.isnvs[sample].add_indel(chrom, pos, acounts, libinfo) + + def dump_isnv_tmp_file(self, sample): + fn = util.file.mkstempfname('.txt') + with open(fn, 'wt') as outf: + for row in self.isnvs[sample]: + outf.write('\t'.join(map(str, row)) + '\n') + return fn + + def run_and_get_vcf_rows(self, retree=1, omit_samplenames=False): + outVcf = util.file.mkstempfname('.vcf.gz') + + self.multi_align_samples(retree=retree) + + if not omit_samplenames: + intrahost.merge_to_vcf(self.ref, outVcf, self.sample_order, list(self.dump_isnv_tmp_file(s) for s in self.sample_order), + self.alignedFastas) + else: + intrahost.merge_to_vcf(self.ref, outVcf, [], list(self.dump_isnv_tmp_file(s) for s in self.sample_order), + self.alignedFastas) + + + with util.vcf.VcfReader(outVcf) as vcf: + rows = list(vcf.get()) + return rows + + def multi_align_samples(self, retree=1): + + # store here a dict, {sample_name: [sequence_id1, sequence_id2, ...]} + + # because in Python3 OrderedDict does not have iteritems(), it simply has items() + if hasattr(self.genomeFastas, ""iteritems""): + genomeKVIterator = self.genomeFastas.iteritems() + else: + genomeKVIterator = self.genomeFastas.items() + + for sampleName, fastaFile in genomeKVIterator: + with util.file.open_or_gzopen(fastaFile, 'r') as inf: + for seq in Bio.SeqIO.parse(inf, 'fasta'): + self.sequence_order.setdefault(sampleName, default=[]) + self.sequence_order[sampleName].append(seq.id) + + inputFastas = [] + inputFastas.append(self.ref) + inputFastas.extend(self.genomeFastas.values()) + transposedFiles = interhost.transposeChromosomeFiles(inputFastas) + + # since the FASTA files are + for idx, filePath in enumerate(transposedFiles): + + outFile = util.file.mkstempfname('.fasta') + outFilePath = os.path.dirname(outFile) + + alignedOutFile = tools.mafft.MafftTool().execute( + inFastas=[os.path.abspath(filePath)], + outFile=os.path.join(outFilePath, ""{}{}.fasta"".format(""aligned"", idx)), + localpair=False, + globalpair=True, + preservecase=True, + reorder=None, + gapOpeningPenalty=None, + offset=None, + verbose=False, + outputAsClustal=None, + maxiters=1000, + threads=test._CPUS, + retree=retree) + self.alignedFastas.append(alignedOutFile) + + +class TestVcfMerge(test.TestCaseWithTmp): + ''' This tests step 2 of the iSNV calling process + (intrahost.merge_to_vcf), which gets really nasty and tricky + and has lots of edge cases. These unit tests mock the vphaser + tool output and just tests the merge and VCF stuff. + ''' + + def test_empty_output(self): + ref = makeTempFasta([('ref1', 'ATCGCA')]) + s1 = makeTempFasta([('s1-1', 'ATCGCA')]) + emptyfile = util.file.mkstempfname('.txt') + outVcf = util.file.mkstempfname('.vcf') + #intrahost.merge_to_vcf(ref, outVcf, ['s1'], [emptyfile], [s1]) + self.assertRaises(LookupError, intrahost.merge_to_vcf, ref, outVcf, ['s1'], [emptyfile], [s1]) + self.assertGreater(os.path.getsize(outVcf), 0) + with util.file.open_or_gzopen(outVcf, 'rt') as inf: + for line in inf: + self.assertTrue(line.startswith('#')) + outVcf = util.file.mkstempfname('.vcf.gz') + #intrahost.merge_to_vcf(ref, outVcf, ['s1'], [emptyfile], [s1]) + self.assertRaises(LookupError, intrahost.merge_to_vcf, ref, outVcf, ['s1'], [emptyfile], [s1]) + self.assertGreater(os.path.getsize(outVcf), 0) + with util.file.open_or_gzopen(outVcf, 'rt') as inf: + for line in inf: + self.assertTrue(line.startswith('#')) + + def test_headers_with_two_samps(self): + ref = makeTempFasta([('ref1', 'ATCGTTCA'), ('ref2', 'GGCCC')]) + s1 = makeTempFasta([('s1-1', 'ATCGCA'), ('s1-2', 'GGCCC')]) + s2 = makeTempFasta([('s2-1', 'ATCGTTCA'), ('s2-2', 'GGCCC')]) + emptyfile = util.file.mkstempfname('.txt') + outVcf = util.file.mkstempfname('.vcf.gz') + self.assertRaises( + LookupError, intrahost.merge_to_vcf, ref, outVcf, [ + 's1', 's2' + ], [ + emptyfile, emptyfile + ], [ + s1, s2 + ]) + with util.vcf.VcfReader(outVcf) as vcf: + self.assertEqual(vcf.samples(), ['s1', 's2']) + self.assertEqual(vcf.chrlens(), {'ref1': 8, 'ref2': 5}) + + def test_simple_snps(self): + merger = VcfMergeRunner([('ref1', 'ATCGGACT')]) + merger.add_genome('s1', [('s1-1', 'ATCGGAC')]) + # ATCGGAC- + merger.add_genome('s2', [('s2-1', 'TCGGACT')]) + # -TCGGACT + merger.add_genome('s3', [('s3-1', 'TCGGACT')]) + # -TCGGACT + merger.add_snp('s1', 's1-1', 3, [('C', 80, 80), ('A', 20, 20)]) + merger.add_snp('s2', 's2-1', 2, [('C', 90, 90), ('A', 10, 10)]) + merger.add_snp('s3', 's3-1', 5, [('A', 70, 70), ('T', 30, 30)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 2) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 3) + self.assertEqual(rows[0].ref, 'C') + self.assertEqual(rows[0].alt, 'A') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '0:0.2') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '0:0.1') + self.assertEqual(':'.join(rows[0][2].split(':')[:2]), '0:0.0') + self.assertEqual(rows[1].contig, 'ref1') + self.assertEqual(rows[1].pos + 1, 6) + self.assertEqual(rows[1].ref, 'A') + self.assertEqual(rows[1].alt, 'T') + self.assertEqual(':'.join(rows[1][0].split(':')[:2]), '0:0.0') + self.assertEqual(':'.join(rows[1][1].split(':')[:2]), '0:0.0') + self.assertEqual(':'.join(rows[1][2].split(':')[:2]), '0:0.3') + + def test_simple_snps_guess_samplenames(self): + merger = VcfMergeRunner([('ref1', 'ATCGGACT')]) + merger.add_genome('s1', [('s1-1', 'ATCGGAC')]) + # ATCGGAC- + merger.add_genome('s2', [('s2-1', 'TCGGACT')]) + # -TCGGACT + merger.add_genome('s3', [('s3-1', 'TCGGACT')]) + # -TCGGACT + merger.add_snp('s1', 's1-1', 3, [('C', 80, 80), ('A', 20, 20)]) + merger.add_snp('s2', 's2-1', 2, [('C', 90, 90), ('A', 10, 10)]) + merger.add_snp('s3', 's3-1', 5, [('A', 70, 70), ('T', 30, 30)]) + rows = merger.run_and_get_vcf_rows(omit_samplenames=True) + self.assertEqual(len(rows), 2) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 3) + self.assertEqual(rows[0].ref, 'C') + self.assertEqual(rows[0].alt, 'A') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '0:0.2') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '0:0.1') + self.assertEqual(':'.join(rows[0][2].split(':')[:2]), '0:0.0') + self.assertEqual(rows[1].contig, 'ref1') + self.assertEqual(rows[1].pos + 1, 6) + self.assertEqual(rows[1].ref, 'A') + self.assertEqual(rows[1].alt, 'T') + self.assertEqual(':'.join(rows[1][0].split(':')[:2]), '0:0.0') + self.assertEqual(':'.join(rows[1][1].split(':')[:2]), '0:0.0') + self.assertEqual(':'.join(rows[1][2].split(':')[:2]), '0:0.3') + + def test_snps_with_varying_read_depth(self): + merger = VcfMergeRunner([('ref1', 'ATCGGACT')]) + merger.add_genome('s1', [('s1-1', 'ATCGGAC')]) + # ATCGGAC- + merger.add_genome('s2', [('s2-1', 'TCGGACT')]) + # -TCGGACT + merger.add_genome('s3', [('s3-1', 'TCGGACT')]) + # -TCGGACT + merger.add_snp('s1', 's1-1', 3, [('C', 60, 100), ('A', 25, 15)]) + merger.add_snp('s2', 's2-1', 2, [('C', 12, 6), ('A', 2, 0)]) + merger.add_snp('s3', 's3-1', 5, [('A', 7, 4), ('T', 2, 3)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 2) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 3) + self.assertEqual(rows[0].ref, 'C') + self.assertEqual(rows[0].alt, 'A') + self.assertEqual(':'.join(rows[0][0].split(':')[:3]), '0:0.2:200') + self.assertEqual(':'.join(rows[0][1].split(':')[:3]), '0:0.1:20') + self.assertEqual(':'.join(rows[0][2].split(':')[:3]), '0:0.0:.') + self.assertEqual(rows[1].contig, 'ref1') + self.assertEqual(rows[1].pos + 1, 6) + self.assertEqual(rows[1].ref, 'A') + self.assertEqual(rows[1].alt, 'T') + self.assertEqual(':'.join(rows[1][0].split(':')[:3]), '0:0.0:.') + self.assertEqual(':'.join(rows[1][1].split(':')[:3]), '0:0.0:.') + self.assertEqual(':'.join(rows[1][2].split(':')[:3]), '0:0.3125:16') + + def test_snps_downstream_of_indels(self): + merger = VcfMergeRunner([('ref1', 'ATCGGACT')]) + merger.add_genome('s1', [('s1-1', 'ATCGTTGACT')]) + merger.add_genome('s2', [('s2-1', 'TCGTTGACT')]) + merger.add_genome('s3', [('s3-1', 'TCGGCCT')]) + merger.add_snp('s1', 's1-1', 8, [('A', 80, 80), ('C', 20, 20)]) + merger.add_snp('s2', 's2-1', 7, [('A', 90, 90), ('C', 10, 10)]) + merger.add_snp('s3', 's3-1', 5, [('C', 70, 70), ('A', 30, 30)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 6) + self.assertEqual(rows[0].ref, 'A') + self.assertEqual(rows[0].alt, 'C') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '0:0.2') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '0:0.1') + self.assertEqual(':'.join(rows[0][2].split(':')[:2]), '1:0.7') + + def test_sample_major_allele_not_ref_allele(self): + # make sure we can invert the allele frequency of the isnv + # if necessary to match the reference's definition of ref & alt + merger = VcfMergeRunner([('ref1', 'ATCGCAC')]) + merger.add_genome('s1', [('s1-1', 'ATAGCCC')]) + merger.add_snp('s1', 's1-1', 3, [('C', 10, 10), ('A', 90, 90)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 3) + self.assertEqual(rows[0].ref, 'C') + self.assertEqual(rows[0].alt, 'A') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '1:0.9') + + def test_backfill_sample_from_assembly(self): + # one sample has no isnv, but another does, so we fill it in + # 100% with its assembly allele, unless it doesn't have one + # REF C + # S1 A (isnv) + # S2 A (consensus, no isnv) + # S3 N (no consensus, no isnv) + merger = VcfMergeRunner([('ref1', 'ATCG')]) + merger.add_genome('s1', [('s1-1', 'ATCG')]) + merger.add_genome('s2', [('s2-1', 'ATAG')]) + merger.add_genome('s3', [('s3-1', 'ATNG')]) + merger.add_snp('s1', 's1-1', 3, [('C', 90, 90), ('A', 10, 10)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 3) + self.assertEqual(rows[0].ref, 'C') + self.assertEqual(rows[0].alt, 'A') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '0:0.1') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '1:1.0') + self.assertEqual(rows[0][2], '.:.:.:.:.') + + def test_simple_insertions(self): + # IA, ITCG, etc + # V-Phaser outputs a position that is just prior to where the new + # bases come in. For example: ATCG -> ATiiiCG is at position 2. + # This is consistent with what the VCF conventional position. + # V-Phaser outputs an allele that does not include the position. + # For example: ATCG -> ATAAACG is considered ""IAAA"" at position 2. + # This is not the same as the VCF convention, which includes the + # initial invariant base as part of the allele (it's a T -> TAAA + # variant at position 2). + merger = VcfMergeRunner([('ref1', 'ATCG')]) + merger.add_genome('s1', [('s1-1', 'ATCG')]) + merger.add_genome('s2', [('s2-1', 'ATCG')]) + merger.add_genome('s3', [('s3-1', 'ATCG')]) + merger.add_indel('s1', 's1-1', 2, [('', 80, 80), ('AA', 20, 20)]) + merger.add_indel('s2', 's2-1', 2, [('', 90, 90), ('AT', 10, 10)]) + merger.add_indel('s3', 's3-1', 2, [('', 80, 80), ('GCC', 15, 15), ('AA', 5, 5)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 2) + self.assertEqual(rows[0].ref, 'T') + self.assertEqual(rows[0].alt, 'TAA,TGCC,TAT') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '0:0.2,0.0,0.0') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '0:0.0,0.0,0.1') + self.assertEqual(':'.join(rows[0][2].split(':')[:2]), '0:0.05,0.15,0.0') + + def test_simple_deletions(self): + # D1, D2, etc... + # V-Phaser outputs a position that describes the deleted base and + # the number of bases deleted (but does not tell you what bases + # were deleted). For example: ATCGAT -> ATAT is considered + # a ""D2"" deletion at position 3. + # This is not the same as the VCF convention, which anchors on + # a preceeding invariant base. The above example is considered + # to be a TCG -> T variant at position 2. + merger = VcfMergeRunner([('ref1', 'ATCGAT')]) + merger.add_genome('s1', [('s1-1', 'ATCGAT')]) + merger.add_genome('s2', [('s2-1', 'ATCGAT')]) + merger.add_genome('s3', [('s3-1', 'ATCGAT')]) + merger.add_indel('s1', 's1-1', 3, [('CG', 80, 80), ('', 20, 20)]) + merger.add_indel('s2', 's2-1', 3, [('C', 90, 90), ('', 10, 10)]) + merger.add_indel('s3', 's3-1', 3, [('CG', 80, 80), ('G', 15, 15), ('', 5, 5)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 2) + self.assertEqual(rows[0].ref, 'TCG') + self.assertEqual(rows[0].alt, 'TG,T') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '0:0.0,0.2') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '0:0.1,0.0') + self.assertEqual(':'.join(rows[0][2].split(':')[:2]), '0:0.15,0.05') + + def test_deletion_spans_deletion(self): + # sample assembly has deletion against reference and isnv deletes even more + # POS is anchored right before the deletion + # REF: ATCGTTCA + # S1: ATCG--CA + # isnv: x (position 5, D1) + merger = VcfMergeRunner([('ref1', 'ATCGTTCA')]) + merger.add_genome('s1', [('s1-1', 'ATCGCA')]) + merger.add_indel('s1', 's1-1', 5, [('C', 90, 90), ('', 10, 10)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 4) + self.assertEqual(rows[0].ref, 'GTTC') + self.assertEqual(rows[0].alt, 'GC,G') + self.assertEqual(rows[0][0], '1:0.9,0.1:200:0,1,1:.,1.0,1.0') + + def test_insertion_spans_deletion(self): + # sample assembly has deletion against reference and isnv inserts back into it + # POS is anchored right before the deletion + # REF: ATCGTTGA + # S1: ATCG--GA + # isnv: T (position 4, IT) + # isnv: TT (position 4, ITT) + # isnv: TTC (position 4, ITTC) + merger = VcfMergeRunner([('ref1', 'ATCGTTCACC')]) + merger.add_genome('s1', [('s1-1', 'ATCGCACC')]) + merger.add_genome('s2', [('s2-1', 'ATCGCACC')]) + merger.add_genome('s3', [('s3-1', 'ATCGCACC')]) + merger.add_indel('s1', 's1-1', 4, [('', 70, 70), ('T', 30, 30)]) + merger.add_indel('s2', 's2-1', 4, [('', 80, 80), ('TT', 20, 20)]) + merger.add_indel('s3', 's3-1', 4, [('', 90, 90), ('TTC', 10, 10)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 4) + self.assertEqual(rows[0].ref, 'GTT') + self.assertEqual(rows[0].alt, 'G,GT,GTTC') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '1:0.7,0.3,0.0') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '1:0.8,0.0,0.0') + self.assertEqual(':'.join(rows[0][2].split(':')[:2]), '1:0.9,0.0,0.1') + + def test_snp_within_insertion(self): + # sample assembly has insertion against reference and isnp modifies it + # REF: ATCG--GA + # S1: ATCGTTGA + # isnv: C + # isnv: C + # isnv: C + merger = VcfMergeRunner([('ref1', 'ATCGGACT')]) + merger.add_genome('s1', [('s1-1', 'ATCGTTGACT')]) + merger.add_genome('s2', [('s2-1', 'TCGTTGACT')]) + merger.add_genome('s3', [('s3-1', 'TCGTTGACT')]) + merger.add_snp('s1', 's1-1', 4, [('G', 70, 70), ('C', 30, 30)]) + merger.add_snp('s2', 's2-1', 4, [('T', 80, 80), ('C', 20, 20)]) + merger.add_snp('s3', 's3-1', 5, [('T', 90, 90), ('C', 10, 10)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 4) + self.assertEqual(rows[0].ref, 'G') + self.assertEqual(rows[0].alt, 'GTT,CTT,GCT,GTC') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '1:0.7,0.3,0.0,0.0') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '1:0.8,0.0,0.2,0.0') + self.assertEqual(':'.join(rows[0][2].split(':')[:2]), '1:0.9,0.0,0.0,0.1') + + def test_2snps_within_insertion_same_sample(self): + # Sample assembly has insertion against reference containing two SNPs + # in the same sample. + # We don't handle this because we can't see phasing; it should be + # handled by the variant caller. + # REF: ATCG--GACT + # S1: ATCGTTGACT + # isnv: C + # isnv: C + merger = VcfMergeRunner([('ref1', 'ATCGGACT')]) + merger.add_genome('s1', [('s1-1', 'ATCGTTGACT')]) + merger.add_snp('s1', 's1-1', 5, [('T', 80, 80), ('C', 20, 20)]) + merger.add_snp('s1', 's1-1', 6, [('T', 90, 90), ('C', 10, 10)]) + self.assertRaises(NotImplementedError, merger.run_and_get_vcf_rows) + + def test_deletion_past_end_of_some_consensus(self): + # Some sample contains a deletion beyond the end of the consensus + # sequence of another sample with a SNP. It should skip latter rather + # than crashing. + # REF: ATCGAAC + # S1: ATCG--C + # S1isnv: ATCA--C + # S2: ATCT + # S2isnv: ATCC + merger = VcfMergeRunner([('ref1', 'ATCGAAC')]) + merger.add_genome('s1', [('s1-1', 'ATCGC')]) + merger.add_snp('s1', 's1-1', 4, [('G', 70, 70), ('A', 30, 30)]) + merger.add_genome('s2', [('s2-1', 'ATCT')]) + merger.add_snp('s2', 's2-1', 4, [('T', 80, 80), ('C', 20, 20)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 2) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 4) + self.assertEqual(rows[0].ref, 'GAA') + # multiple options because the allele frequencies can be the same + self.assertIn(rows[0].alt, ['C,G,A', 'G,C,A']) + self.assertIn(rows[0][0], ['2:0.0,0.7,0.3:200:0,0,1,1:.,.,1.0,1.0', '1:0.7,0.0,0.3:200:0,1,0,1:.,1.0,.,1.0']) + self.assertIn(rows[0][1], ['1:1.0,0.0,0.0:.:.:.', '2:0.0,1.0,0.0:.:.:.']) + self.assertEqual(rows[1].contig, 'ref1') + self.assertEqual(rows[1].pos + 1, 7) + self.assertEqual(rows[1].ref, 'C') + self.assertEqual(rows[1].alt, 'T') + self.assertEqual(rows[1][0], '0:0.0:.:.:.') + self.assertEqual(rows[1][1], '1:0.8:200:1,1:1.0,1.0') + + def test_snp_past_end_of_some_consensus(self): + # Some sample contains SNP beyond the end of the consensus + # sequence of another. It should skip latter rather + # than crashing. + # REF: AT + # S1: AT + # S1isnv: AG + # S2: A + merger = VcfMergeRunner([('ref1', 'AT')]) + merger.add_genome('s1', [('s1-1', 'AT')]) + merger.add_snp('s1', 's1-1', 2, [('T', 70, 70), ('G', 30, 30)]) + merger.add_genome('s2', [('s2-1', 'A')]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 2) + self.assertEqual(rows[0].ref, 'T') + self.assertEqual(rows[0].alt, 'G') + self.assertEqual(rows[0][0], '0:0.3:200:1,1:1.0,1.0') + self.assertEqual(rows[0][1], '.:.:.:.:.') + + def test_deletion_within_insertion(self): + # sample assembly has insertion against reference and isnv deletes from it + # REF: ATCG--GA + # S1: ATCGTTGA + # isnv: x (position 5, D1) s1 => GTG + # isnv: xx (position 5, D2) s1 => GG + # isnv: xxx (position 5, D3) s1 => G + # isnv: x (position 6, D1) s2, s3 => GTG + # isnv: xx (position 6, D2) s3 => GT + # isnv: x (position 7, D1) s4 => GTT + merger = VcfMergeRunner([('ref1', 'ATCGGACT')]) + merger.add_genome('s1', [('s1-1', 'ATCGTTGACT')]) + merger.add_genome('s2', [('s2-1', 'TCGTTGACT')]) + merger.add_genome('s3', [('s3-1', 'TCGTTGACT')]) + merger.add_genome('s4', [('s4-1', 'TCGTTGACT')]) + merger.add_indel('s1', 's1-1', 5, [('TTG', 40, 40), ('TG', 30, 30), ('G', 20, 20), ('', 10, 10)]) + merger.add_indel('s2', 's2-1', 4, [('T', 80, 80), ('', 20, 20)]) + merger.add_indel('s3', 's3-1', 5, [('TG', 85, 85), ('G', 10, 10), ('', 5, 5)]) + merger.add_indel('s4', 's4-1', 6, [('G', 90, 90), ('', 10, 10)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 4) + self.assertEqual(rows[0].ref, 'GG') + self.assertEqual(rows[0].alt, 'GTTG,GTG,GTT,G,GT') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '1:0.4,0.3,0.0,0.1,0.0') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '1:0.8,0.2,0.0,0.0,0.0') + self.assertEqual(':'.join(rows[0][2].split(':')[:2]), '1:0.85,0.1,0.0,0.0,0.05') + self.assertEqual(':'.join(rows[0][3].split(':')[:2]), '1:0.9,0.0,0.1,0.0,0.0') + + def test_insertion_within_insertion(self): + # sample assembly has insertion against reference and isnv puts even more in + # REF: ATCG--GA + # S1: ATCGTTGA + # isnv: ^ (position 4, IA) + # isnv: ^ (position 5, IA) + # isnv: ^ (position 6, IA) + merger = VcfMergeRunner([('ref1', 'ATCGGACT')]) + merger.add_genome('s1', [('s1-1', 'ATCGTTGACT')]) + merger.add_genome('s2', [('s2-1', 'TCGTTGACT')]) + merger.add_genome('s3', [('s3-1', 'TCGTTGACT')]) + merger.add_indel('s1', 's1-1', 4, [('', 70, 70), ('A', 30, 30)]) + merger.add_indel('s2', 's2-1', 4, [('', 80, 80), ('A', 20, 20)]) + merger.add_indel('s3', 's3-1', 5, [('', 90, 90), ('A', 10, 10)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 4) + self.assertEqual(rows[0].ref, 'G') + self.assertEqual(rows[0].alt, 'GTT,GATT,GTAT,GTTA') + self.assertEqual(':'.join(rows[0][0].split(':')[:2]), '1:0.7,0.3,0.0,0.0') + self.assertEqual(':'.join(rows[0][1].split(':')[:2]), '1:0.8,0.0,0.2,0.0') + self.assertEqual(':'.join(rows[0][2].split(':')[:2]), '1:0.9,0.0,0.0,0.1') + + def test_indel_collapse(self): + # vphaser describes insertions and deletions separately + # test appropriate collapse of coincident insertions and deletions into + # a single output VCF row + # isnv: (position 2, IA) + # isnv: (position 3, D1) + # Note: This is where V-Phaser gets weird. For sites that have both + # insertions and deletions, the insertions are described on one row + # and the deletions get described on a separate row. But both rows + # will have a read count for the majority/consensus allele + # (called ""i"" in one and ""d"" in the other), but the counts for + # that allele often do not agree between the two rows! + # So in this scenario, we ought to average them. + merger = VcfMergeRunner([('ref1', 'ATCG')]) + merger.add_genome('s1', [('s1-1', 'ATCG')]) + merger.add_indel('s1', 's1-1', 2, [('', 40, 40), ('A', 20, 20)]) + merger.add_indel('s1', 's1-1', 3, [('C', 60, 60), ('', 30, 30)]) + rows = merger.run_and_get_vcf_rows() + self.assertEqual(len(rows), 1) + self.assertEqual(rows[0].contig, 'ref1') + self.assertEqual(rows[0].pos + 1, 2) + self.assertEqual(rows[0].ref, 'TC') + self.assertEqual(rows[0].alt, 'T,TAC') + self.assertEqual(rows[0][0].split(':')[0], '0') # s1 is 0.5 TC, 0.3 T, 0.2 TAC + for actual, expected in zip(rows[0][0].split(':')[1].split(','), [0.3, 0.2]): + self.assertAlmostEqual(float(actual), expected, places=2) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_metagenomics.py",".py","10221","324","# Unit tests for metagenomics.py +from builtins import super +import six +import argparse +from collections import Counter +import copy +import os.path +from os.path import join +import tempfile +import textwrap +import unittest +import pytest + +import mock +from mock import patch + +import tools.picard +import metagenomics +import util.file +import util.misc +from test import TestCaseWithTmp, assert_equal_bam_reads, _CPUS + +from io import StringIO + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_fun in metagenomics.__commands__: + parser = parser_fun(argparse.ArgumentParser()) + helpstring = parser.format_help() + + +class TestKronaCalls(TestCaseWithTmp): + + def setUp(self): + super().setUp() + patcher = patch('tools.krona.Krona', autospec=True) + self.addCleanup(patcher.stop) + self.mock_krona = patcher.start() + + self.inTsv = util.file.mkstempfname('.tsv') + self.db = tempfile.mkdtemp('db') + + def test_krona_import_taxonomy(self): + out_html = util.file.mkstempfname('.html') + metagenomics.krona(self.inTsv, self.db, out_html, queryColumn=3, taxidColumn=5, scoreColumn=7, + noHits=True, noRank=True, inputType='tsv') + self.mock_krona().import_taxonomy.assert_called_once_with( + self.db, [self.inTsv], out_html, query_column=3, taxid_column=5, score_column=7, + no_hits=True, no_rank=True, magnitude_column=None, root_name=os.path.basename(self.inTsv)) + + +@pytest.fixture +def taxa_db_simple(): + db = metagenomics.TaxonomyDb() + db.gis = {1:2, 2:3, 3:4, 4:5} + db.parents = {1: 1, 2: 1, 3: 2, 4: 3, 5: 4} + return db + + +@pytest.fixture +def taxa_db(parents, names, ranks): + db = metagenomics.TaxonomyDb() + db.parents = parents + db.names = names + db.ranks = ranks + return db + + +@pytest.fixture +def parents(): + return { + 1: 1, + 3: 1, + 6: 3, + 7: 6, + 8: 7, + 10: 6, + 11: 7, + 12: 8, + 13: 12 + } + + +@pytest.fixture +def names(): + names = { + 1: ""root"", + 2: ""two"", + 3: ""three"", + 4: ""four"", + 6: ""six"", + 7: ""seven"", + 8: ""eight"", + 10: ""ten"", + 11: ""eleven"", + 12: ""twelve"", + 13: ""thirteen"" + } + return names + + +@pytest.fixture +def ranks(): + return { + 1: ""root"", + 2: """", + 3: ""superkingdom"", + 4: ""kingdom"", + 6: """", + 7: """", + 8: """", + 10: """", + 11: ""genus"", + 12: ""species"", + 13: """" + } + + +@pytest.fixture +def simple_m8(): + test_path = join(util.file.get_test_input_path(), + 'TestTaxonomy') + return open(join(test_path, 'simple.m8')) + + +def test_tree_level_lookup(parents): + level_cache = {1: 1} + assert metagenomics.tree_level_lookup(parents, 1, level_cache) == 1 + assert metagenomics.tree_level_lookup(parents, 3, level_cache) == 2 + assert metagenomics.tree_level_lookup(parents, 12, level_cache) == 6 + level_cache = {1: 1} + assert metagenomics.tree_level_lookup(parents, 12, level_cache) == 6 + assert metagenomics.tree_level_lookup(parents, 8, level_cache) == 5 + + +def test_push_up_tree_hits(parents): + hits = Counter({1: 3, 3: 5, 6: 3, 7: 3, 13: 5}) + with pytest.raises(AssertionError): + metagenomics.push_up_tree_hits(parents, hits) + + expected = hits.copy() + assert metagenomics.push_up_tree_hits(parents, hits.copy(), min_support=1) == expected + + expected = Counter({3: 5, 6: 6, 13: 5}) + assert metagenomics.push_up_tree_hits(parents, hits.copy(), min_support=5) == expected + + assert (metagenomics.push_up_tree_hits(parents, hits.copy(), min_support=10) == + Counter({6: 11})) + assert (metagenomics.push_up_tree_hits(parents, hits.copy(), min_support=18) == + Counter({1: 19})) + assert (metagenomics.push_up_tree_hits(parents, hits.copy(), min_support_percent=100) == + Counter({1: 19})) + + +def test_parents_to_children(parents): + children = metagenomics.parents_to_children(parents) + assert children[1] == [3] + + +def test_rank_code(): + assert metagenomics.rank_code('species') == 'S' + assert metagenomics.rank_code('genus') == 'G' + assert metagenomics.rank_code('superkingdom') == 'D' + assert metagenomics.rank_code('nonexist') == '-' + + +def test_blast_records(simple_m8): + test_path = join(util.file.get_test_input_path(), + 'TestTaxonomy') + with simple_m8 as f: + records = list(metagenomics.blast_records(f)) + assert len(records) == 110 + assert records[0].bit_score == 63.5 + assert records[-1].bit_score == 67.4 + + +def test_blast_lca(taxa_db_simple, simple_m8): + test_path = join(util.file.get_test_input_path(), + 'TestTaxonomy') + expected = textwrap.dedent(""""""\ + C\tM04004:13:000000000-AGV3H:1:1101:12068:2105\t2 + C\tM04004:13:000000000-AGV3H:1:1101:13451:2146\t2 + C\tM04004:13:000000000-AGV3H:1:1101:13509:2113\t2 + C\tM04004:13:000000000-AGV3H:1:1101:14644:2160\t2 + C\tM04004:13:000000000-AGV3H:1:1101:18179:2130\t2 + C\tM04004:13:000000000-AGV3H:1:1111:10629:2610\t2 + C\tM04004:13:000000000-AGV3H:1:1111:10629:26101\t2 + """""") + out = StringIO() + with simple_m8 as f: + metagenomics.blast_lca(taxa_db_simple, f, out, paired=True) + out.seek(0) + assert out.read() == expected + + +def test_paired_query_id(): + tup = ['query', 'gi|10|else', 90., 80, 60, 2, 30, 80, + 1100, 1150, 1e-7, 64.5, []] + + blast1 = metagenomics.BlastRecord(*tup) + assert metagenomics.paired_query_id(blast1) == blast1 + + new_tup = copy.copy(tup) + new_tup[0] = 'query/1' + new_blast1 = metagenomics.BlastRecord(*new_tup) + assert metagenomics.paired_query_id(new_blast1) == blast1 + + new_tup = copy.copy(tup) + new_tup[0] = 'query/2' + new_blast1 = metagenomics.BlastRecord(*new_tup) + assert metagenomics.paired_query_id(new_blast1) == blast1 + + new_tup = copy.copy(tup) + new_tup[0] = 'query/3' + new_blast1 = metagenomics.BlastRecord(*new_tup) + assert metagenomics.paired_query_id(new_blast1) == new_blast1 + + +def test_translate_gi_to_tax_id(taxa_db_simple): + tup = ['query', 'gi|4|else', 90., 80, 60, 2, 30, 80, + 1100, 1150, 1e-7, 64.5, []] + blast1 = metagenomics.BlastRecord(*tup) + + tup[1] = 5 + expected = metagenomics.BlastRecord(*tup) + assert metagenomics.translate_gi_to_tax_id(taxa_db_simple, blast1) == expected + + +def test_kraken_dfs_report(taxa_db): + hits = Counter({1: 101, 3: 103, 10: 105, 12: 107}) + + expected = textwrap.dedent('''\ + 100.00\t416\t101\t-\t1\troot + 75.72\t315\t103\tD\t3\t three + 50.96\t212\t0\t-\t6\t six + 25.24\t105\t105\t-\t10\t ten + 25.72\t107\t0\t-\t7\t seven + 25.72\t107\t0\t-\t8\t eight + 25.72\t107\t107\tS\t12\t twelve + ''') + report = metagenomics.kraken_dfs_report(taxa_db, hits) + text_report = '\n'.join(list(report)) + '\n' + assert text_report == expected + + +def test_coverage_lca(taxa_db): + assert metagenomics.coverage_lca([10, 11, 12], taxa_db.parents) == 6 + assert metagenomics.coverage_lca([1, 3], taxa_db.parents) == 1 + assert metagenomics.coverage_lca([6, 7, 8], taxa_db.parents) == 6 + assert metagenomics.coverage_lca([10, 11, 12], taxa_db.parents, 50) == 7 + assert metagenomics.coverage_lca([9], taxa_db.parents) is None + + +def test_krakenuniq(mocker): + p = mocker.patch('tools.kraken.KrakenUniq.pipeline') + args = [ + 'db', + 'input.bam', + '--outReports', 'output.report', + '--outReads', 'output.reads', + ] + args = metagenomics.parser_krakenuniq(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + p.assert_called_with('db', ['input.bam'], num_threads=mock.ANY, filter_threshold=mock.ANY, out_reports=['output.report'], out_reads=['output.reads']) + + +def test_kaiju(mocker): + p = mocker.patch('tools.kaiju.Kaiju.classify') + args = [ + 'input.bam', + 'db.fmi', + 'tax_db', + 'output.report', + '--outReads', 'output.reads', + ] + args = metagenomics.parser_kaiju(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + p.assert_called_with('db.fmi', 'tax_db', 'input.bam', output_report='output.report', num_threads=mock.ANY, output_reads='output.reads') + + +class TestBamFilter(TestCaseWithTmp): + def test_bam_filter_simple(self): + temp_dir = tempfile.gettempdir() + input_dir = util.file.get_test_input_path(self) + taxonomy_dir = os.path.join(util.file.get_test_input_path(),""TestMetagenomicsSimple"",""db"",""taxonomy"") + + filtered_bam = util.file.mkstempfname('.bam') + args = [ + os.path.join(input_dir,""input.bam""), + os.path.join(input_dir,""input.kraken-reads.tsv.gz""), + filtered_bam, + os.path.join(taxonomy_dir,""nodes.dmp""), + os.path.join(taxonomy_dir,""names.dmp""), + ""--taxNames"", + ""Ebolavirus"" + ] + args = metagenomics.parser_filter_bam_to_taxa(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + + expected_bam = os.path.join(input_dir,""expected.bam"") + assert_equal_bam_reads(self, filtered_bam, expected_bam) + + def test_bam_filter_by_tax_id(self): + temp_dir = tempfile.gettempdir() + input_dir = util.file.get_test_input_path(self) + taxonomy_dir = os.path.join(util.file.get_test_input_path(),""TestMetagenomicsSimple"",""db"",""taxonomy"") + + filtered_bam = util.file.mkstempfname('.bam') + args = [ + os.path.join(input_dir,""input.bam""), + os.path.join(input_dir,""input.kraken-reads.tsv.gz""), + filtered_bam, + os.path.join(taxonomy_dir,""nodes.dmp""), + os.path.join(taxonomy_dir,""names.dmp""), + ""--taxIDs"", + ""186538"" + ] + args = metagenomics.parser_filter_bam_to_taxa(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + + expected_bam = os.path.join(input_dir,""expected.bam"") + assert_equal_bam_reads(self, filtered_bam, expected_bam) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_illumina.py",".py","20059","401","# Unit tests for illumina.py +# -*- coding: utf-8 -*- + +__author__ = ""dpark@broadinstitute.org"" + +import unittest +import os +import os.path +import tempfile +import argparse +import filecmp +import util +import util.file +import illumina +import tools.samtools +from test import TestCaseWithTmp + + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_fun in illumina.__commands__: + parser = parser_fun(argparse.ArgumentParser()) + helpstring = parser.format_help() + + +class TestSampleSheet(TestCaseWithTmp): + + def test_miseq(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-miseq-1.csv')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 20) + + def test_broad_platform(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-hiseq-1.csv'), only_lane=2) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 24) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-hiseq-1.csv'), allow_non_unique=True) + self.assertEqual(len(samples.get_rows()), 48) + + def test_walkup_submission_no_header_no_lf(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-submit-1.csv')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 24) + + def test_walkup_submission(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-submit-2.csv')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 96) + + def test_walkup_submission_no_lf(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-submit-3.csv')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 24) + + def test_tabfile(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-custom-1.txt')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 24) + + def test_tabfile_win_endings(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-custom-1_win-endings.txt')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 24) + + def test_gz_tabfile_win_endings(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-custom-1_win-endings.txt.gz')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 24) + + def test_tabfile_macos9_endings(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-custom-1_macos9-endings.txt')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 24) + + def test_blank_line_in_tabular_section(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-with-blanklines.csv')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 12) + + def test_blank_line_in_tabular_section(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-in-Broad-MiSeq-Format_with_Picard_Block.csv')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 11) + + +class TestRunInfo(TestCaseWithTmp): + + def test_miseq(self): + inDir = util.file.get_test_input_path(self) + runinfo = illumina.RunInfo(os.path.join(inDir, 'RunInfo-miseq.xml')) + self.assertEqual(runinfo.get_flowcell(), 'AEF96') + self.assertEqual(runinfo.get_rundate_american(), '08/21/2015') + self.assertEqual(runinfo.get_rundate_iso(), '2015-08-21') + self.assertEqual(runinfo.get_machine(), 'M04004') + self.assertEqual(runinfo.get_read_structure(), '101T8B8B101T') + self.assertEqual(runinfo.num_reads(), 2) + + def test_hiseq(self): + inDir = util.file.get_test_input_path(self) + runinfo = illumina.RunInfo(os.path.join(inDir, 'RunInfo-hiseq.xml')) + self.assertEqual(runinfo.get_flowcell(), 'HVFF2ADXX') + self.assertEqual(runinfo.get_rundate_american(), '08/21/2015') + self.assertEqual(runinfo.get_rundate_iso(), '2015-08-21') + self.assertEqual(runinfo.get_machine(), 'SL-HDF') + self.assertEqual(runinfo.get_read_structure(), '101T8B8B101T') + self.assertEqual(runinfo.num_reads(), 2) + + def test_novaseq(self): + inDir = util.file.get_test_input_path(self) + runinfo = illumina.RunInfo(os.path.join(inDir, 'RunInfo-novaseq.xml')) + self.assertEqual(runinfo.get_flowcell(), 'HCYTJDMXX') + self.assertEqual(runinfo.get_rundate_american(), '06/27/2018') + self.assertEqual(runinfo.get_rundate_iso(), '2018-06-27') + self.assertEqual(runinfo.get_machine(), 'A00198') + self.assertEqual(runinfo.get_read_structure(), '101T8B8B101T') + self.assertEqual(runinfo.num_reads(), 2) + + +class TestIlluminaDir(TestCaseWithTmp): + + def test_directory(self): + inDir = util.file.get_test_input_path(self) + test_in = os.path.join(inDir, 'empty_dir') + with illumina.IlluminaDirectory(test_in) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + + def test_tarball_normal(self): + inDir = util.file.get_test_input_path(self) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-plain.tgz')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-plain.tar.bz2')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-plain.tar.lz4')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + + def test_tarball_indented(self): + inDir = util.file.get_test_input_path(self) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-indented.tgz')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + + def test_tarball_sample_sheet(self): + inDir = util.file.get_test_input_path(self) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-samplesheet.tar.gz')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + self.assertEqual(len(idir.get_SampleSheet().get_rows()), 15) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-both.tar.gz')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + self.assertEqual(len(idir.get_SampleSheet().get_rows()), 15) + + def test_tarball_uncompressed(self): + inDir = util.file.get_test_input_path(self) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-both-uncompressed.tar')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + self.assertEqual(len(idir.get_SampleSheet().get_rows()), 15) + + def test_tarball_deep_dir_tree(self): + inDir = util.file.get_test_input_path(self) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-both-broad_full_path.tar.gz')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + self.assertEqual(len(idir.get_SampleSheet().get_rows()), 15) + + def test_zip_archive(self): + inDir = util.file.get_test_input_path(self) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-both-2.zip')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + self.assertEqual(len(idir.get_SampleSheet().get_rows()), 15) + + def test_tarball_run_info(self): + inDir = util.file.get_test_input_path(self) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-runinfo.tar.gz')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + self.assertEqual(idir.get_RunInfo().get_flowcell(), 'AHVPA') + self.assertEqual(idir.get_RunInfo().get_machine(), 'M04004') + self.assertEqual(idir.get_RunInfo().get_rundate_iso(), '2015-08-27') + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-both.tar.gz')) as idir: + self.assertTrue(os.path.isdir(idir.get_BCLdir())) + self.assertEqual(idir.get_RunInfo().get_flowcell(), 'AHVPA') + self.assertEqual(idir.get_RunInfo().get_read_structure(), '101T8B8B101T') + + def test_tarball_fail_missing_data(self): + inDir = util.file.get_test_input_path(self) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-runinfo.tar.gz')) as idir: + self.assertRaises(Exception, idir.get_SampleSheet) + with illumina.IlluminaDirectory(os.path.join(inDir, 'bcl-samplesheet.tar.gz')) as idir: + self.assertRaises(Exception, idir.get_RunInfo) + + +class TestDifficultSampleNames(TestCaseWithTmp): + + def test_paired_1(self): + inDir = util.file.get_test_input_path(self) + outBam = util.file.mkstempfname('.bam') + outHeader = util.file.mkstempfname('.txt') + sampleSheet = os.path.join(inDir, 'SampleSheet.csv') + runInfo = os.path.join(inDir, 'RunInfo.xml') + fastq = (os.path.join(inDir, 'mebv-0-1_S5_L001_R1_001.fastq.gz'), + os.path.join(inDir, 'mebv-0-1_S5_L001_R2_001.fastq.gz')) + illumina.miseq_fastq_to_bam(outBam, sampleSheet, fastq[0], inFastq2=fastq[1], runInfo=runInfo) + rgs = list(tools.samtools.SamtoolsTool().getReadGroups(outBam).values()) + self.assertEqual(len(rgs), 1) + rgs = rgs[0] + self.assertEqual(rgs.get('ID'), 'AEF96') + self.assertEqual(rgs.get('PL'), 'illumina') + self.assertEqual(rgs.get('PU'), 'AEF96.1.CGTACTAG-CTAAGCCT') + self.assertEqual(rgs.get('LB'), u'GID-14-E021.ldifficult-value+for_-Sénégalsample_name0.1') + self.assertEqual(rgs.get('SM'), u'GID-14-E021') + self.assertEqual(rgs.get('CN'), 'M04004') + self.assertTrue(rgs.get('DT','').startswith('2015-08-2')) + + def test_inline_commas_strings(self): + inDir = util.file.get_test_input_path(self) + samples = illumina.SampleSheet(os.path.join(inDir, 'SampleSheet-inline-commas-strings.csv')) + self.assertEqual(samples.num_indexes(), 2) + self.assertEqual(len(samples.get_rows()), 18) + + sample_names = [r[""sample""] for r in samples.get_rows()] + names_to_validate = [ + 'Zika ""seedstock_1 (in K562, 5ng)', + ""Zika 'seedstock_3 (in K562, 5ng)"", + ""Zika seedstock_7 (in K562, 10pg)"" + ] + for sample_name in names_to_validate: + assert util.file.string_to_file_name(sample_name) in sample_names + + +class TestIlluminaBarcodeHelper(TestCaseWithTmp): + def test_one_correction(self): + dir_prefix = ""one_correction"" + in_dir = util.file.get_test_input_path(self) + in_barcodes = os.path.join(in_dir,dir_prefix,""barcodes.txt"") + in_metrics = os.path.join(in_dir,dir_prefix,""metrics.txt"") + out_report = util.file.mkstempfname('.txt') + expected = os.path.join(in_dir,dir_prefix,""expected.txt"") + + args = [in_barcodes, in_metrics, out_report] + args = illumina.parser_guess_barcodes(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + + self.assertEqualContents(out_report, expected) + + def test_ambiguous(self): + dir_prefix = ""ambiguous"" + in_dir = util.file.get_test_input_path(self) + in_barcodes = os.path.join(in_dir,dir_prefix,""barcodes.txt"") + in_metrics = os.path.join(in_dir,dir_prefix,""metrics.txt"") + out_report = util.file.mkstempfname('.txt') + expected = os.path.join(in_dir,dir_prefix,""expected.txt"") + + args = [in_barcodes, in_metrics, out_report] + args = illumina.parser_guess_barcodes(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + + self.assertEqualContents(out_report, expected) + + def test_single_index_run(self): + dir_prefix = ""single_index"" + in_dir = util.file.get_test_input_path(self) + in_barcodes = os.path.join(in_dir,dir_prefix,""barcodes.txt"") + in_metrics = os.path.join(in_dir,dir_prefix,""metrics.txt"") + out_report = util.file.mkstempfname('.txt') + expected = os.path.join(in_dir,dir_prefix,""expected.txt"") + + args = [in_barcodes, in_metrics, out_report] + args = illumina.parser_guess_barcodes(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + + self.assertEqualContents(out_report, expected) + + def test_few_assigned(self): + dir_prefix = ""few_assigned"" + in_dir = util.file.get_test_input_path(self) + in_barcodes = os.path.join(in_dir,dir_prefix,""barcodes.txt"") + in_metrics = os.path.join(in_dir,dir_prefix,""metrics.txt"") + out_report = util.file.mkstempfname('.txt') + + self.assertRaises(Exception, illumina.main_guess_barcodes, in_barcodes, in_metrics, out_report) + +class TestMiseqToBam(TestCaseWithTmp): + + def test_paired_1(self): + inDir = util.file.get_test_input_path(self) + outBam = util.file.mkstempfname('.bam') + outHeader = util.file.mkstempfname('.txt') + sampleSheet = os.path.join(inDir, 'SampleSheet.csv') + runInfo = os.path.join(inDir, 'RunInfo.xml') + fastq = (os.path.join(inDir, 'mebv-0-1_S5_L001_R1_001.fastq.gz'), + os.path.join(inDir, 'mebv-0-1_S5_L001_R2_001.fastq.gz')) + illumina.miseq_fastq_to_bam(outBam, sampleSheet, fastq[0], inFastq2=fastq[1], runInfo=runInfo) + rgs = list(tools.samtools.SamtoolsTool().getReadGroups(outBam).values()) + self.assertEqual(len(rgs), 1) + rgs = rgs[0] + self.assertEqual(rgs.get('ID'), 'AEF96') + self.assertEqual(rgs.get('PL'), 'illumina') + self.assertEqual(rgs.get('PU'), 'AEF96.1.CGTACTAG-CTAAGCCT') + self.assertEqual(rgs.get('LB'), 'mebv.0.1') + self.assertEqual(rgs.get('SM'), 'mebv.0.1') + self.assertEqual(rgs.get('CN'), 'M04004') + self.assertTrue(rgs.get('DT','').startswith('2015-08-2')) + + def test_paired_2(self): + inDir = util.file.get_test_input_path(self) + outBam = util.file.mkstempfname('.bam') + outHeader = util.file.mkstempfname('.txt') + sampleSheet = os.path.join(inDir, 'SampleSheet.csv') + runInfo = os.path.join(inDir, 'RunInfo.xml') + fastq = (os.path.join(inDir, 'mebv-48-5_S17_L001_R1_001.fastq.gz'), + os.path.join(inDir, 'mebv-48-5_S17_L001_R2_001.fastq.gz')) + illumina.miseq_fastq_to_bam(outBam, sampleSheet, fastq[0], inFastq2=fastq[1], runInfo=runInfo) + rgs = list(tools.samtools.SamtoolsTool().getReadGroups(outBam).values()) + self.assertEqual(len(rgs), 1) + rgs = rgs[0] + self.assertEqual(rgs.get('ID'), 'AEF96') + self.assertEqual(rgs.get('PL'), 'illumina') + self.assertEqual(rgs.get('PU'), 'AEF96.1.GGACTCCT-TATCCTCT') + self.assertEqual(rgs.get('LB'), 'mebv.48.5') + self.assertEqual(rgs.get('SM'), 'mebv.48.5') + self.assertEqual(rgs.get('CN'), 'M04004') + self.assertTrue(rgs.get('DT','').startswith('2015-08-2')) + + def test_paired_custom_seq_center(self): + inDir = util.file.get_test_input_path(self) + outBam = util.file.mkstempfname('.bam') + outHeader = util.file.mkstempfname('.txt') + sampleSheet = os.path.join(inDir, 'SampleSheet.csv') + runInfo = os.path.join(inDir, 'RunInfo.xml') + fastq = (os.path.join(inDir, 'mebv-48-5_S17_L001_R1_001.fastq.gz'), + os.path.join(inDir, 'mebv-48-5_S17_L001_R2_001.fastq.gz')) + illumina.miseq_fastq_to_bam(outBam, sampleSheet, fastq[0], inFastq2=fastq[1], runInfo=runInfo, sequencing_center='CustomSeqCenter') + rgs = list(tools.samtools.SamtoolsTool().getReadGroups(outBam).values()) + self.assertEqual(len(rgs), 1) + rgs = rgs[0] + self.assertEqual(rgs.get('ID'), 'AEF96') + self.assertEqual(rgs.get('PL'), 'illumina') + self.assertEqual(rgs.get('PU'), 'AEF96.1.GGACTCCT-TATCCTCT') + self.assertEqual(rgs.get('LB'), 'mebv.48.5') + self.assertEqual(rgs.get('SM'), 'mebv.48.5') + self.assertEqual(rgs.get('CN'), 'CustomSeqCenter') + self.assertTrue(rgs.get('DT','').startswith('2015-08-2')) + + def test_fail_missing_pair(self): + inDir = util.file.get_test_input_path(self) + outBam = util.file.mkstempfname('.bam') + sampleSheet = os.path.join(inDir, 'SampleSheet.csv') + runInfo = os.path.join(inDir, 'RunInfo.xml') + fastq = (os.path.join(inDir, 'mebv-48-5_S17_L001_R1_001.fastq.gz'),) + self.assertRaises(Exception, illumina.miseq_fastq_to_bam, outBam, sampleSheet, fastq[0], runInfo=runInfo) + + def test_fail_backwards_pair(self): + inDir = util.file.get_test_input_path(self) + outBam = util.file.mkstempfname('.bam') + sampleSheet = os.path.join(inDir, 'SampleSheet.csv') + runInfo = os.path.join(inDir, 'RunInfo.xml') + fastq = (os.path.join(inDir, 'mebv-48-5_S17_L001_R2_001.fastq.gz'), + os.path.join(inDir, 'mebv-48-5_S17_L001_R1_001.fastq.gz')) + self.assertRaises(Exception, illumina.miseq_fastq_to_bam, outBam, sampleSheet, fastq[0], fastq2=fastq[1], runInfo=runInfo) + + def test_fail_mismatched_pair(self): + inDir = util.file.get_test_input_path(self) + outBam = util.file.mkstempfname('.bam') + sampleSheet = os.path.join(inDir, 'SampleSheet.csv') + runInfo = os.path.join(inDir, 'RunInfo.xml') + fastq = (os.path.join(inDir, 'mebv-48-5_S16_L001_R1_001.fastq.gz'), + os.path.join(inDir, 'mebv-48-5_S17_L001_R2_001.fastq.gz')) + self.assertRaises(Exception, illumina.miseq_fastq_to_bam, outBam, sampleSheet, fastq[0], fastq2=fastq[1], runInfo=runInfo) + + def test_fail_oob_index(self): + inDir = util.file.get_test_input_path(self) + outBam = util.file.mkstempfname('.bam') + sampleSheet = os.path.join(inDir, 'SampleSheet.csv') + runInfo = os.path.join(inDir, 'RunInfo.xml') + fastq = (os.path.join(inDir, 'mebv-48-5_S33_L001_R1_001.fastq.gz'), + os.path.join(inDir, 'mebv-48-5_S33_L001_R2_001.fastq.gz')) + self.assertRaises(Exception, illumina.miseq_fastq_to_bam, outBam, sampleSheet, fastq[0], fastq2=fastq[1], runInfo=runInfo) + + def test_fail_bad_format(self): + inDir = util.file.get_test_input_path(self) + outBam = util.file.mkstempfname('.bam') + sampleSheet = os.path.join(inDir, 'SampleSheet.csv') + runInfo = os.path.join(inDir, 'RunInfo.xml') + fastq = (os.path.join(inDir, 'mebv-48-5_S17_L001_R1_002.fastq.gz'), + os.path.join(inDir, 'mebv-48-5_S17_L001_R2_002.fastq.gz')) + self.assertRaises(Exception, illumina.miseq_fastq_to_bam, outBam, sampleSheet, fastq[0], fastq2=fastq[1], runInfo=runInfo) + fastq = (os.path.join(inDir, 'mebv-48-5_S17_L002_R1_001.fastq.gz'), + os.path.join(inDir, 'mebv-48-5_S17_L002_R2_001.fastq.gz')) + self.assertRaises(Exception, illumina.miseq_fastq_to_bam, outBam, sampleSheet, fastq[0], fastq2=fastq[1], runInfo=runInfo) + fastq = (os.path.join(inDir, 'mebv-48-5_17_L001_R1_001.fastq.gz'), + os.path.join(inDir, 'mebv-48-5_17_L001_R2_001.fastq.gz')) + self.assertRaises(Exception, illumina.miseq_fastq_to_bam, outBam, sampleSheet, fastq[0], fastq2=fastq[1], runInfo=runInfo) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_megan.py",".py","468","20","# Unit tests for MEGAN + +from builtins import super +import unittest +import tools.megan +from test import TestCaseWithTmp + + +class TestToolMegan(TestCaseWithTmp): + + def setUp(self): + super().setUp() + self.megan = tools.megan.Megan() + self.megan.install() + + # Just a simple test that MEGAN can open/close. + @unittest.skip('Requires installed MEGAN') + def test_megan_runs(self): + self.assertEqual(0, self.megan.execute('quit;\n')[0]) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_file_utils.py",".py","7097","201","# Unit tests for ncbi.py + +__author__ = ""tomkinsc@broadinstitute.org"" + +# built-ins +import os +import sys +import tempfile +import unittest +import argparse +import tarfile +import subprocess + +# third-party +import pytest +from mock import patch + +# module-specific +import file_utils +import util.file +from test import TestCaseWithTmp, assert_equal_contents + + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_func in file_utils.__commands__: + parser = parser_func(argparse.ArgumentParser()) + helpstring = parser.format_help() + +class TestTarballMerger(TestCaseWithTmp): + def setUp(self): + super(TestTarballMerger, self).setUp() + self.input_dir = util.file.get_test_input_path(self) + self.raw_files = [""file{}"".format(x) for x in range(1,5)] + self.input_tgz_files = [os.path.join(self.input_dir, ""compressed-input"", x+"".tar.gz"") for x in self.raw_files] + + def test_simple_merge(self): + """""" + Simple repack test + """""" + temp_dir = tempfile.gettempdir() + out_tarball_file = os.path.join(temp_dir,""out.tar.gz"") + + file_utils.merge_tarballs( out_tarball_file, + self.input_tgz_files + ) + + tb = tarfile.open(out_tarball_file) + tb.extractall(path=temp_dir) + + for i in range(len(self.raw_files)): + inf = os.path.join(self.input_dir,""raw-input"",self.raw_files[i]) + outf = os.path.join(temp_dir,self.raw_files[i]) + + assert_equal_contents(self, inf, outf) + + + def test_merge_with_extract(self): + """""" + Test streaming repack with intermediate extraction to disk + """""" + temp_dir = tempfile.gettempdir() + out_tarball_file = os.path.join(temp_dir,""out.tar.gz"") + out_extracted_path = os.path.join(temp_dir,""extracted"") + + file_utils.merge_tarballs( out_tarball_file, + self.input_tgz_files, + extract_to_disk_path=out_extracted_path + ) + + tb = tarfile.open(out_tarball_file) + tb.extractall(path=temp_dir) + + # inspect merged + for i in range(len(self.raw_files)): + inf = os.path.join(self.input_dir,""raw-input"",self.raw_files[i]) + outf = os.path.join(temp_dir,self.raw_files[i]) + + assert_equal_contents(self, inf, outf) + + # inspect extracted + for i in range(len(self.raw_files)): + inf = os.path.join(self.input_dir,""raw-input"",self.raw_files[i]) + outf = os.path.join(out_extracted_path,self.raw_files[i]) + + assert_equal_contents(self, inf, outf) + + def test_merge_with_extract_repack_from_disk(self): + """""" + Test with repack from disk source after extraction + """""" + temp_dir = tempfile.gettempdir() + out_tarball_file = os.path.join(temp_dir,""out.tar.gz"") + out_extracted_path = os.path.join(temp_dir,""extracted"") + + util.file.repack_tarballs( out_tarball_file, + self.input_tgz_files, + extract_to_disk_path=out_extracted_path, + avoid_disk_roundtrip=False + ) + + tb = tarfile.open(out_tarball_file) + tb.extractall(path=temp_dir) + + # inspect merged + for i in range(len(self.raw_files)): + inf = os.path.join(self.input_dir,""raw-input"",self.raw_files[i]) + outf = os.path.join(temp_dir,self.raw_files[i]) + + assert_equal_contents(self, inf, outf) + + # inspect extracted + for i in range(len(self.raw_files)): + inf = os.path.join(self.input_dir,""raw-input"",self.raw_files[i]) + outf = os.path.join(out_extracted_path,self.raw_files[i]) + + assert_equal_contents(self, inf, outf) + + + def test_piped_in_merge(self): + """""" + Test with streamed input + """""" + temp_dir = tempfile.gettempdir() + out_tarball_file = os.path.join(temp_dir,""out.tar.gz"") + + ps = subprocess.Popen(""cat {files}"".format(files=' '.join(self.input_tgz_files)).split(), stdout=subprocess.PIPE) + with patch('sys.stdin', ps.stdout): + file_utils.merge_tarballs( out_tarball_file, + [""-""], + pipe_hint_in=""gz"" ) + ps.wait() + + tb = tarfile.open(out_tarball_file) + tb.extractall(path=temp_dir) + + for i in range(len(self.raw_files)): + inf = os.path.join(self.input_dir,""raw-input"",self.raw_files[i]) + outf = os.path.join(temp_dir,self.raw_files[i]) + + assert_equal_contents(self, inf, outf) + + @pytest.fixture(autouse=True) + def capsys(self, capsys): + self.capsys = capsys + + def test_piped_out_merge(self): + """""" + Test with streamed output + """""" + temp_dir = tempfile.gettempdir() + out_tarball_file = os.path.join(temp_dir,""out.tar.gz"") + + with open(out_tarball_file, ""wb"", 0) as outf: + # temporarily disable pytest's capture of sys.stdout + with self.capsys.disabled(): + with patch('sys.stdout', outf): + file_utils.merge_tarballs( ""-"", + self.input_tgz_files, + pipe_hint_out=""gz"" ) + + tb = tarfile.open(out_tarball_file) + tb.extractall(path=temp_dir) + + for i in range(len(self.raw_files)): + inf = os.path.join(self.input_dir,""raw-input"",self.raw_files[i]) + outf = os.path.join(temp_dir,self.raw_files[i]) + + assert_equal_contents(self, inf, outf) + + def test_merge_piped_in_and_out(self): + """""" + Test with streamed input and output + """""" + temp_dir = tempfile.gettempdir() + + out_tarball_file = os.path.join(temp_dir,""out.tar.gz"") + + ps = subprocess.Popen(""cat {files}"".format(files=' '.join(self.input_tgz_files)).split(), stdout=subprocess.PIPE) + with patch('sys.stdin', ps.stdout): + with open(out_tarball_file, ""wb"", 0) as outf: + # temporarily disable pytest's capture of sys.stdout + with self.capsys.disabled(): + with patch('sys.stdout', outf): + file_utils.merge_tarballs( ""-"", + [""-""], + pipe_hint_out=""gz"", + pipe_hint_in=""gz"" ) + ps.wait() + + tb = tarfile.open(out_tarball_file) + tb.extractall(path=temp_dir) + + for i in range(len(self.raw_files)): + inf = os.path.join(self.input_dir,""raw-input"",self.raw_files[i]) + outf = os.path.join(temp_dir,self.raw_files[i]) + + assert_equal_contents(self, inf, outf) + +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_read_utils.py",".py","14856","334","# Unit tests for read_utils.py + +__author__ = ""irwin@broadinstitute.org"" + +import unittest +import argparse +import filecmp +import os +import glob + +import read_utils +import shutil +import tempfile +import tools +import tools.bwa +import tools.samtools +import util +import util.file +from test import TestCaseWithTmp, assert_equal_bam_reads + + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_fun in read_utils.__commands__: + parser = parser_fun(argparse.ArgumentParser()) + helpstring = parser.format_help() + + +class TestPurgeUnmated(TestCaseWithTmp): + + def test_purge_unmated(self): + myInputDir = util.file.get_test_input_path(self) + inFastq1 = os.path.join(myInputDir, 'in1.fastq') + inFastq2 = os.path.join(myInputDir, 'in2.fastq') + outFastq1 = util.file.mkstempfname('.fastq') + outFastq2 = util.file.mkstempfname('.fastq') + parser = read_utils.parser_purge_unmated(argparse.ArgumentParser()) + args = parser.parse_args([inFastq1, inFastq2, outFastq1, outFastq2]) + args.func_main(args) + + # Check that results match expected + expected1Fastq = os.path.join(myInputDir, 'expected1.fastq') + expected2Fastq = os.path.join(myInputDir, 'expected2.fastq') + self.assertEqualContents(outFastq1, expected1Fastq) + self.assertEqualContents(outFastq2, expected2Fastq) + + # test on FASTQs with read IDs in the style of SRA fastq-dump + def test_purge_unmated_sra(self): + myInputDir = util.file.get_test_input_path(self) + inFastq1 = os.path.join(myInputDir, 'in_sra1.fastq') + inFastq2 = os.path.join(myInputDir, 'in_sra2.fastq') + outFastq1 = util.file.mkstempfname('.fastq') + outFastq2 = util.file.mkstempfname('.fastq') + parser = read_utils.parser_purge_unmated(argparse.ArgumentParser()) + args = parser.parse_args(['--regex', r'^@(\S+).[1|2] .*', inFastq1, inFastq2, outFastq1, outFastq2]) + args.func_main(args) + + # The expected outputs are identical to the previous case. + expected1Fastq = os.path.join(myInputDir, 'expected1.fastq') + expected2Fastq = os.path.join(myInputDir, 'expected2.fastq') + self.assertEqualContents(outFastq1, expected1Fastq) + self.assertEqualContents(outFastq2, expected2Fastq) + + +class TestBwamemIdxstats(TestCaseWithTmp): + + def setUp(self): + TestCaseWithTmp.setUp(self) + self.tempDir = tempfile.mkdtemp() + self.ebolaRef = util.file.mkstempfname('.fasta', directory=self.tempDir) + shutil.copyfile(os.path.join(util.file.get_test_input_path(), 'G5012.3.fasta'), self.ebolaRef) + self.bwa = tools.bwa.Bwa() + self.samtools = tools.samtools.SamtoolsTool() + self.bwa.index(self.ebolaRef) + + def test_bwamem_idxstats(self): + inBam = os.path.join(util.file.get_test_input_path(), 'G5012.3.testreads.bam') + outBam = util.file.mkstempfname('.bam', directory=self.tempDir) + outStats = util.file.mkstempfname('.stats.txt', directory=self.tempDir) + read_utils.bwamem_idxstats(inBam, self.ebolaRef, outBam, outStats) + with open(outStats, 'rt') as inf: + actual_count = int(inf.readline().strip().split('\t')[2]) + self.assertEqual(actual_count, self.samtools.count(outBam, opts=['-F', '4'])) + self.assertGreater(actual_count, 18000) + + def test_bwamem_idxstats_no_bam_output(self): + inBam = os.path.join(util.file.get_test_input_path(), 'G5012.3.testreads.bam') + outStats = util.file.mkstempfname('.stats.txt', directory=self.tempDir) + read_utils.bwamem_idxstats(inBam, self.ebolaRef, None, outStats) + with open(outStats, 'rt') as inf: + actual_count = int(inf.readline().strip().split('\t')[2]) + self.assertGreater(actual_count, 18000) + + +class TestFastqBam(TestCaseWithTmp): + 'Class for testing fastq <-> bam conversions' + + def test_fastq_bam(self): + myInputDir = util.file.get_test_input_path(self) + + # Define file names + inFastq1 = os.path.join(myInputDir, 'in1.fastq') + inFastq2 = os.path.join(myInputDir, 'in2.fastq') + inHeader = os.path.join(myInputDir, 'inHeader.txt') + expected1_7Sam = os.path.join(myInputDir, 'expected.java1_7.sam') + expected1_8Sam = os.path.join(myInputDir, 'expected.java1_8.sam') + expected1_8Sam_v15 = os.path.join(myInputDir, 'expected.java1_8_v1.5.sam') + expectedFastq1 = os.path.join(myInputDir, 'expected.fastq1') + outBamCmd = util.file.mkstempfname('.bam') + outBamTxt = util.file.mkstempfname('.bam') + outSam = util.file.mkstempfname('.sam') + outFastq1 = util.file.mkstempfname('.fastq') + outFastq2 = util.file.mkstempfname('.fastq') + outHeader = util.file.mkstempfname('.txt') + outHeaderFix = util.file.mkstempfname('.fix.txt') + + # in1.fastq, in2.fastq -> out.bam; header params from command-line + parser = read_utils.parser_fastq_to_bam(argparse.ArgumentParser()) + args = parser.parse_args([inFastq1, + inFastq2, + outBamCmd, + '--sampleName', + 'FreeSample', + '--JVMmemory', + '1g', + '--picardOptions', + 'LIBRARY_NAME=Alexandria', + 'PLATFORM=9.75', + 'SEQUENCING_CENTER=KareemAbdul-Jabbar',]) + args.func_main(args) + + alternate_expected_vals = { + ""VN"":[""1.4"",""1.5"",""1.6"",""1.7""] + } + self.assertEqualSamHeaders(outBamCmd, expected1_7Sam, other_allowed_values=alternate_expected_vals) + assert_equal_bam_reads(self, outBamCmd, expected1_7Sam) + + parser = read_utils.parser_fastq_to_bam(argparse.ArgumentParser()) + args = parser.parse_args([inFastq1, inFastq2, outBamTxt, '--header', inHeader]) + args.func_main(args) + + +class TestRmdupUnaligned(TestCaseWithTmp): + def test_mvicuna_canned_input(self): + samtools = tools.samtools.SamtoolsTool() + + input_bam = os.path.join(util.file.get_test_input_path(self), 'input.bam') + expected_bam = os.path.join(util.file.get_test_input_path(self), 'expected.bam') + output_bam = util.file.mkstempfname(""output.bam"") + read_utils.rmdup_mvicuna_bam( + input_bam, + output_bam + ) + + self.assertEqual(samtools.count(output_bam), samtools.count(expected_bam)) + + def test_mvicuna_empty_input(self): + samtools = tools.samtools.SamtoolsTool() + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + output_bam = util.file.mkstempfname(""output.bam"") + read_utils.rmdup_mvicuna_bam( + empty_bam, + output_bam + ) + self.assertEqual(samtools.count(output_bam), 0) + + def test_cdhit_canned_input(self): + samtools = tools.samtools.SamtoolsTool() + + input_bam = os.path.join(util.file.get_test_input_path(self), 'input.bam') + expected_bam = os.path.join(util.file.get_test_input_path(self), 'expected.bam') + output_bam = util.file.mkstempfname(""output.bam"") + read_utils.rmdup_cdhit_bam( + input_bam, + output_bam + ) + + self.assertEqual(samtools.count(output_bam), 1772) + + def test_cdhit_empty_input(self): + samtools = tools.samtools.SamtoolsTool() + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + output_bam = util.file.mkstempfname(""output.bam"") + read_utils.rmdup_cdhit_bam( + empty_bam, + output_bam + ) + self.assertEqual(samtools.count(output_bam), 0) + + +class TestMvicuna(TestCaseWithTmp): + """""" + Input consists of 3 read pairs. + Second read pair is identical to first. + Third read pair has same 5' read as first, but different 3' read. + What Mvicuna did was create paired output files in which the 2nd read + was deleted. It created an empty unpaired output file. Although + it initially created the postDupRm pair, it renamed them to the output + pair. + [IJ:]I have no idea if this is the correct behavior, but test checks that it + doesn't change. + """""" + + def test_mvicuna(self): + tempDir = tempfile.mkdtemp() + myInputDir = util.file.get_test_input_path(self) + + # Run mvicuna + inFastq1 = os.path.join(myInputDir, 'in.1.fastq') + inFastq2 = os.path.join(myInputDir, 'in.2.fastq') + pairedOutFastq1 = os.path.join(tempDir, 'pairedOut.1.fastq') + pairedOutFastq2 = os.path.join(tempDir, 'pairedOut.2.fastq') + unpairedOutFastq = os.path.join(tempDir, 'unpairedOut.fastq') + tools.mvicuna.MvicunaTool().rmdup( + (inFastq1, inFastq2), (pairedOutFastq1, pairedOutFastq2), + outUnpaired=unpairedOutFastq) + + # Compare to expected + for filename in ['pairedOut.1.fastq', 'pairedOut.2.fastq', 'unpairedOut.fastq']: + self.assertEqualContents(os.path.join(tempDir, filename), os.path.join(myInputDir, 'expected_' + filename)) + + + +class TestAlignAndFix(TestCaseWithTmp): + def setUp(self): + super(TestAlignAndFix, self).setUp() + orig_ref = os.path.join(util.file.get_test_input_path(), 'ebov-makona.fasta') + self.refFasta = util.file.mkstempfname('.ref.fasta') + shutil.copyfile(orig_ref, self.refFasta) + + def test_novoalign(self): + self.simple_execution('novoalign') + + def test_bwa(self): + self.simple_execution('bwa') + + def simple_execution(self, aligner): + inBam = os.path.join(util.file.get_test_input_path(), 'G5012.3.mini.bam') + outBamAll = util.file.mkstempfname('.outBamAll.bam') + outBamFiltered = util.file.mkstempfname('.outBamFiltered.bam') + + args = read_utils.parser_align_and_fix(argparse.ArgumentParser()).parse_args( + [inBam, self.refFasta, '--outBamAll', outBamAll, '--outBamFiltered', outBamFiltered, '--aligner', aligner]) + args.func_main(args) + +class TestDownsampleBams(TestCaseWithTmp): + def setUp(self): + super(TestDownsampleBams, self).setUp() + orig_larger_bam = os.path.join(util.file.get_test_input_path(), 'G5012.3.testreads.bam') + orig_smaller_bam = os.path.join(util.file.get_test_input_path(), 'G5012.3.mini.bam') + orig_with_dup = os.path.join(util.file.get_test_input_path(), 'TestRmdupUnaligned','input.bam') + self.larger_bam = util.file.mkstempfname('.larger.bam') + self.smaller_bam = util.file.mkstempfname('.smaller.bam') + self.with_dups = util.file.mkstempfname('.with_dups.bam') + shutil.copyfile(orig_larger_bam, self.larger_bam) + shutil.copyfile(orig_smaller_bam, self.smaller_bam) + shutil.copyfile(orig_with_dup, self.with_dups) + + self.samtools = tools.samtools.SamtoolsTool() + + def test_normalization_to_lowest_cardinality(self): + """""" Also tests subdir output """""" + temp_dir = tempfile.mkdtemp() + + target_count = self.samtools.count(self.smaller_bam) + # target count not passed in since we are checking that the count of the smaller file is used + read_utils.main_downsample_bams([self.larger_bam, self.smaller_bam], temp_dir, JVMmemory=""1g"") + + output_bams = list(glob.glob(os.path.join(temp_dir, '*.bam'))) + + self.assertGreater(len(output_bams), 0, msg=""No output found"") + for out_bam in output_bams: + self.assertAlmostEqual(self.samtools.count(out_bam), target_count, delta=10, msg=""{} not downsampled to the target size: {}"".format(os.path.basename(out_bam),target_count)) + + def test_downsample_to_target_count(self): + """""" Also tests subdir output """""" + temp_dir = tempfile.mkdtemp() + + target_count = 4000 + read_utils.main_downsample_bams([self.larger_bam, self.smaller_bam], temp_dir, specified_read_count=target_count, JVMmemory=""1g"") + + output_bams = list(glob.glob(os.path.join(temp_dir, '*.bam'))) + + self.assertGreater(len(output_bams), 0, msg=""No output found"") + for out_bam in output_bams: + self.assertAlmostEqual(self.samtools.count(out_bam), target_count, delta=10, msg=""{} not downsampled to the target size: {}"".format(os.path.basename(out_bam),target_count)) + + def test_downsample_to_target_count_without_subdir(self): + target_count = 4000 + read_utils.main_downsample_bams([self.larger_bam], out_path=None, specified_read_count=target_count, JVMmemory=""1g"") + + output_bams = list(glob.glob(os.path.join(os.path.dirname(self.larger_bam), '*downsampled-*.bam'))) + + print(output_bams) + self.assertGreater(len(output_bams), 0, msg=""No output files matching *downsampled-*.bam found"") + for out_bam in output_bams: + self.assertAlmostEqual(self.samtools.count(out_bam), target_count, delta=10, msg=""{} not downsampled to the target size: {}"".format(os.path.basename(out_bam),target_count)) + + def test_downsample_with_dedup_after(self): + """""" Also tests subdir output """""" + temp_dir = tempfile.mkdtemp() + + target_count = 1500 + read_utils.main_downsample_bams([self.with_dups], temp_dir, deduplicate_after=True, specified_read_count=target_count, JVMmemory=""1g"") + + output_bams = list(glob.glob(os.path.join(temp_dir, '*.bam'))) + + self.assertGreater(len(output_bams), 0, msg=""No output found"") + for out_bam in output_bams: + self.assertLess(self.samtools.count(out_bam), target_count, msg=""{} not downsampled to the target size: {}"".format(os.path.basename(out_bam),target_count)) + + def test_downsample_with_dedup_before(self): + """""" Also tests subdir output """""" + temp_dir = tempfile.mkdtemp() + + target_count = 1500 + read_utils.main_downsample_bams([self.with_dups], temp_dir, deduplicate_before=True, specified_read_count=target_count, JVMmemory=""1g"") + + output_bams = list(glob.glob(os.path.join(temp_dir, '*.bam'))) + + self.assertGreater(len(output_bams), 0, msg=""No output found"") + for out_bam in output_bams: + self.assertAlmostEqual(self.samtools.count(out_bam), target_count, delta=10, msg=""{} not downsampled to the target size: {}"".format(os.path.basename(out_bam),target_count)) + + def test_downsample_to_too_large_target_count(self): + """""" Should fail """""" + temp_dir = tempfile.mkdtemp() + + target_count = 20000 + + with self.assertRaises(ValueError): + read_utils.main_downsample_bams([self.larger_bam, self.smaller_bam], temp_dir, specified_read_count=target_count, JVMmemory=""1g"") +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools.py",".py","461","23","# Unit tests for tools/__init__.py + +__author__ = ""yesimon@broadinstitute.org"" + +import pytest +import tools +from tools import * + +# Simply do nothing to override stub_conda in conftest.py +@pytest.fixture(autouse=True) +def stub_conda(): + pass + +@pytest.fixture(params=tools.all_tool_classes()) +def tool_class(request): + return request.param + +@pytest.mark.slow +def test_tool_install(tool_class): + t = tool_class() + t.install() + assert t.is_installed() +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_conftest.py",".py","1783","43","""""""Unit tests for pytest customizations"""""" + +import sys +import os +import os.path +import functools +import pytest + +import util.misc +from util.file import slurp_file, get_test_input_path + + +def test_monkeypatch_function_result(monkeypatch_function_result): + assert list(util.misc.unique([])) == [] + with monkeypatch_function_result(util.misc.unique, [], patch_result=[1]): + assert list(util.misc.unique([])) == [1] + assert list(util.misc.unique([2,1,2])) == [2, 1] + assert list(util.misc.unique([])) == [] + + inp = functools.partial(os.path.join, get_test_input_path()) + + with pytest.raises(Exception): + slurp_file('/some/file') + + with monkeypatch_function_result(slurp_file, '/some/file', patch_result='some_content', + patch_module=sys.modules[__name__]): + assert slurp_file('/some/file') == 'some_content' + assert slurp_file(inp('ebov-makona.fasta')).startswith('>KJ660346.2') + with monkeypatch_function_result(slurp_file, inp('ebov-makona.fasta'), patch_result='something_else', + patch_module=sys.modules[__name__]): + assert slurp_file('/some/file') == 'some_content' + assert slurp_file(inp('ebov-makona.fasta')) == 'something_else' + assert slurp_file(inp('ebov-makona.fasta')).startswith('>KJ660346.2') + + with monkeypatch_function_result(slurp_file, inp('ebov-makona.fasta'), patch_exception=RuntimeError(), + patch_module=sys.modules[__name__]): + with pytest.raises(Exception): + slurp_file(inp('ebov-makona.fasta')) + assert slurp_file('/some/file') == 'some_content' + + with pytest.raises(Exception): + slurp_file('/some/file') +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_bbmap.py",".py","1001","32","# Unit tests for bbmap aligner and related tools + +__author__ = ""ilya@broadinstitute.org"" + +import unittest +import os.path +import shutil +import util.file +import tools.bbmap +import tools.samtools +import pysam +from test import TestCaseWithTmp, assert_md5_equal_to_line_in_file + + +class TestToolBBMap(TestCaseWithTmp): + + def setUp(self): + super(TestToolBBMap, self).setUp() + self.bbmap = tools.bbmap.BBMapTool() + self.bbmap.install() + self.samtools = tools.samtools.SamtoolsTool() + + def test_align(self): + orig_ref = os.path.join(util.file.get_test_input_path(), 'ebola.fasta') + inRef = util.file.mkstempfname('.fasta') + shutil.copyfile(orig_ref, inRef) + reads = os.path.join(util.file.get_test_input_path(self), 'ebov_reads.bam') + outBam = util.file.mkstempfname('.bam') + self.bbmap.align(inBam=reads, refFasta=inRef, outBam=outBam) + self.assertTrue(os.path.isfile(outBam)) + self.assertTrue(os.path.getsize(outBam)) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_util_file.py",".py","3816","105","# Unit tests for util.file.py + +__author__ = ""ilya@broadinstitute.org"" + +import os, os.path +import builtins +import util.file +import pytest + +def testTempFiles(): + '''Test creation of tempfiles using context managers, as well as dump_file/slurp_file routines''' + tmp_fns = [] + sfx='tmp-file-test' + with util.file.tempfname(sfx) as my_tmp_fn: + tmp_dir_listing = os.listdir( os.path.dirname( my_tmp_fn ) ) + assert os.path.basename( my_tmp_fn ) in tmp_dir_listing + + with util.file.tempfnames((sfx+'-A',sfx+'-B')) as my_tmp_fns: + + assert len(my_tmp_fns)==2 + for fn in my_tmp_fns: + assert os.path.dirname(fn) == os.path.dirname(my_tmp_fn) + assert os.path.basename(fn) not in tmp_dir_listing + + for fn in my_tmp_fns: + + assert sfx in fn + assert os.path.isfile(fn) + assert os.path.getsize(fn)==0 + assert os.access(fn, os.R_OK | os.W_OK) + + fileValue='my\ntest\ndata\n' + fn + '\n' + util.file.dump_file( fname=fn, value=fileValue ) + assert os.path.isfile(fn) + assert os.path.getsize(fn) == len(fileValue) + assert util.file.slurp_file(fn) == fileValue + + util.file.make_empty(fn) + assert os.path.getsize(fn)==0 + + tmp_fns.append(fn) + + assert os.path.isfile(my_tmp_fn) and not os.path.isfile(my_tmp_fns[0]) and not os.path.isfile(my_tmp_fns[1]) + + largeString = 'A' * (2*1024*1024) + util.file.dump_file(fname=my_tmp_fn, value=largeString) + with pytest.raises(RuntimeError): + util.file.slurp_file(my_tmp_fn, maxSizeMb=1) + + assert not os.path.isfile(my_tmp_fn) + +def test_check_paths(tmpdir): + '''Test the util.file.check_paths()''' + from os.path import join + from util.file import check_paths + inDir = util.file.get_test_input_path() + def test_f(f): + return join(inDir, f) + check_paths(read=test_f('empty.bam')) + check_paths(read=[test_f('empty.bam')]) + with pytest.raises(Exception): + check_paths(read=test_f('non_existent_file')) + with pytest.raises(Exception): + check_paths(write='/non/writable/dir/file.txt') + writable_dir = str(tmpdir) + check_paths(write=(join(writable_dir, 'mydata1.txt'), + join(writable_dir, 'mydata2.txt'))) + with pytest.raises(Exception): + check_paths(write=writable_dir) + + util.file.make_empty(join(writable_dir, 'myempty.dat')) + check_paths(read_and_write=join(writable_dir, 'myempty.dat')) + +def test_uncompressed_file_type(): + """"""Test util.file.uncompressed_file_type()"""""" + uft = util.file.uncompressed_file_type + assert uft('test.fasta.gz') == '.fasta' + assert uft('test.fasta.bz2') == '.fasta' + assert uft('test.fasta') == '.fasta' + assert uft('test.gz') == '' + + assert uft('/tmp/test.fasta.gz') == '.fasta' + assert uft('/test/dir/test.fasta.bz2') == '.fasta' + assert uft('/a/b/c/test.fasta') == '.fasta' + assert uft('/a/test.gz') == '' + +def test_string_to_file_name(): + """"""Test util.file.string_to_file_name()"""""" + + unichr = getattr(builtins, 'unichr', chr) + + test_fnames = ( + 'simple', 'simple.dat', 'a/b', '/a', '/a/b', '/a/b/', 'a\\b', + 'a^b&c|d"" e::f!g;*?`test`', '(somecmd -f --flag < input > output) && ls', + 'long' * 8000, 'oddchars\\xAA\\o037', + ''.join(map(chr, range(128))) * 20, + ''.join(map(unichr, range(1000))), + ) + + with util.file.tmp_dir() as tmp_d: + for test_fname in test_fnames: + t_path = os.path.join(tmp_d, util.file.string_to_file_name(test_fname, tmp_d)) + util.file.make_empty(t_path) + assert os.path.isfile(t_path) and os.path.getsize(t_path) == 0 +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_util_misc.py",".py","11323","299","# Unit tests for util.misc.py + +__author__ = ""dpark@broadinstitute.org"" + +import os, random, collections +import unittest +import subprocess +import util.misc +import util.file +import pytest + + +class TestRunAndPrint(unittest.TestCase): + + def testBasicRunSuccess(self): + util.misc.run_and_print(['cat', '/dev/null'], + silent=False, buffered=False, check=False) + util.misc.run_and_print(['cat', '/dev/null'], + silent=False, buffered=False, check=True) + util.misc.run_and_print(['cat', '/dev/null'], + silent=True, buffered=False, check=False) + util.misc.run_and_print(['cat', '/dev/null'], + silent=True, buffered=False, check=True) + util.misc.run_and_print(['cat', '/dev/null'], + silent=False, buffered=True, check=False) + util.misc.run_and_print(['cat', '/dev/null'], + silent=False, buffered=True, check=True) + util.misc.run_and_print(['cat', '/dev/null'], + silent=True, buffered=True, check=False) + util.misc.run_and_print(['cat', '/dev/null'], + silent=True, buffered=True, check=True) + + def testBasicRunFailDontCare(self): + util.misc.run_and_print(['cat', '/notdev/notnull'], + silent=False, buffered=False, check=False) + util.misc.run_and_print(['cat', '/notdev/notnull'], + silent=True, buffered=False, check=False) + util.misc.run_and_print(['cat', '/notdev/notnull'], + silent=False, buffered=True, check=False) + util.misc.run_and_print(['cat', '/notdev/notnull'], + silent=True, buffered=True, check=False) + + def testBasicRunFailAndCatch(self): + self.assertRaises(subprocess.CalledProcessError, + util.misc.run_and_print, ['cat', '/notdev/notnull'], + silent=False, buffered=False, check=True) + self.assertRaises(subprocess.CalledProcessError, + util.misc.run_and_print, ['cat', '/notdev/notnull'], + silent=False, buffered=True, check=True) + self.assertRaises(subprocess.CalledProcessError, + util.misc.run_and_print, ['cat', '/notdev/notnull'], + silent=True, buffered=False, check=True) + self.assertRaises(subprocess.CalledProcessError, + util.misc.run_and_print, ['cat', '/notdev/notnull'], + silent=True, buffered=True, check=True) + + +class TestFeatureSorter(unittest.TestCase): + + def testBasicSortingWithOverlap(self): + fs = util.misc.FeatureSorter(( + ('abca', 10, 20), + ('abca', 25, 35), + ('abca', 15, 30), + )) + self.assertEqual( + list(fs.get_features()), + [ + ('abca', 10, 20, '+', None), + ('abca', 15, 30, '+', None), + ('abca', 25, 35, '+', None), + ] + ) + + def testBasicIntervalsWithOverlap(self): + fs = util.misc.FeatureSorter(( + ('abca', 10, 20), + ('abca', 25, 35), + ('abca', 15, 30), + )) + self.assertEqual( + list(fs.get_intervals()), + [ + ('abca', 10, 14, 1, [('abca', 10, 20, '+', None),]), + ('abca', 15, 20, 2, [('abca', 10, 20, '+', None),('abca', 15, 30, '+', None),]), + ('abca', 21, 24, 1, [('abca', 15, 30, '+', None),]), + ('abca', 25, 30, 2, [('abca', 15, 30, '+', None),('abca', 25, 35, '+', None),]), + ('abca', 31, 35, 1, [('abca', 25, 35, '+', None),]), + ] + ) + + def testDisjointAndOverlappingIntervals(self): + fs = util.misc.FeatureSorter(( + ('abca', 10, 20), + ('abca', 80, 90, '+', None), + ('abca', 25, 35, '-'), + ('abca', 15, 30), + )) + self.assertEqual( + list(fs.get_intervals()), + [ + ('abca', 10, 14, 1, [('abca', 10, 20, '+', None),]), + ('abca', 15, 20, 2, [('abca', 10, 20, '+', None),('abca', 15, 30, '+', None),]), + ('abca', 21, 24, 1, [('abca', 15, 30, '+', None),]), + ('abca', 25, 30, 2, [('abca', 15, 30, '+', None),('abca', 25, 35, '-', None),]), + ('abca', 31, 35, 1, [('abca', 25, 35, '-', None),]), + ('abca', 36, 79, 0, []), + ('abca', 80, 90, 1, [('abca', 80, 90, '+', None),]), + ] + ) + + def testMultiChrWindowedFeatures(self): + fs = util.misc.FeatureSorter(( + ('abca', 10, 20), + ('aaaa', 17, 33), + ('abca', 80, 90), + ('abca', 25, 35), + ('abca', 15, 30), + )) + self.assertEqual( + list(fs.get_features('abca', 11, 22)), + [ + ('abca', 10, 20, '+', None), + ('abca', 15, 30, '+', None), + ] + ) + + def testOpenWindowRight(self): + fs = util.misc.FeatureSorter(( + ('abca', 10, 20), + ('aaaa', 17, 33), + ('abca', 80, 90), + ('abca', 25, 35), + ('abca', 15, 30), + )) + self.assertEqual( + list(fs.get_features('abca', 22)), + [ + ('abca', 15, 30, '+', None), + ('abca', 25, 35, '+', None), + ('abca', 80, 90, '+', None), + ] + ) + + def testOpenWindowLeft(self): + fs = util.misc.FeatureSorter(( + ('abca', 10, 20), + ('aaaa', 17, 33), + ('abca', 80, 90), + ('abca', 25, 35), + ('abca', 15, 30), + )) + self.assertEqual( + list(fs.get_features('abca', right=18)), + [ + ('abca', 10, 20, '+', None), + ('abca', 15, 30, '+', None), + ] + ) + + def testMultiChrWithPayloadIntervals(self): + fs = util.misc.FeatureSorter(( + ('abca', 10, 20), + ('aaaa', 17, 33, '-', [100, 'name', []]), + ('abca', 80, 90, '+', ['other info']), + ('abca', 25, 35, '-'), + ('abca', 15, 30), + )) + self.assertEqual( + list(fs.get_intervals()), + [ + ('abca', 10, 14, 1, [('abca', 10, 20, '+', None),]), + ('abca', 15, 20, 2, [('abca', 10, 20, '+', None),('abca', 15, 30, '+', None),]), + ('abca', 21, 24, 1, [('abca', 15, 30, '+', None),]), + ('abca', 25, 30, 2, [('abca', 15, 30, '+', None),('abca', 25, 35, '-', None),]), + ('abca', 31, 35, 1, [('abca', 25, 35, '-', None),]), + ('abca', 36, 79, 0, []), + ('abca', 80, 90, 1, [('abca', 80, 90, '+', ['other info']),]), + ('aaaa', 17, 33, 1, [('aaaa', 17, 33, '-', [100, 'name', []]),]), + ] + ) + + +class TestConfigIncludes(unittest.TestCase): + + def testConfigIncludes(self): + + def test_fn(f): return os.path.join(util.file.get_test_input_path(), 'TestUtilMisc', f) + cfg1 = util.misc.load_config(test_fn('cfg1.yaml')) + cfg2 = util.misc.load_config(test_fn('cfg2.yaml'), std_includes=[test_fn('cfg_std.yaml')], + param_renamings={'std_param_A_old': 'std_param_A_new'}) + + self.assertIn('paramA', cfg2) + self.assertEqual(cfg2[""env_vars""][""var_A""],1) + self.assertEqual(cfg2[""env_vars""][""var_B""],3) + self.assertEqual(cfg2[""env_vars""][""var_C""],4) + with self.assertRaises(KeyError): cfg2[""env_vars""][""var_E""] + with self.assertRaises(KeyError): cfg2[""var_A""] + self.assertFalse(cfg2[""paramZ""]) + self.assertTrue(cfg1[""paramZ""]) + self.assertEqual(cfg2[""empty_subtree""][""x""], 1) + + self.assertEqual(cfg2[""std_methods""], ['a','b','c']) + self.assertEqual(cfg2[""stage1""][""stage2""][""step_num""],3) + self.assertEqual(cfg2[""stage1""][""stage2""][""step_list""],[5,10,15]) + self.assertEqual(cfg2[""stage1""][""stage3""][""step_list""],[3,33]) + self.assertEqual(cfg1[""stage1""][""stage3""][""step_list""],[51,101,151]) + + self.assertEqual(cfg2[""std_param_A_new""], 111) # specified as std_param_A_old in cfg1.yaml + + self.assertEqual(util.misc.load_config(test_fn('empty.yaml')), {}) + +def test_as_type(): + """"""Test util.misc.as_type()"""""" + + as_type = util.misc.as_type + + test_data = ( + ('1', int, 1, int), + ('1', (int,), 1, int), + ('1', (int, float), 1, int), + ('1', (float, int), 1., float), + ('1.2', (float, int), 1.2, float), + ('1.2', (int, float), 1.2, float), + (1, int, 1, int), + ('1.', (int, float), 1., float), + (1., int, 1, int), + (1.2, (int, float), 1, int), + ('1e3', (int, float), 1000., float), + ('1e3', (float, int), 1000., float), + ('1.1e3', (int, float), 1100., float), + ('-1.1e3', (float, int), -1100., float), + ) + + for val, types, out_val, out_type in test_data: + result = as_type(val, types) + assert result == out_val + assert type(result) == out_type + + err_data = ( + ('1.', int), ('1.', (int,)), ('1e3', int), ('1e3', (int,)), ([1], int), + ('', int), ('', (int, float)), ('', (float, int)) + ) + + for val, types in err_data: + with pytest.raises(TypeError): + as_type(val, types) + +@pytest.mark.parametrize(""iter_d"", [False, True]) +@pytest.mark.parametrize(""iter_subset"", [False, True]) +def test_subdict(iter_d, iter_subset): + """"""Test util.misc.subdict()"""""" + def subdict(d, subset): + return util.misc.subdict(iter(d.items()) if iter_d else d, + iter(subset) if iter_subset else subset) + + test_data = ( + ({}, {}, {}), + ({1:2}, {}, {}), + ({1:2}, {1}, {1:2}), + ({1:2}, {2}, {}), + ({1:2}, {1,2}, {1:2}), + ({1:2,3:4}, {1,2,3}, {1:2,3:4}), + ({1:2,3:4}, {2,3,5}, {3:4}), + ) + + for d, subset, expected in test_data: + assert subdict(d, subset) == expected + + assert set(subdict(d, subset).keys()) == (set(d.keys()) & set(subset)) + assert subdict(d, {}) == {} + assert subdict(d, d.keys()) == d + assert subdict(d, list(d.keys())*2) == d + +def test_chk(): + chk = util.misc.chk + chk(True, 'no error') + with pytest.raises(RuntimeError): + chk(False) + with pytest.raises(RuntimeError): + chk(2 == 3, 'Something wrong') + with pytest.raises(TypeError): + chk(isinstance(None, int), 'Expected an int', TypeError) + +def test_available_cpu_count(monkeypatch_function_result): + reported_cpu_count = util.misc.available_cpu_count() + + assert reported_cpu_count >= int(os.environ.get('PYTEST_XDIST_WORKER_COUNT', '1')) + + with monkeypatch_function_result(util.file.slurp_file, '/sys/fs/cgroup/cpu/cpu.cfs_quota_us', patch_result='1'), \ + monkeypatch_function_result(util.file.slurp_file, '/sys/fs/cgroup/cpu/cpu.cfs_period_us', patch_result='1'): + assert util.misc.available_cpu_count() == 1 + + assert util.misc.available_cpu_count() == reported_cpu_count + + with monkeypatch_function_result(util.file.slurp_file, '/sys/fs/cgroup/cpu/cpu.cfs_quota_us', patch_result='-1'), \ + monkeypatch_function_result(util.file.slurp_file, '/sys/fs/cgroup/cpu/cpu.cfs_period_us', patch_result='1'): + assert util.misc.available_cpu_count() == reported_cpu_count +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/__init__.py",".py","1","2"," +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_picard.py",".py","2450","65","# Unit tests for tools.PicardTools + +__author__ = ""dpark@broadinstitute.org"" + +import unittest +import re +import os +import tempfile +import shutil +import util +import util.file +import tools +import tools.picard +import tools.samtools +from test import TestCaseWithTmp + + +class TestToolPicard(TestCaseWithTmp): + + def test_fasta_index(self): + orig_ref = os.path.join(util.file.get_test_input_path(self), 'in.fasta') + expected_dict = os.path.join(util.file.get_test_input_path(self), 'in.dict') + picard_index = tools.picard.CreateSequenceDictionaryTool() + with open(expected_dict, 'rt') as inf: + expected_first3 = [x.strip().split('\t')[:3] for x in inf.readlines()] + for ext in ('.fasta', '.fa'): + inRef = util.file.mkstempfname(ext) + shutil.copyfile(orig_ref, inRef) + outDict = inRef[:-len(ext)] + '.dict' + + picard_index.execute(inRef, overwrite=True) + + # the dict files will not be exactly the same, just the first 3 cols + with open(outDict, 'rt') as inf: + # .replace(""VN:1.5"",""VN:1.4"") ==> because the header version may be 1.[4|5|6] + actual_first3 = [re.sub(r'VN:1\.[4-6]','VN:1.4',x.strip()).split('\t')[:3] for x in inf.readlines()] + self.assertEqual(actual_first3, expected_first3) + + def test_sam_downsample(self): + desired_count = 100 + tolerance = 0.02 + + in_sam = os.path.join(util.file.get_test_input_path(), 'G5012.3.subset.bam') + out_bam = util.file.mkstempfname('.bam') + + downsamplesam = tools.picard.DownsampleSamTool() + samtools = tools.samtools.SamtoolsTool() + + downsamplesam.downsample_to_approx_count(in_sam, out_bam, desired_count) + + assert samtools.count(out_bam) in range( + int(desired_count - (desired_count * tolerance)), int(desired_count + (desired_count * tolerance))+1 + ), ""Downsampled bam file does not contain the expected number of reads within tolerance: %s"" % tolerance + + def test_revert_bam_empty_input(self): + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + out_bam = util.file.mkstempfname() + tools.picard.RevertSamTool().execute( + empty_bam, + out_bam, + picardOptions=['SORT_ORDER=queryname', 'SANITIZE=true'] + ) + samtools = tools.samtools.SamtoolsTool() + assert samtools.count(out_bam) == 0 +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_util_vcf.py",".py","7246","179","# Unit tests for util/vcf.py + +__author__ = ""dpark@broadinstitute.org"" + +import util.vcf +import util.file +import unittest +''' +TODO +make_intervals +sliding_windows +calc_maf +TabixReader - edge cases in a simple file +VcfReader - proper one-based genomic coordinates +VcfReader - haploid cases, diploid cases +VcfReader.getFullSequences and replaceAlleles - this needs a whole battery of tests, + since it does so much and is subject to so many edge cases and weird scenarios and + keeps breaking each time we refactor. +''' + + +class StubGenome: + ''' This is a mock genome that should satisfy very simple functions in util.vcf + like get_chrlens, GenomePosition, make_intervals, sliding_windows, etc. + It simply contains a list of chromosome names and lengths. + ''' + + def __init__(self, chromlist): + self.chrs = [c for c, clen in chromlist] + self.chrlen = dict(chromlist) + self.totlen = sum(clen for c, clen in chromlist) + + def chrlens(self): + return [(c, self.chrlen[c]) for c in self.chrs] + + +class TestGenomePosition(unittest.TestCase): + ''' Test the GenomePosition class which maps chr,pos pairs to a single gpos int and vice versa ''' + + def test_fail_OOB_get_gpos(self): + genome = StubGenome([('SDF', 123), ('ASDF', 256), ('lala', 47)]) + invalids = [('SDF', 0), ('SDF', 124), ('ASDF', -1), ('lala', 48), ('lala', 200), ('sdf', 80), ('la', 2), + (None, 3)] + gmap = util.vcf.GenomePosition(genome) + for c, p in invalids: + self.assertRaises(Exception, gmap.get_gpos, c, p) + + def test_fail_OOB_get_chr_pos(self): + genome = StubGenome([('SDF', 123), ('ASDF', 256), ('lala', 47)]) + invalids = [0, -1, genome.totlen + 1, genome.totlen * 2] + gmap = util.vcf.GenomePosition(genome) + for gpos in invalids: + self.assertRaises(Exception, gmap.get_chr_pos, gpos) + + def test_fail_non_int_pos(self): + genome = StubGenome([('SDF', 123), ('ASDF', 256), ('lala', 47)]) + invalids = [('SDF', 5.3), ('lala', '10'), ('ASDF', None)] + gmap = util.vcf.GenomePosition(genome) + for c, p in invalids: + self.assertRaises(Exception, gmap.get_gpos, c, p) + self.assertRaises(Exception, gmap.get_chr_pos, p) + + def test_spotcheck_edges(self): + genome = StubGenome([('SDF', 123), ('ASDF', 256), ('lala', 47)]) + knowns = [('SDF', 1, 1), ('SDF', 123, 123), ('ASDF', 1, 124), ('ASDF', 256, 379), ('lala', 1, 380), + ('lala', 47, 426)] + gmap = util.vcf.GenomePosition(genome) + for c, p, gpos in knowns: + self.assertEqual(gpos, gmap.get_gpos(c, p)) + self.assertEqual((c, p), gmap.get_chr_pos(gpos)) + + def test_equality_1chrGenome(self): + genome = StubGenome([('one chr', 10)]) + c = genome.chrs[0] + gmap = util.vcf.GenomePosition(genome) + for i in range(1, genome.totlen + 1): + self.assertEqual(i, gmap.get_gpos(c, i)) # c,p -> gpos should produce p=gpos + self.assertEqual((c, i), gmap.get_chr_pos(i)) # gpos -> c,p should produce p=gpos + + def test_equality_3chrGenome(self): + genome = StubGenome([('SDF', 123), ('ASDF', 256), ('lala', 47)]) + gmap = util.vcf.GenomePosition(genome) + # test gpos -> c,p -> same gpos + for gpos in range(1, genome.totlen + 1): + c, p = gmap.get_chr_pos(gpos) + gpos2 = gmap.get_gpos(c, p) + self.assertEqual(gpos, gpos2) + # test c,p -> gpos -> same c,p + for c, clen in genome.chrlen.items(): + for p in range(1, clen + 1): + gpos = gmap.get_gpos(c, p) + c2, p2 = gmap.get_chr_pos(gpos) + self.assertEqual(c, c2) + self.assertEqual(p, p2) + + def test_gpos_inbounds(self): + genome = StubGenome([('SDF', 123), ('ASDF', 256), ('lala', 47)]) + gmap = util.vcf.GenomePosition(genome) + for c, clen in genome.chrlen.items(): + for p in range(1, clen + 1): + gpos = gmap.get_gpos(c, p) + self.assertIsNotNone(gpos) + self.assertIsInstance(gpos, int) + self.assertLessEqual(1, gpos) + self.assertLessEqual(gpos, genome.totlen) + + def test_chr_pos_inbounds(self): + genome = StubGenome([('SDF', 123), ('ASDF', 256), ('lala', 47)]) + gmap = util.vcf.GenomePosition(genome) + for gpos in range(1, genome.totlen + 1): + c, p = gmap.get_chr_pos(gpos) + self.assertIsNotNone(c) + self.assertIn(c, genome.chrlen) + self.assertIsNotNone(p) + self.assertIsInstance(p, int) + self.assertLessEqual(1, p) + self.assertLessEqual(p, genome.chrlen[c]) + + def test_unique_gpos(self): + genome = StubGenome([('SDF', 123), ('ASDF', 256), ('lala', 47)]) + gmap = util.vcf.GenomePosition(genome) + seen = set() + for c, clen in genome.chrlen.items(): + for p in range(1, clen + 1): + gpos = gmap.get_gpos(c, p) + self.assertNotIn(gpos, seen) + seen.add(gpos) + self.assertEqual(len(seen), genome.totlen) + + def test_unique_chr_pos(self): + genome = StubGenome([('SDF', 123), ('ASDF', 256), ('lala', 47)]) + gmap = util.vcf.GenomePosition(genome) + seen = set() + for gpos in range(1, genome.totlen + 1): + c, p = gmap.get_chr_pos(gpos) + self.assertNotIn((c, p), seen) + seen.add((c, p)) + self.assertEqual(len(seen), genome.totlen) + + +class TestVcfReaderPositions(unittest.TestCase): + ''' Test the OBO errors in the pysam-based VCFReader class (it's prone to such errors) ''' + + def setUp(self): + self.vcf_fname = util.file.get_test_path() + '/input/one_gene.vcf.gz' + self.vcf_window = ('Pf3D7_13_v3', 1724817, 1726997) + try: + self.basestring = basestring + except NameError: + self.basestring = str + + def test_sample_names(self): + expected = ['3D7', 'SenT001.08', 'SenT001.11', 'SenT002.07', 'SenT002.09'] + vcfdb = util.vcf.VcfReader(self.vcf_fname) + self.assertEqual(expected, vcfdb.samples()) + for s in vcfdb.samples(): + self.assertIsInstance(s, self.basestring) + + def test_get_one_base(self): + vcfdb = util.vcf.VcfReader(self.vcf_fname) + genos = vcfdb.get_snp_genos(self.vcf_window[0], 1726432) + alleles = [genos[s] for s in vcfdb.samples()] + expected = ['T', 'T', 'T', 'G', 'T'] + self.assertEqual(expected, alleles) + for a in alleles: + self.assertIsInstance(a, self.basestring) + + def test_get_positions_edges(self): + vcfdb = util.vcf.VcfReader(self.vcf_fname) + out = list(vcfdb.get_positions(self.vcf_window[0])) + self.assertEqual(out[0][1], self.vcf_window[1]) + self.assertEqual(out[-1][2], self.vcf_window[2]) + + def test_get_range_edges(self): + vcfdb = util.vcf.VcfReader(self.vcf_fname) + out = [p for c, p, alleles, genos in vcfdb.get_range(self.vcf_window[0])] + self.assertEqual(out[0], self.vcf_window[1]) + self.assertEqual(out[-1], self.vcf_window[2]) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_vphaser2.py",".py","1878","46","# Unit tests for vphaser tool + +__author__ = ""irwin@broadinstitute.org"" + +import os +import pickle +import unittest +import util.file +import tools +from intrahost import vphaser_main +from test import TestCaseWithTmp, _CPUS + + +#@unittest.skipIf(tools.is_osx(), ""vphaser2 osx binary from bioconda has issues"") +class TestVPhaser2(TestCaseWithTmp): + + def test_vphaser2(self): + myInputDir = util.file.get_test_input_path(self) + inBam = os.path.join(myInputDir, 'in.bam') + outTab = util.file.mkstempfname('.txt') + vphaser_main(inBam, outTab, numThreads=_CPUS) + with open(outTab, 'rt') as outf: + recs = map(lambda s: s.strip('\n').split('\t'), outf.readlines()) + with open(os.path.join(myInputDir, 'expected.cpickle'), 'rb') as expf: + expectedRecs = pickle.load(expf) + # Vphaser2 p-val calculation is unstable and sometimes varies from + # run to run, so exclude it from comparison. + self.assertEqual([rec[:4] + rec[5:] for rec in recs], [rec[:4] + rec[5:] for rec in expectedRecs]) + """""" + Creation of in.bam: + Start with test file that ships with V-Phaser 2. + cp 4528.454.indelRealigned.bam orig.bam + samtools index orig.bam + samtools view -h orig.bam V4528_assembly:1-100 V4528_assembly:950-1050 >c1.sam + samtools view -h orig.bam V4528_assembly:8950-9050 V4528_assembly:9900-9950 >c2.sam + Change all occurences of V4528_assembly in c1.sam to chr1, + Change all occurences of V4528_assembly in c2.sam to chr2, + Move the @SQ line from c2.sam to c1.sam and delete header of c2.sam. + cat c1.sam c2.sam >new.sam + samtools view -bh new.sam >new.bam + + Creation of expected.cpickle: + cPickle.dump(list(Vphaser2Tool().iterate(inBam, numThreads = 8)), + open('expected.cpickle', 'w')) + """""" +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_kraken.py",".py","1962","64","# Unit tests for kraken +import os.path + +import pytest + +import util.file +import util.misc +import tools.kraken +from test import _CPUS + + +@pytest.fixture +def krakenuniq(): + return tools.kraken.KrakenUniq() + + +@pytest.fixture +def in_bam(): + return os.path.join(util.file.get_test_input_path(), 'almost-empty.bam') + + +@pytest.fixture +def db(tmpdir_factory): + return str(tmpdir_factory.mktemp('db')) + + +@pytest.fixture(autouse=True) +def mocks(mocker): + mock_run = mocker.patch('util.misc.run', autospec=True) + mock_check_call = mocker.patch('subprocess.check_call', autospec=True) + return { + 'run': mock_run, + 'check_call': mock_check_call, + } + + +def test_krakenuniq_classify(mocks, krakenuniq, db, in_bam): + out_reads = util.file.mkstempfname('.reads.txt') + krakenuniq.classify(in_bam, db, out_reads) + args = mocks['check_call'].call_args[0][0] + assert 'krakenuniq' == os.path.basename(args[0]) + assert util.misc.list_contains(['--db', db], args) + assert util.misc.list_contains(['--output', out_reads], args) + assert util.misc.list_contains(['--threads', str(_CPUS)], args) + +def test_classify_num_threads(mocks, krakenuniq, db, in_bam): + out_reads = util.file.mkstempfname('.reads.txt') + + krakenuniq.classify(in_bam, db, out_reads) + args = mocks['check_call'].call_args[0][0] + assert 'krakenuniq' == os.path.basename(args[0]) + assert '--threads' in args + actual = args[args.index('--threads')+1] + assert actual == str(_CPUS) + + for requested in (1,2,3,8,11,20): + expected = min(_CPUS, requested) + krakenuniq.classify(in_bam, db, out_reads, num_threads=requested) + args = mocks['check_call'].call_args[0][0] + assert 'krakenuniq' == os.path.basename(args[0]) + assert '--threads' in args + actual = args[args.index('--threads')+1] + assert actual == str(expected), ""failure for requested %s, expected %s, actual %s"" % (requested, expected, actual) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_taxonomy.py",".py","680","19","import os.path +from os.path import join + +import util.file +import metagenomics + + +def test_taxonomy_subset_zaire(request, tmpdir_factory): + data_dir = join(util.file.get_test_input_path(), 'TestMetagenomicsSimple') + db_dir = join(data_dir, 'db', 'taxonomy') + sub_dir = str(tmpdir_factory.mktemp('taxonomy_subset')) + # Zaire species + metagenomics.subset_taxonomy(db_dir, sub_dir, whitelistTaxids=[], whitelistTreeTaxids=[186538]) + + tax_db = metagenomics.TaxonomyDb(sub_dir, load_nodes=True, load_names=True) + assert 186538 in tax_db.parents # Zaire species + assert 186540 not in tax_db.parents # Sudan species + assert 2 not in tax_db.parents # Bacteria +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_trimmomatic.py",".py","3104","63","# Unit tests for Trimmomatic tool + +__author__ = ""dpark@broadinstitute.org"" + +import os +import unittest +import util.file +import tools +import tools.trimmomatic +from test import TestCaseWithTmp, assert_equal_contents + +class TestTrimmomatic(TestCaseWithTmp): + + def test_trimmomatic_paired(self): + myInputDir = util.file.get_test_input_path(self) + inFastq1 = os.path.join(myInputDir, 'in1.fastq') + inFastq2 = os.path.join(myInputDir, 'in2.fastq') + pairedOutFastq1 = util.file.mkstempfname('.out1.fastq') + pairedOutFastq2 = util.file.mkstempfname('.out2.fastq') + clipFasta = os.path.join(myInputDir, 'clip.fasta') + tools.trimmomatic.TrimmomaticTool().execute(inFastq1, inFastq2, pairedOutFastq1, pairedOutFastq2, clipFasta) + + # Check that results match expected + expected1Fastq = os.path.join(myInputDir, 'expected1.fastq') + expected2Fastq = os.path.join(myInputDir, 'expected2.fastq') + assert_equal_contents(self, pairedOutFastq1, expected1Fastq) + assert_equal_contents(self, pairedOutFastq2, expected2Fastq) + + + def test_trimmomatic_paired_maxinfo(self): + myInputDir = util.file.get_test_input_path(self) + inFastq1 = os.path.join(myInputDir, 'in1.fastq') + inFastq2 = os.path.join(myInputDir, 'in2.fastq') + clipFasta = os.path.join(myInputDir, 'clip.fasta') + with util.file.tempfnames(('.out1.fastq', '.out2.fastq')) as (pairedOutFastq1, pairedOutFastq2): + tools.trimmomatic.TrimmomaticTool().execute(inFastq1, inFastq2, pairedOutFastq1, pairedOutFastq2, clipFasta, + maxinfo_target_length=30, maxinfo_strictness=.3) + + # Check that results match expected + expected1Fastq = os.path.join(myInputDir, 'expected1.maxinfo.fastq') + expected2Fastq = os.path.join(myInputDir, 'expected2.maxinfo.fastq') + assert_equal_contents(self, pairedOutFastq1, expected1Fastq) + assert_equal_contents(self, pairedOutFastq2, expected2Fastq) + + + def test_trimmomatic_single(self): + myInputDir = util.file.get_test_input_path(self) + inFastq1 = os.path.join(myInputDir, 'in1.fastq') + pairedOutFastq1 = util.file.mkstempfname('.out1.fastq') + pairedOutFastq2 = util.file.mkstempfname('.out2.fastq') + unpairedOutFastq1 = util.file.mkstempfname('.out3.fastq') + unpairedOutFastq2 = util.file.mkstempfname('.out4.fastq') + clipFasta = os.path.join(myInputDir, 'clip.fasta') + tools.trimmomatic.TrimmomaticTool().execute(inFastq1, None, pairedOutFastq1, pairedOutFastq2, clipFasta, + unpairedOutFastq1=unpairedOutFastq1, unpairedOutFastq2=unpairedOutFastq2) + + # Check that results match expected + emptyFastq = os.path.join(myInputDir, 'empty.fastq') + expectedFastq = os.path.join(myInputDir, 'expected1.fastq') + assert_equal_contents(self, pairedOutFastq1, emptyFastq) + assert_equal_contents(self, pairedOutFastq2, emptyFastq) + assert_equal_contents(self, unpairedOutFastq1, expectedFastq) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_krakenuniq.py",".py","3261","94","# Unit tests for krakenuniq +import os.path + +import pytest + +import util.file +import util.misc +import tools.kraken +from test import _CPUS + + +@pytest.fixture +def kraken(): + return tools.kraken.Kraken() + + +@pytest.fixture +def in_bam(): + return os.path.join(util.file.get_test_input_path(), 'almost-empty.bam') + + +@pytest.fixture +def db(tmpdir_factory): + return str(tmpdir_factory.mktemp('db')) + + +@pytest.fixture(autouse=True) +def mocks(mocker): + + mock_run = mocker.patch('util.misc.run', autospec=True) + mock_check_call = mocker.patch('subprocess.check_call', autospec=True) + + mock_conda = mocker.patch('tools.CondaPackage', autospec=True) + mock_conda.return_value.verify_install.return_value = ""mock"" + mock_conda.return_value.is_attempted.return_value = True + mock_conda.return_value.is_installed.return_value = True + mock_conda.return_value.require_executability = False + mock_conda.return_value.executable_path.return_value = ""/dev/null"" + return { + 'conda': mock_conda, + 'run': mock_run, + 'check_call': mock_check_call, + } + + +def test_kraken_classify(mocks, kraken, db, in_bam): + out_reads = util.file.mkstempfname('.reads.txt') + kraken.classify(in_bam, db, out_reads) + args = mocks['check_call'].call_args[0][0] + assert 'kraken' == os.path.basename(args[0]) + assert util.misc.list_contains(['--db', db], args) + assert util.misc.list_contains(['--output', out_reads], args) + assert util.misc.list_contains(['--threads', str(_CPUS)], args) + + +def test_kraken_filter(mocks, kraken, db): + in_reads = util.file.mkstempfname('.kraken_reads.unfilt.txt') + out_reads = util.file.mkstempfname('.kraken_reads.filt.txt') + for thresh in (0.05, 0.3, 0.81): + kraken.filter(in_reads, db, out_reads, thresh) + args = mocks['run'].call_args[0][0] + assert 'kraken-filter' == os.path.basename(args[0]) + assert in_reads in args + assert util.misc.list_contains(['--db', db], args) + assert util.misc.list_contains(['--threshold', str(thresh)], args) + +def test_kraken_report(mocks, kraken, db): + in_reads = util.file.mkstempfname('.kraken_reads.txt') + out_report = util.file.mkstempfname('.kraken_report.txt') + kraken.report(in_reads, db, out_report) + args = mocks['run'].call_args[0][0] + assert 'kraken-report' == os.path.basename(args[0]) + assert in_reads in args + assert util.misc.list_contains(['--db', db], args) + +def test_classify_num_threads(mocks, kraken, db, in_bam): + out_reads = util.file.mkstempfname('.reads.txt') + + kraken.classify(in_bam, db, out_reads) + args = mocks['check_call'].call_args[0][0] + assert 'kraken' == os.path.basename(args[0]) + assert '--threads' in args + actual = args[args.index('--threads')+1] + assert actual == str(_CPUS) + + for requested in (1,2,3,8,11,20): + expected = min(_CPUS, requested) + kraken.classify(in_bam, db, out_reads, numThreads=requested) + args = mocks['check_call'].call_args[0][0] + assert 'kraken' == os.path.basename(args[0]) + assert '--threads' in args + actual = args[args.index('--threads')+1] + assert actual == str(expected), ""failure for requested %s, expected %s, actual %s"" % (requested, expected, actual) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_kmer_utils.py",".py","20414","433","""""""Unit tests for kmer_utils.py"""""" + +__author__ = ""ilya@broadinstitute.org"" + +import os +import sys +import collections +import argparse +import logging +import itertools +import unittest + +import Bio.SeqIO +from Bio.Seq import Seq +from Bio.SeqRecord import SeqRecord +from Bio.Alphabet import IUPAC +import pytest + +import kmer_utils +import read_utils +import util.cmd +import util.file +import util.misc +import tools.kmc +import tools.samtools + + +_log = logging.getLogger(__name__) # pylint: disable=invalid-name + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_fun in kmer_utils.__commands__: + parser = parser_fun(argparse.ArgumentParser()) + helpstring = parser.format_help() + +################################# +# Some general utils used below # +################################# + +def _seq_as_str(s): # pylint: disable=invalid-name + """"""Return a sequence as a str, regardless of whether it was a str, a Seq or a SeqRecord"""""" + if isinstance(s, Seq): + return str(s) + if isinstance(s, SeqRecord): + return str(s.seq) + return s + +def _yield_seq_recs(seq_file): + """"""Yield sequence records from the file, regardless of file format."""""" + with util.file.tmp_dir(suffix='_seqs_as_strs') as t_dir: + if seq_file.endswith('.bam'): + t_fa = os.path.join(t_dir, 'bam2fa.fasta') + tools.samtools.SamtoolsTool().bam2fa(seq_file, t_fa, append_mate_num=True) + seq_file = t_fa + with util.file.open_or_gzopen(seq_file, 'rt') as seq_f: + for rec in Bio.SeqIO.parse(seq_f, util.file.uncompressed_file_type(seq_file)[1:]): + yield rec + +def _list_seq_recs(seq_file): + """"""Return a list of sequence records from the file, regardless of file format."""""" + return list(_yield_seq_recs(seq_file)) + + +def _yield_seqs_as_strs(seqs): + """"""Yield sequence(s) from `seqs` as strs. seqs can be a str/SeqRecord/Seq, a filename of a sequence file, + or an iterable of these. If a filename of a sequence file, all sequences from that file are yielded."""""" + for seq in util.misc.make_seq(seqs, (str, SeqRecord, Seq)): + seq = _seq_as_str(seq) + if not any(seq.endswith(ext) for ext in '.fasta .fasta.gz .fastq .fastq.gz .bam'): + yield seq + else: + for rec in _yield_seq_recs(seq): + yield str(rec.seq) + +def _list_seqs_as_strs(seqs): + """"""Return a list of sequence(s) from `seqs` as strs. seqs can be a str/SeqRecord/Seq, a filename of a sequence file, + or an iterable of these. If a filename of a sequence file, all sequences from that file are yielded."""""" + return list(_yield_seqs_as_strs(seqs)) + +def _getargs(args, valid_args): + """"""Extract valid args from an argparse.Namespace or a dict. Returns a dict containing keys from `args` + that are in `valid_args`; `valid_args` is a space-separated list of valid args."""""" + return util.misc.subdict(vars(args) if isinstance(args, argparse.Namespace) else args, valid_args.split()) + +def _strip_mate_num(rec_id): + """"""Name of a read, with any /1 or /2 at the end removed"""""" + return rec_id[:-2] if rec_id.endswith('/1') or rec_id.endswith('/2') else rec_id + +################################################################################################################# + + +class KmcPy(object): + """"""Reimplementation of some kmc functions in simple Python code. + + To help generate the expected correct output, we reimplement in simple Python code some + of KMC's functionality. This is also to make up for KMC's lack of a public test suite + ( https://github.com/refresh-bio/KMC/issues/55 ). + """""" + + def _revcomp(self, kmer): + """"""Return the reverse complement of a kmer, given as a string"""""" + assert isinstance(kmer, str) + return str(Seq(kmer, IUPAC.unambiguous_dna).reverse_complement()) + + def _canonicalize(self, kmer): + """"""Return the canonical version of a kmer"""""" + return min(kmer, self._revcomp(kmer)) + + def _compute_kmers_iter(self, seq_strs, kmer_size, single_strand, **ignore): + """"""Yield kmers of seq(s). Unless `single_strand` is True, each kmer + is canonicalized before being returned. Note that + deduplication is not done, so each occurrence of each kmer is + yielded. Kmers containing non-TCGA bases are skipped. + """""" + for seq in seq_strs: + n_kmers = len(seq)-kmer_size+1 + + # mark kmers containing invalid base(s) + valid_kmer = [True] * n_kmers + for i in range(len(seq)): # pylint: disable=consider-using-enumerate + if seq[i].upper() not in 'TCGA': + invalid_lo = max(0, i-kmer_size+1) + invalid_hi = min(n_kmers, i+1) + valid_kmer[invalid_lo:invalid_hi] = [False]*(invalid_hi-invalid_lo) + + for i in range(n_kmers): + if valid_kmer[i]: + kmer = seq[i:i+kmer_size] + yield kmer if single_strand else self._canonicalize(kmer) + + def _compute_kmers(self, *args, **kw): + """"""Return list of kmers of seq(s). Unless `single_strand` is True, each kmer + is canonicalized before being returned. Note that + deduplication is not done, so each occurrence of each kmer is + yielded. Kmers containing non-TCGA bases are skipped. + """""" + return list(self._compute_kmers_iter(*args, **kw)) + + def compute_kmer_counts(self, seq_files, kmer_size, min_occs, max_occs, + counter_cap, single_strand, **ignore): + """"""Yield kmer counts of seq(s). Unless `single_strand` is True, each kmer is + canonicalized before being counted. Kmers containing non-TCGA bases are skipped. + Kmers with fewer than `min_occs` or more than `max_occs` occurrences + are dropped, and kmer counts capped at `counter_cap`, if these args are given. + """""" + counts = collections.Counter(self._compute_kmers(_list_seqs_as_strs(seq_files), kmer_size, single_strand)) + return self._filter_kmer_counts(counts=counts, min_occs=min_occs, max_occs=max_occs, counter_cap=counter_cap) + + def _filter_kmer_counts(self, counts, min_occs=None, max_occs=None, counter_cap=None): + """"""From a dict of kmer counts, drop kmers with counts below `min_occs` or above `max_occs`, and + cap counter values at `counter_cap`."""""" + return collections.Counter({kmer : min(count, counter_cap or count) \ + for kmer, count in counts.items() \ + if (count >= (min_occs or count)) and \ + (count <= (max_occs or count))}) + + + def filter_reads(self, db_kmer_counts, in_reads, kmer_size, single_strand, + db_min_occs, db_max_occs, read_min_occs, read_max_occs, + read_min_occs_frac, read_max_occs_frac, **ignore): + """"""Fiter sequences based on their kmer contents; returns the ids of the passing seqs. + + Inputs: + in_reads: sequences to filter, as a fasta/fastq/bam + + Params: + db_kmer_counts: a collections.Counter mapping kmers to their counts in the kmer database + kmer_size: kmer size + single_strand: if False, kmers are canonicalized + db_min_occs: drop from db_kmer_counts kmers with counts below this + db_max_occs: drop from db_kmer_counts kmers with counts above this + read_min_occs: drop reads with fewer than this many occurrences of kmers from the database + read_max_occs: drop reads with more than this many occurrences of kmers from the database + read_min_occs_frac: only keep reads with at least this many occurrences of kmers from database, + interpreted as a fraction of read length in kmers + read_max_occs_frac: only keep reads with no more than this many occurrence of kmers from the database. + interpreted as a fraction of read length in kmers. + """""" + db_kmers = self._filter_kmer_counts(counts=db_kmer_counts, min_occs=db_min_occs, max_occs=db_max_occs).keys() + + seqs_ids_out = set() + rel_thresholds = (read_min_occs_frac, read_max_occs_frac) != (0., 1.) + in_recs = _list_seq_recs(in_reads) + + seq_occs_hist = collections.Counter() + mate_cnt = collections.Counter() + + for rec in in_recs: + seq = str(rec.seq) + seq_kmer_counts = self.compute_kmer_counts(seq, kmer_size=kmer_size, single_strand=single_strand, + min_occs=1, max_occs=util.misc.MAX_INT32, + counter_cap=util.misc.MAX_INT32) + assert not single_strand + seq_occs = sum([seq_count for kmer, seq_count in seq_kmer_counts.items() \ + if kmer in db_kmers]) + seq_occs_hist[seq_occs] += 1 + + if rel_thresholds: + n_seq_kmers = len(seq)-kmer_size+1 + read_min_occs_seq, read_max_occs_seq = (int(read_min_occs_frac * n_seq_kmers), + int(read_max_occs_frac * n_seq_kmers)) + else: + read_min_occs_seq, read_max_occs_seq = (read_min_occs, read_max_occs) + + if read_min_occs_seq <= seq_occs <= read_max_occs_seq: + seqs_ids_out.add(rec.id) + mate_cnt[rec.id[-2:] if rec.id[-2:] in ('/1', '/2') else '/0'] += 1 + + + _log.debug('kmer occs histogram: %s', sorted(seq_occs_hist.items())) + _log.debug('filter_reads: %d of %d passed; mate_cnt=%s', len(seqs_ids_out), len(in_recs), + mate_cnt) + + return seqs_ids_out + + def binary_op(self, op, kmer_counts_1, kmer_counts_2, result_counter_cap=255): + assert isinstance(kmer_counts_1, collections.Counter) + assert isinstance(kmer_counts_2, collections.Counter) + if op == 'intersect': + result = kmer_counts_1 & kmer_counts_2 + elif op == 'union': + result = collections.Counter({k: (kmer_counts_1[k] + kmer_counts_2[k]) + for k in (set(kmer_counts_1.keys()) | set(kmer_counts_2.keys()))}) + elif op == 'kmers_subtract': + result = collections.Counter(util.misc.subdict(kmer_counts_1, + set(kmer_counts_1.keys()) - set(kmer_counts_2.keys()))) + elif op == 'counters_subtract': + result = kmer_counts_1 - kmer_counts_2 + else: + raise ValueError('Unknown operation: {}'.format(op)) + return self._filter_kmer_counts(counts=result, counter_cap=result_counter_cap) + +# end: class KmcPy + +kmcpy = KmcPy() + +def _inp(fname): + """"""Return full path to a test input file for this module"""""" + return os.path.join(util.file.get_test_input_path(), 'TestKmers', fname) + +def _stringify(arg): + """"""Return a string based on `arg`, suitable for use as a pytest test id"""""" + return util.file.string_to_file_name(str(arg)) + +def _do_build_kmer_db(t_dir, val_cache, seq_files, kmer_db_opts): + """"""Build a database of kmers from given sequence file(s) using given options. + + Args: + t_dir: dir where to build the kmer dbase + val_cache: a dict where results can be cached + seq_files: a string of sequence file name(s), space-separated + kmer_db_opts: options to build_kmer_db command, as one string + Returns: + an argparse.Namespace() with the following attrs: + kmer_db: path to the kmer db created from seq_files + kmc_kmer_counts: map from kmer to count, as computed by kmc + kmc_db_args: the result of parsing kmer_db_opts + """""" + key = (seq_files, kmer_db_opts) + if key in val_cache: + _log.debug('reusing cached kmer db: %s', key) + return val_cache[key] + + _log.debug('constructing kmer db: %s', key) + + k_db = os.path.join(t_dir, 'bld_kmer_db_{}'.format(hash(key))) + assert not tools.kmc.KmcTool().is_kmer_db(k_db) + seq_files = list(map(_inp, seq_files.split())) + kmer_db_args = util.cmd.run_cmd(module=kmer_utils, cmd='build_kmer_db', + args=seq_files + [k_db] + kmer_db_opts.split() + ['--memLimitGb', 4]).args_parsed + assert tools.kmc.KmcTool().is_kmer_db(k_db) + kmc_kmer_counts=tools.kmc.KmcTool().get_kmer_counts(k_db, threads=kmer_db_args.threads) + _log.debug('KMER_DB_FIXTURE: param=%s counts=%d db=%s', key, len(kmc_kmer_counts), k_db) + return val_cache.setdefault(key, argparse.Namespace(kmer_db=k_db, + kmc_kmer_counts=kmc_kmer_counts, + kmer_db_args=kmer_db_args)) + +KMER_DBS_EMPTY = [('empty.fasta', '')] + +KMER_DBS_SMALL = [ + ('ebola.fasta.gz', '-k 7'), + ('almost-empty-2.bam', '-k 23 --singleStrand'), + ('almost-empty-2.bam', '-k 5 --minOccs 1 --maxOccs 5 --counterCap 3'), + ('tcgaattt.fasta', '-k 7'), + ('ambig_bases.fasta', '-k 7'), + ('palindromic_kmers.fasta', '-k 7') +] + +KMER_DBS_MEDIUM = [ + ('test-reads.bam test-reads-human.bam', '-k 17'), +] + +@pytest.fixture(scope='module') +def dict_module(): + return dict() + +@pytest.fixture(scope='module', params=KMER_DBS_EMPTY+KMER_DBS_SMALL, ids=_stringify) +def kmer_db_fixture(request, tmpdir_module, dict_module): + yield _do_build_kmer_db(tmpdir_module, dict_module, *request.param) + +@pytest.fixture(scope='module', params=KMER_DBS_EMPTY+KMER_DBS_SMALL, ids=_stringify) +def kmer_db_fixture2(request, tmpdir_module, dict_module): + yield _do_build_kmer_db(tmpdir_module, dict_module, *request.param) + +@pytest.mark.parametrize(""kmer_db_fixture"", KMER_DBS_EMPTY+KMER_DBS_SMALL+KMER_DBS_MEDIUM, + ids=_stringify, indirect=[""kmer_db_fixture""]) +def test_build_kmer_db(kmer_db_fixture): + _test_build_kmer_db(kmer_db_fixture) + +def _test_build_kmer_db(kmer_db_fixture): + assert tools.kmc.KmcTool().is_kmer_db(kmer_db_fixture.kmer_db) + + kmer_db_info = tools.kmc.KmcTool().get_kmer_db_info(kmer_db_fixture.kmer_db) + assert kmer_db_info.kmer_size == kmer_db_fixture.kmer_db_args.kmer_size + assert kmer_db_info.min_occs == kmer_db_fixture.kmer_db_args.min_occs + assert kmer_db_info.max_occs == kmer_db_fixture.kmer_db_args.max_occs + + kmcpy_kmer_counts = kmcpy.compute_kmer_counts(**vars(kmer_db_fixture.kmer_db_args)) + assert kmer_db_info.total_kmers == len(kmcpy_kmer_counts) + assert kmer_db_fixture.kmc_kmer_counts == kmcpy_kmer_counts + +########### +SEQ_FILES = [ + # 'empty.fasta', + # 'ebola.fasta.gz', + # 'almost-empty-2.bam', + # 'test-reads.bam', + # 'test-reads-human.bam', + # 'tcgaattt.fasta', + 'G5012.3.fasta', + 'G5012.3.mini.bam', +] + +KMER_SIZES = [1, 2, 7, 17, 27, 31, 55, 63] +#KMER_SIZES = [1, 17, 31, 55] +STRAND_OPTS = ['', '--singleStrand'] +KMER_OCCS_OPTS = [ '', '--minOccs 1', '--minOccs 10', '--maxOccs 10' ] +NTHREADS = [1, 2, 12] +COMBO_OPTS = [(seq_file, '-k{} {} {} --threads {}'.format(kmer_size, strand_opt, kmer_occs_opt, nthreads)) + for seq_file, kmer_size, strand_opt, kmer_occs_opt, nthreads \ + in itertools.product(SEQ_FILES, KMER_SIZES, STRAND_OPTS, + KMER_OCCS_OPTS, NTHREADS)] + +@pytest.mark.slow +@pytest.mark.parametrize(""kmer_db_fixture"", COMBO_OPTS, ids=_stringify, indirect=[""kmer_db_fixture""]) +def test_build_kmer_db_combo(kmer_db_fixture): + _test_build_kmer_db(kmer_db_fixture) + + +############################################################################################## + +def _test_filter_reads(kmer_db_fixture, reads_file, filter_opts, tmpdir_function): + """"""Test read filtering. + + Args: + kmer_size: kmer size + single_strand: whether to canonicalize kmers + kmers_fasta: kmers for filtering will be extracted from here + reads_bam: reads to filter with kmers extracted from kmers_fasta + + """""" + assert tools.kmc.KmcTool().is_kmer_db(kmer_db_fixture.kmer_db) + + reads_file = _inp(reads_file) + reads_file_out = os.path.join(tmpdir_function, 'reads_out' + util.file.uncompressed_file_type(reads_file)) + + filter_args = util.cmd.run_cmd(module=kmer_utils, cmd='filter_reads', + args=[kmer_db_fixture.kmer_db, + reads_file, reads_file_out] + filter_opts.split()).args_parsed + + _log.debug('Running filte: kmer_db_args=%s filter_arg=%s', kmer_db_fixture.kmer_db_args, filter_args) + filtered_ids_expected = kmcpy.filter_reads(db_kmer_counts=kmer_db_fixture.kmc_kmer_counts, + kmer_size=kmer_db_fixture.kmer_db_args.kmer_size, + single_strand=kmer_db_fixture.kmer_db_args.single_strand, + **vars(filter_args)) + + reads_file_out_ids_txt = reads_file_out+'.ids.txt' + read_utils.read_names(reads_file_out, reads_file_out_ids_txt) + reads_out_ids = util.file.slurp_file(reads_file_out_ids_txt).strip().split() + + _log.debug('FILT %d %d %s %s %s', len(_list_seq_recs(reads_file)), len(_list_seq_recs(reads_file_out)), + kmer_db_fixture.kmer_db, reads_file, filter_opts) + def normed_read_ids(ids): return set(map(_strip_mate_num, ids)) + + assert normed_read_ids(reads_out_ids) == normed_read_ids(filtered_ids_expected) + +# end: def _test_filter_reads(kmer_db_fixture, reads_file, filter_opts, tmpdir_function) + +@pytest.mark.parametrize(""kmer_db_fixture"", [('empty.fasta', '')], ids=_stringify, indirect=[""kmer_db_fixture""]) +@pytest.mark.parametrize(""reads_file"", ['empty.fasta', 'tcgaattt.fasta', 'G5012.3.subset.bam']) +@pytest.mark.parametrize(""filter_opts"", ['', '--readMinOccs 1', '--readMaxOccs 2']) +def test_filter_with_empty_db(kmer_db_fixture, reads_file, filter_opts, tmpdir_function): + _test_filter_reads(**locals()) + +@pytest.mark.parametrize(""kmer_db_fixture"", [('ebola.fasta.gz', '-k 7')], ids=_stringify, indirect=[""kmer_db_fixture""]) +@pytest.mark.parametrize(""reads_file"", [pytest.param('G5012.3.testreads.bam', marks=pytest.mark.slow), + 'G5012.3.subset.bam']) +@pytest.mark.parametrize(""filter_opts"", ['--dbMinOccs 7 --readMinOccs 93', + '--dbMinOccs 4 --readMinOccsFrac .6', + '--readMinOccsFrac .4 --readMaxOccsFrac .55']) +def test_filter_reads(kmer_db_fixture, reads_file, filter_opts, tmpdir_function): + _test_filter_reads(**locals()) + + +@pytest.mark.parametrize(""kmer_db_fixture"", KMER_DBS_EMPTY+KMER_DBS_SMALL[:1], ids=_stringify, indirect=[""kmer_db_fixture""]) +@pytest.mark.parametrize(""set_to_val"", [1, util.misc.MAX_INT32]) +def test_kmer_set_counts(kmer_db_fixture, tmpdir_function, set_to_val): + db_with_set_counts = os.path.join(tmpdir_function, 'set_counts_db') + util.cmd.run_cmd(module=kmer_utils, cmd='kmers_set_counts', + args=[kmer_db_fixture.kmer_db, set_to_val, db_with_set_counts]) + new_counts = tools.kmc.KmcTool().get_kmer_counts(db_with_set_counts) + assert set(new_counts.keys()) == set(kmer_db_fixture.kmc_kmer_counts.keys()) + assert not new_counts or set(new_counts.values()) == set([set_to_val]) + + +@pytest.mark.parametrize(""op"", ('intersect', 'union', 'kmers_subtract', 'counters_subtract')) +def test_kmers_binary_op(kmer_db_fixture, kmer_db_fixture2, op, tmpdir_function): + if kmer_db_fixture.kmer_db_args.kmer_size != kmer_db_fixture2.kmer_db_args.kmer_size: + pytest.skip('(always skip) binary ops not defined on kmers of different size') + db_result = os.path.join(tmpdir_function, 'op_result') + _log.debug('fixture1args=%s', kmer_db_fixture.kmer_db_args) + _log.debug('fixture2args=%s', kmer_db_fixture2.kmer_db_args) + _log.debug('op=%s', op) + args = util.cmd.run_cmd(module=kmer_utils, cmd='kmers_binary_op', + args=[op, kmer_db_fixture.kmer_db, kmer_db_fixture2.kmer_db, db_result]).args_parsed + + kmc_counts = tools.kmc.KmcTool().get_kmer_counts(db_result) + kmcpy_counts = kmcpy.binary_op(op, kmer_db_fixture.kmc_kmer_counts, kmer_db_fixture2.kmc_kmer_counts, + result_counter_cap=args.result_counter_cap) + + assert kmc_counts == kmcpy_counts +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_diamond.py",".py","1796","55","# Unit tests for diamond + +from builtins import super +import collections +import glob +import mock +import os.path +import tempfile +import unittest +import util.file +import util.misc +import tools.diamond +import test + + +CompletedProcess = collections.namedtuple( + 'CompletedProcess', ['args', 'returncode', 'stdout', 'stderr']) + + +class TestToolDiamond(test.TestCaseWithTmp): + + def setUp(self): + super().setUp() + + patcher = mock.patch('subprocess.check_call', autospec=True) + self.addCleanup(patcher.stop) + self.mock_run = patcher.start() + self.mock_run.return_value = CompletedProcess([], 0, '', '') + + patcher = mock.patch('tools.CondaPackage', autospec=True) + self.addCleanup(patcher.stop) + self.mock_conda = patcher.start() + self.mock_conda.return_value.verify_install.return_value = ""mock"" + self.mock_conda.return_value.is_attempted.return_value = True + self.mock_conda.return_value.is_installed.return_value = True + self.mock_conda.return_value.require_executability = False + self.mock_conda.return_value.executable_path.return_value = ""/dev/null"" + + self.diamond = tools.diamond.Diamond() + self.diamond.install() + self.data_dir = os.path.join(util.file.get_test_input_path(), 'TestMetagenomicsSimple') + self.db_dir = os.path.join(self.data_dir, 'db') + + def test_create(self): + db = os.path.join(tempfile.tempdir, 'fake.dmnd') + + # To be replaced with recursive glob in Python 3.5. + protein_fastas = glob.glob('{}/library/*/*/*.faa'.format(self.db_dir)) + + self.diamond.build(db, protein_fastas) + args = self.mock_run.call_args[0][0] + self.assertIn('makedb', args) + self.assertIn('--db', args) + self.assertIn(db, args) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_tools_novoalign.py",".py","5784","137","# Unit tests for Novoalign aligner + +__author__ = ""dpark@broadinstitute.org"" + +import unittest +import os.path +import shutil +import util.file +import tools.novoalign +import tools.samtools +import pysam +from test import TestCaseWithTmp, assert_md5_equal_to_line_in_file + + +class TestToolNovoalign(TestCaseWithTmp): + + def setUp(self): + super(TestToolNovoalign, self).setUp() + self.novoalign = tools.novoalign.NovoalignTool() + self.novoalign.install() + self.samtools = tools.samtools.SamtoolsTool() + + def test_index(self): + orig_ref = os.path.join(util.file.get_test_input_path(), 'ebola.fasta') + inRef = util.file.mkstempfname('.fasta') + shutil.copyfile(orig_ref, inRef) + self.novoalign.index_fasta(inRef) + outfile = inRef[:-6] + '.nix' + + self.assertTrue(os.path.isfile(outfile)) + self.assertTrue(os.path.getsize(outfile)) + + def test_align(self): + orig_ref = os.path.join(util.file.get_test_input_path(), 'ebola.fasta') + inRef = util.file.mkstempfname('.fasta') + shutil.copyfile(orig_ref, inRef) + self.novoalign.index_fasta(inRef) + reads = os.path.join(util.file.get_test_input_path(self), 'ebov_reads.bam') + outBam = util.file.mkstempfname('.bam') + self.novoalign.execute(reads, inRef, outBam) + self.assertTrue(os.path.isfile(outBam)) + self.assertTrue(os.path.getsize(outBam)) + self.assertTrue(os.path.isfile(outBam[:-1] + 'i')) + + def test_align_filter(self): + orig_ref = os.path.join(util.file.get_test_input_path(), 'ebola.fasta') + inRef = util.file.mkstempfname('.fasta') + shutil.copyfile(orig_ref, inRef) + self.novoalign.index_fasta(inRef) + reads = os.path.join(util.file.get_test_input_path(self), 'ebov_reads.bam') + outBam = util.file.mkstempfname('.bam') + self.novoalign.execute(reads, inRef, outBam, min_qual=1) + self.assertTrue(os.path.isfile(outBam)) + self.assertTrue(os.path.getsize(outBam)) + self.assertTrue(os.path.isfile(outBam[:-1] + 'i')) + + def test_multi_read_groups(self): + orig_ref = os.path.join(util.file.get_test_input_path(), 'G5012.3.fasta') + inRef = util.file.mkstempfname('.fasta') + shutil.copyfile(orig_ref, inRef) + self.novoalign.index_fasta(inRef) + + # align with Novoalign (BAM input, BAM output) + reads = os.path.join(util.file.get_test_input_path(), 'G5012.3.subset.bam') + outBam = util.file.mkstempfname('.bam') + self.novoalign.execute(reads, inRef, outBam) + self.assertTrue(os.path.isfile(outBam)) + self.assertTrue(os.path.getsize(outBam)) + self.assertTrue(os.path.isfile(outBam[:-1] + 'i')) + sam_in = util.file.mkstempfname('.in.sam') + sam_out = util.file.mkstempfname('.out.sam') + self.samtools.view([], reads, sam_in) + self.samtools.view([], outBam, sam_out) + + # assert that all reads are present in output + self.assertEqual(self.samtools.count(reads), self.samtools.count(outBam)) + + # assert that all read groups are described exactly the same + # in the output header (not necessarily same order, but same content) + orig_rgs = self.samtools.getReadGroups(reads) + new_rgs = self.samtools.getReadGroups(outBam) + self.assertTrue(len(orig_rgs) > 1) + self.assertTrue(len(new_rgs) > 1) + for rgid in new_rgs.keys(): + self.assertIn(rgid, orig_rgs) + orig_rg = orig_rgs[rgid] + new_rg = new_rgs[rgid] + if 'DT' in orig_rg and 'DT' in new_rg: + # don't bother comparing the date because Novoalign seems + # to enjoy doing senseless time zone conversions on the + # ISO date string + del orig_rg['DT'] + del new_rg['DT'] + self.assertEqual(orig_rgs[rgid], new_rgs[rgid]) + + # if any RGs are missing, it should be because they were never really there + for rgid in orig_rgs.keys(): + if rgid not in new_rgs: + self.assertEqual(0, self.samtools.count(reads, ['-r', rgid])) + + # assert that all reads retained their original RG assignments + read_to_rg = {} + read_seen = set() + with open(sam_in, 'rt') as inf: + for read in inf: + read = read.rstrip('\n').split('\t') + tags = [t[5:] for t in read[11:] if t.startswith('RG:Z:')] + self.assertTrue(len(tags) == 1) + read_to_rg[read[0]] = tags[0] + with open(sam_out, 'rt') as inf: + for read in inf: + read = read.rstrip('\n').split('\t') + tags = [t[5:] for t in read[11:] if t.startswith('RG:Z:')] + self.assertTrue(len(tags) == 1) + self.assertIn(read[0], read_to_rg) + self.assertEqual(tags[0], read_to_rg[read[0]]) + read_seen.add(read[0]) + self.assertEqual(len(read_seen), len(read_to_rg)) + + # clean up + for fn in (sam_in, sam_out, outBam, inRef): + os.unlink(fn) + + def test_multi_read_groups_filter(self): + orig_ref = os.path.join(util.file.get_test_input_path(), 'G5012.3.fasta') + inRef = util.file.mkstempfname('.fasta') + shutil.copyfile(orig_ref, inRef) + self.novoalign.index_fasta(inRef) + + # align with Novoalign (BAM input, BAM output) + reads = os.path.join(util.file.get_test_input_path(), 'G5012.3.subset.bam') + outBam = util.file.mkstempfname('.bam') + self.novoalign.execute(reads, inRef, outBam, min_qual=1) + self.assertTrue(os.path.isfile(outBam)) + self.assertTrue(os.path.getsize(outBam)) + self.assertTrue(os.path.isfile(outBam[:-1] + 'i')) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_interhost.py",".py","14495","309","# Unit tests for interhost.py + +__author__ = ""irwin@broadinstitute.org"" + +import interhost +import test +import util.file +import unittest +import argparse +import itertools + + +class TestCommandHelp(unittest.TestCase): + + def test_help_parser_for_each_command(self): + for cmd_name, parser_fun in interhost.__commands__: + parser = parser_fun(argparse.ArgumentParser()) + helpstring = parser.format_help() + + +def makeTempFasta(seqs): + fn = util.file.mkstempfname('.fasta') + with open(fn, 'wt') as outf: + for line in util.file.fastaMaker(seqs): + outf.write(line) + return fn + + +class TestCoordMapper(test.TestCaseWithTmp): + + def setUp(self): + super(TestCoordMapper, self).setUp() + self.genomeA = makeTempFasta([('chr1', 'ATGCACGTACGTATGCAAATCGG'), ('chr2', 'AGTCGGTTTTCAG'),]) + self.genomeB = makeTempFasta([('first_chrom', 'GCACGTACGTATTTGCAAATC'), ('second_chr', 'AGTCGGTTTCCAC'),]) + self.cm = interhost.CoordMapper() + self.cm.align_and_load_sequences([self.genomeA, self.genomeB]) + + def test_no_indels(self): + for pos in range(1, 14): + self.assertEqual(self.cm.mapAtoB('chr2', pos), ('second_chr', pos)) + self.assertEqual(self.cm.mapBtoA('second_chr', pos), ('chr2', pos)) + + def test_map_indels(self): + expLists = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, [11, 13], 14, 15, 16, 17, 18, 19, 20, 21], + [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 14, 15, 16, 17, 18, 19, 20, 21],] + for mapper, fromChrom, goodRange, toChrom, expected in [ + [self.cm.mapAtoB, 'chr1', range(3, 22), 'first_chrom', expLists[0]], [self.cm.mapBtoA, 'first_chrom', + range(1, 22), 'chr1', expLists[1]] + ]: + result = [mapper(fromChrom, pos) for pos in goodRange] + for chrom, mappedPos in result: + self.assertEqual(chrom, toChrom) + self.assertEqual(expected, [mappedPos for chrom, mappedPos in result]) + + def test_side_param(self): + self.assertEqual(self.cm.mapAtoB('chr1', 13), ('first_chrom', [11, 13])) + self.assertEqual(self.cm.mapAtoB('chr1', 13, 0), ('first_chrom', [11, 13])) + self.assertEqual(self.cm.mapAtoB('chr1', 13, -1), ('first_chrom', 11)) + self.assertEqual(self.cm.mapAtoB('chr1', 13, 1), ('first_chrom', 13)) + self.assertEqual(self.cm.mapAtoB('chr1', 12), ('first_chrom', 10)) + self.assertEqual(self.cm.mapAtoB('chr1', 12, 0), ('first_chrom', 10)) + self.assertEqual(self.cm.mapAtoB('chr1', 12, -1), ('first_chrom', 10)) + self.assertEqual(self.cm.mapAtoB('chr1', 12, 1), ('first_chrom', 10)) + + def test_oob_errors(self): + for pos in [-1, 0, 1, 2, 22, 23, 24]: + self.assertEqual(self.cm.mapAtoB('chr1', pos), ('first_chrom', None)) + for pos in [-1, 0, 14, 15]: + self.assertEqual(self.cm.mapBtoA('second_chr', pos), ('chr2', None)) + + def test_invalid_pos_error(self): + with self.assertRaises(TypeError): + self.cm.mapAtoB('chr1', 1.5) + with self.assertRaises(TypeError): + self.cm.mapBtoA('second_chr', 4.5) + + def test_invalid_chr_error(self): + with self.assertRaises(KeyError): + self.cm.mapAtoB('nonexistentchr', 2) + with self.assertRaises(KeyError): + self.cm.mapBtoA('nonexistentchr', 2) + + def test_unequal_genomes_error(self): + genomeA = makeTempFasta([('chr1', 'ATGCACGTACGTATGCAAATCGG'), ('chr2', 'AGTCGGTTTTCAG'),]) + genomeB = makeTempFasta([('first_chrom', 'GCACGTACGTATTTGCAAATC')]) + with self.assertRaises(interhost.TranspositionError): + cm = interhost.CoordMapper() + cm.align_and_load_sequences([genomeA, genomeB]) + + def test_map_chr_only(self): + self.assertEqual(self.cm.mapAtoB('chr1'), 'first_chrom') + self.assertEqual(self.cm.mapBtoA('first_chrom'), 'chr1') + self.assertEqual(self.cm.mapAtoB('chr2'), 'second_chr') + self.assertEqual(self.cm.mapBtoA('second_chr'), 'chr2') + with self.assertRaises(KeyError): + self.cm.mapAtoB('nonexistentchr') + + +class TestCoordMapperMultipleSeqs(test.TestCaseWithTmp): + + def setUp(self): + super(TestCoordMapperMultipleSeqs, self).setUp() + self.genomeA = makeTempFasta([ + ('chr1', 'ATGCACGTACGTATGCAAATCGG'), + ('chr2', 'AGTCGGTTTTCAG'), + ('chr3', 'GACTTTTGGCTGA'), + ]) + self.genomeB = makeTempFasta([ + ('first_chrom', 'GCACGTACGTATTTGCAAATC'), + ('second_chr', 'AGTCGGTTTCCAC'), + ('third_chr', 'CACCTTTGGCTGA'), + ]) + self.cm = interhost.CoordMapper() + self.cm.align_and_load_sequences([self.genomeA, self.genomeB]) + + def test_legacy_call(self): + ''' + If mapAtoB or mapBtoA is called on a CoordMapper object with >2 sequences, + an AssertionError should be raised. + ''' + self.assertRaises(LookupError, self.cm.mapAtoB, 'chr1', 1) + self.assertRaises(LookupError, self.cm.mapBtoA, 'chr2', 1) + + def test_no_indels(self): + for pos in range(1, 14): + self.assertEqual(self.cm.mapChr('chr2', 'second_chr', pos), ('second_chr', pos)) + self.assertEqual(self.cm.mapChr('second_chr', 'chr2', pos), ('chr2', pos)) + + def test_map_indels(self): + expLists = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, [11, 13], 14, 15, 16, 17, 18, 19, 20, 21], + [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 14, 15, 16, 17, 18, 19, 20, 21],] + for mapper, fromChrom, goodRange, toChrom, expected in [ + [self.cm.mapChr, 'chr1', range(3, 22), 'first_chrom', expLists[0]], [self.cm.mapChr, 'first_chrom', + range(1, 22), 'chr1', expLists[1]] + ]: + result = [mapper(fromChrom, toChrom, pos) for pos in goodRange] + for chrom, mappedPos in result: + self.assertEqual(chrom, toChrom) + self.assertEqual(expected, [mappedPos for chrom, mappedPos in result]) + + def test_side_param(self): + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom', 13), ('first_chrom', [11, 13])) + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom', 13, 0), ('first_chrom', [11, 13])) + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom', 13, -1), ('first_chrom', 11)) + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom', 13, 1), ('first_chrom', 13)) + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom', 12), ('first_chrom', 10)) + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom', 12, 0), ('first_chrom', 10)) + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom', 12, -1), ('first_chrom', 10)) + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom', 12, 1), ('first_chrom', 10)) + + def test_oob_errors(self): + for pos in [-1, 0, 1, 2, 22, 23, 24]: + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom', pos), ('first_chrom', None)) + for pos in [-1, 0, 14, 15]: + self.assertEqual(self.cm.mapChr('second_chr', 'chr2', pos), ('chr2', None)) + + def test_invalid_pos_error(self): + with self.assertRaises(TypeError): + self.cm.mapChr('chr1', 'first_chrom', 1.5) + with self.assertRaises(TypeError): + self.cm.mapChr('second_chr', 'chr2', 4.5) + + def test_invalid_chr_error(self): + self.assertRaises(KeyError, self.cm.mapChr, 'nonexistentchr', 'chr1', 2) + self.assertRaises(KeyError, self.cm.mapChr, 'chr1', 'nonexistentchr', 2) + + def test_unequal_genomes_error(self): + genomeA = makeTempFasta([('chr1', 'ATGCACGTACGTATGCAAATCGG'), ('chr2', 'AGTCGGTTTTCAG'),]) + genomeB = makeTempFasta([('first_chrom', 'GCACGTACGTATTTGCAAATC')]) + with self.assertRaises(Exception): + cm = interhost.CoordMapper() + cm.align_and_load_sequences([genomeA, genomeB]) + + def test_duplicate_chr_names_error(self): + genomeA = makeTempFasta([('chr1', 'ATGCACGTACGTATGCAAATCGG'),]) + genomeB = makeTempFasta([('chr1', 'GCACGTACGTATTTGCAAATC')]) + with self.assertRaises(Exception): + cm = interhost.CoordMapper() + cm.align_and_load_sequences([genomeA, genomeB]) + + def test_multiple_input_genomes(self): + genomeA = makeTempFasta([('chr1', 'ATGCACGTACGTATGCAAATCGG'),]) + genomeB = makeTempFasta([('first_chr', 'ATGCACTACGTATGCAAATCGG')]) + genomeC = makeTempFasta([('chr_one', 'ATGCACGTACGTATGCAATCGG')]) + cm = interhost.CoordMapper() + cm.align_and_load_sequences([genomeA, genomeB, genomeC]) + # check that toChrom is in the map + self.assertEqual(cm.mapChr('chr1', 'chr_one'), 'chr_one') + + def test_single_chr_error(self): + genomeA = makeTempFasta([('chr1', 'ATGCACGTACGTATGCAAATCGG'),]) + genomeB = makeTempFasta([]) + with self.assertRaises(Exception): + cm = interhost.CoordMapper() + cm.align_and_load_sequences([genomeA, genomeB]) + + def test_map_chr_only(self): + self.assertEqual(self.cm.mapChr('chr1', 'first_chrom'), 'first_chrom') + self.assertEqual(self.cm.mapChr('first_chrom', 'chr1'), 'chr1') + self.assertEqual(self.cm.mapChr('chr2', 'second_chr'), 'second_chr') + self.assertEqual(self.cm.mapChr('second_chr', 'chr2'), 'chr2') + self.assertEqual(self.cm.mapChr('chr3', 'third_chr'), 'third_chr') + self.assertEqual(self.cm.mapChr('third_chr', 'chr3'), 'chr3') + self.assertRaises(KeyError, self.cm.mapChr, 'nonexistentchr', 'chr1') + + +class TestSpecificAlignments(test.TestCaseWithTmp): + """""" For the most part, CoordMapper2Seqs is tested implicitly when + CoordMapper is tested. Focus here on special cases that are hard + or impossible to get out of the aligner. + """""" + + def test_basic_alignment(self): + alignment = makeTempFasta([('s1', 'ATCG'), ('s2', 'ACCG'), ('s3', 'AG-T'),]) + cm = interhost.CoordMapper() + cm.load_alignments([alignment]) + + def test_unequal_len(self): + alignment = makeTempFasta([('s1', 'AA'), ('s2', 'A'),]) + cm = interhost.CoordMapper() + with self.assertRaises(Exception): + cm.load_alignments([alignment]) + + def test_no_real_bases_in_sample(self): + alignment1 = makeTempFasta([('s1', 'AA'), ('s2', '--'),]) + cm = interhost.CoordMapper() + cm.load_alignments([alignment1]) + with self.assertRaises(Exception): + cm.mapChr('s1', 's2', 1) + + alignment2 = makeTempFasta([('s1', '--'), ('s2', 'AA'), ('s3', 'TT'),]) + cm = interhost.CoordMapper() + cm.load_alignments([alignment2]) + with self.assertRaises(Exception): + cm.mapChr('s2', 's1', 1) + + def test_no_real_bases_at_position(self): + alignment = makeTempFasta([('s1', 'AT-G'), ('s2', 'AC-G'), ('s3', 'AG-T'),]) + cm = interhost.CoordMapper() + cm.load_alignments([alignment]) + for i in (1, 2, 3): + self.assertEqual(cm.mapChr('s1', 's2', i), ('s2', i)) + self.assertEqual(cm.mapChr('s2', 's1', i), ('s1', i)) + self.assertEqual(cm.mapChr('s1', 's3', i), ('s3', i)) + self.assertEqual(cm.mapChr('s3', 's1', i), ('s1', i)) + self.assertEqual(cm.mapChr('s2', 's3', i), ('s3', i)) + self.assertEqual(cm.mapChr('s3', 's2', i), ('s2', i)) + + def test_aligned_gaps(self): + alignment = makeTempFasta([('s1', 'ATCG'), ('s2', 'AC-G'), ('s3', 'AG-T'),]) + cm = interhost.CoordMapper() + cm.load_alignments([alignment]) + for i in (1, 2, 3): + self.assertEqual(cm.mapChr('s2', 's3', i), ('s3', i)) + self.assertEqual(cm.mapChr('s3', 's2', i), ('s2', i)) + for x, y in ((1, 1), (2, 2), (3, 2), (4, 3)): + self.assertEqual(cm.mapChr('s1', 's2', x), ('s2', y)) + self.assertEqual(cm.mapChr('s1', 's3', x), ('s3', y)) + for x, y in ((1, 1), (2, [2, 3]), (3, 4)): + self.assertEqual(cm.mapChr('s2', 's1', x), ('s1', y)) + self.assertEqual(cm.mapChr('s3', 's1', x), ('s1', y)) + + def test_adjacent_gaps(self): + alignment = makeTempFasta([ + ('s1', 'ATCTG'), + ('s2', 'AC--G'), + ('s3', 'A-TTG'), + ('s4', 'A-C-G'), + ('s5', 'A--CG'), + ]) + cm = interhost.CoordMapper() + cm.load_alignments([alignment]) + for x, y in ((1, 1), (2, 2), (3, 2), (4, 2), (5, 3)): + self.assertEqual(cm.mapChr('s1', 's2', x), ('s2', y)) + for x, y in ((1, 1), (2, [2, 4]), (3, 5)): + self.assertEqual(cm.mapChr('s2', 's1', x), ('s1', y)) + for x, y in ((1, 1), (2, 1), (3, 2), (4, 3), (5, 4)): + self.assertEqual(cm.mapChr('s1', 's3', x), ('s3', y)) + for x, y in ((1, [1, 2]), (2, 3), (3, 4), (4, 5)): + self.assertEqual(cm.mapChr('s3', 's1', x), ('s1', y)) + for x, y in ((1, 1), (2, [2, 3]), (3, 4)): + self.assertEqual(cm.mapChr('s2', 's3', x), ('s3', y)) + for x, y in ((1, 1), (2, 2), (3, 2), (4, 3)): + self.assertEqual(cm.mapChr('s3', 's2', x), ('s2', y)) + for a, b in itertools.combinations(('s2', 's4', 's5'), 2): + for i in (1, 2, 3): + self.assertEqual(cm.mapChr(a, b, i), (b, i)) + self.assertEqual(cm.mapChr(b, a, i), (a, i)) + + def test_one_real_base(self): + alignment = makeTempFasta([('s1', 'AC-'), ('s2', '-CA'),]) + cm = interhost.CoordMapper() + cm.load_alignments([alignment]) + self.assertEqual(cm.mapChr('s1', 's2', 1), ('s2', None)) + self.assertEqual(cm.mapChr('s1', 's2', 2), ('s2', 1)) + self.assertEqual(cm.mapChr('s2', 's1', 1), ('s1', 2)) + self.assertEqual(cm.mapChr('s2', 's1', 2), ('s1', None)) + + def test_exactly_two_pairs(self): + alignment = makeTempFasta([('s1', 'A--T'), ('s2', 'AGGT'),]) + cm = interhost.CoordMapper() + cm.load_alignments([alignment]) + self.assertEqual(cm.mapChr('s1', 's2', 1), ('s2', [1, 3])) + self.assertEqual(cm.mapChr('s1', 's2', 2), ('s2', 4)) + self.assertEqual(cm.mapChr('s2', 's1', 1), ('s1', 1)) + self.assertEqual(cm.mapChr('s2', 's1', 2), ('s1', 1)) + self.assertEqual(cm.mapChr('s2', 's1', 3), ('s1', 1)) + self.assertEqual(cm.mapChr('s2', 's1', 4), ('s1', 2)) +","Python" +"Viral","broadinstitute/viral-ngs","test/unit/test_snake.py",".py","4002","125","# Unit tests for snakemake pipelines + +__author__ = ""dpark@broadinstitute.org"" + +import sys +import os +import subprocess +import shutil +import itertools + +import pytest +import yaml + +import util.cmd +import util.file + + +needs_snakemake = pytest.mark.skipif( + sys.version_info < (3, 5), + reason='python version is too old for snakemake') + + +if sys.version_info >= (3, 5): + import snakemake + + +def add_to_sample_list(workdir, sample_list_name, sample_names): + with open(os.path.join(workdir, 'samples-{}.txt'.format(sample_list_name)), 'a') as outf: + for sample_name in sample_names: + outf.write(sample_name + '\n') + + +def setup_dummy_simple(workdir, sample_names=('G1234', 'G5678', 'G3671.1_r1', 'G3680-1_4', '9876', 'x.y-7b')): + ''' Set up a very simple project directory with empty input files. ''' + + os.mkdir(os.path.join(workdir, 'data')) + os.mkdir(os.path.join(workdir, 'ref_genome_dir')) + os.mkdir(os.path.join(workdir, 'data', '00_raw')) + os.mkdir(os.path.join(workdir, 'data', '01_per_sample')) + os.mkdir(os.path.join(workdir, 'log')) + os.mkdir(os.path.join(workdir, 'reports')) + os.mkdir(os.path.join(workdir, 'tmp')) + + for s in sample_names: + with open(os.path.join(workdir, 'data', '01_per_sample', s + '.raw.bam'), 'wt') as outf: + pass + with open(os.path.join(workdir, 'data', '00_raw', s + '.bam'), 'wt') as outf: + pass + for name in ('assembly', 'depletion', 'runs', 'assembly-failures', 'metagenomics'): + add_to_sample_list(workdir, name, sample_names) + + shutil.copy(os.path.join(util.file.get_project_path(), 'pipes', 'Snakefile'), workdir) + + with open(os.path.join(util.file.get_project_path(), 'pipes', 'config.yaml')) as f: + config = yaml.load(f) + + def translate_remote_s3(uri): + remote_path = uri[5:] + fake_s3_root = os.path.join(util.file.get_project_path(), 'test', 'input', 's3') + local_path = os.path.join(fake_s3_root, remote_path) + return local_path + + for k, v in config.items(): + if isinstance(v, str): + if v.startswith('s3://'): + config[k] = translate_remote_s3(v) + + if util.misc.is_nonstr_iterable(v): + for i, vv in enumerate(v): + if isinstance(vv, str): + if vv.startswith('s3://'): + v[i] = translate_remote_s3(vv) + with open(os.path.join(workdir, 'config.yaml'), 'w') as f: + yaml.dump(config, f) + + os.symlink(util.file.get_project_path(), os.path.join(workdir, 'bin')) + return workdir + + +@pytest.fixture +def workdir(request, tmpdir_function): + env = {'GATK_PATH': os.environ.get('GATK_PATH'), 'NOVOALIGN_PATH': os.environ.get('NOVOALIGN_PATH')} + setup_dummy_simple(tmpdir_function) + yield tmpdir_function + for k, v in env.items(): + if v: + os.environ[k] = v + + +def call_snakemake(workdir, targets=None): + return snakemake.snakemake( + os.path.join(workdir, 'Snakefile'), + configfile=os.path.join(workdir, 'config.yaml'), + workdir=workdir, + dryrun=True, + targets=targets) + + +@needs_snakemake +def test_dryrun_all(workdir): + ''' Test that the ""all"" rule dryruns properly ''' + assert call_snakemake(workdir) + assert call_snakemake(workdir, ['all']) + + +@needs_snakemake +def test_dryrun_all_assemble(workdir): + ''' Test that the ""all_assemble"" rule dryruns properly ''' + assert call_snakemake(workdir, ['all_assemble']) + +@needs_snakemake +def test_dryrun_all_deplete(workdir): + ''' Test that the ""all_deplete"" rule dryruns properly ''' + assert call_snakemake(workdir, ['all_deplete']) + +@needs_snakemake +def test_dryrun_all_metagenomics(workdir): + ''' Test that the ""all_metagenomics"" rule dryruns properly ''' + assert call_snakemake(workdir, ['all_metagenomics']) + +@needs_snakemake +def test_missing_merge_inputs(workdir): + add_to_sample_list(workdir, 'assembly', 'G_missing') + assert call_snakemake(workdir, ['all_assemble']) == False +","Python" +"Viral","broadinstitute/viral-ngs","test/pipelines/snakemake/snake.py",".py","4369","131","""""""Snakemake integration test runner."""""" +from __future__ import print_function +import copy +import os +from os.path import join +import shutil +import tempfile +import subprocess +import util.file +import util.misc +import yaml +from test import _CPUS + + +def merge_yaml_dicts(*dicts): + """"""Merge yaml dicts. + + Only handle top-level yaml dicts. Simply uses dict.update and ignores None + dicts. + """""" + out = copy.deepcopy(dicts[0]) + for d in dicts[1:]: + if d: + out.update(d) + return out + + +def touch(f): + open(f, 'a').close() + + +def rename_raw_bam(bam): + '''*.bam -> *.raw.bam''' + return '.'.join([os.path.splitext(bam)[0], 'raw', 'bam']) + + +class SnakemakeRunner(object): + """"""Generates a working directory for snakemake integration tests. + """""" + + # Keys in config for sample file lists + SAMPLE_FILE_KEYS = { + 'samples_depletion', + 'samples_assembly', + 'samples_metagenomics', + 'samples_assembly_failures', + 'samples_per_run', + } + + def __init__(self, workdir=None): + self.workdir = workdir + self.samples = set() + self.config = None + + @property + def data_dir(self): + return join(self.workdir, self.config['data_dir']) + + def set_override_config(self, config): + """"""Sets a dict of keys to override in base config."""""" + self.override_config = config + + def setup(self): + """"""Create working directory, subdirs, and config."""""" + if not self.workdir: + self.workdir = tempfile.mkdtemp('-snakemake') + elif not os.path.isdir(self.workdir): + os.makedirs(self.workdir) + self.bindir = join(self.workdir, 'bin') + self.root = util.file.get_project_path() + os.symlink(self.root, self.bindir) + os.symlink(join(self.root, 'pipes', 'Snakefile'), join(self.workdir, 'Snakefile')) + with open(join(self.root, 'pipes', 'config.yaml')) as f: + config = yaml.load(f) + self.config = merge_yaml_dicts(config, {'number_of_threads': _CPUS}) + if self.override_config: + self.config = merge_yaml_dicts(self.config, self.override_config) + else: + self.config = config + with open(join(self.workdir, 'config.yaml'), 'w') as f: + yaml.dump(self.config, f) + self.create_subdirs() + + def create_subdirs(self): + """"""Create the data subdirs."""""" + for _, subdir in self.config['subdirs'].items(): + os.makedirs(join(self.data_dir, subdir)) + + def link_samples(self, samples, destination='source', link_transform=None): + """"""Links samples files in data destination dir."""""" + for sample in samples: + link = join(self.data_dir, self.config['subdirs'][destination], os.path.basename(sample)) + + if link_transform: + link = link_transform(link) + os.symlink(sample, link) + self.samples.add(sample) + + def create_sample_files(self, samples=None, sample_files=None): + """"""Creates files for sample lists. + + If samples is None, add all samples to all selected sample_files. If + sample_files is None, write to all sample files. Afterwards, touch all + sample files that weren't written to. + """""" + samples = samples or self.samples + all_sample_files = [self.config[key] for key in SnakemakeRunner.SAMPLE_FILE_KEYS] + + if not sample_files: + sample_files = all_sample_files + for sample_key in sample_files: + sample_file = self.config[sample_key] + with open(join(self.workdir, sample_file), 'w') as f: + for sample in samples: + print(os.path.splitext(os.path.basename(sample))[0], file=f) + + for sample_file in set(all_sample_files) - set(sample_files): + touch(join(self.workdir, sample_file)) + + def run(self, rules=None): + """"""Run snakemake with extra verbosity. """""" + # --resources (with nargs) cannot be the last option before targets + cmd = ['snakemake', '--resources', 'mem=1', 'threads={}'.format(_CPUS), + '--verbose', '--reason', '--printshellcmds'] + if rules: + cmd.extend(rules) + + # run the snakemake command within the runner's workdir + with util.file.pushd_popd(self.workdir): + res = subprocess.check_call(cmd) +","Python" +"Viral","broadinstitute/viral-ngs","test/pipelines/snakemake/test_krakenuniq.py",".py","1346","36","#!/usr/bin/env python + +import os +import sys + +import pytest + +from test.pipelines.snakemake import snake +from test.integration.test_krakenuniq import * # for pytest fixtures + +@pytest.mark.skipif(sys.version_info < (3, 5), reason=""Python version is too old for snakemake."") +def test_pipes(tmpdir_function, krakenuniq_db, krona_db, input_bam): + runner = snake.SnakemakeRunner(workdir=tmpdir_function) + override_config = { + 'krakenuniq_db': krakenuniq_db, + 'krona_db': krona_db, + } + runner.set_override_config(override_config) + runner.setup() + runner.link_samples([input_bam], destination='per_sample', link_transform=snake.rename_raw_bam) + runner.create_sample_files(sample_files=['samples_metagenomics']) + + krakenuniq_out = join( + runner.config['data_dir'], runner.config['subdirs']['metagenomics'], + '.'.join([os.path.splitext(os.path.basename(input_bam))[0], 'raw', 'krakenuniq.report']) + ) + + krona_out = join( + runner.config['data_dir'], runner.config['subdirs']['metagenomics'], + '.'.join([os.path.splitext(os.path.basename(input_bam))[0], 'raw', 'krakenuniq.krona.html']) + ) + + runner.run([krakenuniq_out, krona_out]) + assert os.path.getsize(os.path.join(runner.workdir, krakenuniq_out)) > 0 + assert os.path.getsize(os.path.join(runner.workdir, krona_out)) > 0 +","Python" +"Viral","broadinstitute/viral-ngs","test/pipelines/snakemake/test_kaiju.py",".py","1354","35","#!/usr/bin/env python + +import os +import sys + +import pytest + +import tools +from test.pipelines.snakemake import snake +from test.integration.test_kaiju import * # for pytest fixtures + +@pytest.mark.skipif(sys.version_info < (3, 5), reason=""Python version is too old for snakemake."") +def test_pipes(tmpdir_function, kaiju_db, taxonomy_db, krona_db, input_bam): + runner = snake.SnakemakeRunner(workdir=tmpdir_function) + override_config = { + 'kaiju_db': kaiju_db, + 'taxonomy_db': taxonomy_db, + 'krona_db': krona_db, + } + runner.set_override_config(override_config) + runner.setup() + runner.link_samples([input_bam], destination='per_sample', link_transform=snake.rename_raw_bam) + runner.create_sample_files(sample_files=['samples_metagenomics']) + + krona_out = join(runner.config['data_dir'], runner.config['subdirs']['metagenomics'], + '.'.join([os.path.splitext(os.path.basename(input_bam))[0], 'raw', 'kaiju.krona.html'])) + + kaiju_out = join( + runner.config['data_dir'], runner.config['subdirs']['metagenomics'], + '.'.join([os.path.splitext(os.path.basename(input_bam))[0], 'raw', 'kaiju.report']) + ) + runner.run([krona_out]) + assert os.path.getsize(os.path.join(runner.workdir, kaiju_out)) > 0 + assert os.path.getsize(os.path.join(runner.workdir, krona_out)) > 0 +","Python" +"Viral","broadinstitute/viral-ngs","test/integration/test_assembly.py",".py","5655","142","# Integration tests for assembly.py + +__author__ = ""dpark@broadinstitute.org"" + +import os +import shutil +import tempfile +import itertools +import unittest +import pytest + +import Bio.SeqIO + +import assembly +import util.cmd +import util.file +import tools.novoalign +from test import TestCaseWithTmp, _CPUS + + +@unittest.skip(""redundant, and takes 1 minute"") +class TestAssemble(TestCaseWithTmp): + ''' Test the de novo assembly pipeline ''' + + def test_ref_assisted_assembly(self): + novoalign = tools.novoalign.NovoalignTool() + novoalign.install() + + # prep inputs + orig_ref = os.path.join(util.file.get_test_input_path(), 'ebov-makona.fasta') + refGenome = util.file.mkstempfname('.ref.fasta') + shutil.copyfile(orig_ref, refGenome) + novoalign.index_fasta(refGenome) + inBam = os.path.join(util.file.get_test_input_path(), 'G5012.3.mini.bam') + outFasta = util.file.mkstempfname('.refined.fasta') + + # run refine_assembly + args = [refGenome, inBam, outFasta, ""--chr_names"", 'G5012.3', ""--min_coverage"", '3', ""--novo_params"", + ""-r Random -l 30 -g 40 -x 20 -t 502""] + args = assembly.parser_refine_assembly().parse_args(args) + args.func_main(args) + self.assertTrue(os.path.isfile(outFasta)) + self.assertTrue(os.path.getsize(outFasta) > 1000) + + # check assembly quality + with open(outFasta, 'rt') as inf: + seq = Bio.SeqIO.read(inf, 'fasta') + self.assertGreater(len(seq), 17000) + self.assertGreater(assembly.unambig_count(seq.seq), len(seq) * 0.95) + +# in order to test the actual de novo pipeline, we need to add a clip db for trimmomatic +# then we should test from G5012.3.testreads.bam all the way through the assembly pipe + +class TestRefineAssembly(TestCaseWithTmp): + def test_ebov_refine1(self): + inDir = util.file.get_test_input_path(self) + inFasta = os.path.join(inDir, 'impute.ebov.fasta') + imputeFasta = util.file.mkstempfname('.imputed.fasta') + refine1Fasta = util.file.mkstempfname('.refine1.fasta') + shutil.copy(inFasta, imputeFasta) + tools.picard.CreateSequenceDictionaryTool().execute(imputeFasta, overwrite=True) + tools.novoalign.NovoalignTool().index_fasta(imputeFasta) + assembly.refine_assembly( + imputeFasta, + os.path.join(util.file.get_test_input_path(), 'G5012.3.mini.bam'), + refine1Fasta, + # normally -r Random, but for unit tests, we want deterministic behavior + novo_params='-r None -l 30 -x 20 -t 502', + min_coverage=2) + actual = str(Bio.SeqIO.read(refine1Fasta, 'fasta').seq) + expected = str(Bio.SeqIO.read(os.path.join(inDir, 'expected.ebov.refine1.fasta'), 'fasta').seq) + self.assertEqual(actual, expected) + + def test_ebov_refine2(self): + inDir = util.file.get_test_input_path(self) + inFasta = os.path.join(inDir, 'expected.ebov.refine1.fasta') + refine1Fasta = util.file.mkstempfname('.refine1.fasta') + refine2Fasta = util.file.mkstempfname('.refine2.fasta') + shutil.copy(inFasta, refine1Fasta) + tools.picard.CreateSequenceDictionaryTool().execute(refine1Fasta, overwrite=True) + tools.novoalign.NovoalignTool().index_fasta(refine1Fasta) + assembly.refine_assembly( + refine1Fasta, + os.path.join(util.file.get_test_input_path(), 'G5012.3.mini.bam'), + refine2Fasta, + # normally -r Random, but for unit tests, we want deterministic behavior + novo_params='-r None -l 40 -x 20 -t 100', + min_coverage=3) + actual = str(Bio.SeqIO.read(refine2Fasta, 'fasta').seq) + expected = str(Bio.SeqIO.read(os.path.join(inDir, 'expected.ebov.refine2.fasta'), 'fasta').seq) + self.assertEqual(actual, expected) + + +class TestOrderOrientAndImputeFromReference(TestCaseWithTmp): + # common setup + def setUp(self): + super(TestOrderOrientAndImputeFromReference, self).setUp() + self.inDir = util.file.get_test_input_path(self) + + self.refFasta = os.path.join(self.inDir, 'ref.influenza_partial.fasta') + self.outOrientFasta = util.file.mkstempfname('.fasta') + assembly.order_and_orient( + os.path.join(self.inDir, 'contigs.influenza.fasta'), + self.refFasta, + self.outOrientFasta) + + # common teardown + def tearDown(self): + os.unlink(self.outOrientFasta) + super(TestOrderOrientAndImputeFromReference, self).tearDown() + + def test_impute_from_oriented_muscle(self): + self.influenza_impute(""muscle"") + + def test_impute_from_oriented_mafft(self): + self.influenza_impute(""mafft"") + + def test_impute_from_oriented_mummer(self): + self.influenza_impute(""mummer"") + + # common impute function using the specified aligner + def influenza_impute(self, aligner): + outImputeFasta = util.file.mkstempfname('.fasta') + expected = os.path.join(self.inDir, 'expected.influenza.impute.'+aligner+'.fasta') + # ensure we can run impute_from_reference from the output of order_and_orient + # without errors, but don't actually check the output + assembly.impute_from_reference( + self.outOrientFasta, + self.refFasta, + outImputeFasta, + minLengthFraction=0.8, + minUnambig=0.2, + replaceLength=5, + newName='test_influenza.genome', + aligner=aligner) + + # if we were interested in checking the output... + # self.assertEqualContents( + # outImputeFasta, + # expected + # ) +","Python" +"Viral","broadinstitute/viral-ngs","test/integration/test_taxon_filter.py",".py","4916","134","# Integration tests for taxon_filter.py + +__author__ = ""dpark@broadinstitute.org"" + +import unittest +import os +import tempfile +import subprocess +import shutil + +import argparse + +import taxon_filter +import util.file +import tools.last +import tools.bmtagger +import tools.blast +from test import assert_equal_bam_reads, TestCaseWithTmp + + +class TestDepleteHuman(TestCaseWithTmp): + ''' + This class should move to test/integration. + + How test data was created: + exported 5kb region of chr6 + created pan-viral fasta file from all NCBI viral accessions + used wgsim to create simulated reads + ''' + + def setUp(self): + TestCaseWithTmp.setUp(self) + self.tempDir = tempfile.mkdtemp() + myInputDir = util.file.get_test_input_path() + ref_fasta = os.path.join(myInputDir, '5kb_human_from_chr6.fasta') + self.database_prefix_path = os.path.join(self.tempDir, ""5kb_human_from_chr6"") + + # create blast db + self.blastdb_path = tools.blast.MakeblastdbTool().build_database(ref_fasta, self.database_prefix_path) + + # create bmtagger db + taxon_filter.bmtagger_build_db(ref_fasta, self.tempDir, ""5kb_human_from_chr6"", word_size=8) + + def test_deplete_human(self): + myInputDir = util.file.get_test_input_path(self) + + # Run deplete_human + args = taxon_filter.parser_deplete(argparse.ArgumentParser()).parse_args( + [ + os.path.join(myInputDir, 'test-reads.bam'), + # output files + os.path.join(self.tempDir, 'test-reads.revert.bam'), + os.path.join(self.tempDir, 'test-reads.bwa.bam'), + os.path.join(self.tempDir, 'test-reads.bmtagger.bam'), + os.path.join(self.tempDir, 'test-reads.rmdup.bam'), + os.path.join(self.tempDir, 'test-reads.blastn.bam'), + # DBs + ""--blastDbs"", self.blastdb_path, + ""--bmtaggerDbs"", self.database_prefix_path, + ""--chunkSize"", ""0"", + ""--srprismMemory"", '1500', + ] + ) + args.func_main(args) + + # Compare to expected + for fname in [ + 'test-reads.revert.bam', + 'test-reads.bwa.bam', + 'test-reads.bmtagger.bam', + 'test-reads.rmdup.bam', + 'test-reads.blastn.bam' + ]: + assert_equal_bam_reads(self, os.path.join(self.tempDir, fname), os.path.join(myInputDir, 'expected', fname)) + + def test_deplete_human_aligned_input(self): + myInputDir = util.file.get_test_input_path(self) + + # Run deplete_human + args = taxon_filter.parser_deplete(argparse.ArgumentParser()).parse_args( + [ + os.path.join(myInputDir, 'test-reads-aligned.bam'), + # output files + os.path.join(self.tempDir, 'test-reads.revert.bam'), + os.path.join(self.tempDir, 'test-reads.bwa.bam'), + os.path.join(self.tempDir, 'test-reads.bmtagger.bam'), + os.path.join(self.tempDir, 'test-reads.rmdup.bam'), + os.path.join(self.tempDir, 'test-reads.blastn.bam'), + # DBs + ""--blastDbs"", self.blastdb_path, + ""--bmtaggerDbs"", self.database_prefix_path, + ""--srprismMemory"", '1500', + ] + ) + args.func_main(args) + + # Compare to expected + for fname in [ + 'test-reads.revert.bam', + 'test-reads.bwa.bam', + 'test-reads.bmtagger.bam', + 'test-reads.rmdup.bam', + 'test-reads.blastn.bam' + ]: + assert_equal_bam_reads(self, os.path.join(self.tempDir, fname), os.path.join(myInputDir, 'aligned-expected', fname)) + + def test_deplete_empty(self): + empty_bam = os.path.join(util.file.get_test_input_path(), 'empty.bam') + + # Run deplete_human + args = taxon_filter.parser_deplete(argparse.ArgumentParser()).parse_args( + [ + empty_bam, + # output files + os.path.join(self.tempDir, 'deplete-empty.revert.bam'), + os.path.join(self.tempDir, 'deplete-empty.bwa.bam'), + os.path.join(self.tempDir, 'deplete-empty.bmtagger.bam'), + os.path.join(self.tempDir, 'deplete-empty.rmdup.bam'), + os.path.join(self.tempDir, 'deplete-empty.blastn.bam'), + # DBs + ""--blastDbs"", self.blastdb_path, + ""--bmtaggerDbs"", self.database_prefix_path, + ""--srprismMemory"", '1500', + ] + ) + args.func_main(args) + + # Compare to expected + for fname in [ + 'deplete-empty.bmtagger.bam', + 'deplete-empty.rmdup.bam', 'deplete-empty.blastn.bam', + ]: + assert_equal_bam_reads(self, os.path.join(self.tempDir, fname), empty_bam) +","Python" +"Viral","broadinstitute/viral-ngs","test/integration/test_ncbi.py",".py","16147","369","#!/usr/bin/python + +__author__ = ""tomkinsc@broadinstitute.org"" + +# built-ins +import unittest +import os +import argparse +import pickle +import shutil +import tempfile +from collections import OrderedDict +import logging + +# module-specific +from test import TestCaseWithTmp +import ncbi +import util.file + +log = logging.getLogger(__name__) + + +skip_test = True + +@unittest.skipIf(skip_test, ""test is marked to be skipped"") +class TestNcbiFetch(TestCaseWithTmp): + + def setUp(self): + super(TestNcbiFetch, self).setUp() + + # these are Orungo accessions + self.accessions = [""JQ610675.1"", ""JQ610676.1"", ""JQ610677.1"", ""JQ610678.1"", ""JQ610679.1"", ""JQ610680.1"", + ""JQ610681.1"", ""JQ610682.1"", ""JQ610683.1"", ""JQ610684.1""] + + self.myInputDir = util.file.get_test_input_path(self) + + def perform_download_and_check(self, parser_func, additional_args, expected_files, null_files): + temp_dir = tempfile.gettempdir() + + args = [""viral-ngs-test@example.com"", temp_dir] + args.extend(self.accessions) + args.extend(additional_args) + + args = parser_func(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + + # check that each file that each expected file was downloaded + # and that the contents match what they should be + for fileName in expected_files: + createdFilePath = os.path.join(temp_dir, fileName) + log.info(""createdFilePath: {}"".format(createdFilePath)) + assert os.path.exists( + createdFilePath), ""File that should have been created does not exist: %s"" % createdFilePath + self.assertEqualContents(createdFilePath, os.path.join(self.myInputDir, fileName)) + + for fileName in null_files: + shouldNotExistFilePath = os.path.join(temp_dir, fileName) + assert not os.path.exists( + shouldNotExistFilePath), ""File exists but it should not: %s"" % shouldNotExistFilePath + + +class TestFastaFetch(TestNcbiFetch): + + def setUp(self): + super(TestFastaFetch, self).setUp() + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_download(self): + args = [] + expectedFiles = [a + "".fasta"" for a in self.accessions] + null_files = [] + + self.perform_download_and_check(ncbi.parser_fetch_fastas, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_concat(self): + args = [""--combinedFilePrefix"", ""orungo""] + expectedFiles = [""orungo.fasta""] + null_files = [] + + self.perform_download_and_check(ncbi.parser_fetch_fastas, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_removal_of_intermediates(self): + args = [""--combinedFilePrefix"", ""orungo"", ""--removeSeparateFiles""] + expectedFiles = [""orungo.fasta""] + null_files = [a + "".fasta"" for a in self.accessions] + + self.perform_download_and_check(ncbi.parser_fetch_fastas, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_individual_preexistance(self): + # since the arguments are positional, including an accession here makes a duplicate that should + # raise an Error + args = [self.accessions[0]] + args.extend([""--combinedFilePrefix"", ""orungo""]) + expectedFiles = [""orungo.fasta""] + null_files = [] + + with self.assertRaises(AssertionError): + self.perform_download_and_check(ncbi.parser_fetch_fastas, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_combined_preexistance(self): + args = [""--combinedFilePrefix"", ""orungo""] + expectedFiles = [""orungo.fasta""] + null_files = [] + + # call once to create the combined file + self.perform_download_and_check(ncbi.parser_fetch_fastas, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + # an error should be raised the second time the call is made + with self.assertRaises(AssertionError): + self.perform_download_and_check(ncbi.parser_fetch_fastas, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_overwrite(self): + args = [""--combinedFilePrefix"", ""orungo"", ""--forceOverwrite""] + expectedFiles = [""orungo.fasta""] + null_files = [] + + # call once to create the combined file + self.perform_download_and_check(ncbi.parser_fetch_fastas, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + # no error should be raised the second time the call is made + self.perform_download_and_check(ncbi.parser_fetch_fastas, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_different_file_extension(self): + args = [""--fileExt"", ""fa"", ""--combinedFilePrefix"", ""orungo""] + expectedFiles = [a + "".fa"" for a in self.accessions] + expectedFiles.append(""orungo.fa"") + null_files = [] + + self.perform_download_and_check(ncbi.parser_fetch_fastas, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + +class TestFeatureTableFetch(TestNcbiFetch): + + def setUp(self): + super(TestFeatureTableFetch, self).setUp() + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_download(self): + args = [] + expectedFiles = [a + "".tbl"" for a in self.accessions] + null_files = [] + + self.perform_download_and_check(ncbi.parser_fetch_feature_tables, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_concat(self): + args = [""--combinedFilePrefix"", ""orungo""] + expectedFiles = [""orungo.tbl""] + null_files = [] + + self.perform_download_and_check(ncbi.parser_fetch_feature_tables, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_removal_of_intermediates(self): + args = [""--combinedFilePrefix"", ""orungo"", ""--removeSeparateFiles""] + expectedFiles = [""orungo.tbl""] + null_files = [a + "".tbl"" for a in self.accessions] + + self.perform_download_and_check(ncbi.parser_fetch_feature_tables, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_individual_preexistance(self): + # since the arguments are positional, including an accession here makes a duplicate that should + # raise an Error + args = [self.accessions[0]] + args.extend([""--combinedFilePrefix"", ""orungo""]) + expectedFiles = [""orungo.tbl""] + null_files = [] + + with self.assertRaises(AssertionError): + self.perform_download_and_check(ncbi.parser_fetch_feature_tables, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_combined_preexistance(self): + args = [""--combinedFilePrefix"", ""orungo""] + expectedFiles = [""orungo.tbl""] + null_files = [] + + # call once to create the combined file + self.perform_download_and_check(ncbi.parser_fetch_feature_tables, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + # an error should be raised the second time the call is made + with self.assertRaises(AssertionError): + self.perform_download_and_check(ncbi.parser_fetch_feature_tables, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_overwrite(self): + args = [""--combinedFilePrefix"", ""orungo"", ""--forceOverwrite""] + expectedFiles = [""orungo.tbl""] + null_files = [] + + # call once to create the combined file + self.perform_download_and_check(ncbi.parser_fetch_feature_tables, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + # no error should be raised the second time the call is made + self.perform_download_and_check(ncbi.parser_fetch_feature_tables, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_different_file_extension(self): + args = [""--fileExt"", ""table"", ""--combinedFilePrefix"", ""orungo""] + expectedFiles = [a + "".table"" for a in self.accessions] + expectedFiles.append(""orungo.table"") + null_files = [] + + self.perform_download_and_check(ncbi.parser_fetch_feature_tables, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + +class TestGenbankRecordFetch(TestNcbiFetch): + + def setUp(self): + super(TestGenbankRecordFetch, self).setUp() + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_download(self): + args = [] + expectedFiles = [a + "".gbk"" for a in self.accessions] + null_files = [] + + self.perform_download_and_check(ncbi.parser_fetch_genbank_records, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_concat(self): + args = [""--combinedFilePrefix"", ""orungo""] + expectedFiles = [""orungo.gbk""] + null_files = [] + + self.perform_download_and_check(ncbi.parser_fetch_genbank_records, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_removal_of_intermediates(self): + args = [""--combinedFilePrefix"", ""orungo"", ""--removeSeparateFiles""] + expectedFiles = [""orungo.gbk""] + null_files = [a + "".gbk"" for a in self.accessions] + + self.perform_download_and_check(ncbi.parser_fetch_genbank_records, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_individual_preexistance(self): + # since the arguments are positional, including an accession here makes a duplicate that should + # raise an Error + args = [self.accessions[0]] + args.extend([""--combinedFilePrefix"", ""orungo""]) + expectedFiles = [""orungo.gbk""] + null_files = [] + + with self.assertRaises(AssertionError): + self.perform_download_and_check(ncbi.parser_fetch_genbank_records, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_combined_preexistance(self): + args = [""--combinedFilePrefix"", ""orungo""] + expectedFiles = [""orungo.gbk""] + null_files = [] + + # call once to create the combined file + self.perform_download_and_check(ncbi.parser_fetch_genbank_records, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + # an error should be raised the second time the call is made + with self.assertRaises(AssertionError): + self.perform_download_and_check(ncbi.parser_fetch_genbank_records, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_overwrite(self): + args = [""--combinedFilePrefix"", ""orungo"", ""--forceOverwrite""] + expectedFiles = [""orungo.gbk""] + null_files = [] + + # call once to create the combined file + self.perform_download_and_check(ncbi.parser_fetch_genbank_records, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + # no error should be raised the second time the call is made + self.perform_download_and_check(ncbi.parser_fetch_genbank_records, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) + + @unittest.skipIf(skip_test, ""test is marked to be skipped"") + def test_different_file_extension(self): + args = [""--fileExt"", ""gb"", ""--combinedFilePrefix"", ""orungo""] + expectedFiles = [a + "".gb"" for a in self.accessions] + expectedFiles.append(""orungo.gb"") + null_files = [] + + self.perform_download_and_check(ncbi.parser_fetch_genbank_records, + additional_args=args, + expected_files=expectedFiles, + null_files=null_files) +","Python" +"Viral","broadinstitute/viral-ngs","test/integration/test_intrahost.py",".py","7784","157","# Integration tests for intrahost.py + +__author__ = ""dpark@broadinstitute.org"" + +# built-ins +import os +import os.path +import shutil +import tempfile +import argparse +import unittest + +# module-specific +import intrahost +import interhost +import tools.mafft +import util.file +import util.vcf +import test +from test import TestCaseWithTmp +import tools + +# third-party +import pytest + +class TestPerSample(test.TestCaseWithTmp): + ''' This tests step 1 of the iSNV calling process + (intrahost.vphaser_one_sample), which runs V-Phaser2 on + a single sample, reformats the output slightly, and performs + strand-bias filtering and adds library-bias statistics. + ''' + + #@unittest.skipIf(tools.is_osx(), ""vphaser2 osx binary from bioconda has issues"") + def test_vphaser_one_sample_indels(self): + # Files here were created as follows: + # ref.indels.fasta is Seed-stock-137_S2_L001_001.fasta + # in.indels.bam was created from Seed-stock-137_S2_L001_001.mapped.bam + # as follows: + # Created two .sam files using samtools view, restricting to ranges + # 6811-7011 and 13081-13281, respectively. Paired reads were removed + # from those files by throwing out the second occurence of any read name + # and anding the flag fields with 16. Then, a random 90% of reads were + # removed, except that any reads containing the indel variants at + # 6911 and 13181 were kept. Then the resulting 2 files were combined. + myInputDir = util.file.get_test_input_path(self) + inBam = os.path.join(myInputDir, 'in.indels.bam') + refFasta = os.path.join(myInputDir, 'ref.indels.fasta') + outTab = util.file.mkstempfname('.txt') + intrahost.vphaser_one_sample(inBam, refFasta, outTab, vphaserNumThreads=test._CPUS, minReadsEach=0) + expected = os.path.join(myInputDir, 'vphaser_one_sample_indels_expected.txt') + self.assertEqualContents(outTab, expected) + + def test_vphaser_one_sample_one_mate_unpaired(self): + # Files here were created as follows: + # ref.indels.fasta is Seed-stock-137_S2_L001_001.fasta + # in.oneunmapped.bam was created from in.indels.bam, with flag 0->89, 16->73: + # When removing doubly mapped reads, doing so can result in all reads + # being removed in the case of low-quality runs with few reads + # This tests that when v-phaser2 input is empty, a blank + # file is created as output. + myInputDir = util.file.get_test_input_path(self) + inBam = os.path.join(myInputDir, 'in.oneunmapped.bam') + refFasta = os.path.join(myInputDir, 'ref.indels.fasta') + outTab = util.file.mkstempfname('.txt') + intrahost.vphaser_one_sample(inBam, refFasta, outTab, vphaserNumThreads=test._CPUS, minReadsEach=0, removeDoublyMappedReads=True) + assert os.path.getsize(outTab) == 0 + + #@unittest.skipIf(tools.is_osx(), ""vphaser2 osx binary from bioconda has issues"") + def test_vphaser_one_sample_2libs(self): + # in.2libs.bam was created by ""manually"" editing in.bam and moving about + # 1/3 of the reads to ReadGroup2. + myInputDir = util.file.get_test_input_path(self) + inBam = os.path.join(myInputDir, 'in.2libs.bam') + refFasta = os.path.join(myInputDir, 'ref.fasta') + outTab = util.file.mkstempfname('.txt') + intrahost.vphaser_one_sample(inBam, refFasta, outTab, vphaserNumThreads=test._CPUS, minReadsEach=6, maxBias=3) + expected = os.path.join(myInputDir, 'vphaser_one_sample_2libs_expected.txt') + self.assertEqualContents(outTab, expected) + + #@unittest.skipIf(tools.is_osx(), ""vphaser2 osx binary from bioconda has issues"") + def test_vphaser_one_sample_3libs_and_chi2(self): + # In addition to testing that we can handle 3 libraries, this is testing + # the chi2_contingency approximation to fisher_exact. The 4th, 5th, + # and 6th rows have large enough minor allele count that their + # p-values are calculated using the chi2 approximation. The other + # rows are testing the 2 x 3 case of fisher_exact. + # in.3libs.bam was created by ""manually"" editing in.2libs.bam and moving + # about 1/2 of the reads in ReadGroup2 to ReadGroup3. + myInputDir = util.file.get_test_input_path(self) + inBam = os.path.join(myInputDir, 'in.3libs.bam') + refFasta = os.path.join(myInputDir, 'ref.fasta') + outTab = util.file.mkstempfname('.txt') + intrahost.vphaser_one_sample(inBam, refFasta, outTab, vphaserNumThreads=test._CPUS, minReadsEach=6, maxBias=3) + expected = os.path.join(myInputDir, 'vphaser_one_sample_3libs_expected.txt') + self.assertEqualContents(outTab, expected) + +class TestSnpEff(TestCaseWithTmp): + @pytest.fixture(autouse=True) + def capsys(self, capsys): + self.capsys = capsys + + def test_snpeff(self): + temp_dir = tempfile.gettempdir() + input_dir = util.file.get_test_input_path(self) + + ref_fasta = os.path.join(input_dir,""ref-rabies-JQ685920.fasta"") + assembly_fasta = os.path.join(input_dir,""RBV16.fasta"") + isnv_calls = os.path.join(input_dir,""vphaser2.RBV16.mapped.txt.gz"") + + # align sample to reference to create MSA + msa_fasta = util.file.mkstempfname('.fasta') + expected_msa_fasta = os.path.join(input_dir,""msa.fasta"") + args = [ref_fasta, assembly_fasta, msa_fasta, ""--localpair"", ""--preservecase""] + args = interhost.parser_align_mafft(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + test.assert_equal_contents(self, msa_fasta, expected_msa_fasta) + + # merge (one) VCF to merged vcf + merged_vcf = os.path.join(temp_dir,""merged.vcf.gz"") + expected_merged_vcf = os.path.join(input_dir,""merged.vcf.gz"") + args = [ref_fasta, merged_vcf, ""--isnvs"", isnv_calls, ""--alignments"", msa_fasta, ""--strip_chr_version"", ""--parse_accession""] + args = intrahost.parser_merge_to_vcf(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + vcf = util.vcf.VcfReader(merged_vcf) + expected_vcf = util.vcf.VcfReader(expected_merged_vcf) + rows = list(vcf.get()) + expected_rows = list(expected_vcf.get()) + #self.assertEqual(rows, expected_rows) + + # run snpEff against merged VCF to predict SNP effects + eff_vcf = os.path.join(temp_dir,""ann_eff.vcf.gz"") + expected_eff_vcf = os.path.join(input_dir,""ann_eff.vcf.gz"") + args = [merged_vcf, ""JQ685920"", eff_vcf, ""--emailAddress=test@example.com""] + args = interhost.parser_snpEff(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + vcf = util.vcf.VcfReader(eff_vcf) + expected_vcf = util.vcf.VcfReader(expected_eff_vcf) + rows = list(vcf.get()) + expected_rows = list(expected_vcf.get()) + #self.assertEqual(rows, expected_rows) + + # create tabular iSNV output + eff_txt = os.path.join(temp_dir,""ann_eff.txt.gz"") + expected_eff_txt = os.path.join(input_dir,""ann_eff.txt.gz"") + args = [eff_vcf, eff_txt] + args = intrahost.parser_iSNV_table(argparse.ArgumentParser()).parse_args(args) + args.func_main(args) + for outrow, expectedrow in zip(util.file.read_tabfile(eff_txt),util.file.read_tabfile(expected_eff_txt)): + for colout, colexpected in zip(outrow, expectedrow): + # if it casts to float, perform approx comparison + try: + f1=float(colout) + f2=float(colexpected) + self.assertAlmostEqual(f1, f1) + except ValueError: + self.assertEqual(sorted(sorted(colout.split("",""))), sorted(sorted(colexpected.split("","")))) +","Python" +"Viral","broadinstitute/viral-ngs","test/integration/fixtures.py",".py","1359","51","import gzip +import os +from os.path import join +import shutil +import tools +import tools.kaiju +import tools.picard +import tools.krona +import util.file + +# @pytest.fixture(scope='module') +def krona(): + krona = tools.krona.Krona() + krona.install() + return krona + + +# @pytest.fixture(scope='module', params=['TestMetagenomicsSimple', 'TestMetagenomicsViralMix']) +def db_type(request): + return request.param + + +# @pytest.fixture(scope='module') +def krona_db(request, tmpdir_module, krona, db_type): + data_dir = join(util.file.get_test_input_path(), db_type) + db_dir = join(data_dir, 'db') + + db = join(tmpdir_module, 'krona_db_{}'.format(db_type)) + os.mkdir(db) + for d in ('names.dmp', 'nodes.dmp'): + src = join(db_dir, 'taxonomy', d) + dest = join(db, d) + if os.path.isfile(src): + os.symlink(src, dest) + krona.create_db(db) + return db + + +def taxonomy_db(request, tmpdir_module, db_type): + taxonomy = join(tmpdir_module, db_type, 'taxonomy') + shutil.copytree(join(util.file.get_test_input_path(), db_type, 'db', 'taxonomy'), + taxonomy) + prot = join(taxonomy, 'accession2taxid', 'prot.accession2taxid') + prot_gz = prot + '.gz' + + with open(prot, 'rb') as f_in: + with gzip.open(prot_gz, 'wb') as f_out: + shutil.copyfileobj(f_in, f_out) + + return taxonomy +","Python" +"Viral","broadinstitute/viral-ngs","test/integration/__init__.py",".py","1","2"," +","Python" +"Viral","broadinstitute/viral-ngs","test/integration/test_krakenuniq.py",".py","4899","142","# Integration tests for krakenuniq +import argparse +import binascii +import os +import os.path +from os.path import join + +import lxml.html.clean +import pytest + +import metagenomics +import unittest +import util.file +import tools +import tools.kraken +import tools.krona +import tools.picard +import test.integration.fixtures + + +def is_gz_file(filepath): + with open(filepath, 'rb') as test_f: + return binascii.hexlify(test_f.read(2)) == b'1f8b' + + +krona = pytest.fixture(scope='module')(test.integration.fixtures.krona) +krona_db = pytest.fixture(scope='module')(test.integration.fixtures.krona_db) + + +@pytest.fixture() +def input_bam(db_type): + data_dir = join(util.file.get_test_input_path(), db_type) + return join(data_dir, 'test-reads.bam') + + +@pytest.fixture(scope='module') +def krakenuniq(): + krakenuniq = tools.kraken.KrakenUniq() + krakenuniq.install() + return krakenuniq + + +@pytest.fixture(scope='module', params=['TestMetagenomicsSimple', 'TestMetagenomicsViralMix']) +def db_type(request): + return request.param + + +@pytest.fixture(scope='module') +def krakenuniq_db(request, tmpdir_module, krakenuniq, db_type): + data_dir = join(util.file.get_test_input_path(), db_type) + db_dir = join(data_dir, 'db') + + db = join(tmpdir_module, 'krakenuniq_db_{}'.format(db_type)) + parser = metagenomics.parser_krakenuniq_build(argparse.ArgumentParser()) + cmd = [db, '--library', join(db_dir, 'library'), + '--taxonomy', join(db_dir, 'taxonomy'), + '--subsetTaxonomy', + '--minimizerLen', '10', + '--clean'] + + parser.parse_args(cmd) + args = parser.parse_args(cmd) + args.func_main(args) + return db + + +def test_krakenuniq(krakenuniq_db, input_bam): + out_report = util.file.mkstempfname('.report') + out_reads = util.file.mkstempfname('.reads.gz') + cmd = [krakenuniq_db, input_bam, '--outReports', out_report, '--outReads', out_reads] + parser = metagenomics.parser_krakenuniq(argparse.ArgumentParser()) + args = parser.parse_args(cmd) + args.func_main(args) + + with util.file.open_or_gzopen(out_reads, 'r') as inf: + assert len(inf.read()) > 0 + with util.file.open_or_gzopen(out_report) as inf: + report_lines = [x.strip().split('\t') for x in inf.readlines()] + report_lines = [x for x in report_lines if x] + + assert is_gz_file(out_reads) + assert os.path.getsize(out_report) > 0 + + if 'TestMetagenomicsSimple' in krakenuniq_db: + zaire_found = False + tai_found = False + for line in report_lines: + if 'Zaire ebolavirus' in line[-1] and float(line[0]) > 90: + zaire_found = True + elif 'Tai Forest' in line[-1]: + tai_found = True + assert zaire_found + assert not tai_found + + +def test_krakenuniq_krona(krakenuniq_db, krona_db, input_bam): + out_report = util.file.mkstempfname('.report') + out_reads = util.file.mkstempfname('.reads.gz') + + cmd = [krakenuniq_db, input_bam, '--outReport', out_report, '--outReads', out_reads] + parser = metagenomics.parser_krakenuniq(argparse.ArgumentParser()) + args = parser.parse_args(cmd) + args.func_main(args) + + out_html = util.file.mkstempfname('.krona.html') + parser = metagenomics.parser_krona(argparse.ArgumentParser()) + args = parser.parse_args(['--inputType', 'krakenuniq', out_report, krona_db, out_html]) + args.func_main(args) + + if 'TestMetagenomicsSimple' in krakenuniq_db: + ebola_found = False + cleaner = lxml.html.clean.Cleaner(remove_unknown_tags=False, page_structure=False) + tree = cleaner.clean_html(lxml.html.parse(out_html)) + root_node = tree.xpath('//krona/node')[0] + for n in root_node.iterdescendants(): + if n.get('name') == 'Zaire ebolavirus': + if int(n.xpath('magnitude/val')[0].text) > 0: + ebola_found = True + assert ebola_found + + +def test_krakenuniq_on_empty(krakenuniq_db, input_bam): + if 'TestMetagenomicsViralMix' not in krakenuniq_db: + return + input_bam = join(util.file.get_test_input_path(), 'empty.bam') + out_report = util.file.mkstempfname('.report') + out_reads = util.file.mkstempfname('.reads.gz') + cmd = [krakenuniq_db, input_bam, '--outReport', out_report, '--outReads', out_reads] + parser = metagenomics.parser_krakenuniq(argparse.ArgumentParser()) + args = parser.parse_args(cmd) + args.func_main(args) + + with util.file.open_or_gzopen(out_reads, 'r') as inf: + assert len(inf.read()) == 0 + + assert is_gz_file(out_reads) + with open(out_report, 'rt') as inf: + lines = [line.strip() for line in inf.readlines() if not line.startswith('#') and not line.startswith('%')] + out_report_contents = [line for line in lines if line] + assert len(out_report_contents) == 1 + assert out_report_contents[0].split('\t') == ['100.00', '0', '0', '0', '0', 'NA', '0', 'no rank', 'unclassified'] +","Python" +"Viral","broadinstitute/viral-ngs","test/integration/test_kaiju.py",".py","5193","164","# Integration tests for kaiju +from builtins import super +import argparse +import binascii +import fnmatch +import gzip +import os +from os.path import join +import sys +import shutil +import tempfile + +import lxml.html.clean +import pytest +from Bio import SeqIO + +import metagenomics +import tools +import tools.kaiju +import tools.picard +import util.file +import test.integration.fixtures + + +def is_gz_file(filepath): + with open(filepath, 'rb') as test_f: + return binascii.hexlify(test_f.read(2)) == b'1f8b' + + +def find_files(root_dir, filt): + matches = [] + for root, dirnames, filenames in os.walk(root_dir): + for filename in fnmatch.filter(filenames, filt): + yield join(root, filename) + + +krona = pytest.fixture(scope='module')(test.integration.fixtures.krona) +krona_db = pytest.fixture(scope='module')(test.integration.fixtures.krona_db) +taxonomy_db = pytest.fixture(scope='module')(test.integration.fixtures.taxonomy_db) + + +@pytest.fixture(scope='module') +def fastq_to_sam(): + return tools.picard.FastqToSamTool() + + +@pytest.fixture(scope='module') +def sam_to_fastq(): + return tools.picard.SamToFastqTool() + + +@pytest.fixture(scope='module') +def kaiju(): + kaiju = tools.kaiju.Kaiju() + kaiju.install() + return kaiju + + +@pytest.fixture(scope='module', params=['TestMetagenomicsSimple', 'TestMetagenomicsViralMix']) +def db_type(request): + return request.param + + +def input_fastq_paths(): + data_dir = join(util.file.get_test_input_path(), 'TestMetagenomicsSimple') + return [join(data_dir, f) for f in ['zaire_ebola.1.fastq', 'zaire_ebola.2.fastq']] + + +def input_bam_paths(): + data_dir = join(util.file.get_test_input_path(), 'TestMetagenomicsViralMix') + return join(data_dir, 'test-reads.bam') + + +@pytest.fixture(scope='module') +def input_bam(request, tmpdir_module, fastq_to_sam, db_type): + data_dir = join(util.file.get_test_input_path(), db_type) + if db_type == 'TestMetagenomicsSimple': + fastqs = [join(data_dir, f) for f in ['zaire_ebola.1.fastq', 'zaire_ebola.2.fastq']] + + bam_name = 'zaire_ebola.bam' + bam = join(tmpdir_module, bam_name) + fastq_to_sam.execute(fastqs[0], fastqs[1], '', bam) + return bam + + return input_bam_paths() + + +@pytest.fixture(scope='module') +def input_fastqs(request, tmpdir_module, sam_to_fastq, db_type): + data_dir = join(util.file.get_test_input_path(), db_type) + if db_type == 'TestMetagenomicsSimple': + fastqs = [join(data_dir, f) for f in ['zaire_ebola.1.fastq', 'zaire_ebola.2.fastq']] + return fastqs + + bam = join(data_dir, 'test-reads.bam') + basename = os.path.basename(bam) + fastq1 = join(tmpdir_module, '{}.1.fastq'.format(basename)) + fastq2 = join(tmpdir_module, '{}.2.fastq'.format(basename)) + sam_to_fastq.execute(bam, fastq1, fastq2) + return fastq1, fastq2 + + +@pytest.fixture(scope='module') +def kaiju_db(request, tmpdir_module, kaiju, taxonomy_db, db_type): + data_dir = join(util.file.get_test_input_path(), db_type) + db_dir = join(data_dir, 'db') + + db_prefix = join(tmpdir_module, db_type) + translated = join(tmpdir_module, db_type + '.faa') + + lib_dir = join(db_dir, 'library') + util.file.cat(translated, find_files(db_dir, '*.faa')) + + kaiju.build(db_prefix, [translated], tax_db=taxonomy_db, translate_accessions=True) + return db_prefix + '.fmi' + + +def test_kaiju(kaiju_db, krona_db, taxonomy_db, input_bam): + out_report = util.file.mkstempfname('.report') + out_reads = util.file.mkstempfname('.reads') + cmd = [input_bam, kaiju_db, taxonomy_db, out_report, '--outReads', out_reads] + parser = metagenomics.parser_kaiju(argparse.ArgumentParser()) + args = parser.parse_args(cmd) + args.func_main(args) + + assert os.path.getsize(out_report) > 0 + assert os.path.getsize(out_reads) > 0 + + with util.file.open_or_gzopen(out_report) as inf: + report_lines = [x.strip().split('\t') for x in inf.readlines()] + report_lines = [x for x in report_lines if x] + + assert is_gz_file(out_reads) + assert os.path.getsize(out_report) > 0 + + if 'TestMetagenomicsSimple' in kaiju_db: + zaire_found = False + tai_found = False + for line in report_lines: + if len(line) < 2: + continue + if 'Zaire ebolavirus' in line[-2] and float(line[0]) > 40: + zaire_found = True + elif 'Tai Forest' in line[-2]: + tai_found = True + assert zaire_found + assert not tai_found + + out_html = util.file.mkstempfname('.krona.html') + parser = metagenomics.parser_krona(argparse.ArgumentParser()) + args = parser.parse_args(['--inputType', 'kaiju', out_report, krona_db, out_html]) + args.func_main(args) + + if 'TestMetagenomicsSimple' in kaiju_db: + ebola_found = False + cleaner = lxml.html.clean.Cleaner(remove_unknown_tags=False, page_structure=False) + tree = cleaner.clean_html(lxml.html.parse(out_html)) + root_node = tree.xpath('//krona/node')[0] + for n in root_node.iterdescendants(): + if n.get('name') == 'Zaire ebolavirus': + if int(n.xpath('magnitude/val')[0].text) > 0: + ebola_found = True + assert ebola_found +","Python" +"Viral","broadinstitute/viral-ngs","packaging/conda-recipe/render-recipe.py",".py","12744","302","#!/usr/bin/env python + +# stdlib +import os, sys, re +import glob +import json +import pprint +import argparse +import hashlib +import time + +from urllib.request import urlopen + +# third party +import jinja2 + +"""""" +Renders Jinja2 templates using variables from dependency files + +The behavior is not (yet) recursive. +"""""" + +input_directory = ""viral-ngs-template"" +output_directory = ""viral-ngs"" +source_url = """" + +dir_path = os.path.dirname(os.path.realpath(__file__)) + +class VersionString(object): + """""" + Class to validate and parse PEP440 version strings (also used by conda) + Shortened and derived from: https://github.com/pypa/packaging/blob/16.7/packaging/version.py + """""" + + VERSION_PATTERN = r"""""" + (?Pv?) + (?: + (?:(?P[0-9]+)!)? # epoch + (?P[0-9]+(?:\.[0-9]+)*) # release segment + (?P
                                          # pre-release
+            [-_\.]?
+            (?P(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+        (?P                                         # post release
+            (?:-(?P[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?Ppost|rev|r)
+                [-_\.]?
+                (?P[0-9]+)?
+            )
+        )?
+        (?P                                          # dev release
+            [-_\.]?
+            (?Pdev)
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+    )
+    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+    """"""
+    version_re = re.compile(
+        r""^\s*"" + VERSION_PATTERN + r""\s*$"",
+        re.VERBOSE | re.IGNORECASE,)
+
+    def __init__(self, v):
+        self.v = v
+
+    def __str__(self):
+        parts = []
+
+        try:
+            # 'v' prefix
+            if self.version_re.match(self.v).group(""prefix"") is not None:
+                parts.append(""{0}"".format(self.version_re.match(self.v).group(""prefix"")))
+
+            # Epoch
+            if ( int(self.version_re.match(self.v).group(""epoch"")) if self.version_re.match(self.v).group(""epoch"") else 0) != 0:
+                parts.append(""{0}!"".format(self.version_re.match(self.v).group(""epoch"")))
+
+            # Release segment
+            parts.append(""."".join(str(x) for x in self.version_re.match(self.v).group(""release"").split(""."")))
+
+            # Pre-release
+            if self.version_re.match(self.v).group(""pre"") is not None:
+                parts.append("""".join(str(x) for x in self.version_re.match(self.v).group(""pre"")))
+
+            # Post-release
+            if self.version_re.match(self.v).group(""post"") is not None:
+                parts.append(""{0}"".format(self.version_re.match(self.v).group(""post"")))
+
+            # Development release
+            if self.version_re.match(self.v).group(""dev"") is not None:
+                parts.append(""{0}"".format(self.version_re.match(self.v).group(""dev"")))
+
+            # Local version segment
+            if self.version_re.match(self.v).group(""local"") is not None:
+                parts.append(
+                    ""+{0}"".format("""".join(str(x) for x in self.version_re.match(self.v).group(""local"")))
+                )
+        except:
+            raise argparse.ArgumentTypeError(""String '%s' does not match required PEP440 format"" % (self.v,))
+
+        return """".join(parts)
+
+
+def reformat_package_line(line):
+    """"""
+    This function is meant to take a package spec in conda or pip format
+    and return one in conda recipe format: https://conda.io/docs/spec.html
+    """"""
+    # regex to match comment-only line
+    comment_re = re.compile(r""^(?:\s*\#.*)$"")
+
+    # regex to match package spec line, with support for comments and selectors.
+    # This will also capture hash-indicated selectors and comments (ex. ""# [osx]"")
+    # which may, or may not, be useful in their original context.
+    package_re = re.compile(r""^(?P[a-zA-Z0-9\-\_]+)(?:\s*)(?:(?P[\>\<=]?=?)(?:\s*)(?P[^\s\#=]+)(?:=(?P[0-9]*))?(?:\s*))?(?P\s*\#\s*\[.*\])?(?P\s*\#.*)?$"")
+
+    # when we need to specify a different comparator for the recipe
+    comparator_replacements = {
+        ""="": ""=="",
+    }
+
+    # the line shold not have a newline
+    line = line.replace(""\n"","""").replace(""\r"","""")
+
+    # if the line is a comment, simpy return it
+    if len(line)==0 or comment_re.match(line):
+        return line
+    # otherwise, build a package spec string suitable for a conda recipe
+    else: 
+        m = package_re.match(line)
+        recipe_package_string = ""- {package} {comparator}{version}{build}{selector}{comment}"".format(
+            package    = m.group(""package"").lower(), # conda packages must have lowercase names
+            comparator = """" if not m.group(""comparator"") else comparator_replacements.get(m.group(""comparator""), m.group(""comparator"")),
+            version    = """" if not m.group(""version"") else m.group(""version""),
+            build      = """" if not m.group(""build"") else "" ""+m.group(""build"")+""*"", # Todo: verify build separator character for recip format
+            selector   = """" if not m.group(""selector"") else "" ""+m.group(""selector""),
+            comment    = """" if not m.group(""comment"") else "" ""+m.group(""comment"")
+        )
+        return recipe_package_string
+
+def url_md5(url):
+    hash_md5 = hashlib.md5()
+    CHUNK_SIZE = 16 * 1024
+
+    # try four times to download the file. If one fails, wait two seconds and try again.
+    try_count = 1
+    while True:
+        try:
+            print(""Downloading source package for hash calculation..."")
+            print(url)
+            response = urlopen(url)
+            for chunk in iter(lambda: response.read(CHUNK_SIZE), b""""):
+                hash_md5.update(chunk)
+            break
+        except:
+            print(""Download {} failed, sleeping then retrying..."".format(try_count))
+            try_count +=1
+            if try_count >3:
+                raise
+            time.sleep(2)
+            continue
+
+    return hash_md5.hexdigest()
+
+if __name__ == ""__main__"":
+
+    parser = argparse.ArgumentParser(description='Renger the conda recipe.')
+    parser.add_argument('version',
+                        type=VersionString,
+                        help='the version number of the package')
+    parser.add_argument('--package-name', dest=""package_name"",
+                        type=str,
+                        help='override the default name of the package described in the recipe')
+    parser.add_argument('--build-reqs', nargs='*', dest='build_requirements',
+                        type=argparse.FileType('r'),
+                        help='build-time requirements file')
+    parser.add_argument('--run-reqs', nargs='*', dest='run_requirements',
+                        type=argparse.FileType('r'),
+                        help='run-time requirements file')
+    parser.add_argument('--py3-run-reqs', nargs='*', dest='py3_run_requirements',
+                        type=argparse.FileType('r'),
+                        help='python3-only run-time requirements file')
+    parser.add_argument('--linux-run-reqs', nargs='*', dest='linux_run_requirements',
+                        type=argparse.FileType('r'),
+                        help='linux-only run-time requirements file')
+    parser.add_argument('--osx-run-reqs', nargs='*', dest='osx_run_requirements',
+                        type=argparse.FileType('r'),
+                        help='osx-only run-time requirements file')
+    parser.add_argument('--test-reqs', nargs='*', dest='test_requirements',
+                        type=argparse.FileType('r'),
+                        help='test-time requirements file')
+    parser.add_argument('--download-filename', dest='src_download_filename',
+                        type=str,
+                        help='An argument to override the usual filename to download; '
+                        'useful for specifying a branch name.')
+
+    try:
+       args = parser.parse_args()
+       if not any(vars(args).values()):
+            parser.print_help()
+            sys.exit(0)
+    except:
+        sys.exit(0)
+
+    args_dict = vars(args)
+
+    recipe_variables = {}
+
+    # store two separate version strings, one to use for the conda package and one
+    # that should match github tagged releases
+    recipe_variables[""PKG_VERSION""] = str(args_dict.pop(""version""))
+    if ""src_download_filename"" in args_dict and args_dict[""src_download_filename""] is not None:
+        recipe_variables[""SRC_FILE_PREFIX""] = str(args_dict.pop(""src_download_filename""))
+    else:
+        # otherwise use the ""tag""
+        recipe_variables[""SRC_FILE_PREFIX""] = recipe_variables[""PKG_VERSION""]
+
+    if ""package_name"" in args_dict and args_dict[""package_name""] is not None:
+        recipe_variables[""PKG_NAME""] = str(args_dict.pop(""package_name""))
+
+    # strip ""v"" prefix from versions that look like v1.14.0
+    if recipe_variables[""PKG_VERSION""].startswith(""v""):
+        recipe_variables[""PKG_VERSION_CONDA""] = recipe_variables[""PKG_VERSION""][1:]
+    else:
+        recipe_variables[""PKG_VERSION_CONDA""] = recipe_variables[""PKG_VERSION""]
+
+    # after we pop the positional argument(s), the optional ones remaining are all files
+    for var_name, req_files in args_dict.items():
+        if req_files:
+            for reqs_file in req_files:
+                if reqs_file:
+                    recipe_variables[var_name] = []
+                    for line in reqs_file:
+                        conda_style_package_line = reformat_package_line(line)
+                        if len(conda_style_package_line):
+                            recipe_variables[var_name].append(conda_style_package_line)
+    pprint.pprint(recipe_variables)
+
+    j_env = jinja2.Environment(loader=jinja2.FileSystemLoader(os.path.join(dir_path, input_directory)))
+
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+
+    template_files = os.listdir(os.path.join(dir_path,input_directory))
+
+    for template_file in template_files:
+        print(""Rendering ""+ template_file)
+        # jinja expects the filename to be just that, not a path
+        # it should be relative to the FileSystemLoader() path set above
+        template = j_env.get_template(template_file)
+        output_from_parsed_template = template.render(recipe_variables)
+
+        # save the rendered output
+        with open(os.path.join(dir_path, output_directory, template_file), ""w"") as f:
+            f.write(output_from_parsed_template)
+
+        # populate md5 hashes for any source urls present
+        if(template_file.endswith("".yaml"")):
+            # calculate and add md5 hashes to recipe
+            with open(os.path.join(dir_path, output_directory, template_file), ""r"") as inf:
+                with open(os.path.join(dir_path, output_directory, template_file+"".checksumed""), ""w"") as outf:
+                    for line in inf:
+                        # if this is an md5 line, don't write it out
+                        if line.strip().startswith(""md5""):
+                            continue
+                        # if this is not an md5 line, write it verbatim
+                        else:
+                            outf.writelines([line])
+
+                            # if this is a url line
+                            if line.strip().startswith(""url""):
+                                # parse out the url
+                                url_re = re.compile(r""^(?:(?P\s*)url:\s*)(?P[\S]*)(?P.*)$"")
+                                matches = url_re.match(line)
+                                if matches:
+                                    if matches.group(""url""):
+                                        # download file and calculate md5
+                                        src_hash = url_md5(matches.group(""url""))
+                                        hash_line = ""{leadingspace}md5: {src_hash}{extra}"".format(
+                                            leadingspace="""" if not matches.group(""leadingspace"") else matches.group(""leadingspace""),
+                                            src_hash=src_hash,
+                                            extra="""" if not matches.group(""extra"") else matches.group(""extra"")
+                                        )
+                                        outf.writelines([hash_line+""\n""])
+
+                                    else:
+                                        raise Exception(""The yaml file url line does not appear to contain a url"")
+
+
+            # move the file with checksums
+            os.rename(os.path.join(dir_path, output_directory, template_file+"".checksumed""), os.path.join(dir_path, output_directory, template_file))
+
+
+
+
+","Python"
+"Viral","broadinstitute/viral-ngs","packaging/conda-recipe/viral-ngs-template/post-link.sh",".sh","176","9","#!/bin/bash
+
+echo ""viral-ngs depends on GATK""
+# call gatk-register which will print its usage statement
+$PREFIX/bin/gatk-register
+
+# exit 0 so the install is a success
+exit 0 
+","Shell"
+"Viral","broadinstitute/viral-ngs","packaging/conda-recipe/viral-ngs-template/build.sh",".sh","451","21","#!/bin/bash
+
+BINARY_HOME=$PREFIX/bin
+PACKAGE_HOME=$PREFIX/opt/$PKG_NAME-$PKG_VERSION
+
+cd $SRC_DIR
+
+#chmod +x tools/scripts/*
+
+find tools/scripts/ -name ""*.py"" -exec chmod +x {} \;
+find tools/scripts/ -name ""*.sh"" -exec chmod +x {} \;
+
+# copy source to bin
+mkdir -p $PREFIX/bin
+mkdir -p $PACKAGE_HOME
+cp -R $SRC_DIR/* $PACKAGE_HOME/
+cd $PACKAGE_HOME && chmod a+x *.py
+
+cd $PACKAGE_HOME
+find *.py -type f -exec ln -s $PACKAGE_HOME/{} $BINARY_HOME/{} \;
+","Shell"
+"Viral","broadinstitute/viral-ngs","pipes/run-pipe_local.sh",".sh","2033","50","#!/bin/bash
+# Wrappers around Snakemake for execution on a single instance
+
+# determine the directory of this script
+SCRIPT_DIRECTORY=$(dirname $(readlink --canonicalize-existing $0))
+
+# if a conda environment is active, deactivate it
+# if [[ ! -z ""${CONDA_PREFIX}"" ]]; then
+#     echo ""deactivating env: $CONDA_PREFIX""
+#     source deactivate
+# fi
+
+python_check=$(hash python &> /dev/null || hash python3 &> /dev/null)
+if [ $? -ne 0 ]; then
+    echo ""It looks like Python is not installed. Exiting.""
+    if [[ $sourced -eq 0 ]]; then
+        exit 1
+    else
+        return 1
+    fi
+fi
+
+python3_check=$(hash python3 &> /dev/null)
+if [ $? -eq 0 ]; then
+    python_to_use=""$(which python3)""
+fi
+
+$python_to_use --version
+
+# load config dirs from config.yaml. After using the conda dotkit, we should have PyYAML 
+CONDAENVDIR=`$python_to_use -c ""import yaml, os;f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['conda_env_dir']));f.close()""`
+MINICONDADIR=`$python_to_use -c 'import yaml; import os; f=open(""config.yaml"");print(os.path.realpath(yaml.safe_load(f)[""miniconda_dir""]));f.close()'`
+BINDIR=`$python_to_use -c ""import yaml, os;f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['bin_dir']));f.close()""`
+DATADIR=`$python_to_use -c ""import yaml, os; f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['data_dir']));f.close()""`
+LOGDIR=`$python_to_use -c ""import yaml, os; f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['log_dir']));f.close()""`
+
+#export PATH=""$MINICONDADIR/bin:$PATH""
+
+# load conda environment
+#source activate ""$CONDAENVDIR""
+
+ARGS=""""
+# invoke Snakemake in cluster mode with custom wrapper scripts
+snakemake --rerun-incomplete --keep-going --nolock \
+          $ARGS \
+          --latency-wait 20 \
+          --directory . \
+          --resources mem_mb=$(expr $(cat /proc/meminfo | grep MemTotal | awk '{print $2}') / 1000) \
+          --cores $(expr $(grep -c ^processor /proc/cpuinfo) - 1) \
+          ""$@"" | tee ""$LOGDIR/snakemake_$(date +%F_%s).log""","Shell"
+"Viral","broadinstitute/viral-ngs","pipes/Broad_UGER/jobscript.sh",".sh","3477","89","#!/bin/sh
+# properties = {properties}
+# this is identical to the default jobscript with the exception of the exit code
+
+source /broad/software/scripts/useuse
+use UGER
+use .anaconda3-5.0.1
+CONDAENVDIR=`python -c 'import yaml; import os; f=open(""config.yaml"");print(os.path.realpath(yaml.safe_load(f)[""conda_env_dir""]));f.close()'`
+MINICONDADIR=`python -c 'import yaml; import os; f=open(""config.yaml"");print(os.path.realpath(yaml.safe_load(f)[""miniconda_dir""]));f.close()'`
+BINDIR=`python -c 'import yaml; import os; f=open(""config.yaml"");print(os.path.realpath(yaml.safe_load(f)[""bin_dir""]));f.close()'`
+DATADIR=`python -c 'import yaml; import os; f=open(""config.yaml"");print(os.path.realpath(yaml.safe_load(f)[""data_dir""]));f.close()'`
+unuse .anaconda3-5.0.1
+
+export PATH=""$MINICONDADIR/bin:$PATH""
+
+# load Python virtual environment
+source activate ""$CONDAENVDIR""
+
+
+# As a simple solution to transient UGER problems, maintain a list of blacklisted
+# nodes. When a node fails a check, add its hostname to the list and exit 99
+# to reschedule the job. Blacklist these nodes via qsub
+# Maintain the list of blacklisted nodes as filenames in /broad/hptmp/$(whoami)/blacklisted-nodes
+BLACKLISTED_NODES=""/broad/hptmp/$(whoami)/blacklisted-nodes""
+mkdir -p $BLACKLISTED_NODES
+
+# Cleanup blacklisted nodes if they have not been touched in a day
+find $BLACKLISTED_NODES -name ""*"" -type f -mmin +2880 -delete
+
+# Specify whether to require that a node have the NFS share mounted
+REQUIRE_NFS_SHARE_MOUNTED=true
+
+# Specify whether to require that a node have >1G of shared memory
+# (/dev/shm) available (e.g., snakemake requires a little for its
+# use of multiprocessing.Lock() to setup logging)
+REQUIRE_AVAILABLE_SHARED_MEMORY=true
+
+# Specify whether to require that a node can run java without
+# error (e.g., for some time the node 'sgi1' could not run java)
+REQUIRE_JAVA_TO_RUN=true
+
+# Perform checks on node and decide whether to blacklist
+if [[ ""$REQUIRE_NFS_SHARE_MOUNTED"" = true ]] && ! $(ls ""$DATADIR"" &> /dev/null); then
+    # Listing the data directory fails since the node does not have the
+    # NFS share mounted
+    echo ""Host '$(hostname)' does not have NFS share mounted. Retrying.."" 1>&2
+    touch ""$BLACKLISTED_NODES/$(hostname)""
+    exit 99
+fi
+if [[ ""$REQUIRE_AVAILABLE_SHARED_MEMORY"" = true ]] && [[ $(df -k /dev/shm | tail -n 1 | awk '{{print $4}}') -lt 1000000 ]]; then
+    # There is too little shared memory available
+    echo ""Host '$(hostname)' has full or near-full /dev/shm. Retrying.."" 1>&2
+    touch ""$BLACKLISTED_NODES/$(hostname)""
+    exit 99
+fi
+if [[ ""$REQUIRE_JAVA_TO_RUN"" = true ]] && ! java -version; then
+    # Java does not run successfully
+    echo ""Host '$(hostname)' cannot run java. Retrying.."" 1>&2
+    touch ""$BLACKLISTED_NODES/$(hostname)""
+    exit 99
+fi
+
+
+echo -e ""JOB ID\t$JOB_ID""
+echo ""==============================""
+
+{exec_job}
+EXIT_STATUS=$?
+
+# Report resource consumption because it's not reported by default
+echo ""------------------------------""
+qstat -j $JOB_ID | grep '^usage'
+
+# if the job succeeds, snakemake 
+# touches jobfinished, thus if it exists cat succeeds. if cat fails, the error code indicates job failure
+# an error code of 100 is needed since UGER only prevents execution of dependent jobs if the preceding
+# job exits with error code 100
+
+cat $1 &>/dev/null
+if [[ $? -eq 0 ]]; then
+    exit 0
+else
+    if [[ ""{workflow.immediate_submit}"" -eq ""True"" ]]; then
+        exit 100
+    else
+        exit $EXIT_STATUS
+    fi
+fi
+","Shell"
+"Viral","broadinstitute/viral-ngs","pipes/Broad_UGER/cluster-submitter.py",".py","3142","88","#!/usr/bin/env python3
+import os
+import sys
+import re
+import getpass
+from snakemake.utils import read_job_properties
+
+LOGDIR = sys.argv[-2]
+jobscript = sys.argv[-1]
+mo = re.match(r'(\S+)/snakejob\.\S+\.(\d+)\.sh', jobscript)
+assert mo
+sm_tmpdir, sm_jobid = mo.groups()
+props = read_job_properties(jobscript)
+
+# Blacklist problematic nodes; this list is stored as filenames
+# in /broad/hptmp/[username]/blacklisted-nodes/
+whoami = getpass.getuser()
+blacklisted_node_dir = os.path.join(""/broad/hptmp"", whoami, ""blacklisted-nodes"")
+if not os.path.exists(blacklisted_node_dir):
+    os.makedirs(blacklisted_node_dir)
+def hard_blacklist_node(node):
+    blacklist_path = os.path.join(blacklisted_node_dir, node)
+    with open(blacklist_path, 'a'):
+        os.utime(blacklist_path, None)
+# Always blacklist 'sgi1'; it cannot perform basic operations like
+# allocating memory
+hard_blacklist_node('sgi1')
+blacklisted_nodes = os.listdir(blacklisted_node_dir)
+
+# set up job name, project name
+jobname = ""{rule}-{jobid}"".format(rule=props[""rule""], jobid=sm_jobid)
+if props[""params""].get(""logid""):
+    jobname = ""{rule}-{id}"".format(rule=props[""rule""], id=props[""params""][""logid""])
+cmdline = ""qsub -N {jobname} -cwd -r y "".format(jobname=jobname)
+
+# log file output
+cmdline += ""-o {logdir} -j y "".format(logdir=LOGDIR)
+
+# pass memory resource request to cluster
+mem = props.get('resources', {}).get('mem_mb')
+threads = props.get('resources', {}).get('threads')
+
+if mem:
+    mem = int(mem)
+    threads = int(threads) or 1 # only used here for the calculation of memory per-core
+    # on UGER, memory requests are per-core (according to BITS as of Sept. 6, 2016)
+    mem_per_core = round(float(mem)/float(threads), 2)
+    # increase memory requested to reflect new JVM-UGER changes requiring greater memory headroom
+    mem_per_core = round(mem_per_core*1.1,2)
+    if blacklisted_nodes:
+        # Pass h= as the hostname parameter; it accepts a regex, so
+        # invert the match to blacklist hostnames
+        cmdline += "" -l h_vmem={}M,h_rss={}M,h='!({})' "".format(
+            mem_per_core, round(1.2 * mem_per_core, 2),
+            '|'.join(blacklisted_nodes))
+    else:
+        cmdline += "" -l h_vmem={}M,h_rss={}M "".format(
+            mem_per_core, round(1.2 * mem_per_core, 2))
+    if mem >= 15 or (threads and threads >= 4):
+        cmdline += ' -R y '
+elif blacklisted_nodes:
+    # Pass h= as the hostname parameter; it accepts a regex, so
+    # invert the match to blacklist hostnames
+    cmdline += "" -l h='!({})' "".format('|'.join(blacklisted_nodes))
+
+if threads:
+    cmdline += ' -pe smp {} -binding linear:{} '.format(int(threads), int(threads))
+
+# rule-specific UGER parameters (e.g. queue)
+cmdline += props[""params""].get(""UGER"", """") + "" ""
+
+# figure out job dependencies
+dependencies = set(sys.argv[1:-2])
+if dependencies:
+    cmdline += ""-hold_jid '{}' "".format("","".join(dependencies))
+
+# the actual job
+cmdline += jobscript
+
+# the success file
+cmdline += "" %s/%s.jobfinished"" % (sm_tmpdir, sm_jobid)
+
+# the part that strips bsub's output to just the job id
+cmdline += r"" | tail -1 | cut -f 3 -d \ ""
+
+# call the command
+os.system(cmdline)
+","Python"
+"Viral","broadinstitute/viral-ngs","pipes/Broad_UGER/run-pipe.sh",".sh","2024","54","#!/bin/bash
+# Wrappers around Snakemake for use on the Broad UGER cluster
+
+# determine the directory of this script
+SCRIPT_DIRECTORY=$(dirname $(readlink --canonicalize-existing $0))
+
+
+# Use --wait-submit to run snakemake without --immediate-submit. This means that the snakemake
+# process must be alive for the duration of the pipeline.
+IMMEDIATE_SUBMIT=1
+while [[ $# -gt 0 ]]; do
+    case ""$1"" in
+        --wait-submit ) IMMEDIATE_SUBMIT=0; shift ;;
+        * ) break ;;
+    esac
+done
+
+# if a conda environment is active, deactivate it
+if [[ ! -z ""${CONDA_PREFIX}"" ]]; then
+    echo ""deactivating env: $CONDA_PREFIX""
+    source deactivate
+fi
+
+# load necessary Broad dotkits
+source /broad/software/scripts/useuse
+reuse -q UGER
+
+reuse -q Python-3.4
+# load config dirs from config.yaml. After using the conda dotkit, we should have PyYAML 
+CONDAENVDIR=`python -c ""import yaml, os;f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['conda_env_dir']));f.close()""`
+MINICONDADIR=`python -c 'import yaml; import os; f=open(""config.yaml"");print(os.path.realpath(yaml.safe_load(f)[""miniconda_dir""]));f.close()'`
+BINDIR=`python -c ""import yaml, os;f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['bin_dir']));f.close()""`
+DATADIR=`python -c ""import yaml, os; f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['data_dir']));f.close()""`
+unuse  Python-3.4
+
+export PATH=""$MINICONDADIR/bin:$PATH""
+
+# load conda environment
+source activate ""$CONDAENVDIR""
+
+ARGS=""""
+[[ $IMMEDIATE_SUBMIT -eq 1 ]] && ARGS+="" --immediate-submit --notemp ""
+# invoke Snakemake in cluster mode with custom wrapper scripts
+snakemake --rerun-incomplete --keep-going --nolock \
+          $ARGS \
+          --jobs 90 \
+          --force-use-threads \
+          --latency-wait 60 \
+          --config mode=UGER \
+          --directory . \
+          --jobscript ""$BINDIR/pipes/Broad_UGER/jobscript.sh"" \
+          --cluster ""$BINDIR""'/pipes/Broad_UGER/cluster-submitter.py {dependencies} {config[log_dir]}' \
+          ""$@""
+","Shell"
+"Viral","broadinstitute/viral-ngs","pipes/Broad_LSF/jobscript.sh",".sh","277","8","#!/bin/sh
+# properties = {properties}
+# this is identical to the default jobscript with the exception of the exit code
+{exec_job}
+
+# if the job succeeds, snakemake 
+# touches jobfinished, thus if it exists cat succeeds. if cat fails, the error code indicates job failure
+cat $1","Shell"
+"Viral","broadinstitute/viral-ngs","pipes/Broad_LSF/cluster-submitter.py",".py","1688","52","#!/usr/bin/env python3
+import os
+import sys
+import re
+from snakemake.utils import read_job_properties
+
+LOGDIR = sys.argv[-2]
+DATADIR = sys.argv[-3]
+jobscript = sys.argv[-1]
+mo = re.match(r'(\S+)/snakejob\.\S+\.(\d+)\.sh', jobscript)
+assert mo
+sm_tmpdir, sm_jobid = mo.groups()
+props = read_job_properties(jobscript)
+
+# set up job name, project name
+jobname = ""{rule}-{jobid}"".format(rule=props[""rule""], jobid=sm_jobid)
+if props[""params""].get(""logid""):
+    jobname = ""{rule}-{id}"".format(rule=props[""rule""], id=props[""params""][""logid""])
+
+# -E is a pre-exec command, that reschedules the job if the command fails
+#   in this case, if the data dir is unavailable (as may be the case for a hot-mounted file path)
+cmdline = 'bsub -P {proj_name} -J {jobname} -r -E ""ls {datadir}"" '.format(proj_name='viral_ngs', jobname=jobname, datadir=DATADIR)
+
+# log file output
+if ""-N"" not in props[""params""].get(""LSF"", """"):
+    cmdline += ""-oo {logdir}/LSF-{jobname}.txt "".format(logdir=LOGDIR, jobname=jobname)
+
+# pass memory resource request to LSF
+mem = int(props.get('resources', {}).get('mem_mb',1000))/1000
+if mem:
+    cmdline += '-R ""rusage[mem={}]"" -M {} '.format(mem, 2 * int(mem))
+
+# rule-specific LSF parameters (e.g. queue, runtime)
+cmdline += props[""params""].get(""LSF"", """") + "" ""
+
+# figure out job dependencies
+dependencies = set(sys.argv[1:-3])
+if dependencies:
+    cmdline += ""-w '{}' "".format("" && "".join(dependencies))
+
+# the actual job
+cmdline += jobscript
+
+# the success file
+cmdline += "" %s/%s.jobfinished"" % (sm_tmpdir, sm_jobid)
+
+# the part that strips bsub's output to just the job id
+cmdline += r"" | tail -1 | cut -f 2 -d \< | cut -f 1 -d \>""
+
+# call the command
+os.system(cmdline)
+","Python"
+"Viral","broadinstitute/viral-ngs","pipes/Broad_LSF/run-pipe.sh",".sh","1456","33","#!/bin/bash
+# Wrappers around Snakemake for use on the Broad LSF cluster
+
+# determine the directory of this script
+SCRIPT_DIRECTORY=$(dirname $(readlink --canonicalize-existing $0))
+
+# load necessary Broad dotkits
+source /broad/software/scripts/useuse
+reuse -q LSF
+
+reuse -q Python-3.4
+# load config dirs from config.yaml. After using the conda dotkit, we should have PyYAML 
+CONDAENVDIR=`python -c ""import yaml, os;f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['conda_env_dir']));f.close()""`
+MINICONDADIR=`python -c 'import yaml; import os; f=open(""config.yaml"");print(os.path.realpath(yaml.safe_load(f)[""miniconda_dir""]));f.close()'`
+BINDIR=`python -c ""import yaml, os;f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['bin_dir']));f.close()""`
+DATADIR=`python -c ""import yaml, os; f=open(\""config.yaml\"");print(os.path.realpath(yaml.safe_load(f)['data_dir']));f.close()""`
+unuse  Python-3.4
+
+export PATH=""$MINICONDADIR/bin:$PATH""
+
+# load conda environment
+source activate ""$CONDAENVDIR""
+
+# invoke Snakemake in cluster mode with custom wrapper scripts
+snakemake --rerun-incomplete --keep-going --nolock \
+	--jobs 100000 --immediate-submit \
+        --latency-wait 20 \
+	--config mode=LSF job_profiler=""$BINDIR/pipes/Broad_LSF/lsf-report.py"" \
+	--directory . \
+	--jobscript ""$BINDIR/pipes/Broad_LSF/jobscript.sh"" \
+	--cluster $BINDIR""/pipes/Broad_LSF/cluster-submitter.py {dependencies} $DATADIR {config[log_dir]}"" \
+	""$@""
+","Shell"
+"Viral","broadinstitute/viral-ngs","pipes/Broad_LSF/lsf-report.py",".py","3508","96","#!/usr/bin/env python
+''' This script contains utilities for analyzing LSF reports for
+    data on runtime and performance.
+'''
+
+__author__ = ""dpark@broadinstitute.org""
+
+import argparse
+import re
+import time
+import os
+import os.path
+import sys
+
+
+def read_lsf_logfile(infname):
+    out = {'logfile': infname}
+    num_dash_lines = 0
+    with open(infname, 'rU', encoding='latin-1') as inf:
+        for line in inf:
+            line = line.strip()
+            if line.startswith('Subject:'):
+                mo = re.match(r'Subject: Job (\d+)', line)
+                out['job_id'] = mo.group(1)
+            elif line.startswith('Job <'):
+                mo = re.match(r'Job <(\S+)> was submitted from host', line)
+                out['job_name'] = mo.group(1)
+                if '-' in out['job_name']:
+                    out['job_prefix'], out['job_suffix'] = out['job_name'].split('-', 1)
+            elif line.startswith('Job was executed on host'):
+                mo = re.match(r'Job was executed on host\(s\) <(\S+?)>, in queue <(\w+)>', line)
+                out['exec_host'] = mo.group(1)
+                out['queue'] = mo.group(2)
+            elif line.startswith('Started at'):
+                mo = re.match(r'Started at (.+)$', line)
+                out['start_time'] = mo.group(1)
+            elif line.startswith('Results reported at'):
+                mo = re.match(r'Results reported at (.+)$', line)
+                out['end_time'] = mo.group(1)
+            elif line.startswith('----------------'):
+                num_dash_lines += 1
+            elif line.startswith('The output (if any) follows'):
+                break
+            else:
+                if line and num_dash_lines == 2:
+                    if 'status' not in out:
+                        if line.startswith('TERM'):
+                            line = line.split(':')[0]
+                        out['status'] = line
+                    elif ':' in line:
+                        k, v = [s.strip() for s in line.split(':')]
+                        out[k] = v
+    if 'start_time' in out and 'end_time' in out:
+        out['run_time'] = time.mktime(time.strptime(out['end_time'])) \
+            - time.mktime(time.strptime(out['start_time']))
+    return out
+
+
+def read_all_logfiles(dirname):
+    header = ['job_id', 'job_name', 'job_prefix', 'job_suffix', 'queue', 'exec_host', 'status', 'run_time',
+              'start_time', 'end_time', 'CPU time', 'Max Memory', 'Max Swap', 'Max Processes', 'Max Threads', 'logfile'
+             ]
+    yield header
+    for fname in os.listdir(dirname):
+        try:
+            row = read_lsf_logfile(os.path.join(dirname, fname))
+        except:
+            print(""Error parsing "" + fname)
+            raise
+        yield [str(row.get(h, '')) for h in header]
+
+
+def parser_report():
+    parser = argparse.ArgumentParser(
+        description=""Read a directory full of LSF log files and produce a tabular report."")
+    parser.add_argument(""log_dir"", help=""Input directory of LSF log files"")
+    parser.add_argument(""outFile"", help=""Output report file"")
+    return parser
+
+
+def main_report(args):
+    with open(args.outFile, 'wt') as outf:
+        for row in read_all_logfiles(args.log_dir):
+            outf.write('\t'.join(row) + '\n')
+    return 0
+
+
+if __name__ == '__main__':
+    argv = sys.argv[1:]
+    report_parser = parser_report()
+    if len(argv) == 0:
+        report_parser.print_help()
+    else:
+        report_args = report_parser.parse_args(argv)
+        main_report(report_args)
+","Python"
+"Viral","broadinstitute/viral-ngs","docs/conf.py",".py","9232","271","#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# viral-ngs documentation build configuration file, created by
+# sphinx-quickstart on Fri Jan 16 00:23:17 2015.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys
+import os
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.insert(0, os.path.dirname(os.path.abspath('.')))
+
+# -- Mock out the heavyweight pip packages, esp those that require C ----
+import mock
+MOCK_MODULES = ['scipy', 'pysam', 'Bio', 'Bio.AlignIO', 'Bio.Alphabet',
+                'Bio.Alphabet.IUPAC', 'Bio.SeqIO', 'Bio.Data.IUPACData',
+                'Bio.Seq', 'Bio.SeqRecord', 'pybedtools', 'pybedtools.BedTool',
+                'arrow']
+for mod_name in MOCK_MODULES:
+    sys.modules[mod_name] = mock.Mock()
+
+    # -- Obtain GIT version --
+import subprocess
+
+
+def _git_version():
+    cmd = ['git', 'describe', '--tags', '--always']  # omit ""--dirty"" from doc build
+    out = subprocess.check_output(cmd)
+    if type(out) != str:
+        out = out.decode('utf-8')
+    return out.strip()
+
+
+__version__ = _git_version()
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.imgmath', 'sphinxarg.ext',]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = 'viral-ngs'
+copyright = '2015, Broad Institute Viral Genomics'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+release = __version__
+version = '.'.join(release.split('.')[:2])
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+today_fmt = '%Y-%m-%d'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = ['_build']
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+# If true, keep warnings as ""system message"" paragraphs in the built documents.
+#keep_warnings = False
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+on_rtd = os.environ.get('READTHEDOCS') == 'True'
+if on_rtd:
+    html_theme = 'default'
+else:
+    import sphinx_rtd_theme
+    html_theme = ""sphinx_rtd_theme""
+    html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "" v documentation"".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named ""default.css"" will overwrite the builtin ""default.css"".
+# html_static_path = ['_static']
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+#html_extra_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+html_last_updated_fmt = '%Y-%m-%d. {}'.format(release)
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, ""Created using Sphinx"" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, ""(C) Copyright ..."" is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a  tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. "".xhtml"").
+#html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'viral-ngsdoc'
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #'papersize': 'letterpaper',
+    # The font size ('10pt', '11pt' or '12pt').
+    #'pointsize': '10pt',
+    # Additional stuff for the LaTeX preamble.
+    #'preamble': '',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [('index', 'viral-ngs.tex', 'viral-ngs Documentation', 'Broad Institute Viral Genomics', 'manual'),]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For ""manual"" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [('index', 'viral-ngs', 'viral-ngs Documentation', ['Broad Institute Viral Genomics'], 1)]
+
+# If true, show URL addresses after external links.
+#man_show_urls = False
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    ('index', 'viral-ngs', 'viral-ngs Documentation', 'Broad Institute Viral Genomics', 'viral-ngs',
+     'Viral genomics analysis pipelines', 'Miscellaneous'),
+]
+
+# Documents to append as an appendix to all manuals.
+#texinfo_appendices = []
+# If false, no module index is generated.
+#texinfo_domain_indices = True
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#texinfo_show_urls = 'footnote'
+# If true, do not generate a @detailmenu in the ""Top"" node's menu.
+#texinfo_no_detailmenu = False
+","Python"
+"Viral","broadinstitute/viral-ngs","contrib/update-conda-env.sh",".sh","428","19","#!/bin/bash
+
+function cmd_exists() {
+    if hash $@ 2> /dev/null ; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# if conda is available
+if cmd_exists ""conda""; then
+    # if a conda environment is active
+    if [ ! -z ""$CONDA_DEFAULT_ENV"" ]; then
+        # update the conda environment to install the requirements specified
+        conda install -y -c broad-viral -c bioconda --file requirements-conda.txt
+    fi
+fi
+","Shell"
+"Viral","mw55309/Kraken_db_install_scripts","kraken_shell_scripts/download_genomic_library.sh",".sh","4242","138","#!/bin/bash
+
+# Copyright 2013-2015, Derrick Wood 
+#
+# This file is part of the Kraken taxonomic sequence classification system.
+#
+# Kraken is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Kraken is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Kraken.  If not, see .
+
+# Download specific genomic libraries for use with Kraken.
+# Supported choices are:
+#   bacteria - NCBI RefSeq complete bacterial/archaeal genomes
+#   plasmids - NCBI RefSeq plasmid sequences
+#   viruses - NCBI RefSeq complete viral DNA and RNA genomes
+#   human - NCBI RefSeq GRCh38 human reference genome
+
+set -u  # Protect against uninitialized vars.
+set -e  # Stop on error
+
+LIBRARY_DIR=""$KRAKEN_DB_NAME/library""
+NCBI_SERVER=""ftp.ncbi.nih.gov""
+FTP_SERVER=""ftp://$NCBI_SERVER""
+RSYNC_SERVER=""rsync://$NCBI_SERVER""
+THIS_DIR=$PWD
+
+case ""$1"" in
+  ""fungi"")
+    mkdir -p $LIBRARY_DIR/Fungi
+    cd $LIBRARY_DIR/Fungi
+    if [ ! -e ""lib.complete"" ]
+    then
+      wget $FTP_SERVER/refseq/release/fungi/*.genomic.fna.gz
+      echo -n ""Unpacking...""
+      gunzip *.genomic.fna.gz
+      echo "" complete.""
+      touch ""lib.complete""
+    else
+      echo ""Skipping download of fungal genomes, already downloaded here.""
+    fi
+    ;;
+  ""archaea"")
+    mkdir -p $LIBRARY_DIR/Archaea
+    cd $LIBRARY_DIR/Archaea
+    if [ ! -e ""lib.complete"" ]
+    then
+      wget $FTP_SERVER/refseq/release/archaea/*.genomic.fna.gz
+      echo -n ""Unpacking...""
+      gunzip *.genomic.fna.gz
+      echo "" complete.""
+      touch ""lib.complete""
+    else
+      echo ""Skipping download of archaeal genomes, already downloaded here.""
+    fi
+    ;;
+  ""bacteria"")
+    mkdir -p $LIBRARY_DIR/Bacteria
+    cd $LIBRARY_DIR/Bacteria
+    if [ ! -e ""lib.complete"" ]
+    then
+      wget $FTP_SERVER/refseq/release/bacteria/*.genomic.fna.gz
+      echo -n ""Unpacking...""
+      gunzip *.genomic.fna.gz
+      echo "" complete.""
+      touch ""lib.complete""
+    else
+      echo ""Skipping download of bacterial genomes, already downloaded here.""
+    fi
+    ;;
+  ""plasmids"")
+    mkdir -p $LIBRARY_DIR/Plasmids
+    cd $LIBRARY_DIR/Plasmids
+    if [ ! -e ""lib.complete"" ]
+    then
+      wget $FTP_SERVER/refseq/release/plasmid/*.genomic.fna.gz
+      echo -n ""Unpacking...""
+      gunzip *.genomic.fna.gz
+      echo "" complete.""
+      touch ""lib.complete""
+    else
+      echo ""Skipping download of plasmids, already downloaded here.""
+    fi
+    ;;
+  ""viruses"")
+    mkdir -p $LIBRARY_DIR/Viruses
+    cd $LIBRARY_DIR/Viruses
+    if [ ! -e ""lib.complete"" ]
+    then
+      wget $FTP_SERVER/refseq/release/viral/*.genomic.fna.gz
+      echo -n ""Unpacking...""
+      gunzip *.genomic.fna.gz
+      echo "" complete.""
+      touch ""lib.complete""
+    else
+      echo ""Skipping download of viral genomes, already downloaded here.""
+    fi
+    ;;
+  ""human"")
+    mkdir -p $LIBRARY_DIR/Human
+    cd $LIBRARY_DIR/Human
+    if [ ! -e ""lib.complete"" ]
+    then
+      # get list of CHR_* directories
+      wget --spider --no-remove-listing $FTP_SERVER/genomes/H_sapiens/
+      directories=$(perl -nle '/^d/ and /(CHR_\w+)\s*$/ and print $1' .listing)
+      rm .listing
+
+      # For each CHR_* directory, get GRCh* fasta gzip file name, d/l, unzip, and add
+      for directory in $directories
+      do
+        wget --spider --no-remove-listing $FTP_SERVER/genomes/H_sapiens/$directory/
+        file=$(perl -nle '/^-/ and /\b(hs_ref_GRCh\w+\.fa\.gz)\s*$/ and print $1' .listing)
+        [ -z ""$file"" ] && exit 1
+        rm .listing
+        wget $FTP_SERVER/genomes/H_sapiens/$directory/$file
+        gunzip ""$file""
+      done
+
+      touch ""lib.complete""
+    else
+      echo ""Skipping download of human genome, already downloaded here.""
+    fi
+    ;;
+  *)
+    echo ""Unsupported library.  Valid options are: ""
+    echo ""  bacteria plasmids virus human""
+    ;;
+esac
+","Shell"
+"Viral","mw55309/Kraken_db_install_scripts","kraken_shell_scripts/standard_installation.sh",".sh","1754","46","#!/bin/bash
+
+# Copyright 2013-2015, Derrick Wood 
+#
+# This file is part of the Kraken taxonomic sequence classification system.
+#
+# Kraken is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Kraken is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Kraken.  If not, see .
+
+# Build the standard Kraken database
+# Designed to be called by kraken_build
+
+set -u  # Protect against uninitialized vars.
+set -e  # Stop on error
+set -o pipefail  # Stop on failures in non-final pipeline commands
+
+WOD_FLAG=""""
+if [ -n ""$KRAKEN_WORK_ON_DISK"" ]
+then
+  WOD_FLAG=""--work-on-disk""
+fi
+
+check_for_jellyfish.sh
+kraken-build --db $KRAKEN_DB_NAME --download-taxonomy
+kraken-build --db $KRAKEN_DB_NAME --download-library bacteria
+kraken-build --db $KRAKEN_DB_NAME --download-library viruses
+kraken-build --db $KRAKEN_DB_NAME --download-library plasmids
+kraken-build --db $KRAKEN_DB_NAME --download-library archaea
+kraken-build --db $KRAKEN_DB_NAME --download-library fungi
+kraken-build --db $KRAKEN_DB_NAME --build --threads $KRAKEN_THREAD_CT \
+               --jellyfish-hash-size ""$KRAKEN_HASH_SIZE"" \
+               --max-db-size ""$KRAKEN_MAX_DB_SIZE"" \
+               --minimizer-len $KRAKEN_MINIMIZER_LEN \
+               --kmer-len $KRAKEN_KMER_LEN \
+               $WOD_FLAG
+","Shell"
+"Viral","stevenliuyi/covid19","scripts/data_processing.sh",".sh","2820","39","#!/bin/bash
+
+# reverse DXY data file so that the lastest record is in the end instead of beginning
+tac data/dxy-data/DXYArea.csv > data/DXYArea_reversed.csv
+
+# generate data in JSON format and include data in TOPOJSON maps
+data_processing_filenames=""world_current world china china_overall korea italy us us_1p3a france germany japan austria australia canada switzerland uk sweden norway iran portugal brazil malaysia belgium czechia russia2 latin_america india ireland south_africa philippines romania indonesia thailand hong_kong pakistan croatia finland ukraine hungary denmark slovakia albania latvia estonia slovenia haiti algeria nigeria senegal ghana morocco bangladesh2 venezuela bolivia turkey sri_lanka nepal guatemala""
+
+# skipped: Netherlands, Spain, Poland, Saudi Arabia
+
+for filename in $data_processing_filenames; do
+    echo ""Running data_processing_${filename}.js ...""
+    node scripts/data_processing_${filename}.js
+    if [ $? != 0 ]; then
+       exit 1
+    fi
+done
+
+yarn mapshaper ./public/maps/gadm36_NOR_1.json -dissolve NAME_1 copy-fields=CHINESE_NAME,REGION -o format=topojson ./public/maps/gadm36_NOR_1.json
+yarn mapshaper ./public/maps/gadm36_GBR_2.json -dissolve NAME_2 copy-fields=CHINESE_NAME,COUNTRY_CHINESE_NAME,REGION -o format=topojson ./public/maps/gadm36_GBR_2.json
+yarn mapshaper ./public/maps/gadm36_USA_2.json -dissolve NAME_1,NAME_2 copy-fields=CHINESE_NAME,STATE_CHINESE_NAME,REGION -o format=topojson ./public/maps/gadm36_USA_2.json
+yarn mapshaper ./public/maps/NLD.json -dissolve GM_NAAM copy-fields=CHINESE_NAME,REGION -o format=topojson ./public/maps/NLD.json
+yarn mapshaper ./public/maps/gadm36_PRT_2.json -dissolve NAME_1 copy-fields=CHINESE_NAME,REGION -o format=topojson ./public/maps/gadm36_PRT_2.json
+yarn mapshaper ./public/maps/gadm36_PER_1.json -dissolve NAME_1 copy-fields=CHINESE_NAME,REGION -o format=topojson ./public/maps/gadm36_PER_1.json
+yarn mapshaper ./public/maps/gadm36_HKG_1.json -dissolve NAME_1 copy-fields=CHINESE_NAME,REGION -o format=topojson ./public/maps/gadm36_HKG_1.json
+yarn mapshaper ./public/maps/gadm36_PAK_1.json -dissolve NAME_1 copy-fields=CHINESE_NAME,REGION -o format=topojson ./public/maps/gadm36_PAK_1.json
+yarn mapshaper ./public/maps/gadm36_FIN_4.json -dissolve NAME_2 copy-fields=CHINESE_NAME,REGION -o format=topojson ./public/maps/gadm36_FIN_4.json
+yarn mapshaper ./public/maps/gadm36_TUR_1.json -dissolve NAME_1 copy-fields=CHINESE_NAME,REGION -o format=topojson ./public/maps/gadm36_TUR_1.json
+yarn mapshaper ./public/maps/IND.json -dissolve st_nm copy-fields=CHINESE_NAME,REGION -o format=topojson ./public/maps/IND.json
+
+script_filenames=""data_merge missing_data_fix""
+
+for filename in $script_filenames; do
+    echo ""Running ${filename}.js ...""
+    node scripts/${filename}.js
+    if [ $? != 0 ]; then
+       exit 1
+    fi
+done","Shell"
+"Viral","stevenliuyi/covid19","scripts/download_data.sh",".sh","3763","76","#!/bin/bash
+
+# download data files for China cases
+curr_date=$(date +""%Y.%m.%d"")
+mkdir -p data/dxy-data
+wget -q ""https://github.com/BlankerL/DXY-COVID-19-Data/releases/download/${curr_date}/DXYArea.csv"" -O data/dxy-data/DXYArea_new.csv
+
+if [ -s data/dxy-data/DXYArea_new.csv ]; then
+    mv data/dxy-data/DXYArea_new.csv data/dxy-data/DXYArea.csv
+else
+    rm data/dxy-data/DXYArea_new.csv
+fi
+
+# download data files for South Korea cases
+mkdir -p data/korea-data
+wget -q --no-check-certificate 'https://docs.google.com/spreadsheets/d/1nKRkOwnGV7RgsMnsYE6l96u4xxl3ZaNiTluPKEPaWm8/export?gid=898304475&format=csv' -O data/korea-data-parksw3/geo_distribution.csv
+wget -q --no-check-certificate 'https://docs.google.com/spreadsheets/d/1nKRkOwnGV7RgsMnsYE6l96u4xxl3ZaNiTluPKEPaWm8/export?gid=306770783&format=csv' -O data/korea-data-parksw3/cumulative_numbers.csv
+
+# download data file for Indonesia cases
+mkdir -p data/indonesia-data
+wget -q --no-check-certificate 'https://docs.google.com/spreadsheets/d/1sgiz8x71QyIVJZQguYtG9n6xBEKdM4fXuDs_d8zKOmY/export?gid=83750310&format=csv' -O data/indonesia-data/data_provinsi.csv
+
+# download official data file for Saudi Arabia
+# mkdir -p data/saudi-arabia-data
+# wget -q 'https://datasource.kapsarc.org/explore/dataset/saudi-arabia-coronavirus-disease-covid-19-situation/download/?format=json&lang=en' -O data/saudi-arabia-data/raw.json
+
+# download data for Finland
+mkdir -p data/finland-data
+wget -q ""https://sampo.thl.fi/pivot/prod/fi/epirapo/covid19case/fact_epirapo_covid19case.csv?row=dateweek2020010120201231-443702L&column=hcdmunicipality2020-445222"" -O data/finland-data/raw.csv
+
+# download data for Latvia
+mkdir -p data/latvia-data
+# new municipalities established in July 2021
+wget -q ""https://data.gov.lv/dati/dataset/e150cc9a-27c1-4920-a6c2-d20d10469873/resource/492931dd-0012-46d7-b415-76fe0ec7c216/download/covid_19_pa_adm_terit.csv"" -O data/latvia-data/raw_new.csv
+
+# download data for Ethiopia
+# data source: https://covid19.qulph.com/
+# https://docs.google.com/spreadsheets/d/1wFUxclZN5IZgnKXlXol2TIrWZ3UW2SLnDwQzZyRW11k
+mkdir -p data/ethiopia-data
+wget -q ""https://docs.google.com/spreadsheets/d/e/2PACX-1vQD01UVxJ0NB9LGp0yrY42Kz___dovoEdmr3zI09WXkOIks6WCq6BiQmjN9On34E1vDQrLbPx0DFpX4/pub?gid=1141696962&output=csv"" -O data/ethiopia-data/raw.csv
+
+# download data for Ireland
+# data source: https://data.gov.ie/dataset/covid19countystatisticshpscireland
+mkdir -p data/ireland-data
+wget -q ""http://opendata-geohive.hub.arcgis.com/datasets/d9be85b30d7748b5b7c09450b8aede63_0.csv"" -O data/ireland-data/raw.csv
+
+# download data for Estonia
+mkdir -p data/estonia-data
+wget -q ""https://koroonakaart.ee/data.json"" -O data/estonia-data/data.json
+
+# download data for Italy
+mkdir -p data/italy-dpc-data/dati-regioni
+mkdir -p data/italy-dpc-data/dati-json
+wget -q ""https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-regioni/dpc-covid19-ita-regioni.csv"" -O data/italy-dpc-data/dati-regioni/dpc-covid19-ita-regioni.csv
+wget -q ""https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-json/dpc-covid19-ita-province.json"" -O data/italy-dpc-data/dati-json/dpc-covid19-ita-province.json
+
+# fix data
+mkdir -p data/albania-data/data/2020-07-28
+cp data/albania-data-fix/2020-07-28.csv data/albania-data/data/2020-07-28/district_summary.csv
+
+cp data/latin-america-data-fix/2020-08-17.csv data/latin-america-data/latam_covid_19_data/daily_reports
+
+# data folder
+mkdir -p public/data
+
+# crawl data
+crawlers=""iran-data chile-data india-data japan-data hungary-data denmark-data slovakia-data hong-kong-data algeria-data morocco-data sri-lanka-data""
+
+# skipped crawlers: Turkey, Thailand, 1P3A
+
+for crawler in $crawlers; do
+    python3 data/${crawler}/crawler.py
+    if [ $? != 0 ]; then
+       exit 1
+    fi
+done","Shell"
+"Viral","stevenliuyi/covid19","scripts/download_maps.sh",".sh","10757","107","#!/bin/bash
+
+mkdir -p ./data/maps
+mkdir -p ./public/maps
+
+# download maps
+gadm_maps=""CHN HKG MAC TWN KOR ITA FRA DEU JPN AUT AUS USA CAN ESP CHE GBR SWE POL NOR IRN PRT BRA MYS CHL BEL CZE RUS MEX ECU ARG PER IRL ZAF PHL ROU IDN SAU THA COL PAK HRV FIN UKR HUN DNK SVK ALB GRC EST SVN HTI DZA NGA SEN BOL HND TUR LKA GTM""
+for map in $gadm_maps; do
+   wget -nc -q https://biogeo.ucdavis.edu/data/gadm3.6/shp/gadm36_${map}_shp.zip -O ./data/maps/gadm36_${map}_shp.zip
+   unzip -q -o -d ./data/maps/ ./data/maps/gadm36_${map}_shp.zip
+done
+
+wget -nc -q https://raw.githubusercontent.com/zcreativelabs/react-simple-maps/master/topojson-maps/world-50m-simplified.json -O ./data/maps/world-50m.json
+wget -nc -q https://cdn.jsdelivr.net/npm/us-atlas@3/states-10m.json -O ./data/maps/states-10m.json
+wget -nc -q https://raw.githubusercontent.com/deldersveld/topojson/master/countries/netherlands/nl-gemeentegrenzen-2016.json -O ./data/maps/netherlands.json
+wget -nc -q https://raw.githubusercontent.com/leakyMirror/map-of-europe/master/TopoJSON/europe.topojson -O ./data/maps/europe.json
+wget -nc -q https://raw.githubusercontent.com/openpolis/geojson-italy/master/geojson/limits_IT_provinces.geojson -O ./data/maps/italy_provinces.json
+wget -nc -q https://raw.githubusercontent.com/covid19india/covid19india-react/master/public/maps/india.json -O ./data/maps/india.json
+wget -nc -q https://raw.githubusercontent.com/mesaugat/geoJSON-Nepal/master/nepal-states.geojson -O ./data/maps/nepal.json
+
+# reference: https://covid-19-data.unstatshub.org/datasets/950f4a57d3354125befc7d6fb65e4ff5_0
+wget -nc -q https://opendata.arcgis.com/datasets/950f4a57d3354125befc7d6fb65e4ff5_0.zip -O data/maps/ghana.zip
+unzip -q -o -d ./data/maps/ ./data/maps/ghana.zip
+
+# reference: https://covid19-geomatic.hub.arcgis.com/datasets/covid-19-au-maroc-par-r%C3%A9gion
+wget -nc -q https://opendata.arcgis.com/datasets/454f46db2cfd49fca37245541810d18b_0.zip -O data/maps/morocco.zip
+unzip -q -o -d ./data/maps/ ./data/maps/morocco.zip
+
+# reference: https://data.humdata.org/dataset/administrative-boundaries-of-bangladesh-as-of-2015
+wget -nc -q https://data.humdata.org/dataset/401d3fae-4262-48c9-891f-461fd776d49b/resource/0939d0f8-c814-4213-a5c9-241e67ec9fe9/download/bgd_admbnda_adm1_bbs_20180410.zip -O data/maps/bangladesh.zip
+
+# simplify maps
+yarn mapshaper ./data/maps/gadm36_CHN_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_CHN_1.json
+yarn mapshaper ./data/maps/gadm36_CHN_2.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_CHN_2.json
+yarn mapshaper ./data/maps/gadm36_HKG_0.shp -simplify 0.2% -clean -o format=topojson ./data/maps/gadm36_HKG_0.json
+yarn mapshaper ./data/maps/gadm36_HKG_1.shp -simplify 20% -clean -o format=topojson ./data/maps/gadm36_HKG_1.json
+yarn mapshaper ./data/maps/gadm36_MAC_0.shp -simplify 3% -clean -o format=topojson ./data/maps/gadm36_MAC_0.json
+yarn mapshaper ./data/maps/gadm36_TWN_0.shp -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_TWN_0.json
+yarn mapshaper ./data/maps/gadm36_KOR_1.shp -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_KOR_1.json
+yarn mapshaper ./data/maps/gadm36_ITA_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_ITA_1.json
+yarn mapshaper ./data/maps/gadm36_FRA_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_FRA_1.json
+yarn mapshaper ./data/maps/gadm36_DEU_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_DEU_1.json
+yarn mapshaper ./data/maps/gadm36_JPN_1.shp -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_JPN_1.json
+yarn mapshaper ./data/maps/gadm36_AUT_1.shp -simplify 5% -clean -o format=topojson ./data/maps/gadm36_AUT_1.json
+yarn mapshaper ./data/maps/gadm36_AUS_1.shp -simplify 0.2% -clean -o format=topojson ./data/maps/gadm36_AUS_1.json
+yarn mapshaper ./data/maps/gadm36_USA_2.shp -filter 'TYPE_2 != ""Water body""' -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_USA_2.json
+yarn mapshaper ./data/maps/gadm36_CAN_1.shp -simplify 0.3% -clean -o format=topojson ./data/maps/gadm36_CAN_1.json
+yarn mapshaper ./data/maps/gadm36_ESP_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_ESP_1.json
+yarn mapshaper ./data/maps/gadm36_CHE_1.shp -simplify 10% -clean -o format=topojson ./data/maps/gadm36_CHE_1.json
+yarn mapshaper ./data/maps/gadm36_GBR_2.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_GBR_2.json
+yarn mapshaper ./data/maps/gadm36_SWE_1.shp -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_SWE_1.json
+yarn mapshaper ./data/maps/gadm36_POL_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_POL_1.json
+yarn mapshaper ./data/maps/gadm36_NOR_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_NOR_1.json
+yarn mapshaper ./data/maps/gadm36_IRN_1.shp -simplify 5% -clean -o format=topojson ./data/maps/gadm36_IRN_1.json
+yarn mapshaper ./data/maps/gadm36_PRT_2.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_PRT_2.json
+yarn mapshaper ./data/maps/gadm36_BRA_1.shp -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_BRA_1.json
+yarn mapshaper ./data/maps/gadm36_MYS_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_MYS_1.json
+yarn mapshaper ./data/maps/gadm36_CHL_1.shp -simplify 0.2% -clean -o format=topojson ./data/maps/gadm36_CHL_1.json
+yarn mapshaper ./data/maps/gadm36_BEL_1.shp -simplify 20% -clean -o format=topojson ./data/maps/gadm36_BEL_1.json
+yarn mapshaper ./data/maps/gadm36_CZE_1.shp -simplify 10% -clean -o format=topojson ./data/maps/gadm36_CZE_1.json
+yarn mapshaper ./data/maps/gadm36_RUS_1.shp -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_RUS_1.json
+yarn mapshaper ./data/maps/gadm36_MEX_1.shp -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_MEX_1.json
+yarn mapshaper ./data/maps/gadm36_ECU_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_ECU_1.json
+yarn mapshaper ./data/maps/gadm36_ARG_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_ARG_1.json
+yarn mapshaper ./data/maps/gadm36_PER_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_PER_1.json
+yarn mapshaper ./data/maps/gadm36_IRL_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_IRL_1.json
+yarn mapshaper ./data/maps/gadm36_ZAF_1.shp -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_ZAF_1.json
+yarn mapshaper ./data/maps/gadm36_PHL_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_PHL_1.json
+yarn mapshaper ./data/maps/gadm36_ROU_1.shp -simplify 5% -clean -o format=topojson ./data/maps/gadm36_ROU_1.json
+yarn mapshaper ./data/maps/gadm36_IDN_1.shp -simplify 0.5% -clean -o format=topojson ./data/maps/gadm36_IDN_1.json
+yarn mapshaper ./data/maps/gadm36_SAU_1.shp -simplify 1% -clean -o format=topojson ./data/maps/gadm36_SAU_1.json
+yarn mapshaper ./data/maps/gadm36_THA_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_THA_1.json
+yarn mapshaper ./data/maps/gadm36_COL_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_COL_1.json
+yarn mapshaper ./data/maps/gadm36_PAK_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_PAK_1.json
+yarn mapshaper ./data/maps/gadm36_HRV_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_HRV_1.json
+yarn mapshaper ./data/maps/gadm36_FIN_4.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_FIN_4.json
+yarn mapshaper ./data/maps/gadm36_UKR_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_UKR_1.json
+yarn mapshaper ./data/maps/gadm36_HUN_1.shp -simplify 50% -clean -o format=topojson ./data/maps/gadm36_HUN_1.json
+yarn mapshaper ./data/maps/gadm36_DNK_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_DNK_1.json
+yarn mapshaper ./data/maps/gadm36_SVK_1.shp -simplify 50% -clean -o format=topojson ./data/maps/gadm36_SVK_1.json
+yarn mapshaper ./data/maps/gadm36_ALB_1.shp -simplify 10% -clean -o format=topojson ./data/maps/gadm36_ALB_1.json
+yarn mapshaper ./data/maps/gadm36_LVA_1.shp -simplify 50% -clean -o format=topojson ./data/maps/gadm36_LVA_1.json
+yarn mapshaper ./data/maps/gadm36_GRC_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_GRC_1.json
+yarn mapshaper ./data/maps/gadm36_EST_1.shp -filter 'TYPE_1 != ""Water body""' -simplify 1% -clean -o format=topojson ./data/maps/gadm36_EST_1.json
+yarn mapshaper ./data/maps/gadm36_SVN_1.shp -simplify 50% -clean -o format=topojson ./data/maps/gadm36_SVN_1.json
+yarn mapshaper ./data/maps/gadm36_HTI_1.shp -simplify 5% -clean -o format=topojson ./data/maps/gadm36_HTI_1.json
+yarn mapshaper ./data/maps/gadm36_DZA_1.shp -simplify 50% -clean -o format=topojson ./data/maps/gadm36_DZA_1.json
+yarn mapshaper ./data/maps/gadm36_NGA_1.shp -simplify 5% -clean -o format=topojson ./data/maps/gadm36_NGA_1.json
+yarn mapshaper ./data/maps/gadm36_SEN_1.shp -simplify 10% -clean -o format=topojson ./data/maps/gadm36_SEN_1.json
+yarn mapshaper ./data/maps/gadm36_BOL_1.shp -simplify 10% -clean -o format=topojson ./data/maps/gadm36_BOL_1.json
+yarn mapshaper ./data/maps/gadm36_HND_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_HND_1.json
+yarn mapshaper ./data/maps/gadm36_TUR_1.shp -simplify 5% -clean -o format=topojson ./data/maps/gadm36_TUR_1.json
+yarn mapshaper ./data/maps/gadm36_LKA_1.shp -simplify 2% -clean -o format=topojson ./data/maps/gadm36_LKA_1.json
+yarn mapshaper ./data/maps/gadm36_GTM_1.shp -simplify 10% -clean -o format=topojson ./data/maps/gadm36_GTM_1.json
+
+yarn mapshaper ./data/maps/world-50m.json -filter 'NAME != ""Antarctica""' -simplify 50% -clean -o format=topojson ./data/maps/WORLD.json
+yarn mapshaper ./data/maps/states-10m.json -simplify 50% -clean -o format=topojson ./data/maps/USA.json
+yarn mapshaper ./data/maps/netherlands.json -simplify 10% -clean -o format=topojson ./data/maps/NLD.json
+yarn mapshaper ./data/maps/italy_provinces.json -simplify 10% -clean -o format=topojson ./data/maps/ITA_2.json
+yarn mapshaper ./data/maps/GHANA_16_REGIONS.shp -simplify 1% -clean -o format=topojson ./data/maps/GHA.json
+yarn mapshaper ./data/maps/Covid_19.shp -simplify 1% -clean -o format=topojson ./data/maps/MAR.json
+yarn mapshaper ./data/maps/bgd_admbnda_adm1_bbs_20180410.shp -simplify 2% -clean -o format=topojson ./data/maps/BGD.json
+yarn mapshaper ./data/maps/nepal.json -simplify 5% -clean -o format=topojson ./data/maps/NPL.json
+
+# combine maps
+yarn mapshaper -i ./data/maps/gadm36_CHN_1.json ./data/maps/gadm36_HKG_0.json ./data/maps/gadm36_MAC_0.json ./data/maps/gadm36_TWN_0.json combine-files -merge-layers force -o format=topojson ./data/maps/CHN_1.json
+yarn mapshaper -i ./data/maps/gadm36_CHN_2.json ./data/maps/gadm36_HKG_0.json ./data/maps/gadm36_MAC_0.json ./data/maps/gadm36_TWN_0.json combine-files -merge-layers force -o format=topojson ./data/maps/CHN_2.json","Shell"
+"Viral","stevenliuyi/covid19","scripts/postinstall.sh",".sh","213","11","#!/bin/bash
+
+#scripts=""download_maps download_data data_processing""
+scripts=""download_data data_processing""
+
+for script in $scripts; do
+    ./scripts/${script}.sh
+    if [ $? != 0 ]; then
+       exit 1
+    fi
+done","Shell"
+"Viral","stevenliuyi/covid19","data/guatemala-data/crawler.py",".py","2771","84","from selenium import webdriver
+from selenium.webdriver.support.ui import Select
+import requests
+import time
+import subprocess
+import re
+
+# https://tablerocovid.mspas.gob.gt/
+url = 'https://gtmvigilanciacovid.shinyapps.io/3869aac0fb95d6baf2c80f19f2da5f98/'
+data_folder = 'data/guatemala-data/'
+
+regions = [
+    ""Alta Verapaz"", ""Baja Verapaz"", ""Chimaltenango"", ""Chiquimula"",
+    ""El Progreso"", ""Escuintla"", ""Guatemala"", ""Huehuetenango"", ""Izabal"",
+    ""Jalapa"", ""Jutiapa"", ""Peten"", ""Quetzaltenango"", ""Quiche"", ""Retalhuleu"",
+    ""Sacatepequez"", ""San Marcos"", ""Santa Rosa"", ""Solola"", ""Suchitepequez"",
+    ""Totonicapan"", ""Zacapa""
+]
+
+opts = webdriver.ChromeOptions()
+opts.add_argument(""--headless"")
+opts.add_experimental_option(
+    ""prefs"", {
+        ""download.default_directory"": ""/home/seluser/Downloads"",
+        ""download.prompt_for_download"": False,
+    })
+
+driver = webdriver.Remote(command_executor='http://localhost:4444/wd/hub',
+                          desired_capabilities=opts.to_capabilities())
+
+
+def download_file_by_region(region, metric):
+    driver.get(url)
+    time.sleep(5)
+
+    dropdown = driver.find_element_by_css_selector('.selectize-control')
+    dropdown.click()
+    options = dropdown.find_elements_by_css_selector('.option')
+    for option in options:
+        if (option.text.strip() == region.upper()):
+            option.click()
+            print('Found ' + region)
+            break
+    time.sleep(2)
+
+    tab_name = 'Casos confirmados' if metric == 'confirmed' else 'Casos fallecidos'
+    tabs = driver.find_elements_by_css_selector('span')
+    for tab in tabs:
+        if (tab.text.strip() == tab_name):
+            tab.click()
+    time.sleep(2)
+
+    links = driver.find_elements_by_css_selector('a')
+    table_link = None
+    for link in links:
+        if (link.text.strip() == 'Cuadro de datos'):
+            table_link = link
+
+    if table_link is None:
+        print('Cannot find table link!')
+        exit(1)
+
+    table_link.click()
+    time.sleep(3)
+
+    download_link = driver.find_element_by_css_selector('.buttons-csv')
+    print('Downloading ' + metric + ' data for ' + region)
+    download_link.click()
+    time.sleep(2)
+
+    # copy file from container to host
+    downloaded_filename = 'confirmados_fecha.csv' if metric == 'confirmed' else 'fallecidos_fecha.csv'
+    command = 'docker cp selenium:/home/seluser/Downloads/' + downloaded_filename + ' ' + data_folder + metric + '/' + region.replace(' ', '_') + '.csv'
+    # delete file
+    command += ';docker exec selenium bash -c ""rm /home/seluser/Downloads/' + downloaded_filename + '""'
+    subprocess.Popen(command, shell=True)
+    time.sleep(2)
+
+
+for region in regions:
+    download_file_by_region(region, 'confirmed')
+    download_file_by_region(region, 'deaths')
+
+driver.quit()","Python"
+"Viral","stevenliuyi/covid19","data/sri-lanka-data/crawler.py",".py","2128","63","import os
+import datetime
+import tabula
+from pathlib import Path
+import re
+
+data_folder = 'data/sri-lanka-data/'
+data_files = os.listdir(data_folder)
+
+districts = [
+    'Colombo', 'Gampaha', 'Puttalam', 'Kalutara', 'Anuradhapura', 'Kandy',
+    'Kurunegala', 'Jaffna', 'Ratnapura', 'Polonnaruwa', 'Kegalle',
+    'Moneragala', 'Kalmunai', 'Matale', 'Galle', 'Badulla', 'Matara',
+    'Batticoloa', 'Hambantota', 'Vavunia', 'Trincomalee', 'Ampara',
+    'Nuwaraeliya', 'Kilinochchi', 'Mannar', 'Mullativu'
+]
+
+first_date = datetime.date(2020, 3, 20)
+
+curr_date = first_date
+today = datetime.date.today()
+
+while curr_date < today:
+    curr_date_str = curr_date.strftime('%Y-%m-%d')
+    file_name = curr_date_str + '.csv'
+
+    if not file_name in data_files:
+        pdf_link = 'http://www.epid.gov.lk/web/images/pdf/corona_virus_report/sitrep-sl-en-' + curr_date.strftime(
+            '%d') + '-' + curr_date.strftime('%m') + '_10.pdf'
+        temp_file = data_folder + file_name + '_tmp'
+        try:
+            tabula.convert_into(pdf_link,
+                                temp_file,
+                                output_format=""csv"",
+                                pages=2,
+                                area=(29, 340, 745, 594))
+
+            temp_f = open(temp_file, 'r')
+            f = open(data_folder + file_name, 'w')
+
+            pattern = '|'.join([x.upper() for x in districts])
+            pattern = '(' + pattern + ')(\d+)'
+            lines = temp_f.readlines()
+            for line in lines:
+                new_line = re.sub(r'(\s|\n)', '', line)
+                letters = re.sub(r'\d', '', new_line)
+                numbers = re.sub(r'[A-Za-z]', '', new_line)
+                match = re.search(pattern, letters + numbers)
+                if match is not None:
+                    f.write(match.group(1) + ',' + match.group(2) + '\n')
+
+            temp_f.close()
+            f.close()
+        except:
+            print('Cannot parse Sri Lanka data for ' + curr_date_str)
+
+    # next day
+    curr_date += datetime.timedelta(days=1)
+
+# clean temp files
+for p in Path(data_folder).glob(""*.csv_tmp""):
+    p.unlink()
+","Python"
+"Viral","stevenliuyi/covid19","data/croatia-data/crawler.py",".py","905","30","import requests
+from bs4 import BeautifulSoup
+import json
+
+url = 'https://koronavirus.hr/json/?action=po_danima_zupanijama'
+
+headers = {'Content-Type': 'application/json'}
+request_data = {
+    'cmd': 'request.get',
+    'url': url,
+    'userAgent':
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.117 Safari/537.36',
+    'maxTimeout': 60000
+}
+
+try:
+    response = requests.post(url='http://localhost:8191/v1',
+                             data=json.dumps(request_data),
+                             headers=headers)
+    html_txt = response.json()['solution']['response']
+    soup = BeautifulSoup(html_txt, 'html.parser')
+    data = soup.find('pre').text
+
+    with open('data/croatia-data/raw.json', 'w') as f:
+        f.write(data)
+
+    data = json.loads(data)
+except Exception as e:
+    print('Error ocurred when scraping Croatia data!')
+    print(e)","Python"
+"Viral","stevenliuyi/covid19","data/algeria-data/crawler.py",".py","252","16","import requests
+import json
+
+url = 'https://api.corona-dz.live/province/all'
+
+data = requests.get(url=url).json()
+
+data = json.dumps(
+    data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/algeria-data/raw.json', 'w')
+f.write(data)
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/hungary-data/crawler.py",".py","1341","42","import requests
+from bs4 import BeautifulSoup
+import re
+
+url = 'https://en.wikipedia.org/w/api.php?action=parse&page=COVID-19_pandemic_in_Hungary&prop=text&formatversion=2&format=json'
+html_txt = requests.get(url=url).json()['parse']['text']
+soup = BeautifulSoup(html_txt, 'html.parser')
+
+table = soup.find(
+    text=re.compile('Infections \(cumulative\)')).find_parent('table')
+rows = table.find_all('tr')
+
+date_pattern = re.compile('\d{4}\.\d{2}\.\d{2}\.')
+
+hungary_regions = [
+    'Bács-Kiskun', 'Baranya', 'Békés', 'Borsod-Abaúj-Zemplén',
+    'Csongrád-Csanád', 'Fejér', 'Győr-Moson-Sopron', 'Hajdú-Bihar', 'Heves',
+    'Jász-Nagykun-Szolnok', 'Komárom-Esztergom', 'Nógrád', 'Pest', 'Somogy',
+    'Szabolcs-Szatmár-Bereg', 'Tolna', 'Vas', 'Veszprém', 'Zala', 'Budapest'
+]
+
+f = open('data/hungary-data/data.csv', 'w')
+f.write('Date,' + ','.join(hungary_regions) + '\n')
+
+for row in rows:
+    cells = row.find_all('td')
+    if (len(cells) == 0): continue
+
+    date = row.find('th').text.strip()
+    if (date_pattern.match(date) is None): continue
+    date = date.replace('.', '-')[:-1]
+
+    counts = cells[:20]
+    if (len(counts) != len(hungary_regions)): continue
+    counts = [int(x.text.strip()) for x in counts]
+
+    f.write(date)
+    for count in counts:
+        f.write(',' + str(count))
+    f.write('\n')
+
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/hong-kong-data/crawler.py",".py","358","20","import requests
+import json
+
+url = 'https://api.n-cov.info/case'
+
+try:
+    data = requests.get(url=url).json()
+    data = data[""data""]
+
+    data = json.dumps(
+        data,
+        indent=2,
+        ensure_ascii=False,
+    )
+
+    f = open('data/hong-kong-data/raw.json', 'w')
+    f.write(data)
+    f.close()
+except:
+    print('Cannot obtain Hong Kong data!')","Python"
+"Viral","stevenliuyi/covid19","data/slovenia-data/crawler.py",".py","1701","56","import os
+import datetime
+import tabula
+from pathlib import Path
+import re
+
+data_folder = 'data/slovenia-data/'
+data_files = os.listdir(data_folder)
+
+first_date = datetime.date(2020, 4, 14)
+
+curr_date = first_date
+today = datetime.date.today()
+
+while curr_date < today:
+    curr_date_str = curr_date.strftime('%Y-%m-%d')
+    file_name = curr_date_str + '.csv'
+
+    if not file_name in data_files:
+        pdf_link_base = 'https://www.nijz.si/sites/www.nijz.si/files/uploaded/covid_obcine_'
+
+        if curr_date_str in ['2020-07-31','2020-08-01']:
+            pdf_link_base = 'https://www.nijz.si/sites/www.nijz.si/files/uploaded/publikacije/preprecujmo/covid_obcine_'
+
+        pdf_link = pdf_link_base + curr_date.strftime('%d%m%Y') + '.pdf'
+        temp_file = data_folder + file_name + '_tmp'
+        try:
+            tabula.convert_into(pdf_link,
+                                temp_file,
+                                output_format=""csv"",
+                                pages='all',
+                                stream=True)
+
+            temp_f = open(temp_file, 'r')
+            f = open(data_folder + file_name, 'w')
+
+            lines = temp_f.readlines()
+            lines = [
+                re.compile('(\d)\s(\d)').sub(r'\1,\2', line) for line in lines
+                if not line.startswith('""')
+            ]
+            lines = [line.replace(',,',',') for line in lines]
+            f.writelines(lines)
+
+            temp_f.close()
+            f.close()
+        except:
+            print('Cannot parse Solvenia data for ' + curr_date_str)
+
+    # next day
+    curr_date += datetime.timedelta(days=1)
+
+# clean temp files
+for p in Path(data_folder).glob(""*.csv_tmp""):
+    p.unlink()
+","Python"
+"Viral","stevenliuyi/covid19","data/turkey-data/crawler.py",".py","1701","53","import os
+import datetime
+import tabula
+import re
+import requests
+from bs4 import BeautifulSoup
+from pathlib import Path
+
+folder = 'data/turkey-data/'
+data_files = os.listdir(folder)
+
+url = 'https://sbsgm.saglik.gov.tr/TR,66559/gunluk-rapor--daily-report.html'
+
+regions = [
+    'Istanbul', 'Western Marmara', 'Aegean', 'Eastern Marmara',
+    'Western Anatolia', 'Mediterranean', 'Central Anatolia',
+    'Western Blacksea', 'Eastern Blacksea', 'Northeastern Anatolia',
+    'Mideastern Anatolia', 'Southeastern Anatolia'
+]
+
+html_txt = requests.get(url=url).text
+soup = BeautifulSoup(html_txt, 'html.parser')
+report_elems = soup.find_all('a', string=re.compile('Daily Situation Report'))
+for report_elem in report_elems:
+    pdf_link = 'https://sbsgm.saglik.gov.tr' + report_elem['href']
+    match = re.search(r'(\d{2})(\d{2})(20\d{2})', pdf_link)
+    date = match.group(3) + '-' + match.group(2) + '-' + match.group(1)
+    file_name = date + '.csv'
+
+    if not file_name in data_files:
+        temp_file = folder + file_name + '_tmp'
+        tabula.convert_into(pdf_link,
+                            temp_file,
+                            output_format=""csv"",
+                            pages=3,
+                            stream=True)
+
+        temp_f = open(temp_file, 'r')
+        f = open(folder + file_name, 'w')
+
+        lines = temp_f.readlines()
+        pattern = '(' + '|'.join(regions) + ')\s(\d+)'
+        for line in lines:
+            match = re.search(pattern, line)
+            if match is not None:
+                f.write(match.group(1) + ',' + match.group(2) + '\n')
+
+        temp_f.close()
+        f.close()
+
+# clean temp files
+for p in Path(folder).glob(""*.csv_tmp""):
+    p.unlink()","Python"
+"Viral","stevenliuyi/covid19","data/1p3a-data/crawler.py",".py","1735","68","import requests
+import re
+import json
+import os
+
+url = 'https://coronavirus.1point3acres.com'
+headers = {
+    'User-Agent':
+    'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0'
+}
+
+html_txt = requests.get(url=url, headers=headers).text
+confirmed_data = ""{}""
+deaths_data = ""{}""
+
+js_files = re.findall(r'chunks[^""]+\.js', html_txt)
+
+for js_file in set(js_files):
+    curr_html_txt = requests.get(url=url + '/_next/static/' + js_file,
+                                 headers=headers).text
+    txt_splitted = curr_html_txt.split(""JSON.parse('"")
+    for txt in txt_splitted:
+        data = txt.split(""')}"")[0]
+        if ('""state_name"":[""AK""],""county"":[""Anchorage""]' in data):
+            if (confirmed_data == '{}'):
+                confirmed_data = data
+            else:
+                deaths_data = data
+
+confirmed_data = confirmed_data.encode().decode('unicode_escape')
+confirmed_data = json.loads(confirmed_data)
+
+deaths_data = deaths_data.encode().decode('unicode_escape')
+deaths_data = json.loads(deaths_data)
+
+# check
+test = next((x for x in confirmed_data if isinstance(x[""entries""][0][1], int)),
+            None)
+if test is None:
+    print('Data crawled from 1P3A are not valid!')
+    exit(1)
+
+test = next((x for x in deaths_data if isinstance(x[""entries""][0][1], int)),
+            None)
+if test is None:
+    print('Data crawled from 1P3A are not valid!')
+    exit(1)
+
+confirmed_data = json.dumps(
+    confirmed_data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+deaths_data = json.dumps(
+    deaths_data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/1p3a-data/confirmed.json', 'w')
+f.write(confirmed_data)
+f.close()
+
+f = open('data/1p3a-data/deaths.json', 'w')
+f.write(deaths_data)
+f.close()
+","Python"
+"Viral","stevenliuyi/covid19","data/denmark-data/crawler.py",".py","2723","74","import requests
+from bs4 import BeautifulSoup
+import re
+import os
+import urllib.request
+import zipfile
+import csv
+
+folder = 'data/denmark-data'
+
+url = 'https://www.ssi.dk/sygdomme-beredskab-og-forskning/sygdomsovervaagning/c/covid19-overvaagning/arkiv-med-overvaagningsdata-for-covid19'
+html_txt = requests.get(url=url).text
+soup = BeautifulSoup(html_txt, 'html.parser')
+data = soup.find_all('a',
+                     href=re.compile('Data-Epidemiologisk', re.IGNORECASE))
+
+denmark_regions = [
+    'Hovedstaden', 'Sjælland', 'Syddanmark', 'Midtjylland', 'Nordjylland'
+]
+
+for d in data:
+    link = d['href']
+    date_match = re.search('\d{8}', link)
+    if date_match is None: continue
+    date = date_match[0]
+    date = date[4:] + '-' + date[2:4] + '-' + date[:2]
+    file_path = folder + '/' + date + '.csv'
+    zip_file_path = folder + '/' + date + '.zip'
+
+    if os.path.isfile(file_path):
+        print(file_path + ' already exists')
+    else:
+        try:
+            urllib.request.urlretrieve(link, zip_file_path)
+            with zipfile.ZipFile(zip_file_path, ""r"") as zip_ref:
+                zip_ref.extractall(folder)
+                region_file_path = folder + '/Region_summary.csv'
+                if os.path.isfile(region_file_path):
+                    os.rename(region_file_path, file_path)
+                else:
+                    print('Region_summary.csv does not exist for ' + link)
+        except:
+            print('Cannot access ' + link)
+
+f1 = open(folder + '/confirmed.csv', 'w')
+f2 = open(folder + '/deaths.csv', 'w')
+f1.write('Date,' + ','.join(denmark_regions) + '\n')
+f2.write('Date,' + ','.join(denmark_regions) + '\n')
+
+files = os.listdir(folder)
+files.sort()
+
+for file_name in files:
+    if file_name.startswith('20') and file_name.endswith('.csv'):
+        date = re.search('\d{4}-\d{2}-\d{2}', file_name)[0]
+        with open(folder + '/' + file_name) as csv_file:
+            csv_reader = csv.reader(csv_file, delimiter=';')
+            confirmedCounts = ['', '', '', '', '']
+            deadCounts = ['', '', '', '', '']
+            for row in csv_reader:
+                region = row[0].strip()
+                if region in denmark_regions:
+                    idx = denmark_regions.index(region)
+                    confirmedCount = row[2]
+                    deadCount = row[4]
+                    confirmedCount = confirmedCount.replace('.', '').strip()
+                    deadCount = deadCount.replace('.', '').strip()
+                    confirmedCounts[idx] = confirmedCount
+                    deadCounts[idx] = deadCount
+            f1.write(date + ',' + ','.join(confirmedCounts) + '\n')
+            f2.write(date + ',' + ','.join(deadCounts) + '\n')
+
+f1.close()
+f2.close()","Python"
+"Viral","stevenliuyi/covid19","data/nepal-data/crawler.py",".py","505","30","import requests
+import json
+
+url = 'https://bipad.gov.np/api/v1/covid19-case'
+exit()
+
+data = []
+
+while True:
+    print('fetching ' + url)
+    raw_data = requests.get(url=url).json()
+    data += raw_data['results']
+
+    count = raw_data['count']
+    url = raw_data['next']
+    if url is None: break
+
+if (len(data) != count):
+    print('Invalid Nepal data!')
+    exit(1)
+
+data = json.dumps(
+    data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/nepal-data/raw.json', 'w')
+f.write(data)
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/bangladesh-data/crawler_arcgis.py",".py","691","28","import requests
+import json
+import sys
+from datetime import date, timedelta
+
+# source: http://iedcr.gov.bd/
+
+url = 'https://services3.arcgis.com/nIl76MjbPamkQiu8/arcgis/rest/services/corona_time_tracker_bd/FeatureServer/0/query?where=1%3D1&returnGeometry=false&outFields=*&f=json&resultRecordCount=2000&resultOffset='
+
+offset = 0
+features = []
+
+while True:
+    curr_url = url + str(offset)
+    data = requests.get(url=curr_url).json()
+    features += data['features']
+    if (len(data['features']) == 0): break
+
+    offset += 2000
+
+data_str = json.dumps(
+    features,
+    indent=2,
+    ensure_ascii=False,
+)
+f = open('data/bangladesh-data/time_series.json', 'w')
+f.write(data_str)
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/bangladesh-data/crawler.py",".py","2041","70","from selenium import webdriver
+from selenium.webdriver.support.ui import Select
+from datetime import datetime, timedelta
+import time
+
+opts = webdriver.FirefoxOptions()
+opts.add_argument(""--headless"")
+
+driver = webdriver.Remote(command_executor='http://localhost:4444/wd/hub',
+                          desired_capabilities=opts.to_capabilities())
+
+data_url = 'http://dashboard.dghs.gov.bd/webportal/pages/covid19.php'
+
+f = open('data/bangladesh-data/bangladesh.csv', 'w')
+
+regions = {
+    '1': 'Dhaka',
+    '2': 'Chittagong',
+    '3': 'Rajshahi',
+    '4': 'Rangpur',
+    '5': 'Khulna',
+    '6': 'Barisal',
+    '7': 'Sylhet',
+    '8': 'Mymensingh'
+}
+
+csv_lines = []
+
+try:
+    for regionId, regionName in regions.items():
+        driver.get(data_url)
+        time.sleep(5)
+
+        divisionSelect = Select(driver.find_element_by_id('division'))
+        divisionSelect.select_by_value(regionId)
+
+        periodSelect = Select(driver.find_element_by_id('period'))
+        periodSelect.select_by_value('LAST_6_MONTH')
+
+        driver.find_element_by_name('Submit').submit()
+        time.sleep(5)
+
+        elems = driver.find_elements_by_css_selector(
+            '#confirmed_case .highcharts-data-label .highcharts-text-outline')
+        counts = [
+            elem.get_attribute('innerHTML').strip().replace(',', '')
+            for elem in elems
+        ]
+
+        firstDate = driver.find_element_by_css_selector(
+            '#confirmed_case .highcharts-xaxis-labels text').text
+        firstDate = datetime.strptime('2020-' + firstDate, '%Y-%B-%d')
+        dates = [(firstDate + timedelta(days=i)).strftime('%Y-%m-%d')
+                 for i in range(len(counts))]
+
+        csv_lines += [
+            dates[i] + ',' + regionName + ',' + counts[i]
+            for i in range(len(counts))
+        ]
+
+        print('Fetched data for ' + regionName + '.')
+
+    f.write('data,region,confirmed\n')
+    f.write('\n'.join(csv_lines))
+except Exception as e:
+    print('Error ocurred when scraping Pakistan data!')
+    print(e)
+
+driver.quit()
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/morocco-data/crawler_arcgis.py",".py","798","28","import requests
+import json
+import sys
+from datetime import date, timedelta
+
+# source: https://www.arcgis.com/apps/opsdashboard/index.html#/1a8e3edab77140c3999ccf6f0d4a906d
+
+service_names = ['Villes_COVID19', 'Covid_19']
+
+for name in service_names:
+    url = 'https://services3.arcgis.com/hjUMsSJ87zgoicvl/arcgis/rest/services/' + name + '/FeatureServer/0/query?where=1%3D1&returnGeometry=false&outFields=*&f=json'
+
+    today = date.today()
+    yesterday = today - timedelta(days=1)
+
+    data_date = yesterday.strftime('%Y-%m-%d')
+
+    data = requests.get(url=url).json()
+
+    data_str = json.dumps(
+        data,
+        indent=2,
+        ensure_ascii=False,
+    )
+    f = open('data/morocco-data/raw/' + name + '_' + str(data_date) + '.json',
+             'w')
+    f.write(data_str)
+    f.close()","Python"
+"Viral","stevenliuyi/covid19","data/morocco-data/crawler.py",".py","688","33","import requests
+import json
+import sys
+
+# more data source: https://covid.hespress.com/
+url = 'https://covid.rue20.com/?id='
+
+output = {}
+
+for i in range(1, 13):
+    html_txt = requests.get(url=url + str(i)).text
+    data = html_txt.split('RegionChart')[1]
+    data = data.split('data:')[1]
+    data = data.split(']')[0]
+    data = data.replace(""x"", '""x""')
+    data = data.replace(""y"", '""y""')
+    data = data.replace(""'"", '""')
+    data = ''.join(data.split())
+    data = data[:-1] + ']'
+
+    data = json.loads(data)
+
+    output[str(i)] = data
+
+output = json.dumps(
+    output,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/morocco-data/data.json', 'w')
+f.write(output)
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/japan-data/crawler.py",".py","427","15","import requests
+import csv
+
+url = 'https://www.stopcovid19.jp/data/covid19japan-all.csv'
+
+data = requests.get(url=url).text.splitlines()
+reader = csv.reader(data)
+for i, row in enumerate(reader):
+    if i == 0: continue
+    curr_url = row[5]
+    curr_date = row[0]
+    curr_csv = requests.get(url=curr_url).text
+    curr_file = open('data/japan-data/' + row[0] + '.csv', 'w')
+    curr_file.write(curr_csv)
+    curr_file.close()","Python"
+"Viral","stevenliuyi/covid19","data/chile-data/crawler.py",".py","3851","110","# Until 06 April 2020, this file was uploading data from wikipedia, which is not ideal,
+# because the table is changing the format. Indeed, this sript was not activated in download_data.sh
+# This is the reason why the data was updating only until 27 March.
+# Instead I propose to request the data from YACHAY COVID-19 Repository for Chile
+# avaliable in https://github.com/YachayData/COVID-19/
+# Which is automatically updating data for Chile from the local authorities website.
+
+import pandas as pd
+import requests
+
+url = ""https://github.com/YachayData/COVID-19/raw/master/Consolidado_COVID19_Chile_Regiones.CSV""
+df = pd.read_csv(url)
+
+#rename column to Date
+df.columns = [
+    'Date', 'id_reg', 'nombre_reg', 'casos_totales', 'casos_nuevos',
+    'casos_nuevos_sintomas', 'casos_nuevos_nosintomas', 'fallecidos_totales',
+    'fallecidos_nuevos', 'recuperados_totales', 'recuperados_nuevos'
+]
+
+#we add fill_value=0 because we want to still have integers
+dfConfirmed = df.pivot_table(index='Date',
+                             columns='id_reg',
+                             values='casos_totales',
+                             fill_value=0)
+dfDeaths = df.pivot_table(index='Date',
+                          columns='id_reg',
+                          values='fallecidos_totales',
+                          fill_value=0)
+
+#We'll add spaces and accesnt marks
+columns_names = {
+    1: 'Tarapacá',
+    2: 'Antofagasta',
+    3: 'Atacama',
+    4: 'Coquimbo',
+    5: 'Valparaíso',
+    6: 'O\'Higgins',
+    7: 'Maule',
+    8: 'Biobío',
+    9: 'Araucanía',
+    10: 'Los Lagos',
+    11: 'Aysén',
+    12: 'Magallanes',
+    13: 'Santiago Metropolitan',
+    14: 'Los Ríos',
+    15: 'Arica y Parinacota',
+    16: 'Ñuble'
+}
+
+dfConfirmed = dfConfirmed.rename(columns_names, axis=1)
+dfDeaths = dfDeaths.rename(columns_names, axis=1)
+
+dfConfirmed.to_csv('data/chile-data/chile_confirmed.csv', index=True)
+dfDeaths.to_csv('data/chile-data/chile_deaths.csv', index=True)
+# I will leave the old code below anyway
+##
+
+# import requests
+# from bs4 import BeautifulSoup
+# import re
+
+# url = 'https://en.wikipedia.org/w/api.php?action=parse&page=Template:2019%E2%80%9320_coronavirus_pandemic_data/Chile_medical_cases&prop=text&formatversion=2&format=json'
+# html_txt = requests.get(url=url).json()['parse']['text']
+# soup = BeautifulSoup(html_txt, 'html.parser')
+
+# table = soup.find(text=re.compile('by region')).find_parent('table')
+# rows = table.find_all('tr')
+
+# date_pattern = re.compile('\d{4}-\d{1,2}-\d{1,2}')
+
+# chile_regions = [
+#     'Arica y Parinacota', 'Tarapacá', 'Antofagasta', 'Atacama', 'Coquimbo',
+#     'Valparaíso', 'Santiago Metropolitan', ""O'Higgins"", 'Maule', 'Ñuble',
+#     'Biobío', 'Araucanía', 'Los Ríos', 'Los Lagos', 'Aysén', 'Magallanes'
+# ]
+
+# f1 = open('data/chile-data/chile_confirmed.csv', 'w')
+# f2 = open('data/chile-data/chile_deaths.csv', 'w')
+# f1.write('Date,' + ','.join(chile_regions) + '\n')
+# f2.write('Date,' + ','.join(chile_regions) + '\n')
+
+# for row in rows:
+#     cells = row.find_all('td')
+#     if (len(cells) == 0): continue
+
+#     date = cells[0].text.strip()
+#     if (date_pattern.match(date) is None): continue
+#     date = '-'.join([x.zfill(2) for x in date.split('-')])
+#     f1.write(date)
+#     f2.write(date)
+
+#     counts = cells[1:17]
+#     if (len(counts) != len(chile_regions)): continue
+#     counts = [x.text.strip() for x in counts]
+#     for count in counts:
+#         splitted = count.split('(')
+#         if (len(splitted) == 1):
+#             confirmedCount = 0 if count == '' else int(count)
+#             deadCount = 0
+#         else:
+#             confirmedCount = int(splitted[0])
+#             deadCount = int(splitted[1][:-1])
+#         f1.write(',' + str(confirmedCount))
+#         f2.write(',' + str(deadCount))
+#     f1.write('\n')
+#     f2.write('\n')
+
+# f1.close()
+# f2.close()","Python"
+"Viral","stevenliuyi/covid19","data/iran-data/crawler.py",".py","1536","42","import requests
+from bs4 import BeautifulSoup
+import re
+
+url = 'https://en.wikipedia.org/w/api.php?action=parse&page=Template:COVID-19_pandemic_data/Iran_medical_cases&prop=text&formatversion=2&format=json'
+html_txt = requests.get(url=url).json()['parse']['text']
+soup = BeautifulSoup(html_txt, 'html.parser')
+
+table = soup.find(text=re.compile('in Iran by province')).find_parent('table')
+rows = table.find_all('tr')
+
+date_pattern = re.compile('\d{4}/\d{2}/\d{2}')
+
+iran_provinces = [
+    'Qom', 'Tehran', 'Mazandaran', 'Alborz', 'Semnan', 'Golestan', 'Qazvin',
+    'Isfahan', 'Fars', 'Hormozgan', 'Kohgiluyeh and Boyer-Ahmad',
+    'Chaharmahal and Bakhtiari', 'Bushehr', 'Gilan', 'Ardabil',
+    'East Azerbaijan', 'West Azerbaijan', 'Kordestan', 'Zanjan', 'Markazi',
+    'Hamadan', 'Khuzestan', 'Kermanshah', 'Lorestan', 'Ilam',
+    'Razavi Khorasan', 'Sistan and Baluchestan', 'Yazd', 'South Khorasan',
+    'Kerman', 'North Khorasan'
+]
+
+f = open('data/iran-data/iran.csv', 'w')
+f.write('Date,' + ','.join(iran_provinces) + '\n')
+
+for row in rows:
+    cells = row.find_all('td')
+    if (len(cells) == 0): continue
+
+    date = cells[0].text.strip()
+    if (date_pattern.match(date) is None and date != 'Total'): continue
+    date = date.replace('/', '-')
+
+    counts = cells[1:32]
+    if (len(counts) != len(iran_provinces)): continue
+    counts = [x.text.strip() for x in counts]
+    counts = [0 if x == '' else int(x) for x in counts]
+    counts = [str(x) for x in counts]
+    f.write(date + ',' + ','.join(counts) + '\n')
+
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/haiti-data/crawler.py",".py","671","34","import requests
+import json
+import sys
+from datetime import date, timedelta
+
+if (len(sys.argv) <= 1):
+    print('No token provided for accessing Haiti data.')
+    exit()
+
+token = sys.argv[1]
+url = 'https://www.coronahaiti.org/api/data/regions?token=' + token
+
+today = date.today()
+yesterday = today - timedelta(days=1)
+
+data_date = yesterday.strftime('%Y-%m-%d')
+
+data = requests.get(url=url).json()
+
+if 'data' in data.keys():
+    data = data['data']
+else:
+    print('Crawled Haiti data are not valid!')
+    exit(1)
+
+data = json.dumps(
+    data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/haiti-data/' + str(data_date) + '.json', 'w')
+f.write(data)
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/slovakia-data/crawler.py",".py","291","16","import requests
+import json
+
+url = 'https://api.apify.com/v2/datasets/oUWi8ci7F2R9V5ZFy/items?format=json&clean=1'
+
+data = requests.get(url=url).json()
+
+data = json.dumps(
+    data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/slovakia-data/raw.json', 'w')
+f.write(data)
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/india-data/crawler.py",".py","278","17","import requests
+import json
+
+url = 'https://api.rootnet.in/covid19-in/stats/history'
+
+data = requests.get(url=url).json()
+data = data[""data""]
+
+data = json.dumps(
+    data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/india-data/raw.json', 'w')
+f.write(data)
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/serbia-data/crawler.py",".py","2607","74","import os
+import datetime
+import json
+import requests
+
+data_folder = 'data/serbia-data/'
+data_files = os.listdir(data_folder)
+
+first_date = datetime.date(2020, 3, 6)
+
+curr_date = first_date
+today = datetime.date.today()
+
+url = 'https://covid19.data.gov.rs/api/datasets/statistic/download_CSV'
+headers = {'Content-type': 'application/json'}
+
+while curr_date < today:
+    curr_date_str = curr_date.strftime('%Y-%m-%d')
+    file_name = curr_date_str + '.csv'
+
+    if not file_name in data_files:
+        # total cases
+        data = {
+            ""dataSetId"":
+            1,
+            ""refCodes"": [{
+                ""id"": 1,
+                ""code"": ""COVID-19 statistics"",
+                ""values"": [{
+                    ""id"": 2,
+                    ""name"": ""Total Cases""
+                }]
+            }],
+            ""territoryIds"": [
+                168, 40, 41, 169, 170, 42, 43, 44, 171, 172, 173, 174, 45, 46,
+                177, 175, 47, 176, 163, 64, 65, 66, 67, 68, 69, 70, 71, 151,
+                150, 146, 211, 149, 147, 220, 219, 84, 85, 86, 81, 217, 218,
+                82, 242, 83, 182, 183, 222, 91, 133, 223, 184, 185, 92, 224,
+                93, 94, 96, 95, 225, 226, 238, 160, 186, 187, 97, 98, 99, 100,
+                102, 188, 101, 103, 153, 104, 227, 105, 228, 108, 109, 106,
+                107, 110, 189, 111, 112, 113, 114, 115, 116, 164, 190, 117,
+                191, 192, 118, 193, 229, 230, 195, 194, 231, 119, 196, 120,
+                232, 197, 121, 213, 122, 198, 233, 123, 124, 125, 126, 127,
+                235, 234, 128, 130, 131, 129, 132, 199, 152, 201, 200, 162,
+                212, 136, 137, 138, 139, 202, 236, 203, 204, 205, 206, 240,
+                241, 207, 140, 237, 134, 135, 208, 209, 142, 143, 144, 145,
+                148, 239, 141, 72, 73, 74, 75, 215, 77, 76, 78, 79, 161, 210,
+                80, 178, 216, 179, 87, 88, 90, 180, 89, 181, 221, 243
+            ],
+            ""territoryGroupId"":
+            5,
+            ""number"":
+            10,
+            ""dimTime"":
+            curr_date_str
+        }
+
+        output = requests.post(url=url, data=json.dumps(data), headers=headers)
+
+        f = open(data_folder + 'total_cases/' + file_name, 'w')
+        f.write(output.text)
+        f.close()
+
+        # new cases
+        data[""refCodes""][0][""values""] = [{""id"": 1, ""name"": ""Daily New Cases""}]
+
+        output = requests.post(url=url, data=json.dumps(data), headers=headers)
+
+        f = open(data_folder + 'new_cases/' + file_name, 'w')
+        f.write(output.text)
+        f.close()
+
+    # next day
+    curr_date += datetime.timedelta(days=1)","Python"
+"Viral","stevenliuyi/covid19","data/cds-data/crawler.py",".py","283","16","import requests
+import json
+
+url = 'https://coronadatascraper.com/timeseries-byLocation.json'
+
+data = requests.get(url=url).json()
+
+data = json.dumps(
+    data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/cds-data/timeseries-byLocation.json', 'w')
+f.write(data)
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/thailand-data/crawler.py",".py","276","17","import requests
+import json
+
+url = 'https://covid19.th-stat.com/api/open/cases'
+
+data = requests.get(url=url).json()
+data = data[""Data""]
+
+data = json.dumps(
+    data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/thailand-data/raw.json', 'w')
+f.write(data)
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/ghana-data/crawler.py",".py","752","28","import requests
+import json
+import sys
+from datetime import date, timedelta
+
+url = 'https://services9.arcgis.com/XPDxEtZ1oS0ENZZq/arcgis/rest/services/COVID_19_Ghana/FeatureServer/1/query?where=1%3D1&returnGeometry=false&outFields=*&f=json'
+
+today = date.today()
+yesterday = today - timedelta(days=1)
+
+data_date = yesterday.strftime('%Y-%m-%d')
+
+data = requests.get(url=url).json()
+
+if 'features' in data.keys():
+    data = data['features']
+else:
+    print('Crawled Ghana data are not valid!')
+    exit(1)
+
+f = open('data/ghana-data/history/' + str(data_date) + '.txt', 'w')
+
+for record in data:
+    region = record['attributes']['REGION']
+    count = record['attributes']['Number_of_Cases']
+    f.write(region + ' – ' + str(count) + '\n')
+
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/pakistan-data/crawler.py",".py","1952","55","from selenium import webdriver
+from datetime import datetime, timedelta
+import requests
+import time
+
+opts = webdriver.FirefoxOptions()
+opts.add_argument(""--headless"")
+
+driver = webdriver.Remote(command_executor='http://localhost:4444/wd/hub',
+                          desired_capabilities=opts.to_capabilities())
+
+#url = 'https://covid.gov.pk/stats/pakistan'
+#html_txt = requests.get(url=url).text
+#data_url = html_txt.split('datastudio.google.com')[1]
+#data_url = data_url.split('""')[0]
+#data_url = 'https://datastudio.google.com' + data_url
+data_url = 'https://datastudio.google.com/embed/reporting/1PLVi5amcc_R5Gh928gTE8-8r8-fLXJQF/page/R24IB'
+
+file_name = 'data/pakistan-data/pakistan.csv'
+f = open(file_name, 'r+')
+csv_content = f.read()
+
+try:
+    driver.get(data_url)
+    time.sleep(20)
+
+    tables = driver.find_elements_by_css_selector('lego-table.table')
+    for table in tables:
+        table_text = table.text.strip().replace(',', '')
+        if 'GMT' in table_text:
+            # update time
+            date = table_text.split('\n')[1]
+            date = date.split('-')[0].strip()
+            date = datetime.strptime(date, '%d %b %Y')
+            date -= timedelta(days=1)
+            date = date.strftime('%Y-%m-%d')
+        elif table_text.startswith('AJK'):
+            if (date in csv_content):
+                print('Pakistan data on ' + date + ' already exist!')
+            else:
+                data = table_text.split('\n')
+                csv_lines = []
+                for i in range(0, len(data), 5):
+                    region = data[i]
+                    counts = [data[idx] for idx in [i + 1, i + 3, i + 4]]
+                    csv_lines.append(date + ',' + region + ',' +
+                                     ','.join(counts))
+                f.write('\n')
+                f.write('\n'.join(csv_lines))
+except Exception as e:
+    print('Error ocurred when scraping Pakistan data!')
+    print(e)
+
+driver.quit()
+f.close()","Python"
+"Viral","stevenliuyi/covid19","data/venezuela-data/crawler.py",".py","518","26","import requests
+import json
+from datetime import date, timedelta
+
+url = 'https://covid19.patria.org.ve/api/v1/summary'
+
+today = date.today()
+yesterday = today - timedelta(days=1)
+
+data_date = yesterday.strftime('%Y-%m-%d')
+
+data = requests.get(url=url).json()
+
+if not 'Confirmed' in data.keys():
+    print('Crawled Venezuela data are not valid!')
+    exit(1)
+
+data = json.dumps(
+    data,
+    indent=2,
+    ensure_ascii=False,
+)
+
+f = open('data/venezuela-data/' + str(data_date) + '.json', 'w')
+f.write(data)
+f.close()","Python"
+"Viral","EXJUSTICE/COVID19_Detection_Transfer_Learning_VGG16","Covid19_GradientCrescent_Binary.ipynb",".ipynb","1429016","1","{""nbformat"":4,""nbformat_minor"":0,""metadata"":{""colab"":{""name"":""Covid19_GradientCrescent_Binary.ipynb"",""provenance"":[],""collapsed_sections"":[]},""kernelspec"":{""name"":""python3"",""display_name"":""Python 3""},""accelerator"":""GPU""},""cells"":[{""cell_type"":""markdown"",""metadata"":{""id"":""gyG4OC_n_Bgb"",""colab_type"":""text""},""source"":[""## COVID19 CT Pneumonia Detection - Binary Case\n"",""By Adrian Yijie Xu\n"",""(https://medium.com/@adrianitsaxu)\n"",""\n"",""As discussed in \""Detecting COVID-19 induced Pneumonia from Chest X-rays with Transfer Learning: An implementation in Tensorflow and Keras.\""\n"",""(https://github.com/EXJUSTICE/GradientCrescent)\n"",""\n"",""100% Test Accuracy with 2 classes.\n"",""\n"",""Conclusion: For the binary case, it is possible to separate COVID-19 induced pneumonia from healthy lungs.\n"",""\n"",""\n""]},{""cell_type"":""code"",""metadata"":{""id"":""JHtRS9Wf9mZc"",""colab_type"":""code"",""outputId"":""6232d401-3427-452a-e5b3-4afcf9f685da"",""executionInfo"":{""status"":""ok"",""timestamp"":1584624724363,""user_tz"":-60,""elapsed"":15439,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":1000}},""source"":[""# This Python 3 environment comes with many helpful analytics libraries installed\n"",""# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n"",""# For example, here's several helpful packages to load in \n"",""#set randomness for reproducibility\n"",""from numpy.random import seed\n"",""seed(8) #1\n"",""from tensorflow import set_random_seed\n"",""set_random_seed(7) #2\n"",""\n"",""#\n"",""\n"",""import numpy as np # linear algebra\n"",""import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n"",""\n"",""# Input data files are available in the \""../input/\"" directory.\n"",""# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n"",""\n"",""import os\n"",""\n"",""\n"",""!gdown https://drive.google.com/uc?id=1coM7x3378f-Ou2l6Pg2wldaOI7Dntu1a\n"",""!unzip Covid_Data_GradientCrescent.zip\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""display_data"",""data"":{""text/html"":[""

\n"",""The default version of TensorFlow in Colab will soon switch to TensorFlow 2.x.
\n"",""We recommend you upgrade now \n"",""or ensure your notebook will continue to use TensorFlow 1.x via the %tensorflow_version 1.x magic:\n"",""more info.

\n""],""text/plain"":[""""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""Downloading...\n"",""From: https://drive.google.com/uc?id=1coM7x3378f-Ou2l6Pg2wldaOI7Dntu1a\n"",""To: /content/Covid_Data_GradientCrescent.zip\n"",""154MB [00:02, 52.8MB/s]\n"",""Archive: Covid_Data_GradientCrescent.zip\n"","" creating: all/\n"","" creating: all/test/\n"","" creating: all/test/covid/\n"","" inflating: all/test/covid/nejmoa2001191_f3-PA.jpeg \n"","" inflating: all/test/covid/nejmoa2001191_f4.jpeg \n"","" inflating: all/test/covid/nejmoa2001191_f5-PA.jpeg \n"","" inflating: all/test/covid/radiol.2020200490.fig3.jpeg \n"","" inflating: all/test/covid/ryct.2020200028.fig1a.jpeg \n"","" inflating: all/test/covid/ryct.2020200034.fig2.jpeg \n"","" inflating: all/test/covid/ryct.2020200034.fig5-day0.jpeg \n"","" inflating: all/test/covid/ryct.2020200034.fig5-day4.jpeg \n"","" inflating: all/test/covid/ryct.2020200034.fig5-day7.jpeg \n"","" creating: all/test/normal/\n"","" inflating: all/test/normal/NORMAL2-IM-1385-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1396-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1400-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1401-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1406-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1412-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1419-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1422-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1423-0001.jpeg \n"","" creating: all/test/pneumonia_bac/\n"","" inflating: all/test/pneumonia_bac/person1753_bacteria_4594.jpeg \n"","" inflating: all/test/pneumonia_bac/person1940_bacteria_4859.jpeg \n"","" inflating: all/test/pneumonia_bac/person1940_bacteria_4861.jpeg \n"","" inflating: all/test/pneumonia_bac/person1940_bacteria_4862.jpeg \n"","" inflating: all/test/pneumonia_bac/person1941_bacteria_4863.jpeg \n"","" inflating: all/test/pneumonia_bac/person1942_bacteria_4865.jpeg \n"","" inflating: all/test/pneumonia_bac/person1943_bacteria_4868.jpeg \n"","" inflating: all/test/pneumonia_bac/person1944_bacteria_4869.jpeg \n"","" inflating: all/test/pneumonia_bac/person1945_bacteria_4872.jpeg \n"","" creating: all/test/pneumonia_vir/\n"","" inflating: all/test/pneumonia_vir/desktop.ini \n"","" inflating: all/test/pneumonia_vir/person957_virus_1629.jpeg \n"","" inflating: all/test/pneumonia_vir/person958_virus_1630.jpeg \n"","" inflating: all/test/pneumonia_vir/person960_virus_1633.jpeg \n"","" inflating: all/test/pneumonia_vir/person961_virus_1634.jpeg \n"","" inflating: all/test/pneumonia_vir/person962_virus_1635.jpeg \n"","" inflating: all/test/pneumonia_vir/person963_virus_1636.jpeg \n"","" inflating: all/test/pneumonia_vir/person964_virus_1637.jpeg \n"","" inflating: all/test/pneumonia_vir/person965_virus_1638.jpeg \n"","" inflating: all/test/pneumonia_vir/person966_virus_1639.jpeg \n"","" creating: all/train/\n"","" creating: all/train/covid/\n"","" inflating: all/train/covid/01E392EE-69F9-4E33-BFCE-E5C968654078.jpeg \n"","" inflating: all/train/covid/1-s2.0-S0140673620303706-fx1_lrg.jpg \n"","" inflating: all/train/covid/1-s2.0-S0929664620300449-gr2_lrg-a.jpg \n"","" inflating: all/train/covid/1-s2.0-S0929664620300449-gr2_lrg-b.jpg \n"","" inflating: all/train/covid/1-s2.0-S0929664620300449-gr2_lrg-c.jpg \n"","" inflating: all/train/covid/1-s2.0-S0929664620300449-gr2_lrg-d.jpg \n"","" inflating: all/train/covid/1-s2.0-S1684118220300608-main.pdf-001.jpg \n"","" inflating: all/train/covid/1-s2.0-S1684118220300608-main.pdf-002.jpg \n"","" inflating: all/train/covid/1-s2.0-S1684118220300682-main.pdf-002-a1.png \n"","" inflating: all/train/covid/1-s2.0-S1684118220300682-main.pdf-002-a2.png \n"","" inflating: all/train/covid/1-s2.0-S1684118220300682-main.pdf-003-b1.png \n"","" inflating: all/train/covid/1-s2.0-S1684118220300682-main.pdf-003-b2.png \n"","" inflating: all/train/covid/1312A392-67A3-4EBF-9319-810CF6DA5EF6.jpeg \n"","" inflating: all/train/covid/1B734A89-A1BF-49A8-A1D3-66FAFA4FAC5D.jpeg \n"","" inflating: all/train/covid/23E99E2E-447C-46E5-8EB2-D35D12473C39.png \n"","" inflating: all/train/covid/2C26F453-AF3B-4517-BB9E-802CF2179543.jpeg \n"","" inflating: all/train/covid/31BA3780-2323-493F-8AED-62081B9C383B.jpeg \n"","" inflating: all/train/covid/41591_2020_819_Fig1_HTML.webp-day10.png \n"","" inflating: all/train/covid/41591_2020_819_Fig1_HTML.webp-day5.png \n"","" inflating: all/train/covid/6CB4EFC6-68FA-4CD5-940C-BEFA8DAFE9A7.jpeg \n"","" inflating: all/train/covid/7AF6C1AF-D249-4BD2-8C26-449304105D03.jpeg \n"","" inflating: all/train/covid/7C69C012-7479-493F-8722-ABC29C60A2DD.jpeg \n"","" inflating: all/train/covid/80446565-E090-4187-A031-9D3CEAA586C8.jpeg \n"","" inflating: all/train/covid/85E52EB3-56E9-4D67-82DA-DEA247C82886.jpeg \n"","" inflating: all/train/covid/8FDE8DBA-CFBD-4B4C-B1A4-6F36A93B7E87.jpeg \n"","" inflating: all/train/covid/93FE0BB1-022D-4F24-9727-987A07975FFB.jpeg \n"","" inflating: all/train/covid/9C34AF49-E589-44D5-92D3-168B3B04E4A6.jpeg \n"","" inflating: all/train/covid/all14238-fig-0001-m-b.jpg \n"","" inflating: all/train/covid/all14238-fig-0001-m-c.jpg \n"","" inflating: all/train/covid/auntminnie-a-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: all/train/covid/auntminnie-b-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: all/train/covid/auntminnie-c-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: all/train/covid/auntminnie-d-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: all/train/covid/CD50BA96-6982-4C80-AE7B-5F67ACDBFA56.jpeg \n"","" inflating: all/train/covid/ciaa199.pdf-001-a.png \n"","" inflating: all/train/covid/ciaa199.pdf-001-b.png \n"","" inflating: all/train/covid/ciaa199.pdf-001-c.png \n"","" inflating: all/train/covid/covid-19-pneumonia-12.jpg \n"","" inflating: all/train/covid/covid-19-pneumonia-14-PA.png \n"","" inflating: all/train/covid/covid-19-pneumonia-15-PA.jpg \n"","" inflating: all/train/covid/covid-19-pneumonia-19.jpg \n"","" inflating: all/train/covid/covid-19-pneumonia-2.jpg \n"","" inflating: all/train/covid/covid-19-pneumonia-7-PA.jpg \n"","" inflating: all/train/covid/E63574A7-4188-4C8D-8D17-9D67A18A1AFA.jpeg \n"","" inflating: all/train/covid/F2DE909F-E19C-4900-92F5-8F435B031AC6.jpeg \n"","" inflating: all/train/covid/F4341CE7-73C9-45C6-99C8-8567A5484B63.jpeg \n"","" inflating: all/train/covid/F63AB6CE-1968-4154-A70F-913AF154F53D.jpeg \n"","" inflating: all/train/covid/FE9F9A5D-2830-46F9-851B-1FF4534959BE.jpeg \n"","" inflating: all/train/covid/gr1_lrg-a.jpg \n"","" inflating: all/train/covid/gr1_lrg-b.jpg \n"","" inflating: all/train/covid/kjr-21-e24-g001-l-a.jpg \n"","" inflating: all/train/covid/kjr-21-e24-g002-l-a.jpg \n"","" inflating: all/train/covid/kjr-21-e24-g003-l-a.jpg \n"","" inflating: all/train/covid/kjr-21-e25-g001-l-a.jpg \n"","" inflating: all/train/covid/lancet-case2a.jpg \n"","" inflating: all/train/covid/lancet-case2b.jpg \n"","" inflating: all/train/covid/nCoV-radiol.2020200269.fig1-day7.jpeg \n"","" inflating: all/train/covid/nejmc2001573_f1a.jpeg \n"","" inflating: all/train/covid/nejmc2001573_f1b.jpeg \n"","" inflating: all/train/covid/nejmoa2001191_f1-PA.jpeg \n"","" creating: all/train/normal/\n"","" inflating: all/train/normal/NORMAL2-IM-1281-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1282-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1285-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1286-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1287-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1288-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1289-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1290-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1291-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1292-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1293-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1294-0001-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1294-0001-0002.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1294-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1295-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1296-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1300-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1301-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1302-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1303-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1304-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1305-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1306-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1307-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1308-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1310-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1311-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1314-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1315-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1316-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1317-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1318-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1319-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1320-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1321-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1322-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1323-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1326-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1327-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1328-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1329-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1330-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1332-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1333-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1334-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1335-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1336-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1337-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1338-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1341-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1342-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1343-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1344-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1345-0001-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1345-0001-0002.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1345-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1346-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1347-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1348-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1349-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1350-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1351-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1356-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1357-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1360-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1362-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1365-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1371-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1376-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1379-0001.jpeg \n"","" creating: all/train/pneumonia_bac/\n"","" inflating: all/train/pneumonia_bac/person1843_bacteria_4710.jpeg \n"","" inflating: all/train/pneumonia_bac/person1847_bacteria_4716.jpeg \n"","" inflating: all/train/pneumonia_bac/person1848_bacteria_4719.jpeg \n"","" inflating: all/train/pneumonia_bac/person1850_bacteria_4721.jpeg \n"","" inflating: all/train/pneumonia_bac/person1851_bacteria_4722.jpeg \n"","" inflating: all/train/pneumonia_bac/person1852_bacteria_4724.jpeg \n"","" inflating: all/train/pneumonia_bac/person1855_bacteria_4727.jpeg \n"","" inflating: all/train/pneumonia_bac/person1857_bacteria_4729.jpeg \n"","" inflating: all/train/pneumonia_bac/person1858_bacteria_4730.jpeg \n"","" inflating: all/train/pneumonia_bac/person1859_bacteria_4731.jpeg \n"","" inflating: all/train/pneumonia_bac/person1860_bacteria_4732.jpeg \n"","" inflating: all/train/pneumonia_bac/person1863_bacteria_4735.jpeg \n"","" inflating: all/train/pneumonia_bac/person1864_bacteria_4736.jpeg \n"","" inflating: all/train/pneumonia_bac/person1865_bacteria_4737.jpeg \n"","" inflating: all/train/pneumonia_bac/person1865_bacteria_4739.jpeg \n"","" inflating: all/train/pneumonia_bac/person1866_bacteria_4740.jpeg \n"","" inflating: all/train/pneumonia_bac/person1867_bacteria_4741.jpeg \n"","" inflating: all/train/pneumonia_bac/person1868_bacteria_4743.jpeg \n"","" inflating: all/train/pneumonia_bac/person1869_bacteria_4745.jpeg \n"","" inflating: all/train/pneumonia_bac/person1872_bacteria_4750.jpeg \n"","" inflating: all/train/pneumonia_bac/person1872_bacteria_4751.jpeg \n"","" inflating: all/train/pneumonia_bac/person1875_bacteria_4756.jpeg \n"","" inflating: all/train/pneumonia_bac/person1876_bacteria_4760.jpeg \n"","" inflating: all/train/pneumonia_bac/person1877_bacteria_4761.jpeg \n"","" inflating: all/train/pneumonia_bac/person1879_bacteria_4764.jpeg \n"","" inflating: all/train/pneumonia_bac/person1880_bacteria_4765.jpeg \n"","" inflating: all/train/pneumonia_bac/person1881_bacteria_4767.jpeg \n"","" inflating: all/train/pneumonia_bac/person1883_bacteria_4769.jpeg \n"","" inflating: all/train/pneumonia_bac/person1884_bacteria_4771.jpeg \n"","" inflating: all/train/pneumonia_bac/person1885_bacteria_4772.jpeg \n"","" inflating: all/train/pneumonia_bac/person1886_bacteria_4773.jpeg \n"","" inflating: all/train/pneumonia_bac/person1888_bacteria_4775.jpeg \n"","" inflating: all/train/pneumonia_bac/person1893_bacteria_4781.jpeg \n"","" inflating: all/train/pneumonia_bac/person1896_bacteria_4788.jpeg \n"","" inflating: all/train/pneumonia_bac/person1897_bacteria_4789.jpeg \n"","" inflating: all/train/pneumonia_bac/person1901_bacteria_4795.jpeg \n"","" inflating: all/train/pneumonia_bac/person1903_bacteria_4797.jpeg \n"","" inflating: all/train/pneumonia_bac/person1904_bacteria_4798.jpeg \n"","" inflating: all/train/pneumonia_bac/person1905_bacteria_4801.jpeg \n"","" inflating: all/train/pneumonia_bac/person1906_bacteria_4803.jpeg \n"","" inflating: all/train/pneumonia_bac/person1907_bacteria_4806.jpeg \n"","" inflating: all/train/pneumonia_bac/person1908_bacteria_4811.jpeg \n"","" inflating: all/train/pneumonia_bac/person1910_bacteria_4814.jpeg \n"","" inflating: all/train/pneumonia_bac/person1911_bacteria_4815.jpeg \n"","" inflating: all/train/pneumonia_bac/person1912_bacteria_4816.jpeg \n"","" inflating: all/train/pneumonia_bac/person1912_bacteria_4817.jpeg \n"","" inflating: all/train/pneumonia_bac/person1916_bacteria_4821.jpeg \n"","" inflating: all/train/pneumonia_bac/person1917_bacteria_4823.jpeg \n"","" inflating: all/train/pneumonia_bac/person1918_bacteria_4825.jpeg \n"","" inflating: all/train/pneumonia_bac/person1921_bacteria_4828.jpeg \n"","" inflating: all/train/pneumonia_bac/person1922_bacteria_4830.jpeg \n"","" inflating: all/train/pneumonia_bac/person1923_bacteria_4831.jpeg \n"","" inflating: all/train/pneumonia_bac/person1924_bacteria_4832.jpeg \n"","" inflating: all/train/pneumonia_bac/person1924_bacteria_4833.jpeg \n"","" inflating: all/train/pneumonia_bac/person1926_bacteria_4835.jpeg \n"","" inflating: all/train/pneumonia_bac/person1927_bacteria_4836.jpeg \n"","" inflating: all/train/pneumonia_bac/person1927_bacteria_4837.jpeg \n"","" inflating: all/train/pneumonia_bac/person1929_bacteria_4839.jpeg \n"","" inflating: all/train/pneumonia_bac/person1930_bacteria_4841.jpeg \n"","" inflating: all/train/pneumonia_bac/person1931_bacteria_4842.jpeg \n"","" inflating: all/train/pneumonia_bac/person1932_bacteria_4843.jpeg \n"","" inflating: all/train/pneumonia_bac/person1933_bacteria_4844.jpeg \n"","" inflating: all/train/pneumonia_bac/person1934_bacteria_4846.jpeg \n"","" inflating: all/train/pneumonia_bac/person1935_bacteria_4847.jpeg \n"","" inflating: all/train/pneumonia_bac/person1935_bacteria_4848.jpeg \n"","" inflating: all/train/pneumonia_bac/person1935_bacteria_4849.jpeg \n"","" inflating: all/train/pneumonia_bac/person1935_bacteria_4850.jpeg \n"","" inflating: all/train/pneumonia_bac/person1936_bacteria_4852.jpeg \n"","" inflating: all/train/pneumonia_bac/person1937_bacteria_4853.jpeg \n"","" inflating: all/train/pneumonia_bac/person1938_bacteria_4854.jpeg \n"","" creating: all/train/pneumonia_vir/\n"","" inflating: all/train/pneumonia_vir/desktop.ini \n"","" inflating: all/train/pneumonia_vir/person88_virus_164.jpeg \n"","" inflating: all/train/pneumonia_vir/person88_virus_165.jpeg \n"","" inflating: all/train/pneumonia_vir/person88_virus_166.jpeg \n"","" inflating: all/train/pneumonia_vir/person88_virus_167.jpeg \n"","" inflating: all/train/pneumonia_vir/person890_virus_1540.jpeg \n"","" inflating: all/train/pneumonia_vir/person891_virus_1541.jpeg \n"","" inflating: all/train/pneumonia_vir/person894_virus_1546.jpeg \n"","" inflating: all/train/pneumonia_vir/person895_virus_1547.jpeg \n"","" inflating: all/train/pneumonia_vir/person896_virus_1548.jpeg \n"","" inflating: all/train/pneumonia_vir/person898_virus_1552.jpeg \n"","" inflating: all/train/pneumonia_vir/person899_virus_1553.jpeg \n"","" inflating: all/train/pneumonia_vir/person89_virus_168.jpeg \n"","" inflating: all/train/pneumonia_vir/person900_virus_1554.jpeg \n"","" inflating: all/train/pneumonia_vir/person901_virus_1555.jpeg \n"","" inflating: all/train/pneumonia_vir/person905_virus_1561.jpeg \n"","" inflating: all/train/pneumonia_vir/person906_virus_1562.jpeg \n"","" inflating: all/train/pneumonia_vir/person907_virus_1563.jpeg \n"","" inflating: all/train/pneumonia_vir/person908_virus_1564.jpeg \n"","" inflating: all/train/pneumonia_vir/person909_virus_1565.jpeg \n"","" inflating: all/train/pneumonia_vir/person90_virus_169.jpeg \n"","" inflating: all/train/pneumonia_vir/person90_virus_170.jpeg \n"","" inflating: all/train/pneumonia_vir/person911_virus_1567.jpeg \n"","" inflating: all/train/pneumonia_vir/person913_virus_1570.jpeg \n"","" inflating: all/train/pneumonia_vir/person914_virus_1571.jpeg \n"","" inflating: all/train/pneumonia_vir/person915_virus_1572.jpeg \n"","" inflating: all/train/pneumonia_vir/person918_virus_1575.jpeg \n"","" inflating: all/train/pneumonia_vir/person919_virus_1576.jpeg \n"","" inflating: all/train/pneumonia_vir/person920_virus_1577.jpeg \n"","" inflating: all/train/pneumonia_vir/person921_virus_1578.jpeg \n"","" inflating: all/train/pneumonia_vir/person924_virus_1581.jpeg \n"","" inflating: all/train/pneumonia_vir/person925_virus_1582.jpeg \n"","" inflating: all/train/pneumonia_vir/person926_virus_1583.jpeg \n"","" inflating: all/train/pneumonia_vir/person927_virus_1584.jpeg \n"","" inflating: all/train/pneumonia_vir/person928_virus_1586.jpeg \n"","" inflating: all/train/pneumonia_vir/person929_virus_1588.jpeg \n"","" inflating: all/train/pneumonia_vir/person929_virus_1589.jpeg \n"","" inflating: all/train/pneumonia_vir/person92_virus_174.jpeg \n"","" inflating: all/train/pneumonia_vir/person931_virus_1592.jpeg \n"","" inflating: all/train/pneumonia_vir/person932_virus_1593.jpeg \n"","" inflating: all/train/pneumonia_vir/person933_virus_1594.jpeg \n"","" inflating: all/train/pneumonia_vir/person934_virus_1595.jpeg \n"","" inflating: all/train/pneumonia_vir/person935_virus_1597.jpeg \n"","" inflating: all/train/pneumonia_vir/person936_virus_1598.jpeg \n"","" inflating: all/train/pneumonia_vir/person937_virus_1599.jpeg \n"","" inflating: all/train/pneumonia_vir/person938_virus_1600.jpeg \n"","" inflating: all/train/pneumonia_vir/person93_virus_175.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1602.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1604.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1605.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1607.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1609.jpeg \n"","" inflating: all/train/pneumonia_vir/person941_virus_1610.jpeg \n"","" inflating: all/train/pneumonia_vir/person942_virus_1611.jpeg \n"","" inflating: all/train/pneumonia_vir/person945_virus_1616.jpeg \n"","" inflating: all/train/pneumonia_vir/person947_virus_1618.jpeg \n"","" inflating: all/train/pneumonia_vir/person949_virus_1620.jpeg \n"","" inflating: all/train/pneumonia_vir/person94_virus_176.jpeg \n"","" inflating: all/train/pneumonia_vir/person950_virus_1621.jpeg \n"","" inflating: all/train/pneumonia_vir/person951_virus_1622.jpeg \n"","" inflating: all/train/pneumonia_vir/person952_virus_1623.jpeg \n"","" inflating: all/train/pneumonia_vir/person954_virus_1626.jpeg \n"","" inflating: all/train/pneumonia_vir/person955_virus_1627.jpeg \n"","" inflating: all/train/pneumonia_vir/person956_virus_1628.jpeg \n"","" inflating: all/train/pneumonia_vir/person95_virus_177.jpeg \n"","" inflating: all/train/pneumonia_vir/person96_virus_178.jpeg \n"","" inflating: all/train/pneumonia_vir/person96_virus_179.jpeg \n"","" inflating: all/train/pneumonia_vir/person97_virus_180.jpeg \n"","" inflating: all/train/pneumonia_vir/person97_virus_181.jpeg \n"","" inflating: all/train/pneumonia_vir/person98_virus_182.jpeg \n"","" inflating: all/train/pneumonia_vir/person99_virus_183.jpeg \n"","" creating: two/\n"","" creating: two/test/\n"","" creating: two/test/covid/\n"","" inflating: two/test/covid/nejmoa2001191_f3-PA.jpeg \n"","" inflating: two/test/covid/nejmoa2001191_f4.jpeg \n"","" inflating: two/test/covid/nejmoa2001191_f5-PA.jpeg \n"","" inflating: two/test/covid/radiol.2020200490.fig3.jpeg \n"","" inflating: two/test/covid/ryct.2020200028.fig1a.jpeg \n"","" inflating: two/test/covid/ryct.2020200034.fig2.jpeg \n"","" inflating: two/test/covid/ryct.2020200034.fig5-day0.jpeg \n"","" inflating: two/test/covid/ryct.2020200034.fig5-day4.jpeg \n"","" inflating: two/test/covid/ryct.2020200034.fig5-day7.jpeg \n"","" creating: two/test/normal/\n"","" inflating: two/test/normal/NORMAL2-IM-1385-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1396-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1400-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1401-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1406-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1412-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1419-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1422-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1423-0001.jpeg \n"","" creating: two/train/\n"","" creating: two/train/covid/\n"","" inflating: two/train/covid/01E392EE-69F9-4E33-BFCE-E5C968654078.jpeg \n"","" inflating: two/train/covid/1-s2.0-S0140673620303706-fx1_lrg.jpg \n"","" inflating: two/train/covid/1-s2.0-S0929664620300449-gr2_lrg-a.jpg \n"","" inflating: two/train/covid/1-s2.0-S0929664620300449-gr2_lrg-b.jpg \n"","" inflating: two/train/covid/1-s2.0-S0929664620300449-gr2_lrg-c.jpg \n"","" inflating: two/train/covid/1-s2.0-S0929664620300449-gr2_lrg-d.jpg \n"","" inflating: two/train/covid/1-s2.0-S1684118220300608-main.pdf-001.jpg \n"","" inflating: two/train/covid/1-s2.0-S1684118220300608-main.pdf-002.jpg \n"","" inflating: two/train/covid/1-s2.0-S1684118220300682-main.pdf-002-a1.png \n"","" inflating: two/train/covid/1-s2.0-S1684118220300682-main.pdf-002-a2.png \n"","" inflating: two/train/covid/1-s2.0-S1684118220300682-main.pdf-003-b1.png \n"","" inflating: two/train/covid/1-s2.0-S1684118220300682-main.pdf-003-b2.png \n"","" inflating: two/train/covid/1312A392-67A3-4EBF-9319-810CF6DA5EF6.jpeg \n"","" inflating: two/train/covid/1B734A89-A1BF-49A8-A1D3-66FAFA4FAC5D.jpeg \n"","" inflating: two/train/covid/23E99E2E-447C-46E5-8EB2-D35D12473C39.png \n"","" inflating: two/train/covid/2C26F453-AF3B-4517-BB9E-802CF2179543.jpeg \n"","" inflating: two/train/covid/31BA3780-2323-493F-8AED-62081B9C383B.jpeg \n"","" inflating: two/train/covid/41591_2020_819_Fig1_HTML.webp-day10.png \n"","" inflating: two/train/covid/41591_2020_819_Fig1_HTML.webp-day5.png \n"","" inflating: two/train/covid/6CB4EFC6-68FA-4CD5-940C-BEFA8DAFE9A7.jpeg \n"","" inflating: two/train/covid/7AF6C1AF-D249-4BD2-8C26-449304105D03.jpeg \n"","" inflating: two/train/covid/7C69C012-7479-493F-8722-ABC29C60A2DD.jpeg \n"","" inflating: two/train/covid/80446565-E090-4187-A031-9D3CEAA586C8.jpeg \n"","" inflating: two/train/covid/85E52EB3-56E9-4D67-82DA-DEA247C82886.jpeg \n"","" inflating: two/train/covid/8FDE8DBA-CFBD-4B4C-B1A4-6F36A93B7E87.jpeg \n"","" inflating: two/train/covid/93FE0BB1-022D-4F24-9727-987A07975FFB.jpeg \n"","" inflating: two/train/covid/9C34AF49-E589-44D5-92D3-168B3B04E4A6.jpeg \n"","" inflating: two/train/covid/all14238-fig-0001-m-b.jpg \n"","" inflating: two/train/covid/all14238-fig-0001-m-c.jpg \n"","" inflating: two/train/covid/auntminnie-a-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: two/train/covid/auntminnie-b-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: two/train/covid/auntminnie-c-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: two/train/covid/auntminnie-d-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: two/train/covid/CD50BA96-6982-4C80-AE7B-5F67ACDBFA56.jpeg \n"","" inflating: two/train/covid/ciaa199.pdf-001-a.png \n"","" inflating: two/train/covid/ciaa199.pdf-001-b.png \n"","" inflating: two/train/covid/ciaa199.pdf-001-c.png \n"","" inflating: two/train/covid/covid-19-pneumonia-12.jpg \n"","" inflating: two/train/covid/covid-19-pneumonia-14-PA.png \n"","" inflating: two/train/covid/covid-19-pneumonia-15-PA.jpg \n"","" inflating: two/train/covid/covid-19-pneumonia-19.jpg \n"","" inflating: two/train/covid/covid-19-pneumonia-2.jpg \n"","" inflating: two/train/covid/covid-19-pneumonia-7-PA.jpg \n"","" inflating: two/train/covid/E63574A7-4188-4C8D-8D17-9D67A18A1AFA.jpeg \n"","" inflating: two/train/covid/F2DE909F-E19C-4900-92F5-8F435B031AC6.jpeg \n"","" inflating: two/train/covid/F4341CE7-73C9-45C6-99C8-8567A5484B63.jpeg \n"","" inflating: two/train/covid/F63AB6CE-1968-4154-A70F-913AF154F53D.jpeg \n"","" inflating: two/train/covid/FE9F9A5D-2830-46F9-851B-1FF4534959BE.jpeg \n"","" inflating: two/train/covid/gr1_lrg-a.jpg \n"","" inflating: two/train/covid/gr1_lrg-b.jpg \n"","" inflating: two/train/covid/kjr-21-e24-g001-l-a.jpg \n"","" inflating: two/train/covid/kjr-21-e24-g002-l-a.jpg \n"","" inflating: two/train/covid/kjr-21-e24-g003-l-a.jpg \n"","" inflating: two/train/covid/kjr-21-e25-g001-l-a.jpg \n"","" inflating: two/train/covid/lancet-case2a.jpg \n"","" inflating: two/train/covid/lancet-case2b.jpg \n"","" inflating: two/train/covid/nCoV-radiol.2020200269.fig1-day7.jpeg \n"","" inflating: two/train/covid/nejmc2001573_f1a.jpeg \n"","" inflating: two/train/covid/nejmc2001573_f1b.jpeg \n"","" inflating: two/train/covid/nejmoa2001191_f1-PA.jpeg \n"","" creating: two/train/normal/\n"","" inflating: two/train/normal/NORMAL2-IM-1281-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1282-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1285-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1286-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1287-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1288-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1289-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1290-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1291-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1292-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1293-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1294-0001-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1294-0001-0002.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1294-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1295-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1296-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1300-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1301-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1302-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1303-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1304-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1305-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1306-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1307-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1308-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1310-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1311-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1314-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1315-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1316-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1317-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1318-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1319-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1320-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1321-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1322-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1323-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1326-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1327-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1328-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1329-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1330-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1332-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1333-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1334-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1335-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1336-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1337-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1338-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1341-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1342-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1343-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1344-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1345-0001-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1345-0001-0002.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1345-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1346-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1347-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1348-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1349-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1350-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1351-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1356-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1357-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1360-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1362-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1365-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1371-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1376-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1379-0001.jpeg \n""],""name"":""stdout""}]},{""cell_type"":""code"",""metadata"":{""id"":""cvTuKxbA_6Qx"",""colab_type"":""code"",""outputId"":""e99ceca9-f14c-4424-ca42-67900971be56"",""executionInfo"":{""status"":""ok"",""timestamp"":1584624725944,""user_tz"":-60,""elapsed"":17003,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":35}},""source"":[""print(os.listdir(\""/content/\""))\n"",""\n"",""#Print and remove zips once done\n"",""\n"",""!rm Covid_Data_GradientCrescent.zip\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""['.config', 'Covid_Data_GradientCrescent.zip', 'all', 'two', 'sample_data']\n""],""name"":""stdout""}]},{""cell_type"":""code"",""metadata"":{""id"":""923QFSnj-E_1"",""colab_type"":""code"",""outputId"":""c772bf26-9806-48ad-de01-7b6cd2e565fe"",""executionInfo"":{""status"":""ok"",""timestamp"":1584624725949,""user_tz"":-60,""elapsed"":16993,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":35}},""source"":[""from os import listdir\n"",""data_list = listdir('/content/two/train')\n"",""\n"",""#Delete some classes that may interfere\n"",""\n"",""\n"",""data_list""],""execution_count"":0,""outputs"":[{""output_type"":""execute_result"",""data"":{""text/plain"":[""['covid', 'normal']""]},""metadata"":{""tags"":[]},""execution_count"":3}]},{""cell_type"":""markdown"",""metadata"":{""id"":""SW7NXqkh-Gk8"",""colab_type"":""text""},""source"":[""Case 1: COVID vs Normal\n"",""VGG Initialization""]},{""cell_type"":""code"",""metadata"":{""id"":""0BfmpmKd-JOb"",""colab_type"":""code"",""outputId"":""0ed39715-2244-4318-f2dd-523a04b7eb3e"",""executionInfo"":{""status"":""ok"",""timestamp"":1584624726558,""user_tz"":-60,""elapsed"":17582,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":126}},""source"":[""from tensorflow.keras import backend as K\n"",""from tensorflow.keras.models import Model ,load_model\n"",""from tensorflow.keras.layers import Flatten, Dense, Dropout\n"",""from tensorflow.keras.applications.inception_resnet_v2 import InceptionResNetV2, preprocess_input\n"",""from keras.applications.vgg16 import preprocess_input\n"",""from keras.applications.vgg16 import decode_predictions\n"",""from keras.applications.vgg16 import VGG16\n"",""from tensorflow.keras.optimizers import Adam, RMSprop\n"",""from tensorflow.keras.preprocessing.image import ImageDataGenerator\n"",""from tensorflow.keras.callbacks import ModelCheckpoint\n"",""import numpy as np\n"",""import tensorflow as tf\n"",""\n"",""\n"",""DATASET_PATH = '/content/two/train'\n"",""test_dir = '/content/two/test'\n"",""IMAGE_SIZE = (150, 150)\n"",""NUM_CLASSES = len(data_list)\n"",""BATCH_SIZE = 10 # try reducing batch size or freeze more layers if your GPU runs out of memory\n"",""NUM_EPOCHS = 20\n"",""LEARNING_RATE =0.0005 #start off with high rate first 0.001 #5e-4\n"",""\n"",""\n"",""\n"",""\n"",""#Train datagen here is a preprocessor\n"",""train_datagen = ImageDataGenerator(rescale=1./255,\n"","" rotation_range=50,\n"","" featurewise_center = True,\n"","" featurewise_std_normalization = True,\n"","" width_shift_range=0.2,\n"","" height_shift_range=0.2,\n"","" shear_range=0.25,\n"","" zoom_range=0.1,\n"","" zca_whitening = True,\n"","" channel_shift_range = 20,\n"","" horizontal_flip = True ,\n"","" vertical_flip = True ,\n"","" validation_split = 0.2,\n"","" fill_mode='constant')\n"",""\n"",""# test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input,\n"",""# fill_mode='constant')\n"",""\n"",""train_batches = train_datagen.flow_from_directory(DATASET_PATH,\n"","" target_size=IMAGE_SIZE,\n"","" shuffle=True,\n"","" batch_size=BATCH_SIZE,\n"","" subset = \""training\"",\n"","" seed=42,\n"","" class_mode=\""binary\"",\n"","" \n"","" )\n"",""\n"",""valid_batches = train_datagen.flow_from_directory(DATASET_PATH,\n"","" target_size=IMAGE_SIZE,\n"","" shuffle=True,\n"","" batch_size=BATCH_SIZE,\n"","" subset = \""validation\"",\n"","" seed=42,\n"","" class_mode=\""binary\"",\n"","" \n"","" \n"","" )\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""Using TensorFlow backend.\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:341: UserWarning: This ImageDataGenerator specifies `zca_whitening` which overrides setting of`featurewise_std_normalization`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""},{""output_type"":""stream"",""text"":[""Found 104 images belonging to 2 classes.\n"",""Found 26 images belonging to 2 classes.\n""],""name"":""stdout""}]},{""cell_type"":""markdown"",""metadata"":{""id"":""Arc_63PU-O5K"",""colab_type"":""text""},""source"":[""Layer Modification at upper layer of VGG16""]},{""cell_type"":""code"",""metadata"":{""id"":""lyGm7tYQBBr1"",""colab_type"":""code"",""outputId"":""cd4d4ff4-5277-485b-8123-ec5173b71eeb"",""executionInfo"":{""status"":""ok"",""timestamp"":1584624734649,""user_tz"":-60,""elapsed"":25669,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":552}},""source"":[""#Simple CNN model based on VGG16\n"",""\n"",""\n"",""from keras import models\n"",""from keras import layers\n"",""from keras.applications import VGG16\n"",""from keras import optimizers\n"",""from keras.layers.core import Flatten, Dense, Dropout, Lambda\n"",""\n"",""conv_base = VGG16(weights='imagenet',\n"","" include_top=False,\n"","" input_shape=(150, 150, 3))\n"",""\n"",""conv_base.trainable = False\n"",""\n"",""\n"",""model = models.Sequential()\n"",""model.add(conv_base)\n"",""model.add(layers.Flatten())\n"",""model.add(layers.Dense(256, activation='relu'))\n"",""model.add(layers.Dense(1, activation='sigmoid'))\n"",""\n"",""\n"",""model.compile(loss='binary_crossentropy',\n"","" \n"","" optimizer=optimizers.Adam(lr=LEARNING_RATE),\n"","" metrics=['acc'])""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:66: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:541: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4432: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4267: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n"",""\n"",""Downloading data from https://github.com/fchollet/deep-learning-models/releases/download/v0.1/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5\n"",""58892288/58889256 [==============================] - 1s 0us/step\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:190: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:197: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:203: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:207: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:216: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:223: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3657: The name tf.log is deprecated. Please use tf.math.log instead.\n"",""\n"",""WARNING:tensorflow:From /tensorflow-1.15.0/python3.6/tensorflow_core/python/ops/nn_impl.py:183: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n"",""Instructions for updating:\n"",""Use tf.where in 2.0, which has the same broadcast rule as np.where\n""],""name"":""stdout""}]},{""cell_type"":""code"",""metadata"":{""id"":""GKDLJZjL-UlA"",""colab_type"":""code"",""outputId"":""968a2d21-f8af-4658-9427-74a41817c27e"",""executionInfo"":{""status"":""ok"",""timestamp"":1584624734651,""user_tz"":-60,""elapsed"":25660,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":319}},""source"":[""print(model.summary())""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""Model: \""sequential_1\""\n"",""_________________________________________________________________\n"",""Layer (type) Output Shape Param # \n"",""=================================================================\n"",""vgg16 (Model) (None, 4, 4, 512) 14714688 \n"",""_________________________________________________________________\n"",""flatten_1 (Flatten) (None, 8192) 0 \n"",""_________________________________________________________________\n"",""dense_1 (Dense) (None, 256) 2097408 \n"",""_________________________________________________________________\n"",""dense_2 (Dense) (None, 1) 257 \n"",""=================================================================\n"",""Total params: 16,812,353\n"",""Trainable params: 2,097,665\n"",""Non-trainable params: 14,714,688\n"",""_________________________________________________________________\n"",""None\n""],""name"":""stdout""}]},{""cell_type"":""markdown"",""metadata"":{""id"":""qh3QQZLz-yLW"",""colab_type"":""text""},""source"":[""Training""]},{""cell_type"":""code"",""metadata"":{""id"":""F7IwDhx5-iKe"",""colab_type"":""code"",""outputId"":""f15de9b4-30cb-4445-95f4-5572283e430f"",""executionInfo"":{""status"":""ok"",""timestamp"":1584624810351,""user_tz"":-60,""elapsed"":101348,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":926}},""source"":[""#FIT MODEL\n"",""print(len(train_batches))\n"",""print(len(valid_batches))\n"",""\n"",""STEP_SIZE_TRAIN=train_batches.n//train_batches.batch_size\n"",""STEP_SIZE_VALID=valid_batches.n//valid_batches.batch_size\n"",""\n"",""result=model.fit_generator(train_batches,\n"","" steps_per_epoch =STEP_SIZE_TRAIN,\n"","" validation_data = valid_batches,\n"","" validation_steps = STEP_SIZE_VALID,\n"","" epochs= NUM_EPOCHS,\n"",""# \n"","" )\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""11\n"",""3\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:1033: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n"",""\n"",""WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:1020: The name tf.assign is deprecated. Please use tf.compat.v1.assign instead.\n"",""\n"",""Epoch 1/20\n""],""name"":""stdout""},{""output_type"":""stream"",""text"":[""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:716: UserWarning: This ImageDataGenerator specifies `featurewise_center`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:735: UserWarning: This ImageDataGenerator specifies `zca_whitening`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""},{""output_type"":""stream"",""text"":[""10/10 [==============================] - 8s 829ms/step - loss: 0.5809 - acc: 0.6609 - val_loss: 0.3828 - val_acc: 0.8500\n"",""Epoch 2/20\n"",""10/10 [==============================] - 3s 328ms/step - loss: 0.4026 - acc: 0.8254 - val_loss: 0.4155 - val_acc: 0.7500\n"",""Epoch 3/20\n"",""10/10 [==============================] - 4s 369ms/step - loss: 0.3330 - acc: 0.8900 - val_loss: 0.1630 - val_acc: 0.9375\n"",""Epoch 4/20\n"",""10/10 [==============================] - 3s 320ms/step - loss: 0.1565 - acc: 0.9190 - val_loss: 0.3587 - val_acc: 0.9500\n"",""Epoch 5/20\n"",""10/10 [==============================] - 4s 375ms/step - loss: 0.2409 - acc: 0.8958 - val_loss: 0.1407 - val_acc: 0.9375\n"",""Epoch 6/20\n"",""10/10 [==============================] - 4s 357ms/step - loss: 0.1474 - acc: 0.9400 - val_loss: 0.1590 - val_acc: 0.9375\n"",""Epoch 7/20\n"",""10/10 [==============================] - 4s 405ms/step - loss: 0.1342 - acc: 0.9497 - val_loss: 0.1220 - val_acc: 0.9500\n"",""Epoch 8/20\n"",""10/10 [==============================] - 3s 324ms/step - loss: 0.2412 - acc: 0.9296 - val_loss: 0.1045 - val_acc: 1.0000\n"",""Epoch 9/20\n"",""10/10 [==============================] - 3s 323ms/step - loss: 0.2484 - acc: 0.8994 - val_loss: 0.5000 - val_acc: 0.8750\n"",""Epoch 10/20\n"",""10/10 [==============================] - 4s 370ms/step - loss: 0.2088 - acc: 0.9497 - val_loss: 0.1756 - val_acc: 0.9000\n"",""Epoch 11/20\n"",""10/10 [==============================] - 3s 329ms/step - loss: 0.0896 - acc: 0.9598 - val_loss: 0.1037 - val_acc: 1.0000\n"",""Epoch 12/20\n"",""10/10 [==============================] - 3s 338ms/step - loss: 0.0859 - acc: 0.9698 - val_loss: 0.1613 - val_acc: 0.9375\n"",""Epoch 13/20\n"",""10/10 [==============================] - 3s 349ms/step - loss: 0.0959 - acc: 0.9698 - val_loss: 0.0816 - val_acc: 0.9500\n"",""Epoch 14/20\n"",""10/10 [==============================] - 4s 359ms/step - loss: 0.1271 - acc: 0.9562 - val_loss: 0.6768 - val_acc: 0.8750\n"",""Epoch 15/20\n"",""10/10 [==============================] - 3s 337ms/step - loss: 0.1056 - acc: 0.9497 - val_loss: 0.0555 - val_acc: 1.0000\n"",""Epoch 16/20\n"",""10/10 [==============================] - 4s 357ms/step - loss: 0.1085 - acc: 0.9500 - val_loss: 0.4309 - val_acc: 0.8500\n"",""Epoch 17/20\n"",""10/10 [==============================] - 3s 337ms/step - loss: 0.1231 - acc: 0.9696 - val_loss: 0.0552 - val_acc: 1.0000\n"",""Epoch 18/20\n"",""10/10 [==============================] - 3s 329ms/step - loss: 0.0888 - acc: 0.9598 - val_loss: 0.3088 - val_acc: 0.9375\n"",""Epoch 19/20\n"",""10/10 [==============================] - 4s 377ms/step - loss: 0.0929 - acc: 0.9600 - val_loss: 0.1941 - val_acc: 0.9500\n"",""Epoch 20/20\n"",""10/10 [==============================] - 3s 343ms/step - loss: 0.0928 - acc: 0.9696 - val_loss: 0.4330 - val_acc: 0.8125\n""],""name"":""stdout""}]},{""cell_type"":""markdown"",""metadata"":{""id"":""dBYyDVtmzdB1"",""colab_type"":""text""},""source"":[""Evaluation""]},{""cell_type"":""code"",""metadata"":{""id"":""tNIFRzOvp1yA"",""colab_type"":""code"",""outputId"":""b9a2906a-1900-42b4-d481-56ed1a2c86ac"",""executionInfo"":{""status"":""ok"",""timestamp"":1584624810976,""user_tz"":-60,""elapsed"":101960,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":429}},""source"":[""import matplotlib.pyplot as plt\n"",""\n"",""\n"",""def plot_acc_loss(result, epochs):\n"","" acc = result.history['acc']\n"","" loss = result.history['loss']\n"","" val_acc = result.history['val_acc']\n"","" val_loss = result.history['val_loss']\n"","" plt.figure(figsize=(15, 5))\n"","" plt.subplot(121)\n"","" plt.plot(range(1,epochs), acc[1:], label='Train_acc')\n"","" plt.plot(range(1,epochs), val_acc[1:], label='Test_acc')\n"","" plt.title('Accuracy over ' + str(epochs) + ' Epochs', size=15)\n"","" plt.legend()\n"","" plt.grid(True)\n"","" plt.subplot(122)\n"","" plt.plot(range(1,epochs), loss[1:], label='Train_loss')\n"","" plt.plot(range(1,epochs), val_loss[1:], label='Test_loss')\n"","" plt.title('Loss over ' + str(epochs) + ' Epochs', size=15)\n"","" plt.legend()\n"","" plt.grid(True)\n"","" plt.show()\n"","" \n"",""plot_acc_loss(result, 20)""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:716: UserWarning: This ImageDataGenerator specifies `featurewise_center`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:735: UserWarning: This ImageDataGenerator specifies `zca_whitening`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAA3AAAAFBCAYAAAA2U032AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}}]},{""cell_type"":""code"",""metadata"":{""id"":""g1W_MvpGJ39q"",""colab_type"":""code"",""outputId"":""ea6a0c37-4cfb-4101-b5a2-711ad51d9f7b"",""executionInfo"":{""status"":""ok"",""timestamp"":1584624810980,""user_tz"":-60,""elapsed"":101950,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":108}},""source"":[""model.save('Covid_Binary.h5')""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:716: UserWarning: This ImageDataGenerator specifies `featurewise_center`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:735: UserWarning: This ImageDataGenerator specifies `zca_whitening`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""}]},{""cell_type"":""code"",""metadata"":{""id"":""B1Qqa6YG-6kB"",""colab_type"":""code"",""outputId"":""34051ac4-d8d5-4564-fd90-11f1378c00cd"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625152692,""user_tz"":-60,""elapsed"":784,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":35}},""source"":[""\n"",""#Dont forget shuffle false. Note that Shuffle False is necessary for predict generator due to Keras's internal shuffling.\n"",""#But for true accuracy values in evaluate_generator we should use shuffle_true.\n"",""#In this case, the accuracy values are the same, but the same IS NOT true for the multiclass case.\n"",""#See https://github.com/keras-team/keras/issues/6499\n"",""test_datagen = ImageDataGenerator(rescale=1. / 255)\n"",""\n"",""eval_generator = test_datagen.flow_from_directory(\n"","" test_dir,target_size=IMAGE_SIZE,\n"","" batch_size=1,\n"","" shuffle=False,\n"","" seed=42,\n"","" \n"","" \n"","" class_mode=\""binary\"")\n"",""eval_generator.reset() \n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""Found 18 images belonging to 2 classes.\n""],""name"":""stdout""}]},{""cell_type"":""code"",""metadata"":{""id"":""OruQrAjTAbly"",""colab_type"":""code"",""outputId"":""bb96bae3-1b76-45ac-df0b-48c35586842b"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625152944,""user_tz"":-60,""elapsed"":1017,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":70}},""source"":[""\n"",""eval_generator.reset() \n"",""x = model.evaluate_generator(eval_generator,\n"","" steps = np.ceil(len(eval_generator) / BATCH_SIZE),\n"","" use_multiprocessing = False,\n"","" verbose = 1,\n"","" workers=1\n"","" )\n"",""\n"",""\n"",""print('Test loss:' , x[0])\n"",""print('Test accuracy:',x[1])\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""2/2 [==============================] - 0s 55ms/step\n"",""Test loss: 0.06665200088173151\n"",""Test accuracy: 1.0\n""],""name"":""stdout""}]},{""cell_type"":""markdown"",""metadata"":{""id"":""JL6Qxxl9-8If"",""colab_type"":""text""},""source"":[""Predict""]},{""cell_type"":""code"",""metadata"":{""id"":""-pXEPz0hLnwk"",""colab_type"":""code"",""outputId"":""6a767be8-f748-4737-f9f5-399802aab31e"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625186907,""user_tz"":-60,""elapsed"":34949,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":52}},""source"":[""eval_generator.reset() \n"",""pred = model.predict_generator(eval_generator,1000,verbose=1)\n"",""print(\""Predictions finished\"")\n"",""\n"",""\n"",""\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""1000/1000 [==============================] - 33s 33ms/step\n"",""Predictions finished\n""],""name"":""stdout""}]},{""cell_type"":""code"",""metadata"":{""id"":""gFov8_iNkn1e"",""colab_type"":""code"",""outputId"":""b427d183-cde8-41bc-b616-55fbf37bb47f"",""executionInfo"":{""status"":""error"",""timestamp"":1584625194543,""user_tz"":-60,""elapsed"":42537,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":1000}},""source"":[""import cv2\n"",""\n"",""\n"",""import matplotlib.image as mpimg\n"",""for index, probability in enumerate(pred):\n"","" image_path = test_dir + \""/\"" +eval_generator.filenames[index]\n"","" image = mpimg.imread(image_path)\n"","" #BGR TO RGB conversion using CV2\n"","" image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n"",""\n"","" pixels = np.array(image)\n"","" plt.imshow(pixels)\n"","" \n"","" print(eval_generator.filenames[index])\n"","" if probability > 0.5:\n"","" plt.title(\""%.2f\"" % (probability[0]*100) + \""% Normal\"")\n"","" else:\n"","" plt.title(\""%.2f\"" % ((1-probability[0])*100) + \""% COVID19 Pneumonia\"")\n"","" plt.show()""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""covid/nejmoa2001191_f3-PA.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAToAAAEICAYAAADP8Dj6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nsAAAAABJRU5ErkJggg==\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""covid/nejmoa2001191_f4.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAT4AAAEICAYAAADGG5iAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""covid/nejmoa2001191_f5-PA.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAUYAAAEICAYAAAAjhV3sAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""covid/radiol.2020200490.fig3.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAQEAAAEICAYAAABf40E1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n7/T+Ppt2Vs8AAAAASUVORK5CYII=\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""covid/ryct.2020200028.fig1a.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAOAAAAEICAYAAABGTfi6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n9hzb/wdDUq0v22yGiAAAAABJRU5ErkJggg==\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""covid/ryct.2020200034.fig2.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAARkAAAEICAYAAABrmoApAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nWt7T8hRknpan5Wl5T8v/Dw5J5Apb3gAHAAAAAElFTkSuQmCC\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""covid/ryct.2020200034.fig5-day0.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAOUAAAEICAYAAACgZDP+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nqUHKf1w8F5YAAAAASUVORK5CYII=\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""covid/ryct.2020200034.fig5-day4.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAO4AAAEICAYAAABYhMgJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\npFPFPaVTegzpVHFP6ZQeQ/r/TcGOTVgxKLAAAAAASUVORK5CYII=\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""covid/ryct.2020200034.fig5-day7.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAPAAAAEICAYAAABh43lSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nFgF5gtwawjcAAAAASUVORK5CYII=\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""normal/NORMAL2-IM-1385-0001.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAATEAAAEICAYAAAA3EMMNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""normal/NORMAL2-IM-1396-0001.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAATgAAAEICAYAAADLBejHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""normal/NORMAL2-IM-1400-0001.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAWcAAAEICAYAAACDGjUCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""normal/NORMAL2-IM-1401-0001.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAATYAAAEICAYAAADVzNh0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrgAAAABJRU5ErkJggg==\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""normal/NORMAL2-IM-1406-0001.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAWcAAAEICAYAAACDGjUCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ncL5O1+k6XacrmK7B+Tpdp+t0na5g+v8B7MEcvxyf8E8AAAAASUVORK5CYII=\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""normal/NORMAL2-IM-1412-0001.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAW0AAAEICAYAAACUOKXLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""normal/NORMAL2-IM-1419-0001.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAATEAAAEICAYAAAA3EMMNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nuU6XIHaZLtNleq7TJYhdpst0mZ7r9P8BrUpQLOhhy9AAAAAASUVORK5CYII=\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""normal/NORMAL2-IM-1422-0001.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAAXYAAAEICAYAAABLdt/UAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""normal/NORMAL2-IM-1423-0001.jpeg\n""],""name"":""stdout""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAASgAAAEICAYAAADsq2kvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ndJHObboAqIt0kS7SuU3/P/6gz9otOU92AAAAAElFTkSuQmCC\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}},{""output_type"":""error"",""ename"":""IndexError"",""evalue"":""ignored"",""traceback"":[""\u001b[0;31m---------------------------------------------------------------------------\u001b[0m"",""\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)"",""\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimage\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mmpimg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprobability\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mimage_path\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtest_dir\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\""/\""\u001b[0m \u001b[0;34m+\u001b[0m\u001b[0meval_generator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfilenames\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmpimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimage_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;31m#BGR TO RGB conversion using CV2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n"",""\u001b[0;31mIndexError\u001b[0m: list index out of range""]}]}]}","Unknown" +"Viral","EXJUSTICE/COVID19_Detection_Transfer_Learning_VGG16","Covid19_GradientCrescent_Multi.ipynb",".ipynb","182817","1","{""nbformat"":4,""nbformat_minor"":0,""metadata"":{""colab"":{""name"":""Covid19_GradientCrescent_Multi.ipynb"",""provenance"":[],""collapsed_sections"":[]},""kernelspec"":{""name"":""python3"",""display_name"":""Python 3""},""accelerator"":""GPU""},""cells"":[{""cell_type"":""markdown"",""metadata"":{""id"":""gyG4OC_n_Bgb"",""colab_type"":""text""},""source"":[""## COVID19 CT Pneumonia Detection - Multiclass Case\n"",""By Adrian Yijie Xu\n"",""(https://medium.com/@adrianitsaxu)\n"",""\n"",""As discussed in \""Detecting COVID-19 induced Pneumonia from Chest X-rays with Transfer Learning: An implementation in Tensorflow and Keras.\""\n"",""(https://github.com/EXJUSTICE/GradientCrescent)\n"",""\n"",""50% test accuracy with 4 classes\n"",""100% test accuracy with 3 classes\n"",""\n"",""Conclusion: Viral Pneumonia indistinguishable from COVID19: acceptable, given that COVID19 is itself caused by viral means.\n"",""\n""]},{""cell_type"":""code"",""metadata"":{""id"":""JHtRS9Wf9mZc"",""colab_type"":""code"",""outputId"":""e21794bf-fa33-4fb2-ff46-e9dc1491e87f"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625353133,""user_tz"":-60,""elapsed"":13306,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":1000}},""source"":[""# This Python 3 environment comes with many helpful analytics libraries installed\n"",""# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n"",""# For example, here's several helpful packages to load in \n"",""#set randomness for reproducibility\n"",""from numpy.random import seed\n"",""seed(8) #1\n"",""from tensorflow import set_random_seed\n"",""set_random_seed(7) #2\n"",""\n"",""#\n"",""\n"",""import numpy as np # linear algebra\n"",""import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n"",""\n"",""# Input data files are available in the \""../input/\"" directory.\n"",""# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n"",""\n"",""import os\n"",""\n"",""\n"",""\n"",""!gdown https://drive.google.com/uc?id=1coM7x3378f-Ou2l6Pg2wldaOI7Dntu1a\n"",""!unzip Covid_Data_GradientCrescent.zip\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""display_data"",""data"":{""text/html"":[""

\n"",""The default version of TensorFlow in Colab will soon switch to TensorFlow 2.x.
\n"",""We recommend you upgrade now \n"",""or ensure your notebook will continue to use TensorFlow 1.x via the %tensorflow_version 1.x magic:\n"",""more info.

\n""],""text/plain"":[""""]},""metadata"":{""tags"":[]}},{""output_type"":""stream"",""text"":[""Downloading...\n"",""From: https://drive.google.com/uc?id=1coM7x3378f-Ou2l6Pg2wldaOI7Dntu1a\n"",""To: /content/Covid_Data_GradientCrescent.zip\n"",""154MB [00:00, 169MB/s]\n"",""Archive: Covid_Data_GradientCrescent.zip\n"","" creating: all/\n"","" creating: all/test/\n"","" creating: all/test/covid/\n"","" inflating: all/test/covid/nejmoa2001191_f3-PA.jpeg \n"","" inflating: all/test/covid/nejmoa2001191_f4.jpeg \n"","" inflating: all/test/covid/nejmoa2001191_f5-PA.jpeg \n"","" inflating: all/test/covid/radiol.2020200490.fig3.jpeg \n"","" inflating: all/test/covid/ryct.2020200028.fig1a.jpeg \n"","" inflating: all/test/covid/ryct.2020200034.fig2.jpeg \n"","" inflating: all/test/covid/ryct.2020200034.fig5-day0.jpeg \n"","" inflating: all/test/covid/ryct.2020200034.fig5-day4.jpeg \n"","" inflating: all/test/covid/ryct.2020200034.fig5-day7.jpeg \n"","" creating: all/test/normal/\n"","" inflating: all/test/normal/NORMAL2-IM-1385-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1396-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1400-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1401-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1406-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1412-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1419-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1422-0001.jpeg \n"","" inflating: all/test/normal/NORMAL2-IM-1423-0001.jpeg \n"","" creating: all/test/pneumonia_bac/\n"","" inflating: all/test/pneumonia_bac/person1753_bacteria_4594.jpeg \n"","" inflating: all/test/pneumonia_bac/person1940_bacteria_4859.jpeg \n"","" inflating: all/test/pneumonia_bac/person1940_bacteria_4861.jpeg \n"","" inflating: all/test/pneumonia_bac/person1940_bacteria_4862.jpeg \n"","" inflating: all/test/pneumonia_bac/person1941_bacteria_4863.jpeg \n"","" inflating: all/test/pneumonia_bac/person1942_bacteria_4865.jpeg \n"","" inflating: all/test/pneumonia_bac/person1943_bacteria_4868.jpeg \n"","" inflating: all/test/pneumonia_bac/person1944_bacteria_4869.jpeg \n"","" inflating: all/test/pneumonia_bac/person1945_bacteria_4872.jpeg \n"","" creating: all/test/pneumonia_vir/\n"","" inflating: all/test/pneumonia_vir/desktop.ini \n"","" inflating: all/test/pneumonia_vir/person957_virus_1629.jpeg \n"","" inflating: all/test/pneumonia_vir/person958_virus_1630.jpeg \n"","" inflating: all/test/pneumonia_vir/person960_virus_1633.jpeg \n"","" inflating: all/test/pneumonia_vir/person961_virus_1634.jpeg \n"","" inflating: all/test/pneumonia_vir/person962_virus_1635.jpeg \n"","" inflating: all/test/pneumonia_vir/person963_virus_1636.jpeg \n"","" inflating: all/test/pneumonia_vir/person964_virus_1637.jpeg \n"","" inflating: all/test/pneumonia_vir/person965_virus_1638.jpeg \n"","" inflating: all/test/pneumonia_vir/person966_virus_1639.jpeg \n"","" creating: all/train/\n"","" creating: all/train/covid/\n"","" inflating: all/train/covid/01E392EE-69F9-4E33-BFCE-E5C968654078.jpeg \n"","" inflating: all/train/covid/1-s2.0-S0140673620303706-fx1_lrg.jpg \n"","" inflating: all/train/covid/1-s2.0-S0929664620300449-gr2_lrg-a.jpg \n"","" inflating: all/train/covid/1-s2.0-S0929664620300449-gr2_lrg-b.jpg \n"","" inflating: all/train/covid/1-s2.0-S0929664620300449-gr2_lrg-c.jpg \n"","" inflating: all/train/covid/1-s2.0-S0929664620300449-gr2_lrg-d.jpg \n"","" inflating: all/train/covid/1-s2.0-S1684118220300608-main.pdf-001.jpg \n"","" inflating: all/train/covid/1-s2.0-S1684118220300608-main.pdf-002.jpg \n"","" inflating: all/train/covid/1-s2.0-S1684118220300682-main.pdf-002-a1.png \n"","" inflating: all/train/covid/1-s2.0-S1684118220300682-main.pdf-002-a2.png \n"","" inflating: all/train/covid/1-s2.0-S1684118220300682-main.pdf-003-b1.png \n"","" inflating: all/train/covid/1-s2.0-S1684118220300682-main.pdf-003-b2.png \n"","" inflating: all/train/covid/1312A392-67A3-4EBF-9319-810CF6DA5EF6.jpeg \n"","" inflating: all/train/covid/1B734A89-A1BF-49A8-A1D3-66FAFA4FAC5D.jpeg \n"","" inflating: all/train/covid/23E99E2E-447C-46E5-8EB2-D35D12473C39.png \n"","" inflating: all/train/covid/2C26F453-AF3B-4517-BB9E-802CF2179543.jpeg \n"","" inflating: all/train/covid/31BA3780-2323-493F-8AED-62081B9C383B.jpeg \n"","" inflating: all/train/covid/41591_2020_819_Fig1_HTML.webp-day10.png \n"","" inflating: all/train/covid/41591_2020_819_Fig1_HTML.webp-day5.png \n"","" inflating: all/train/covid/6CB4EFC6-68FA-4CD5-940C-BEFA8DAFE9A7.jpeg \n"","" inflating: all/train/covid/7AF6C1AF-D249-4BD2-8C26-449304105D03.jpeg \n"","" inflating: all/train/covid/7C69C012-7479-493F-8722-ABC29C60A2DD.jpeg \n"","" inflating: all/train/covid/80446565-E090-4187-A031-9D3CEAA586C8.jpeg \n"","" inflating: all/train/covid/85E52EB3-56E9-4D67-82DA-DEA247C82886.jpeg \n"","" inflating: all/train/covid/8FDE8DBA-CFBD-4B4C-B1A4-6F36A93B7E87.jpeg \n"","" inflating: all/train/covid/93FE0BB1-022D-4F24-9727-987A07975FFB.jpeg \n"","" inflating: all/train/covid/9C34AF49-E589-44D5-92D3-168B3B04E4A6.jpeg \n"","" inflating: all/train/covid/all14238-fig-0001-m-b.jpg \n"","" inflating: all/train/covid/all14238-fig-0001-m-c.jpg \n"","" inflating: all/train/covid/auntminnie-a-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: all/train/covid/auntminnie-b-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: all/train/covid/auntminnie-c-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: all/train/covid/auntminnie-d-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: all/train/covid/CD50BA96-6982-4C80-AE7B-5F67ACDBFA56.jpeg \n"","" inflating: all/train/covid/ciaa199.pdf-001-a.png \n"","" inflating: all/train/covid/ciaa199.pdf-001-b.png \n"","" inflating: all/train/covid/ciaa199.pdf-001-c.png \n"","" inflating: all/train/covid/covid-19-pneumonia-12.jpg \n"","" inflating: all/train/covid/covid-19-pneumonia-14-PA.png \n"","" inflating: all/train/covid/covid-19-pneumonia-15-PA.jpg \n"","" inflating: all/train/covid/covid-19-pneumonia-19.jpg \n"","" inflating: all/train/covid/covid-19-pneumonia-2.jpg \n"","" inflating: all/train/covid/covid-19-pneumonia-7-PA.jpg \n"","" inflating: all/train/covid/E63574A7-4188-4C8D-8D17-9D67A18A1AFA.jpeg \n"","" inflating: all/train/covid/F2DE909F-E19C-4900-92F5-8F435B031AC6.jpeg \n"","" inflating: all/train/covid/F4341CE7-73C9-45C6-99C8-8567A5484B63.jpeg \n"","" inflating: all/train/covid/F63AB6CE-1968-4154-A70F-913AF154F53D.jpeg \n"","" inflating: all/train/covid/FE9F9A5D-2830-46F9-851B-1FF4534959BE.jpeg \n"","" inflating: all/train/covid/gr1_lrg-a.jpg \n"","" inflating: all/train/covid/gr1_lrg-b.jpg \n"","" inflating: all/train/covid/kjr-21-e24-g001-l-a.jpg \n"","" inflating: all/train/covid/kjr-21-e24-g002-l-a.jpg \n"","" inflating: all/train/covid/kjr-21-e24-g003-l-a.jpg \n"","" inflating: all/train/covid/kjr-21-e25-g001-l-a.jpg \n"","" inflating: all/train/covid/lancet-case2a.jpg \n"","" inflating: all/train/covid/lancet-case2b.jpg \n"","" inflating: all/train/covid/nCoV-radiol.2020200269.fig1-day7.jpeg \n"","" inflating: all/train/covid/nejmc2001573_f1a.jpeg \n"","" inflating: all/train/covid/nejmc2001573_f1b.jpeg \n"","" inflating: all/train/covid/nejmoa2001191_f1-PA.jpeg \n"","" creating: all/train/normal/\n"","" inflating: all/train/normal/NORMAL2-IM-1281-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1282-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1285-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1286-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1287-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1288-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1289-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1290-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1291-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1292-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1293-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1294-0001-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1294-0001-0002.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1294-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1295-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1296-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1300-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1301-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1302-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1303-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1304-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1305-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1306-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1307-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1308-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1310-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1311-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1314-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1315-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1316-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1317-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1318-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1319-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1320-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1321-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1322-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1323-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1326-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1327-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1328-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1329-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1330-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1332-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1333-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1334-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1335-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1336-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1337-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1338-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1341-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1342-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1343-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1344-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1345-0001-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1345-0001-0002.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1345-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1346-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1347-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1348-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1349-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1350-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1351-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1356-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1357-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1360-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1362-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1365-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1371-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1376-0001.jpeg \n"","" inflating: all/train/normal/NORMAL2-IM-1379-0001.jpeg \n"","" creating: all/train/pneumonia_bac/\n"","" inflating: all/train/pneumonia_bac/person1843_bacteria_4710.jpeg \n"","" inflating: all/train/pneumonia_bac/person1847_bacteria_4716.jpeg \n"","" inflating: all/train/pneumonia_bac/person1848_bacteria_4719.jpeg \n"","" inflating: all/train/pneumonia_bac/person1850_bacteria_4721.jpeg \n"","" inflating: all/train/pneumonia_bac/person1851_bacteria_4722.jpeg \n"","" inflating: all/train/pneumonia_bac/person1852_bacteria_4724.jpeg \n"","" inflating: all/train/pneumonia_bac/person1855_bacteria_4727.jpeg \n"","" inflating: all/train/pneumonia_bac/person1857_bacteria_4729.jpeg \n"","" inflating: all/train/pneumonia_bac/person1858_bacteria_4730.jpeg \n"","" inflating: all/train/pneumonia_bac/person1859_bacteria_4731.jpeg \n"","" inflating: all/train/pneumonia_bac/person1860_bacteria_4732.jpeg \n"","" inflating: all/train/pneumonia_bac/person1863_bacteria_4735.jpeg \n"","" inflating: all/train/pneumonia_bac/person1864_bacteria_4736.jpeg \n"","" inflating: all/train/pneumonia_bac/person1865_bacteria_4737.jpeg \n"","" inflating: all/train/pneumonia_bac/person1865_bacteria_4739.jpeg \n"","" inflating: all/train/pneumonia_bac/person1866_bacteria_4740.jpeg \n"","" inflating: all/train/pneumonia_bac/person1867_bacteria_4741.jpeg \n"","" inflating: all/train/pneumonia_bac/person1868_bacteria_4743.jpeg \n"","" inflating: all/train/pneumonia_bac/person1869_bacteria_4745.jpeg \n"","" inflating: all/train/pneumonia_bac/person1872_bacteria_4750.jpeg \n"","" inflating: all/train/pneumonia_bac/person1872_bacteria_4751.jpeg \n"","" inflating: all/train/pneumonia_bac/person1875_bacteria_4756.jpeg \n"","" inflating: all/train/pneumonia_bac/person1876_bacteria_4760.jpeg \n"","" inflating: all/train/pneumonia_bac/person1877_bacteria_4761.jpeg \n"","" inflating: all/train/pneumonia_bac/person1879_bacteria_4764.jpeg \n"","" inflating: all/train/pneumonia_bac/person1880_bacteria_4765.jpeg \n"","" inflating: all/train/pneumonia_bac/person1881_bacteria_4767.jpeg \n"","" inflating: all/train/pneumonia_bac/person1883_bacteria_4769.jpeg \n"","" inflating: all/train/pneumonia_bac/person1884_bacteria_4771.jpeg \n"","" inflating: all/train/pneumonia_bac/person1885_bacteria_4772.jpeg \n"","" inflating: all/train/pneumonia_bac/person1886_bacteria_4773.jpeg \n"","" inflating: all/train/pneumonia_bac/person1888_bacteria_4775.jpeg \n"","" inflating: all/train/pneumonia_bac/person1893_bacteria_4781.jpeg \n"","" inflating: all/train/pneumonia_bac/person1896_bacteria_4788.jpeg \n"","" inflating: all/train/pneumonia_bac/person1897_bacteria_4789.jpeg \n"","" inflating: all/train/pneumonia_bac/person1901_bacteria_4795.jpeg \n"","" inflating: all/train/pneumonia_bac/person1903_bacteria_4797.jpeg \n"","" inflating: all/train/pneumonia_bac/person1904_bacteria_4798.jpeg \n"","" inflating: all/train/pneumonia_bac/person1905_bacteria_4801.jpeg \n"","" inflating: all/train/pneumonia_bac/person1906_bacteria_4803.jpeg \n"","" inflating: all/train/pneumonia_bac/person1907_bacteria_4806.jpeg \n"","" inflating: all/train/pneumonia_bac/person1908_bacteria_4811.jpeg \n"","" inflating: all/train/pneumonia_bac/person1910_bacteria_4814.jpeg \n"","" inflating: all/train/pneumonia_bac/person1911_bacteria_4815.jpeg \n"","" inflating: all/train/pneumonia_bac/person1912_bacteria_4816.jpeg \n"","" inflating: all/train/pneumonia_bac/person1912_bacteria_4817.jpeg \n"","" inflating: all/train/pneumonia_bac/person1916_bacteria_4821.jpeg \n"","" inflating: all/train/pneumonia_bac/person1917_bacteria_4823.jpeg \n"","" inflating: all/train/pneumonia_bac/person1918_bacteria_4825.jpeg \n"","" inflating: all/train/pneumonia_bac/person1921_bacteria_4828.jpeg \n"","" inflating: all/train/pneumonia_bac/person1922_bacteria_4830.jpeg \n"","" inflating: all/train/pneumonia_bac/person1923_bacteria_4831.jpeg \n"","" inflating: all/train/pneumonia_bac/person1924_bacteria_4832.jpeg \n"","" inflating: all/train/pneumonia_bac/person1924_bacteria_4833.jpeg \n"","" inflating: all/train/pneumonia_bac/person1926_bacteria_4835.jpeg \n"","" inflating: all/train/pneumonia_bac/person1927_bacteria_4836.jpeg \n"","" inflating: all/train/pneumonia_bac/person1927_bacteria_4837.jpeg \n"","" inflating: all/train/pneumonia_bac/person1929_bacteria_4839.jpeg \n"","" inflating: all/train/pneumonia_bac/person1930_bacteria_4841.jpeg \n"","" inflating: all/train/pneumonia_bac/person1931_bacteria_4842.jpeg \n"","" inflating: all/train/pneumonia_bac/person1932_bacteria_4843.jpeg \n"","" inflating: all/train/pneumonia_bac/person1933_bacteria_4844.jpeg \n"","" inflating: all/train/pneumonia_bac/person1934_bacteria_4846.jpeg \n"","" inflating: all/train/pneumonia_bac/person1935_bacteria_4847.jpeg \n"","" inflating: all/train/pneumonia_bac/person1935_bacteria_4848.jpeg \n"","" inflating: all/train/pneumonia_bac/person1935_bacteria_4849.jpeg \n"","" inflating: all/train/pneumonia_bac/person1935_bacteria_4850.jpeg \n"","" inflating: all/train/pneumonia_bac/person1936_bacteria_4852.jpeg \n"","" inflating: all/train/pneumonia_bac/person1937_bacteria_4853.jpeg \n"","" inflating: all/train/pneumonia_bac/person1938_bacteria_4854.jpeg \n"","" creating: all/train/pneumonia_vir/\n"","" inflating: all/train/pneumonia_vir/desktop.ini \n"","" inflating: all/train/pneumonia_vir/person88_virus_164.jpeg \n"","" inflating: all/train/pneumonia_vir/person88_virus_165.jpeg \n"","" inflating: all/train/pneumonia_vir/person88_virus_166.jpeg \n"","" inflating: all/train/pneumonia_vir/person88_virus_167.jpeg \n"","" inflating: all/train/pneumonia_vir/person890_virus_1540.jpeg \n"","" inflating: all/train/pneumonia_vir/person891_virus_1541.jpeg \n"","" inflating: all/train/pneumonia_vir/person894_virus_1546.jpeg \n"","" inflating: all/train/pneumonia_vir/person895_virus_1547.jpeg \n"","" inflating: all/train/pneumonia_vir/person896_virus_1548.jpeg \n"","" inflating: all/train/pneumonia_vir/person898_virus_1552.jpeg \n"","" inflating: all/train/pneumonia_vir/person899_virus_1553.jpeg \n"","" inflating: all/train/pneumonia_vir/person89_virus_168.jpeg \n"","" inflating: all/train/pneumonia_vir/person900_virus_1554.jpeg \n"","" inflating: all/train/pneumonia_vir/person901_virus_1555.jpeg \n"","" inflating: all/train/pneumonia_vir/person905_virus_1561.jpeg \n"","" inflating: all/train/pneumonia_vir/person906_virus_1562.jpeg \n"","" inflating: all/train/pneumonia_vir/person907_virus_1563.jpeg \n"","" inflating: all/train/pneumonia_vir/person908_virus_1564.jpeg \n"","" inflating: all/train/pneumonia_vir/person909_virus_1565.jpeg \n"","" inflating: all/train/pneumonia_vir/person90_virus_169.jpeg \n"","" inflating: all/train/pneumonia_vir/person90_virus_170.jpeg \n"","" inflating: all/train/pneumonia_vir/person911_virus_1567.jpeg \n"","" inflating: all/train/pneumonia_vir/person913_virus_1570.jpeg \n"","" inflating: all/train/pneumonia_vir/person914_virus_1571.jpeg \n"","" inflating: all/train/pneumonia_vir/person915_virus_1572.jpeg \n"","" inflating: all/train/pneumonia_vir/person918_virus_1575.jpeg \n"","" inflating: all/train/pneumonia_vir/person919_virus_1576.jpeg \n"","" inflating: all/train/pneumonia_vir/person920_virus_1577.jpeg \n"","" inflating: all/train/pneumonia_vir/person921_virus_1578.jpeg \n"","" inflating: all/train/pneumonia_vir/person924_virus_1581.jpeg \n"","" inflating: all/train/pneumonia_vir/person925_virus_1582.jpeg \n"","" inflating: all/train/pneumonia_vir/person926_virus_1583.jpeg \n"","" inflating: all/train/pneumonia_vir/person927_virus_1584.jpeg \n"","" inflating: all/train/pneumonia_vir/person928_virus_1586.jpeg \n"","" inflating: all/train/pneumonia_vir/person929_virus_1588.jpeg \n"","" inflating: all/train/pneumonia_vir/person929_virus_1589.jpeg \n"","" inflating: all/train/pneumonia_vir/person92_virus_174.jpeg \n"","" inflating: all/train/pneumonia_vir/person931_virus_1592.jpeg \n"","" inflating: all/train/pneumonia_vir/person932_virus_1593.jpeg \n"","" inflating: all/train/pneumonia_vir/person933_virus_1594.jpeg \n"","" inflating: all/train/pneumonia_vir/person934_virus_1595.jpeg \n"","" inflating: all/train/pneumonia_vir/person935_virus_1597.jpeg \n"","" inflating: all/train/pneumonia_vir/person936_virus_1598.jpeg \n"","" inflating: all/train/pneumonia_vir/person937_virus_1599.jpeg \n"","" inflating: all/train/pneumonia_vir/person938_virus_1600.jpeg \n"","" inflating: all/train/pneumonia_vir/person93_virus_175.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1602.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1604.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1605.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1607.jpeg \n"","" inflating: all/train/pneumonia_vir/person940_virus_1609.jpeg \n"","" inflating: all/train/pneumonia_vir/person941_virus_1610.jpeg \n"","" inflating: all/train/pneumonia_vir/person942_virus_1611.jpeg \n"","" inflating: all/train/pneumonia_vir/person945_virus_1616.jpeg \n"","" inflating: all/train/pneumonia_vir/person947_virus_1618.jpeg \n"","" inflating: all/train/pneumonia_vir/person949_virus_1620.jpeg \n"","" inflating: all/train/pneumonia_vir/person94_virus_176.jpeg \n"","" inflating: all/train/pneumonia_vir/person950_virus_1621.jpeg \n"","" inflating: all/train/pneumonia_vir/person951_virus_1622.jpeg \n"","" inflating: all/train/pneumonia_vir/person952_virus_1623.jpeg \n"","" inflating: all/train/pneumonia_vir/person954_virus_1626.jpeg \n"","" inflating: all/train/pneumonia_vir/person955_virus_1627.jpeg \n"","" inflating: all/train/pneumonia_vir/person956_virus_1628.jpeg \n"","" inflating: all/train/pneumonia_vir/person95_virus_177.jpeg \n"","" inflating: all/train/pneumonia_vir/person96_virus_178.jpeg \n"","" inflating: all/train/pneumonia_vir/person96_virus_179.jpeg \n"","" inflating: all/train/pneumonia_vir/person97_virus_180.jpeg \n"","" inflating: all/train/pneumonia_vir/person97_virus_181.jpeg \n"","" inflating: all/train/pneumonia_vir/person98_virus_182.jpeg \n"","" inflating: all/train/pneumonia_vir/person99_virus_183.jpeg \n"","" creating: two/\n"","" creating: two/test/\n"","" creating: two/test/covid/\n"","" inflating: two/test/covid/nejmoa2001191_f3-PA.jpeg \n"","" inflating: two/test/covid/nejmoa2001191_f4.jpeg \n"","" inflating: two/test/covid/nejmoa2001191_f5-PA.jpeg \n"","" inflating: two/test/covid/radiol.2020200490.fig3.jpeg \n"","" inflating: two/test/covid/ryct.2020200028.fig1a.jpeg \n"","" inflating: two/test/covid/ryct.2020200034.fig2.jpeg \n"","" inflating: two/test/covid/ryct.2020200034.fig5-day0.jpeg \n"","" inflating: two/test/covid/ryct.2020200034.fig5-day4.jpeg \n"","" inflating: two/test/covid/ryct.2020200034.fig5-day7.jpeg \n"","" creating: two/test/normal/\n"","" inflating: two/test/normal/NORMAL2-IM-1385-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1396-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1400-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1401-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1406-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1412-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1419-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1422-0001.jpeg \n"","" inflating: two/test/normal/NORMAL2-IM-1423-0001.jpeg \n"","" creating: two/train/\n"","" creating: two/train/covid/\n"","" inflating: two/train/covid/01E392EE-69F9-4E33-BFCE-E5C968654078.jpeg \n"","" inflating: two/train/covid/1-s2.0-S0140673620303706-fx1_lrg.jpg \n"","" inflating: two/train/covid/1-s2.0-S0929664620300449-gr2_lrg-a.jpg \n"","" inflating: two/train/covid/1-s2.0-S0929664620300449-gr2_lrg-b.jpg \n"","" inflating: two/train/covid/1-s2.0-S0929664620300449-gr2_lrg-c.jpg \n"","" inflating: two/train/covid/1-s2.0-S0929664620300449-gr2_lrg-d.jpg \n"","" inflating: two/train/covid/1-s2.0-S1684118220300608-main.pdf-001.jpg \n"","" inflating: two/train/covid/1-s2.0-S1684118220300608-main.pdf-002.jpg \n"","" inflating: two/train/covid/1-s2.0-S1684118220300682-main.pdf-002-a1.png \n"","" inflating: two/train/covid/1-s2.0-S1684118220300682-main.pdf-002-a2.png \n"","" inflating: two/train/covid/1-s2.0-S1684118220300682-main.pdf-003-b1.png \n"","" inflating: two/train/covid/1-s2.0-S1684118220300682-main.pdf-003-b2.png \n"","" inflating: two/train/covid/1312A392-67A3-4EBF-9319-810CF6DA5EF6.jpeg \n"","" inflating: two/train/covid/1B734A89-A1BF-49A8-A1D3-66FAFA4FAC5D.jpeg \n"","" inflating: two/train/covid/23E99E2E-447C-46E5-8EB2-D35D12473C39.png \n"","" inflating: two/train/covid/2C26F453-AF3B-4517-BB9E-802CF2179543.jpeg \n"","" inflating: two/train/covid/31BA3780-2323-493F-8AED-62081B9C383B.jpeg \n"","" inflating: two/train/covid/41591_2020_819_Fig1_HTML.webp-day10.png \n"","" inflating: two/train/covid/41591_2020_819_Fig1_HTML.webp-day5.png \n"","" inflating: two/train/covid/6CB4EFC6-68FA-4CD5-940C-BEFA8DAFE9A7.jpeg \n"","" inflating: two/train/covid/7AF6C1AF-D249-4BD2-8C26-449304105D03.jpeg \n"","" inflating: two/train/covid/7C69C012-7479-493F-8722-ABC29C60A2DD.jpeg \n"","" inflating: two/train/covid/80446565-E090-4187-A031-9D3CEAA586C8.jpeg \n"","" inflating: two/train/covid/85E52EB3-56E9-4D67-82DA-DEA247C82886.jpeg \n"","" inflating: two/train/covid/8FDE8DBA-CFBD-4B4C-B1A4-6F36A93B7E87.jpeg \n"","" inflating: two/train/covid/93FE0BB1-022D-4F24-9727-987A07975FFB.jpeg \n"","" inflating: two/train/covid/9C34AF49-E589-44D5-92D3-168B3B04E4A6.jpeg \n"","" inflating: two/train/covid/all14238-fig-0001-m-b.jpg \n"","" inflating: two/train/covid/all14238-fig-0001-m-c.jpg \n"","" inflating: two/train/covid/auntminnie-a-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: two/train/covid/auntminnie-b-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: two/train/covid/auntminnie-c-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: two/train/covid/auntminnie-d-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg \n"","" inflating: two/train/covid/CD50BA96-6982-4C80-AE7B-5F67ACDBFA56.jpeg \n"","" inflating: two/train/covid/ciaa199.pdf-001-a.png \n"","" inflating: two/train/covid/ciaa199.pdf-001-b.png \n"","" inflating: two/train/covid/ciaa199.pdf-001-c.png \n"","" inflating: two/train/covid/covid-19-pneumonia-12.jpg \n"","" inflating: two/train/covid/covid-19-pneumonia-14-PA.png \n"","" inflating: two/train/covid/covid-19-pneumonia-15-PA.jpg \n"","" inflating: two/train/covid/covid-19-pneumonia-19.jpg \n"","" inflating: two/train/covid/covid-19-pneumonia-2.jpg \n"","" inflating: two/train/covid/covid-19-pneumonia-7-PA.jpg \n"","" inflating: two/train/covid/E63574A7-4188-4C8D-8D17-9D67A18A1AFA.jpeg \n"","" inflating: two/train/covid/F2DE909F-E19C-4900-92F5-8F435B031AC6.jpeg \n"","" inflating: two/train/covid/F4341CE7-73C9-45C6-99C8-8567A5484B63.jpeg \n"","" inflating: two/train/covid/F63AB6CE-1968-4154-A70F-913AF154F53D.jpeg \n"","" inflating: two/train/covid/FE9F9A5D-2830-46F9-851B-1FF4534959BE.jpeg \n"","" inflating: two/train/covid/gr1_lrg-a.jpg \n"","" inflating: two/train/covid/gr1_lrg-b.jpg \n"","" inflating: two/train/covid/kjr-21-e24-g001-l-a.jpg \n"","" inflating: two/train/covid/kjr-21-e24-g002-l-a.jpg \n"","" inflating: two/train/covid/kjr-21-e24-g003-l-a.jpg \n"","" inflating: two/train/covid/kjr-21-e25-g001-l-a.jpg \n"","" inflating: two/train/covid/lancet-case2a.jpg \n"","" inflating: two/train/covid/lancet-case2b.jpg \n"","" inflating: two/train/covid/nCoV-radiol.2020200269.fig1-day7.jpeg \n"","" inflating: two/train/covid/nejmc2001573_f1a.jpeg \n"","" inflating: two/train/covid/nejmc2001573_f1b.jpeg \n"","" inflating: two/train/covid/nejmoa2001191_f1-PA.jpeg \n"","" creating: two/train/normal/\n"","" inflating: two/train/normal/NORMAL2-IM-1281-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1282-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1285-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1286-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1287-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1288-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1289-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1290-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1291-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1292-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1293-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1294-0001-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1294-0001-0002.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1294-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1295-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1296-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1300-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1301-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1302-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1303-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1304-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1305-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1306-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1307-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1308-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1310-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1311-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1314-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1315-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1316-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1317-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1318-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1319-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1320-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1321-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1322-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1323-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1326-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1327-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1328-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1329-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1330-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1332-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1333-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1334-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1335-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1336-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1337-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1338-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1341-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1342-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1343-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1344-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1345-0001-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1345-0001-0002.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1345-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1346-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1347-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1348-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1349-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1350-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1351-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1356-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1357-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1360-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1362-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1365-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1371-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1376-0001.jpeg \n"","" inflating: two/train/normal/NORMAL2-IM-1379-0001.jpeg \n""],""name"":""stdout""}]},{""cell_type"":""code"",""metadata"":{""id"":""cvTuKxbA_6Qx"",""colab_type"":""code"",""outputId"":""281f8a61-9103-4d93-fe61-7352d8d347ec"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625368917,""user_tz"":-60,""elapsed"":3091,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":35}},""source"":[""print(os.listdir(\""/content/\""))\n"",""\n"",""#Print and remove zips once done\n"",""\n"",""!rm Covid_Data_GradientCrescent.zip\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""['.config', 'Covid_Data_GradientCrescent.zip', 'all', 'two', 'sample_data']\n""],""name"":""stdout""}]},{""cell_type"":""code"",""metadata"":{""id"":""wf3LKpv0BGGk"",""colab_type"":""code"",""colab"":{}},""source"":[""#Enable this cell to remove viral pneumonia class. Remember to Change model's final layer to 3 neurons.\n"",""!rm -rf /content/all/test/pneumonia_vir\n"",""\n"",""!rm -rf /content/all/train/pneumonia_vir""],""execution_count"":0,""outputs"":[]},{""cell_type"":""code"",""metadata"":{""id"":""923QFSnj-E_1"",""colab_type"":""code"",""outputId"":""c1ab9965-b420-43ba-f692-2794213164a3"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625446281,""user_tz"":-60,""elapsed"":1076,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":35}},""source"":[""from os import listdir\n"",""data_list = listdir('/content/all/train')\n"",""\n"",""#Delete some classes that may interfere\n"",""\n"",""\n"",""data_list""],""execution_count"":0,""outputs"":[{""output_type"":""execute_result"",""data"":{""text/plain"":[""['pneumonia_bac', 'covid', 'normal']""]},""metadata"":{""tags"":[]},""execution_count"":6}]},{""cell_type"":""markdown"",""metadata"":{""id"":""SW7NXqkh-Gk8"",""colab_type"":""text""},""source"":[""Case 2: COVID vs Normal vs Tertiary Pneumonia (Bacterial and Viral)\n"",""VGG Initialization""]},{""cell_type"":""code"",""metadata"":{""id"":""0BfmpmKd-JOb"",""colab_type"":""code"",""outputId"":""9efe72c3-0f3c-498a-8ad7-4c135fbb0bef"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625446680,""user_tz"":-60,""elapsed"":1458,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":126}},""source"":[""from tensorflow.keras import backend as K\n"",""from tensorflow.keras.models import Model ,load_model\n"",""from tensorflow.keras.layers import Flatten, Dense, Dropout\n"",""from tensorflow.keras.applications.inception_resnet_v2 import InceptionResNetV2, preprocess_input\n"",""from keras.applications.vgg16 import preprocess_input\n"",""from keras.applications.vgg16 import decode_predictions\n"",""from keras.applications.vgg16 import VGG16\n"",""from tensorflow.keras.optimizers import Adam, RMSprop\n"",""from tensorflow.keras.preprocessing.image import ImageDataGenerator\n"",""from tensorflow.keras.callbacks import ModelCheckpoint\n"",""import numpy as np\n"",""import tensorflow as tf\n"",""\n"",""\n"",""DATASET_PATH = '/content/all/train'\n"",""test_dir = '/content/all/test'\n"",""IMAGE_SIZE = (150, 150)\n"",""NUM_CLASSES = len(data_list)\n"",""BATCH_SIZE = 10 # try reducing batch size or freeze more layers if your GPU runs out of memory\n"",""NUM_EPOCHS = 100\n"",""LEARNING_RATE =0.0001\n"",""\n"",""\n"",""\n"",""#Train datagen here is a preprocessor\n"",""train_datagen = ImageDataGenerator(rescale=1./255,\n"","" rotation_range=50,\n"","" featurewise_center = True,\n"","" featurewise_std_normalization = True,\n"","" width_shift_range=0.2,\n"","" height_shift_range=0.2,\n"","" shear_range=0.25,\n"","" zoom_range=0.1,\n"","" zca_whitening = True,\n"","" channel_shift_range = 20,\n"","" horizontal_flip = True ,\n"","" vertical_flip = True ,\n"","" validation_split = 0.2,\n"","" fill_mode='constant')\n"",""\n"",""# test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input,\n"",""# fill_mode='constant')\n"",""\n"",""train_batches = train_datagen.flow_from_directory(DATASET_PATH,\n"","" target_size=IMAGE_SIZE,\n"","" shuffle=True,\n"","" batch_size=BATCH_SIZE,\n"","" subset = \""training\"",\n"","" seed=42,\n"","" class_mode=\""categorical\""\n"","" )\n"",""\n"",""valid_batches = train_datagen.flow_from_directory(DATASET_PATH,\n"","" target_size=IMAGE_SIZE,\n"","" shuffle=True,\n"","" batch_size=BATCH_SIZE,\n"","" subset = \""validation\"",\n"","" seed=42,\n"","" class_mode=\""categorical\""\n"","" \n"","" )\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""Using TensorFlow backend.\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:341: UserWarning: This ImageDataGenerator specifies `zca_whitening` which overrides setting of`featurewise_std_normalization`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""},{""output_type"":""stream"",""text"":[""Found 160 images belonging to 3 classes.\n"",""Found 40 images belonging to 3 classes.\n""],""name"":""stdout""}]},{""cell_type"":""markdown"",""metadata"":{""id"":""Arc_63PU-O5K"",""colab_type"":""text""},""source"":[""Layer Modification at upper layer of VGG16""]},{""cell_type"":""code"",""metadata"":{""id"":""lyGm7tYQBBr1"",""colab_type"":""code"",""colab"":{}},""source"":[""#Simple CNN model based on VGG16. Set dense layer neuron count to 3 if viral pneumonia class is removed\n"",""\n"",""\n"",""from keras import models\n"",""from keras import layers\n"",""from keras.applications import VGG16\n"",""from keras import optimizers\n"",""\n"",""conv_base = VGG16(weights='imagenet',\n"","" include_top=False,\n"","" input_shape=(150, 150, 3))\n"",""\n"",""\n"",""conv_base.trainable = False\n"",""\n"",""\n"",""model = models.Sequential()\n"",""model.add(conv_base)\n"",""model.add(layers.Flatten())\n"",""model.add(layers.Dense(256, activation='relu'))\n"",""model.add(layers.Dense(3, activation='softmax'))\n"",""\n"",""\n"",""model.compile(loss='categorical_crossentropy',\n"","" \n"","" optimizer=optimizers.Adam(lr=LEARNING_RATE),\n"","" metrics=['acc'])""],""execution_count"":0,""outputs"":[]},{""cell_type"":""code"",""metadata"":{""id"":""GKDLJZjL-UlA"",""colab_type"":""code"",""outputId"":""c04d5d58-f967-4f7b-8f82-ab997e67132c"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625481306,""user_tz"":-60,""elapsed"":1405,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":319}},""source"":[""print(model.summary())""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""Model: \""sequential_2\""\n"",""_________________________________________________________________\n"",""Layer (type) Output Shape Param # \n"",""=================================================================\n"",""vgg16 (Model) (None, 4, 4, 512) 14714688 \n"",""_________________________________________________________________\n"",""flatten_2 (Flatten) (None, 8192) 0 \n"",""_________________________________________________________________\n"",""dense_3 (Dense) (None, 256) 2097408 \n"",""_________________________________________________________________\n"",""dense_4 (Dense) (None, 3) 771 \n"",""=================================================================\n"",""Total params: 16,812,867\n"",""Trainable params: 2,098,179\n"",""Non-trainable params: 14,714,688\n"",""_________________________________________________________________\n"",""None\n""],""name"":""stdout""}]},{""cell_type"":""markdown"",""metadata"":{""id"":""qh3QQZLz-yLW"",""colab_type"":""text""},""source"":[""Training""]},{""cell_type"":""code"",""metadata"":{""id"":""F7IwDhx5-iKe"",""colab_type"":""code"",""outputId"":""e7618c23-a4fc-4802-bfb1-4150267e6559"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625921438,""user_tz"":-60,""elapsed"":441482,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":1000}},""source"":[""#FIT MODEL\n"",""print(len(train_batches))\n"",""print(len(valid_batches))\n"",""\n"",""STEP_SIZE_TRAIN=train_batches.n//train_batches.batch_size\n"",""STEP_SIZE_VALID=valid_batches.n//valid_batches.batch_size\n"",""\n"",""result=model.fit_generator(train_batches,\n"","" steps_per_epoch =STEP_SIZE_TRAIN,\n"","" validation_data = valid_batches,\n"","" validation_steps = STEP_SIZE_VALID,\n"","" epochs= NUM_EPOCHS, \n"","" )\n"",""\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""16\n"",""4\n"",""Epoch 1/100\n""],""name"":""stdout""},{""output_type"":""stream"",""text"":[""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:716: UserWarning: This ImageDataGenerator specifies `featurewise_center`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:735: UserWarning: This ImageDataGenerator specifies `zca_whitening`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""},{""output_type"":""stream"",""text"":[""16/16 [==============================] - 10s 637ms/step - loss: 1.0498 - acc: 0.4313 - val_loss: 0.9339 - val_acc: 0.5500\n"",""Epoch 2/100\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.8062 - acc: 0.6250 - val_loss: 0.8428 - val_acc: 0.5500\n"",""Epoch 3/100\n"",""16/16 [==============================] - 4s 264ms/step - loss: 0.7823 - acc: 0.6500 - val_loss: 0.6858 - val_acc: 0.6750\n"",""Epoch 4/100\n"",""16/16 [==============================] - 4s 263ms/step - loss: 0.7373 - acc: 0.6750 - val_loss: 0.6383 - val_acc: 0.6750\n"",""Epoch 5/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.6715 - acc: 0.7063 - val_loss: 0.6969 - val_acc: 0.6500\n"",""Epoch 6/100\n"",""16/16 [==============================] - 4s 269ms/step - loss: 0.6397 - acc: 0.7188 - val_loss: 0.7267 - val_acc: 0.6000\n"",""Epoch 7/100\n"",""16/16 [==============================] - 4s 271ms/step - loss: 0.6145 - acc: 0.7687 - val_loss: 0.5519 - val_acc: 0.8000\n"",""Epoch 8/100\n"",""16/16 [==============================] - 4s 268ms/step - loss: 0.5296 - acc: 0.8312 - val_loss: 0.5873 - val_acc: 0.7000\n"",""Epoch 9/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.5200 - acc: 0.7938 - val_loss: 0.5974 - val_acc: 0.6750\n"",""Epoch 10/100\n"",""16/16 [==============================] - 4s 263ms/step - loss: 0.4508 - acc: 0.8625 - val_loss: 0.5438 - val_acc: 0.7500\n"",""Epoch 11/100\n"",""16/16 [==============================] - 4s 265ms/step - loss: 0.4888 - acc: 0.8437 - val_loss: 0.6560 - val_acc: 0.7000\n"",""Epoch 12/100\n"",""16/16 [==============================] - 4s 263ms/step - loss: 0.4873 - acc: 0.8250 - val_loss: 0.3684 - val_acc: 0.8750\n"",""Epoch 13/100\n"",""16/16 [==============================] - 4s 262ms/step - loss: 0.4412 - acc: 0.8375 - val_loss: 0.4848 - val_acc: 0.8000\n"",""Epoch 14/100\n"",""16/16 [==============================] - 4s 261ms/step - loss: 0.4017 - acc: 0.8812 - val_loss: 0.6040 - val_acc: 0.7000\n"",""Epoch 15/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.4023 - acc: 0.8437 - val_loss: 0.4515 - val_acc: 0.8500\n"",""Epoch 16/100\n"",""16/16 [==============================] - 4s 260ms/step - loss: 0.4230 - acc: 0.8562 - val_loss: 0.3597 - val_acc: 0.8750\n"",""Epoch 17/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.3787 - acc: 0.8687 - val_loss: 0.4388 - val_acc: 0.8000\n"",""Epoch 18/100\n"",""16/16 [==============================] - 4s 265ms/step - loss: 0.3748 - acc: 0.9000 - val_loss: 0.5102 - val_acc: 0.8250\n"",""Epoch 19/100\n"",""16/16 [==============================] - 4s 263ms/step - loss: 0.3672 - acc: 0.8812 - val_loss: 0.6221 - val_acc: 0.7250\n"",""Epoch 20/100\n"",""16/16 [==============================] - 4s 263ms/step - loss: 0.4125 - acc: 0.8438 - val_loss: 0.4431 - val_acc: 0.8250\n"",""Epoch 21/100\n"",""16/16 [==============================] - 4s 265ms/step - loss: 0.3897 - acc: 0.8437 - val_loss: 0.4752 - val_acc: 0.8500\n"",""Epoch 22/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.3391 - acc: 0.8812 - val_loss: 0.3713 - val_acc: 0.8250\n"",""Epoch 23/100\n"",""16/16 [==============================] - 4s 264ms/step - loss: 0.3423 - acc: 0.8500 - val_loss: 0.6167 - val_acc: 0.6500\n"",""Epoch 24/100\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.3050 - acc: 0.9000 - val_loss: 0.2512 - val_acc: 0.9500\n"",""Epoch 25/100\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.3294 - acc: 0.8875 - val_loss: 0.4502 - val_acc: 0.7750\n"",""Epoch 26/100\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.3327 - acc: 0.9000 - val_loss: 0.3551 - val_acc: 0.9000\n"",""Epoch 27/100\n"",""16/16 [==============================] - 4s 271ms/step - loss: 0.2844 - acc: 0.9000 - val_loss: 0.4075 - val_acc: 0.8250\n"",""Epoch 28/100\n"",""16/16 [==============================] - 4s 271ms/step - loss: 0.3648 - acc: 0.8750 - val_loss: 0.4135 - val_acc: 0.8250\n"",""Epoch 29/100\n"",""16/16 [==============================] - 4s 273ms/step - loss: 0.3066 - acc: 0.9125 - val_loss: 0.5162 - val_acc: 0.8000\n"",""Epoch 30/100\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.3062 - acc: 0.8750 - val_loss: 0.3713 - val_acc: 0.8500\n"",""Epoch 31/100\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.2922 - acc: 0.8875 - val_loss: 0.4748 - val_acc: 0.7250\n"",""Epoch 32/100\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.2781 - acc: 0.8750 - val_loss: 0.5921 - val_acc: 0.7500\n"",""Epoch 33/100\n"",""16/16 [==============================] - 4s 267ms/step - loss: 0.3685 - acc: 0.8312 - val_loss: 0.4834 - val_acc: 0.7000\n"",""Epoch 34/100\n"",""16/16 [==============================] - 4s 273ms/step - loss: 0.3199 - acc: 0.8812 - val_loss: 0.6061 - val_acc: 0.7500\n"",""Epoch 35/100\n"",""16/16 [==============================] - 4s 277ms/step - loss: 0.3069 - acc: 0.8812 - val_loss: 0.4015 - val_acc: 0.8750\n"",""Epoch 36/100\n"",""16/16 [==============================] - 5s 285ms/step - loss: 0.2747 - acc: 0.9125 - val_loss: 0.6850 - val_acc: 0.6750\n"",""Epoch 37/100\n"",""16/16 [==============================] - 4s 271ms/step - loss: 0.3369 - acc: 0.8687 - val_loss: 0.3932 - val_acc: 0.7750\n"",""Epoch 38/100\n"",""16/16 [==============================] - 4s 278ms/step - loss: 0.3191 - acc: 0.8625 - val_loss: 0.4894 - val_acc: 0.7750\n"",""Epoch 39/100\n"",""16/16 [==============================] - 4s 280ms/step - loss: 0.2960 - acc: 0.8812 - val_loss: 0.3257 - val_acc: 0.9000\n"",""Epoch 40/100\n"",""16/16 [==============================] - 4s 279ms/step - loss: 0.2690 - acc: 0.9187 - val_loss: 0.4838 - val_acc: 0.7500\n"",""Epoch 41/100\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.2918 - acc: 0.9062 - val_loss: 0.2917 - val_acc: 0.9500\n"",""Epoch 42/100\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.2654 - acc: 0.9125 - val_loss: 0.3139 - val_acc: 0.9000\n"",""Epoch 43/100\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.2937 - acc: 0.8875 - val_loss: 0.4062 - val_acc: 0.8250\n"",""Epoch 44/100\n"",""16/16 [==============================] - 4s 281ms/step - loss: 0.2640 - acc: 0.8875 - val_loss: 0.2849 - val_acc: 0.8750\n"",""Epoch 45/100\n"",""16/16 [==============================] - 4s 278ms/step - loss: 0.2371 - acc: 0.9187 - val_loss: 0.4868 - val_acc: 0.8250\n"",""Epoch 46/100\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.2096 - acc: 0.9312 - val_loss: 0.3798 - val_acc: 0.8000\n"",""Epoch 47/100\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.2144 - acc: 0.9125 - val_loss: 0.4773 - val_acc: 0.8000\n"",""Epoch 48/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.2406 - acc: 0.9312 - val_loss: 0.3882 - val_acc: 0.8500\n"",""Epoch 49/100\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.2710 - acc: 0.9062 - val_loss: 0.3972 - val_acc: 0.9000\n"",""Epoch 50/100\n"",""16/16 [==============================] - 4s 273ms/step - loss: 0.2491 - acc: 0.9062 - val_loss: 0.3848 - val_acc: 0.9000\n"",""Epoch 51/100\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.2630 - acc: 0.8750 - val_loss: 0.3471 - val_acc: 0.8750\n"",""Epoch 52/100\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.2012 - acc: 0.9312 - val_loss: 0.4871 - val_acc: 0.8250\n"",""Epoch 53/100\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.2329 - acc: 0.9187 - val_loss: 0.3532 - val_acc: 0.8000\n"",""Epoch 54/100\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.2951 - acc: 0.8812 - val_loss: 0.4450 - val_acc: 0.7750\n"",""Epoch 55/100\n"",""16/16 [==============================] - 4s 271ms/step - loss: 0.2317 - acc: 0.9312 - val_loss: 0.2686 - val_acc: 0.9000\n"",""Epoch 56/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.3243 - acc: 0.8687 - val_loss: 0.4179 - val_acc: 0.7750\n"",""Epoch 57/100\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.2610 - acc: 0.9125 - val_loss: 0.3619 - val_acc: 0.8250\n"",""Epoch 58/100\n"",""16/16 [==============================] - 4s 273ms/step - loss: 0.2264 - acc: 0.9187 - val_loss: 0.3839 - val_acc: 0.8500\n"",""Epoch 59/100\n"",""16/16 [==============================] - 4s 268ms/step - loss: 0.2402 - acc: 0.9250 - val_loss: 0.6557 - val_acc: 0.7000\n"",""Epoch 60/100\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.2480 - acc: 0.9125 - val_loss: 0.5197 - val_acc: 0.8000\n"",""Epoch 61/100\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.2044 - acc: 0.9250 - val_loss: 0.4299 - val_acc: 0.8000\n"",""Epoch 62/100\n"",""16/16 [==============================] - 4s 278ms/step - loss: 0.2301 - acc: 0.9250 - val_loss: 0.2088 - val_acc: 0.9250\n"",""Epoch 63/100\n"",""16/16 [==============================] - 4s 277ms/step - loss: 0.2156 - acc: 0.9312 - val_loss: 0.4026 - val_acc: 0.8000\n"",""Epoch 64/100\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.1804 - acc: 0.9312 - val_loss: 0.3116 - val_acc: 0.8500\n"",""Epoch 65/100\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.2786 - acc: 0.9062 - val_loss: 0.5450 - val_acc: 0.8500\n"",""Epoch 66/100\n"",""16/16 [==============================] - 4s 278ms/step - loss: 0.2619 - acc: 0.9000 - val_loss: 0.4454 - val_acc: 0.8500\n"",""Epoch 67/100\n"",""16/16 [==============================] - 4s 268ms/step - loss: 0.2681 - acc: 0.9187 - val_loss: 0.5667 - val_acc: 0.8000\n"",""Epoch 68/100\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.2720 - acc: 0.8875 - val_loss: 0.7804 - val_acc: 0.7250\n"",""Epoch 69/100\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.1899 - acc: 0.9312 - val_loss: 0.3514 - val_acc: 0.9000\n"",""Epoch 70/100\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.2097 - acc: 0.9437 - val_loss: 0.3281 - val_acc: 0.8500\n"",""Epoch 71/100\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.2307 - acc: 0.9312 - val_loss: 0.3554 - val_acc: 0.8250\n"",""Epoch 72/100\n"",""16/16 [==============================] - 4s 281ms/step - loss: 0.1642 - acc: 0.9312 - val_loss: 0.2341 - val_acc: 0.9500\n"",""Epoch 73/100\n"",""16/16 [==============================] - 5s 281ms/step - loss: 0.1738 - acc: 0.9500 - val_loss: 0.4238 - val_acc: 0.8000\n"",""Epoch 74/100\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.1538 - acc: 0.9375 - val_loss: 0.3037 - val_acc: 0.8750\n"",""Epoch 75/100\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.2580 - acc: 0.9062 - val_loss: 0.2859 - val_acc: 0.8500\n"",""Epoch 76/100\n"",""16/16 [==============================] - 4s 265ms/step - loss: 0.2285 - acc: 0.9125 - val_loss: 0.3642 - val_acc: 0.8000\n"",""Epoch 77/100\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.2299 - acc: 0.9000 - val_loss: 0.4593 - val_acc: 0.7500\n"",""Epoch 78/100\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.2053 - acc: 0.9250 - val_loss: 0.2634 - val_acc: 0.9000\n"",""Epoch 79/100\n"",""16/16 [==============================] - 4s 277ms/step - loss: 0.2037 - acc: 0.9187 - val_loss: 0.6324 - val_acc: 0.7750\n"",""Epoch 80/100\n"",""16/16 [==============================] - 4s 280ms/step - loss: 0.2397 - acc: 0.8937 - val_loss: 0.3234 - val_acc: 0.8500\n"",""Epoch 81/100\n"",""16/16 [==============================] - 4s 277ms/step - loss: 0.2453 - acc: 0.9062 - val_loss: 0.5734 - val_acc: 0.8500\n"",""Epoch 82/100\n"",""16/16 [==============================] - 4s 280ms/step - loss: 0.1784 - acc: 0.9687 - val_loss: 0.3941 - val_acc: 0.8000\n"",""Epoch 83/100\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.2302 - acc: 0.8937 - val_loss: 0.5198 - val_acc: 0.8250\n"",""Epoch 84/100\n"",""16/16 [==============================] - 4s 271ms/step - loss: 0.2203 - acc: 0.9250 - val_loss: 0.6268 - val_acc: 0.7750\n"",""Epoch 85/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.1873 - acc: 0.9312 - val_loss: 0.1590 - val_acc: 0.9500\n"",""Epoch 86/100\n"",""16/16 [==============================] - 4s 273ms/step - loss: 0.2030 - acc: 0.9375 - val_loss: 0.3140 - val_acc: 0.9000\n"",""Epoch 87/100\n"",""16/16 [==============================] - 4s 265ms/step - loss: 0.1702 - acc: 0.9312 - val_loss: 0.3678 - val_acc: 0.8750\n"",""Epoch 88/100\n"",""16/16 [==============================] - 4s 264ms/step - loss: 0.1711 - acc: 0.9437 - val_loss: 0.2630 - val_acc: 0.9250\n"",""Epoch 89/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.2215 - acc: 0.9375 - val_loss: 0.5020 - val_acc: 0.8000\n"",""Epoch 90/100\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.2037 - acc: 0.9250 - val_loss: 0.3523 - val_acc: 0.8750\n"",""Epoch 91/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.1913 - acc: 0.9187 - val_loss: 0.5466 - val_acc: 0.8000\n"",""Epoch 92/100\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.1809 - acc: 0.9187 - val_loss: 0.3347 - val_acc: 0.8500\n"",""Epoch 93/100\n"",""16/16 [==============================] - 4s 269ms/step - loss: 0.2262 - acc: 0.9187 - val_loss: 0.3390 - val_acc: 0.8500\n"",""Epoch 94/100\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.1838 - acc: 0.9125 - val_loss: 0.2570 - val_acc: 0.9000\n"",""Epoch 95/100\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.1306 - acc: 0.9625 - val_loss: 0.5554 - val_acc: 0.8000\n"",""Epoch 96/100\n"",""16/16 [==============================] - 4s 265ms/step - loss: 0.1620 - acc: 0.9500 - val_loss: 0.1875 - val_acc: 0.9750\n"",""Epoch 97/100\n"",""16/16 [==============================] - 4s 268ms/step - loss: 0.1760 - acc: 0.9250 - val_loss: 0.4353 - val_acc: 0.8250\n"",""Epoch 98/100\n"",""16/16 [==============================] - 4s 268ms/step - loss: 0.2218 - acc: 0.9250 - val_loss: 0.3306 - val_acc: 0.9000\n"",""Epoch 99/100\n"",""16/16 [==============================] - 4s 267ms/step - loss: 0.1863 - acc: 0.9437 - val_loss: 0.4057 - val_acc: 0.8250\n"",""Epoch 100/100\n"",""16/16 [==============================] - 4s 271ms/step - loss: 0.2445 - acc: 0.9187 - val_loss: 0.6943 - val_acc: 0.7500\n""],""name"":""stdout""}]},{""cell_type"":""markdown"",""metadata"":{""id"":""89ZEQXk50A9-"",""colab_type"":""text""},""source"":[""Evaluation""]},{""cell_type"":""code"",""metadata"":{""id"":""tNIFRzOvp1yA"",""colab_type"":""code"",""outputId"":""9e9deed9-8a8d-4d51-d56e-d422cdade423"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625923061,""user_tz"":-60,""elapsed"":443058,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":429}},""source"":[""import matplotlib.pyplot as plt\n"",""\n"",""\n"",""def plot_acc_loss(result, epochs):\n"","" acc = result.history['acc']\n"","" loss = result.history['loss']\n"","" val_acc = result.history['val_acc']\n"","" val_loss = result.history['val_loss']\n"","" plt.figure(figsize=(15, 5))\n"","" plt.subplot(121)\n"","" plt.plot(range(1,epochs), acc[1:], label='Train_acc')\n"","" plt.plot(range(1,epochs), val_acc[1:], label='Test_acc')\n"","" plt.title('Accuracy over ' + str(epochs) + ' Epochs', size=15)\n"","" plt.legend()\n"","" plt.grid(True)\n"","" plt.subplot(122)\n"","" plt.plot(range(1,epochs), loss[1:], label='Train_loss')\n"","" plt.plot(range(1,epochs), val_loss[1:], label='Test_loss')\n"","" plt.title('Loss over ' + str(epochs) + ' Epochs', size=15)\n"","" plt.legend()\n"","" plt.grid(True)\n"","" plt.show()\n"","" \n"",""plot_acc_loss(result, 100)""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:716: UserWarning: This ImageDataGenerator specifies `featurewise_center`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:735: UserWarning: This ImageDataGenerator specifies `zca_whitening`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""},{""output_type"":""display_data"",""data"":{""image/png"":""iVBORw0KGgoAAAANSUhEUgAAA2oAAAFBCAYAAAAG31zXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"",""text/plain"":[""
""]},""metadata"":{""tags"":[]}}]},{""cell_type"":""code"",""metadata"":{""id"":""g1W_MvpGJ39q"",""colab_type"":""code"",""outputId"":""05ba006a-2d2c-4527-c295-ff9d7979cdc6"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625923063,""user_tz"":-60,""elapsed"":443049,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":108}},""source"":[""model.save('Covid_Multi.h5')""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:716: UserWarning: This ImageDataGenerator specifies `featurewise_center`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:735: UserWarning: This ImageDataGenerator specifies `zca_whitening`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""}]},{""cell_type"":""markdown"",""metadata"":{""id"":""5X6TGa0N-5R0"",""colab_type"":""text""},""source"":[""Predict""]},{""cell_type"":""code"",""metadata"":{""id"":""B1Qqa6YG-6kB"",""colab_type"":""code"",""outputId"":""13f7944e-906c-40a5-f1aa-4f84b71ecc63"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625923064,""user_tz"":-60,""elapsed"":443041,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":35}},""source"":[""\n"",""#Dont forget shuffle false\n"",""#See https://github.com/keras-team/keras/issues/6499\n"",""test_datagen = ImageDataGenerator(rescale=1. / 255)\n"",""\n"",""eval_generator = test_datagen.flow_from_directory(\n"","" test_dir,target_size=IMAGE_SIZE,\n"","" batch_size=1,\n"","" shuffle=True,\n"","" seed=42,\n"","" \n"","" class_mode=\""categorical\"")\n"",""eval_generator.reset() \n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""Found 27 images belonging to 3 classes.\n""],""name"":""stdout""}]},{""cell_type"":""code"",""metadata"":{""id"":""OruQrAjTAbly"",""colab_type"":""code"",""outputId"":""a3603d56-6c95-4067-b315-71a9c18dc2f4"",""executionInfo"":{""status"":""ok"",""timestamp"":1584625923541,""user_tz"":-60,""elapsed"":443508,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":70}},""source"":[""\n"",""eval_generator.reset() \n"",""x = model.evaluate_generator(eval_generator,\n"","" steps = np.ceil(len(eval_generator) / BATCH_SIZE),\n"","" use_multiprocessing = False,\n"","" verbose = 1,\n"","" workers=1\n"","" )\n"",""\n"",""\n"",""print('Test loss:' , x[0])\n"",""print('Test accuracy:',x[1])\n"",""\n"",""#Poor test accuracy due to the small dataset size""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""3/3 [==============================] - 1s 199ms/step\n"",""Test loss: 0.006713376846164465\n"",""Test accuracy: 1.0\n""],""name"":""stdout""}]},{""cell_type"":""markdown"",""metadata"":{""id"":""j-Xt7hwF0KK8"",""colab_type"":""text""},""source"":[""Optional: Finetuning with a learning rate of 5E-5""]},{""cell_type"":""code"",""metadata"":{""id"":""B_KzQruxRfbA"",""colab_type"":""code"",""outputId"":""b9fe2053-a12c-4c36-c20a-0461e688d5d2"",""executionInfo"":{""status"":""ok"",""timestamp"":1584626141873,""user_tz"":-60,""elapsed"":661831,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":1000}},""source"":[""\n"",""model.compile(loss='categorical_crossentropy',\n"","" \n"","" optimizer=optimizers.Adam(lr=5e-5),\n"","" metrics=['acc'])\n"",""\n"",""result=model.fit_generator(train_batches,\n"","" steps_per_epoch =STEP_SIZE_TRAIN,\n"","" validation_data = valid_batches,\n"","" validation_steps = STEP_SIZE_VALID,\n"","" epochs= 20, \n"","" )\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""Epoch 1/50\n""],""name"":""stdout""},{""output_type"":""stream"",""text"":[""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:716: UserWarning: This ImageDataGenerator specifies `featurewise_center`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:735: UserWarning: This ImageDataGenerator specifies `zca_whitening`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""},{""output_type"":""stream"",""text"":[""16/16 [==============================] - 5s 300ms/step - loss: 0.1551 - acc: 0.9562 - val_loss: 0.4131 - val_acc: 0.7750\n"",""Epoch 2/50\n"",""16/16 [==============================] - 4s 255ms/step - loss: 0.1716 - acc: 0.9312 - val_loss: 0.5726 - val_acc: 0.8500\n"",""Epoch 3/50\n"",""16/16 [==============================] - 4s 261ms/step - loss: 0.2124 - acc: 0.9125 - val_loss: 0.4882 - val_acc: 0.8000\n"",""Epoch 4/50\n"",""16/16 [==============================] - 4s 261ms/step - loss: 0.1440 - acc: 0.9437 - val_loss: 0.3906 - val_acc: 0.8000\n"",""Epoch 5/50\n"",""16/16 [==============================] - 4s 267ms/step - loss: 0.1794 - acc: 0.9125 - val_loss: 0.4222 - val_acc: 0.9000\n"",""Epoch 6/50\n"",""16/16 [==============================] - 4s 273ms/step - loss: 0.2027 - acc: 0.9187 - val_loss: 0.4976 - val_acc: 0.8250\n"",""Epoch 7/50\n"",""16/16 [==============================] - 4s 269ms/step - loss: 0.2004 - acc: 0.9500 - val_loss: 0.2417 - val_acc: 0.9000\n"",""Epoch 8/50\n"",""16/16 [==============================] - 4s 269ms/step - loss: 0.2233 - acc: 0.9312 - val_loss: 0.3159 - val_acc: 0.8750\n"",""Epoch 9/50\n"",""16/16 [==============================] - 4s 267ms/step - loss: 0.1797 - acc: 0.9375 - val_loss: 0.5429 - val_acc: 0.7750\n"",""Epoch 10/50\n"",""16/16 [==============================] - 4s 268ms/step - loss: 0.1344 - acc: 0.9750 - val_loss: 0.3393 - val_acc: 0.8000\n"",""Epoch 11/50\n"",""16/16 [==============================] - 4s 264ms/step - loss: 0.1897 - acc: 0.9125 - val_loss: 0.4713 - val_acc: 0.8750\n"",""Epoch 12/50\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.1977 - acc: 0.9437 - val_loss: 0.3230 - val_acc: 0.8500\n"",""Epoch 13/50\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.1581 - acc: 0.9500 - val_loss: 0.3546 - val_acc: 0.9000\n"",""Epoch 14/50\n"",""16/16 [==============================] - 5s 288ms/step - loss: 0.1419 - acc: 0.9687 - val_loss: 0.2552 - val_acc: 0.8750\n"",""Epoch 15/50\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.1260 - acc: 0.9437 - val_loss: 0.5564 - val_acc: 0.8250\n"",""Epoch 16/50\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.1622 - acc: 0.9500 - val_loss: 0.4559 - val_acc: 0.9000\n"",""Epoch 17/50\n"",""16/16 [==============================] - 4s 279ms/step - loss: 0.1765 - acc: 0.9437 - val_loss: 0.3341 - val_acc: 0.8250\n"",""Epoch 18/50\n"",""16/16 [==============================] - 4s 268ms/step - loss: 0.1942 - acc: 0.9312 - val_loss: 0.3183 - val_acc: 0.8750\n"",""Epoch 19/50\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.2028 - acc: 0.9250 - val_loss: 0.5201 - val_acc: 0.8000\n"",""Epoch 20/50\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.1503 - acc: 0.9437 - val_loss: 0.4794 - val_acc: 0.7750\n"",""Epoch 21/50\n"",""16/16 [==============================] - 5s 285ms/step - loss: 0.1345 - acc: 0.9688 - val_loss: 0.4558 - val_acc: 0.8500\n"",""Epoch 22/50\n"",""16/16 [==============================] - 4s 278ms/step - loss: 0.1679 - acc: 0.9437 - val_loss: 0.3326 - val_acc: 0.8000\n"",""Epoch 23/50\n"",""16/16 [==============================] - 4s 280ms/step - loss: 0.1946 - acc: 0.9125 - val_loss: 0.2727 - val_acc: 0.9000\n"",""Epoch 24/50\n"",""16/16 [==============================] - 4s 280ms/step - loss: 0.1584 - acc: 0.9437 - val_loss: 0.4005 - val_acc: 0.8250\n"",""Epoch 25/50\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.1584 - acc: 0.9437 - val_loss: 0.4175 - val_acc: 0.8250\n"",""Epoch 26/50\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.2221 - acc: 0.9250 - val_loss: 0.2564 - val_acc: 0.9000\n"",""Epoch 27/50\n"",""16/16 [==============================] - 5s 283ms/step - loss: 0.1575 - acc: 0.9437 - val_loss: 0.4363 - val_acc: 0.8500\n"",""Epoch 28/50\n"",""16/16 [==============================] - 4s 277ms/step - loss: 0.1381 - acc: 0.9500 - val_loss: 0.4067 - val_acc: 0.8000\n"",""Epoch 29/50\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.1407 - acc: 0.9437 - val_loss: 0.3436 - val_acc: 0.8250\n"",""Epoch 30/50\n"",""16/16 [==============================] - 4s 264ms/step - loss: 0.1706 - acc: 0.9500 - val_loss: 0.5116 - val_acc: 0.8250\n"",""Epoch 31/50\n"",""16/16 [==============================] - 4s 268ms/step - loss: 0.1540 - acc: 0.9562 - val_loss: 0.2620 - val_acc: 0.9000\n"",""Epoch 32/50\n"",""16/16 [==============================] - 4s 268ms/step - loss: 0.1431 - acc: 0.9437 - val_loss: 0.4244 - val_acc: 0.8750\n"",""Epoch 33/50\n"",""16/16 [==============================] - 4s 272ms/step - loss: 0.1510 - acc: 0.9562 - val_loss: 0.3204 - val_acc: 0.8000\n"",""Epoch 34/50\n"",""16/16 [==============================] - 4s 265ms/step - loss: 0.1086 - acc: 0.9750 - val_loss: 0.3930 - val_acc: 0.8500\n"",""Epoch 35/50\n"",""16/16 [==============================] - 4s 265ms/step - loss: 0.1814 - acc: 0.9312 - val_loss: 0.4661 - val_acc: 0.7750\n"",""Epoch 36/50\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.1943 - acc: 0.9375 - val_loss: 0.4861 - val_acc: 0.8250\n"",""Epoch 37/50\n"",""16/16 [==============================] - 4s 276ms/step - loss: 0.1453 - acc: 0.9562 - val_loss: 0.5312 - val_acc: 0.7750\n"",""Epoch 38/50\n"",""16/16 [==============================] - 4s 267ms/step - loss: 0.1858 - acc: 0.9312 - val_loss: 0.2732 - val_acc: 0.9000\n"",""Epoch 39/50\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.1251 - acc: 0.9687 - val_loss: 0.4948 - val_acc: 0.8000\n"",""Epoch 40/50\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.2143 - acc: 0.9187 - val_loss: 0.5600 - val_acc: 0.7750\n"",""Epoch 41/50\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.1791 - acc: 0.9500 - val_loss: 0.3557 - val_acc: 0.8750\n"",""Epoch 42/50\n"",""16/16 [==============================] - 4s 270ms/step - loss: 0.1803 - acc: 0.9187 - val_loss: 0.2693 - val_acc: 0.9000\n"",""Epoch 43/50\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.1964 - acc: 0.9250 - val_loss: 0.4657 - val_acc: 0.8250\n"",""Epoch 44/50\n"",""16/16 [==============================] - 4s 275ms/step - loss: 0.2040 - acc: 0.9312 - val_loss: 0.4766 - val_acc: 0.8500\n"",""Epoch 45/50\n"",""16/16 [==============================] - 4s 279ms/step - loss: 0.1416 - acc: 0.9437 - val_loss: 0.5015 - val_acc: 0.8250\n"",""Epoch 46/50\n"",""16/16 [==============================] - 4s 266ms/step - loss: 0.1854 - acc: 0.9375 - val_loss: 0.3880 - val_acc: 0.8750\n"",""Epoch 47/50\n"",""16/16 [==============================] - 4s 273ms/step - loss: 0.1722 - acc: 0.9187 - val_loss: 0.4548 - val_acc: 0.8500\n"",""Epoch 48/50\n"",""16/16 [==============================] - 4s 274ms/step - loss: 0.1170 - acc: 0.9750 - val_loss: 0.5253 - val_acc: 0.8250\n"",""Epoch 49/50\n"",""16/16 [==============================] - 4s 264ms/step - loss: 0.1491 - acc: 0.9500 - val_loss: 0.4620 - val_acc: 0.8000\n"",""Epoch 50/50\n"",""16/16 [==============================] - 4s 267ms/step - loss: 0.2068 - acc: 0.9125 - val_loss: 0.2923 - val_acc: 0.8500\n""],""name"":""stdout""}]},{""cell_type"":""code"",""metadata"":{""id"":""hpLLum4G9n0Y"",""colab_type"":""code"",""outputId"":""64110e7c-c130-41fe-ba28-cb4e429fdba5"",""executionInfo"":{""status"":""ok"",""timestamp"":1584626141880,""user_tz"":-60,""elapsed"":661832,""user"":{""displayName"":""Yijie Xu"",""photoUrl"":"""",""userId"":""14695674479284134427""}},""colab"":{""base_uri"":""https://localhost:8080/"",""height"":161}},""source"":[""eval_generator.reset() \n"",""x = model.evaluate_generator(eval_generator,\n"","" steps = np.ceil(len(eval_generator) / BATCH_SIZE),\n"","" use_multiprocessing = False,\n"","" verbose = 1,\n"","" workers=1\n"","" )\n"",""\n"",""\n"",""print('Test loss:' , x[0])\n"",""print('Test accuracy:',x[1])\n""],""execution_count"":0,""outputs"":[{""output_type"":""stream"",""text"":[""3/3 [==============================] - 0s 36ms/step\n"",""Test loss: 0.021353596743817132\n"",""Test accuracy: 1.0\n""],""name"":""stdout""},{""output_type"":""stream"",""text"":[""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:716: UserWarning: This ImageDataGenerator specifies `featurewise_center`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n"",""/usr/local/lib/python3.6/dist-packages/keras_preprocessing/image/image_data_generator.py:735: UserWarning: This ImageDataGenerator specifies `zca_whitening`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.\n"","" warnings.warn('This ImageDataGenerator specifies '\n""],""name"":""stderr""}]}]}","Unknown"