def __init__(self, input_file, output_file, algorithm="auto", options={}, dependencies=()): command = AtomicCmdBuilder( _PRESETS[algorithm.lower()] + ["%(IN_FASTA)s"], IN_FASTA=input_file, OUT_STDOUT=output_file, CHECK_VERSION=MAFFT_VERSION, ) apply_options(command, options) self._output_file = output_file CommandNode.__init__( self, command=command.finalize(), description="<MAFFTNode (%s): '%s' -> '%s'>" % ( algorithm, input_file, output_file, ), dependencies=dependencies, )
def __init__(self, infile, bedfile, outfile, padding, options={}, dependencies=()): params = factory.new("vcf_to_fasta") params.set_option("--padding", padding) params.set_option("--genotype", "%(IN_VCFFILE)s") params.set_option("--intervals", "%(IN_INTERVALS)s") params.set_kwargs( IN_VCFFILE=infile, IN_TABIX=infile + ".tbi", IN_INTERVALS=bedfile, OUT_STDOUT=outfile, ) apply_options(params, options) description = "<BuildRegions: '%s' -> '%s'>" % ( infile, outfile, ) CommandNode.__init__( self, description=description, command=params.finalize(), dependencies=dependencies, )
def __init__( self, input_file_1, output_file, reference, prefix, input_file_2=None, threads=1, algorithm="mem", mapping_options={}, cleanup_options={}, dependencies=(), ): if algorithm not in ("mem", "bwasw"): raise NotImplementedError("BWA algorithm %r not implemented" % (algorithm, )) threads = _get_max_threads(reference, threads) aln = _new_bwa_command( ("bwa", algorithm, prefix, "%(IN_FILE_1)s"), prefix, IN_FILE_1=input_file_1, OUT_STDOUT=AtomicCmd.PIPE, ) if input_file_2: aln.add_value("%(IN_FILE_2)s") aln.set_kwargs(IN_FILE_2=input_file_2) aln.set_option("-t", threads) # Mark alternative hits as secondary; required by e.g. Picard aln.set_option("-M") cleanup = _new_cleanup_command(aln, output_file, reference, paired_end=input_file_1 and input_file_2) apply_options(aln, mapping_options) apply_options(cleanup, cleanup_options) description = _get_node_description( name="BWA", algorithm="%s%s" % (algorithm.upper(), "_PE" if input_file_2 else "_SE"), input_files_1=input_file_1, input_files_2=input_file_2, prefix=prefix, ) CommandNode.__init__( self, command=ParallelCmds([aln.finalize(), cleanup.finalize()]), description=description, threads=threads, dependencies=dependencies, )
def __init__(self, input_file, output_prefix, threads=1, options={}, dependencies=()): # See below for parameters in common between SE/PE cmd = _get_common_parameters(threads=threads, options=options) # Prefix for output files, ensure that all end up in temp folder cmd.set_option("--basename", "%(TEMP_OUT_BASENAME)s") output_tmpl = output_prefix + ".%s.gz" cmd.set_kwargs( TEMP_OUT_BASENAME=os.path.basename(output_prefix), OUT_SETTINGS=output_prefix + ".settings", OUT_MATE_1=output_tmpl % ("truncated", ), OUT_DISCARDED=output_tmpl % ("discarded", ), ) cmd.set_option("--file1", "%(IN_READS_1)s") cmd.set_kwargs(IN_READS_1=input_file) apply_options(cmd, options) CommandNode.__init__( self, command=cmd.finalize(), threads=threads, description="<AdapterRM (SE): %s -> '%s.*'>" % ( fileutils.describe_files(input_file), output_prefix, ), dependencies=dependencies, )
def _mapdamage_rescale(self, config, destination, prefix, files_and_nodes): output_filename = self.folder + ".rescaled.bam" # Generates basic plots / table files plot = self._mapdamage_plot(config=config, destination=destination, prefix=prefix, files_and_nodes=files_and_nodes) # Builds model of post-mortem DNA damage model = MapDamageModelNode.customize(reference=prefix["Reference"], directory=destination, dependencies=plot) apply_options(model.command, self.options["mapDamage"]) model = model.build_node() # Rescales BAM quality scores using model built above input_files = files_and_nodes.keys() scale = MapDamageRescaleNode.customize(config=config, reference=prefix["Reference"], input_files=input_files, output_file=output_filename, directory=destination, dependencies=model) apply_options(scale.command, self.options["mapDamage"]) scale = scale.build_node() # Grab indexing and validation nodes, required by ROIs and GATK index_required = bool(prefix.get("RegionsOfInterest")) \ or self.options["Features"]["RealignedBAM"] validate = index_and_validate_bam(config, prefix, scale, create_index=index_required) return {output_filename: validate}, (model,)
def _apply_vcf_filter_options(vcffilter, genotyping, sample): filter_cfg = genotyping["VCF_Filter"] apply_options(vcffilter.commands["filter"], filter_cfg) if filter_cfg["MaxReadDepth"][sample]: max_depth = filter_cfg["MaxReadDepth"][sample] vcffilter.commands["filter"].set_option("--max-read-depth", max_depth) return vcffilter.build_node()
def _mapdamage_rescale(self, config, destination, prefix, files_and_nodes): model = self._mapdamage_model(config=config, destination=destination, prefix=prefix, files_and_nodes=files_and_nodes) # Rescales BAM quality scores using model built above input_files = files_and_nodes.keys() output_filename = self.folder + ".rescaled.bam" scale = MapDamageRescaleNode.customize(config=config, reference=prefix["Reference"], input_files=input_files, output_file=output_filename, directory=destination, dependencies=model) apply_options(scale.command, self.options["mapDamage"]) scale = scale.build_node() # Grab indexing and validation nodes, required by ROIs and GATK index_required = bool(prefix.get("RegionsOfInterest")) \ or self.options["Features"]["RealignedBAM"] validate = index_and_validate_bam(config=config, prefix=prefix, node=scale, create_index=index_required) return {output_filename: validate}, (model, )
def __init__(self, infile, outfile, regions, options, dependencies=()): vcffilter = factory.new("vcf_filter") vcffilter.add_value("%(IN_VCF)s") for contig in regions["HomozygousContigs"]: vcffilter.add_option("--homozygous-chromosome", contig) vcffilter.set_kwargs(IN_VCF=infile, OUT_STDOUT=AtomicCmd.PIPE) apply_options(vcffilter, options) bgzip = AtomicCmdBuilder(["bgzip"], IN_STDIN=vcffilter, OUT_STDOUT=outfile) description = "<VCFFilter: '%s' -> '%s'>" % ( infile, outfile, ) CommandNode.__init__( self, description=description, command=ParallelCmds([vcffilter.finalize(), bgzip.finalize()]), dependencies=dependencies, )
def __init__( self, reference, input_files, output_directory, title="mapDamage", options={}, dependencies=(), ): merge = merge_bam_files_command(input_files) command = AtomicCmdBuilder( [ "mapDamage", "--no-stats", # Prevent references with many contigs from using excessive # amounts of memory, at the cost of per-contig statistics: "--merge-reference-sequences", "-t", title, "-i", "-", "-d", "%(TEMP_DIR)s", "-r", "%(IN_REFERENCE)s", ], IN_STDIN=merge, IN_REFERENCE=reference, OUT_FREQ_3p=os.path.join(output_directory, "3pGtoA_freq.txt"), OUT_FREQ_5p=os.path.join(output_directory, "5pCtoT_freq.txt"), OUT_COMP_USER=os.path.join(output_directory, "dnacomp.txt"), OUT_PLOT_FRAG=os.path.join( output_directory, "Fragmisincorporation_plot.pdf" ), OUT_PLOT_LEN=os.path.join(output_directory, "Length_plot.pdf"), OUT_LENGTH=os.path.join(output_directory, "lgdistribution.txt"), OUT_MISINCORP=os.path.join(output_directory, "misincorporation.txt"), OUT_LOG=os.path.join(output_directory, "Runtime_log.txt"), TEMP_OUT_STDOUT="pipe_mapDamage.stdout", TEMP_OUT_STDERR="pipe_mapDamage.stderr", CHECK_RSCRIPT=RSCRIPT_VERSION, CHECK_MAPDAMAGE=MAPDAMAGE_VERSION, ) apply_options(command, options) CommandNode.__init__( self, command=ParallelCmds([merge, command.finalize()]), description="<mapDamage (plots): %s -> '%s'>" % (describe_files(merge.input_files), output_directory,), dependencies=dependencies, )
def __init__( self, reference, infile, bedfile, outfile, mpileup_options={}, bcftools_options={}, dependencies=(), ): mpileup = AtomicCmdBuilder( ("bcftools", "mpileup", "%(IN_BAMFILE)s"), IN_BAMFILE=infile, IN_INTERVALS=bedfile, OUT_STDOUT=AtomicCmd.PIPE, CHECK_VERSION=BCFTOOLS_VERSION, ) # Ignore read-groups for pileup mpileup.add_option("--ignore-RG") # Reference sequence (FASTA) mpileup.add_option("--fasta-ref", reference) # Output compressed VCF mpileup.add_option("--output-type", "u") if bedfile: mpileup.set_option("--regions-file", "%(IN_INTERVALS)s") apply_options(mpileup, mpileup_options) genotype = AtomicCmdBuilder( ("bcftools", "call", "-"), IN_STDIN=mpileup, IN_BAMFILE=infile, OUT_STDOUT=outfile, CHECK_VERSION=BCFTOOLS_VERSION, ) genotype.set_option("--output-type", "z") apply_options(genotype, bcftools_options) CommandNode.__init__( self, description="<GenotypeRegions: '%s' -> '%s'>" % ( infile, outfile, ), command=ParallelCmds([mpileup.finalize(), genotype.finalize()]), dependencies=dependencies, )
def _mapdamage_plot(self, config, destination, prefix, files_and_nodes): title = "mapDamage plot for library %r" % (self.name, ) dependencies = files_and_nodes.values() plot = MapDamagePlotNode.customize(config=config, reference=prefix["Path"], input_files=files_and_nodes.keys(), output_directory=destination, title=title, dependencies=dependencies) apply_options(plot.command, self.options["mapDamage"]) return plot.build_node()
def _mapdamage_model(self, config, destination, prefix, files_and_nodes): # Generates basic plots / table files plot = self._mapdamage_plot(config=config, destination=destination, prefix=prefix, files_and_nodes=files_and_nodes) # Builds model of post-mortem DNA damage model = MapDamageModelNode.customize(reference=prefix["Reference"], directory=destination, dependencies=plot) apply_options(model.command, self.options["mapDamage"]) return model.build_node()
def _mapdamage_plot(self, config, destination, prefix, files_and_nodes): title = "mapDamage plot for library %r" % (self.name,) dependencies = files_and_nodes.values() plot = MapDamagePlotNode.customize(config=config, reference=prefix["Path"], input_files=files_and_nodes.keys(), output_directory=destination, title=title, dependencies=dependencies) apply_options(plot.command, self.options["mapDamage"]) return plot.build_node()
def __init__( self, input_file_fq_1, input_file_fq_2, input_file_sai_1, input_file_sai_2, output_file, reference, prefix, mapping_options={}, cleanup_options={}, dependencies=(), ): sampe = _new_bwa_command( ( "bwa", "sampe", prefix, "%(IN_SAI_1)s", "%(IN_SAI_2)s", "%(IN_FQ_1)s", "%(IN_FQ_2)s", ), prefix, IN_SAI_1=input_file_sai_1, IN_SAI_2=input_file_sai_2, IN_FQ_1=input_file_fq_1, IN_FQ_2=input_file_fq_2, OUT_STDOUT=AtomicCmd.PIPE, ) cleanup = _new_cleanup_command(sampe, output_file, reference, paired_end=True) apply_options(sampe, mapping_options) apply_options(cleanup, cleanup_options) CommandNode.__init__( self, command=ParallelCmds([sampe.finalize(), cleanup.finalize()]), description=_get_node_description( name="BWA Sampe", input_files_1=input_file_fq_1, input_files_2=input_file_fq_2, prefix=prefix, ), dependencies=dependencies, )
def _build_bowtie2(self, config, prefix, record, parameters): self._set_pe_input_files(parameters) node = Bowtie2Node.customize(threads=config.bowtie2_max_threads, **parameters) command = node.commands["aln"] if self.options["QualityOffset"] == 33: command.set_option("--phred33") else: command.set_option("--phred64") apply_options(command, self.options["Aligners"]["Bowtie2"]) return self._finalize_nodes(config, prefix, parameters, node)
def _build_bwa_algorithm(self, config, prefix, record, parameters): if self.options["QualityOffset"] != 33: raise MakefileError("Mapping with BWA using the %r algorithm " "currently does not support QualityOffsets " "other than 33; please convert your FASTQ " "if you wish to proceed.") self._set_pe_input_files(parameters) node = BWAAlgorithmNode.customize(**parameters) apply_options(node.commands["aln"], self.options["Aligners"]["BWA"]) return self._finalize_nodes(config, prefix, parameters, node)
def __init__( self, input_file_1, input_file_2, output_prefix, collapse=True, threads=1, options={}, dependencies=(), ): cmd = _get_common_parameters(threads=threads, options=options) # Prefix for output files, to ensure that all end up in temp folder cmd.set_option("--basename", "%(TEMP_OUT_BASENAME)s") output_tmpl = output_prefix + ".%s.gz" cmd.set_kwargs( TEMP_OUT_BASENAME=os.path.basename(output_prefix), OUT_SETTINGS=output_prefix + ".settings", OUT_READS_1=output_tmpl % ("pair1.truncated", ), OUT_READS_2=output_tmpl % ("pair2.truncated", ), OUT_SINGLETON=output_tmpl % ("singleton.truncated", ), OUT_DISCARDED=output_tmpl % ("discarded", ), ) if collapse: cmd.set_option("--collapse") cmd.set_kwargs( OUT_COLLAPSED=output_tmpl % ("collapsed", ), OUT_COLLAPSED_TRUNC=output_tmpl % ("collapsed.truncated", ), ) cmd.set_option("--file1", "%(IN_READS_1)s") cmd.set_option("--file2", "%(IN_READS_2)s") cmd.set_kwargs(IN_READS_1=input_file_1, IN_READS_2=input_file_2) apply_options(cmd, options) CommandNode.__init__( self, command=cmd.finalize(), threads=threads, description="<AdapterRM (PE): %s -> '%s.*'>" % ( fileutils.describe_paired_files(input_file_1, input_file_2), output_prefix, ), dependencies=dependencies, )
def _init_raw_reads(self, config, record): ar_options = dict(record["Options"]["AdapterRemoval"]) # Setup of "--collapsed" is handled by the node itself collapse_reads = ar_options.pop("--collapse") collapse_reads = collapse_reads or collapse_reads is None init_args = { "output_prefix": os.path.join(self.folder, "reads"), "output_format": record["Options"]["CompressionFormat"], "threads": config.adapterremoval_max_threads } output_tmpl = "{output_prefix}.%s.{output_format}".format(**init_args) if ("SE" in record["Data"]): self.files["Single"] = output_tmpl % ("truncated", ) init_args["input_files"] = record["Data"]["SE"] command = SE_AdapterRemovalNode.customize(**init_args) else: self.files["Singleton"] = output_tmpl % ("singleton.truncated", ) self.files["Paired"] = output_tmpl % ("pair{Pair}.truncated", ) if collapse_reads: self.files["Collapsed"] = output_tmpl % ("collapsed", ) self.files["CollapsedTruncated"] = output_tmpl % ( "collapsed.truncated", ) init_args["collapse"] = collapse_reads init_args["input_files_1"] = record["Data"]["PE_1"] init_args["input_files_2"] = record["Data"]["PE_2"] command = PE_AdapterRemovalNode.customize(**init_args) # Ensure that any user-specified list of adapters is tracked if "--adapter-list" in ar_options: adapter_list = ar_options.pop("--adapter-list") command.command.set_option("--adapter-list", "%(IN_ADAPTER_LIST)s") command.command.set_kwargs(IN_ADAPTER_LIST=adapter_list) apply_options(command.command, ar_options) output_quality = self.quality_offset if output_quality == "Solexa": output_quality = "64" command.command.set_option("--qualitybase", self.quality_offset) command.command.set_option("--qualitybase-output", output_quality) self.stats = os.path.join(self.folder, "reads.settings") self.nodes = (command.build_node(), )
def build_msa_nodes(options, settings, regions, filtering, dependencies): if settings["Program"].lower() != "mafft": raise RuntimeError("Only MAFFT support has been implemented!") sequencedir = os.path.join(options.destination, "alignments", regions["Name"]) # Run on full set of sequences sequences = regions["Sequences"][None] node = CollectSequencesNode(fasta_files=regions["Genotypes"], destination=sequencedir, sequences=sequences, dependencies=dependencies) if settings["Enabled"]: fasta_files = {} algorithm = settings["MAFFT"]["Algorithm"] for sequence in sequences: input_file = os.path.join(sequencedir, sequence + ".fasta") output_file = os.path.join(sequencedir, sequence + ".afa") mafft = MAFFTNode.customize(input_file=input_file, output_file=output_file, algorithm=algorithm, dependencies=node) apply_options(mafft.command, settings["MAFFT"]) fasta_files[output_file] = mafft.build_node() else: fasta_files = dict((filename, node) for filename in node.output_files) if not any(filtering.itervalues()): return fasta_files.values() destination = sequencedir + ".filtered" filtering = dict(filtering) filtered_nodes = [] for (filename, node) in fasta_files.iteritems(): output_filename = fileutils.reroot_path(destination, filename) filtered_node = FilterSingletonsNode(input_file=filename, output_file=output_filename, filter_by=filtering, dependencies=node) filtered_nodes.append(filtered_node) return filtered_nodes
def __init__(self, reference, directory, options={}, dependencies=()): command = AtomicCmdBuilder( [ "mapDamage", "--stats-only", "-r", "%(IN_REFERENCE)s", "-d", "%(TEMP_DIR)s", ], IN_REFERENCE=reference, TEMP_OUT_FREQ_3p="3pGtoA_freq.txt", TEMP_OUT_FREQ_5p="5pCtoT_freq.txt", TEMP_OUT_COMP_USER="******", TEMP_OUT_MISINCORP="misincorporation.txt", TEMP_OUT_LOG="Runtime_log.txt", TEMP_OUT_STDOUT="pipe_mapDamage.stdout", TEMP_OUT_STDERR="pipe_mapDamage.stderr", OUT_COMP_GENOME=os.path.join(directory, "dnacomp_genome.csv"), OUT_MCMC_PROBS=os.path.join(directory, "Stats_out_MCMC_correct_prob.csv"), OUT_MCMC_HIST=os.path.join(directory, "Stats_out_MCMC_hist.pdf"), OUT_MCMC_ITER=os.path.join(directory, "Stats_out_MCMC_iter.csv"), OUT_MCMC_ITERSUM=os.path.join( directory, "Stats_out_MCMC_iter_summ_stat.csv" ), OUT_MCMC_POSTPRED=os.path.join(directory, "Stats_out_MCMC_post_pred.pdf"), OUT_MCMC_TRACE=os.path.join(directory, "Stats_out_MCMC_trace.pdf"), CHECK_RSCRIPT=RSCRIPT_VERSION, CHECK_MAPDAMAGE=MAPDAMAGE_VERSION, CHECK_R_INLINE=rtools.requirement("inline"), CHECK_R_GGPLOT2=rtools.requirement("ggplot2"), CHECK_R_RCPP=rtools.requirement("Rcpp"), CHECK_R_GAM=rtools.requirement("gam"), CHECK_R_RCPPGSL=rtools.requirement("RcppGSL"), ) apply_options(command, options) self._directory = directory CommandNode.__init__( self, command=command.finalize(), description="<mapDamage (model): %r>" % (directory,), dependencies=dependencies, )
def _init_raw_reads(self, config, record): ar_options = dict(record["Options"]["AdapterRemoval"]) # Setup of "--collapsed" is handled by the node itself collapse_reads = ar_options.pop("--collapse") collapse_reads = collapse_reads or collapse_reads is None init_args = {"output_prefix": os.path.join(self.folder, "reads"), "output_format": record["Options"]["CompressionFormat"], "threads": config.adapterremoval_max_threads} output_tmpl = "{output_prefix}.%s.{output_format}".format(**init_args) if ("SE" in record["Data"]): self.files["Single"] = output_tmpl % ("truncated",) init_args["input_files"] = record["Data"]["SE"] command = SE_AdapterRemovalNode.customize(**init_args) else: self.files["Singleton"] = output_tmpl % ("singleton.truncated",) self.files["Paired"] = output_tmpl % ("pair{Pair}.truncated",) if collapse_reads: self.files["Collapsed"] = output_tmpl % ("collapsed",) self.files["CollapsedTruncated"] = output_tmpl % ("collapsed.truncated",) init_args["collapse"] = collapse_reads init_args["input_files_1"] = record["Data"]["PE_1"] init_args["input_files_2"] = record["Data"]["PE_2"] command = PE_AdapterRemovalNode.customize(**init_args) # Ensure that any user-specified list of adapters is tracked if "--adapter-list" in ar_options: adapter_list = ar_options.pop("--adapter-list") command.command.set_option("--adapter-list", "%(IN_ADAPTER_LIST)s") command.command.set_kwargs(IN_ADAPTER_LIST=adapter_list) apply_options(command.command, ar_options) output_quality = self.quality_offset if output_quality == "Solexa": output_quality = "64" command.command.set_option("--qualitybase", self.quality_offset) command.command.set_option("--qualitybase-output", output_quality) self.stats = os.path.join(self.folder, "reads.settings") self.nodes = (command.build_node(),)
def __init__( self, reference, input_files, output_file, directory, options={}, dependencies=(), ): stats_out_fname = "Stats_out_MCMC_correct_prob.csv" merge = merge_bam_files_command(input_files) command = AtomicCmdBuilder( [ "mapDamage", "--rescale-only", "-i", "-", "-d", "%(TEMP_DIR)s", "-r", "%(IN_REFERENCE)s", "--rescale-out", "%(OUT_BAM)s", ], IN_STDIN=merge, IN_REFERENCE=reference, TEMP_OUT_LOG="Runtime_log.txt", TEMP_OUT_CSV=stats_out_fname, OUT_BAM=output_file, CHECK_VERSION=MAPDAMAGE_VERSION, ) apply_options(command, options) self._directory = directory CommandNode.__init__( self, command=ParallelCmds([merge, command.finalize()]), description="<mapDamage (rescale): %s -> %r>" % (describe_files(merge.input_files), output_file,), dependencies=dependencies, )
def _build_bwa_backtrack_aln(self, parameters, input_file, output_file): """ """ node = BWABacktrack.customize(input_file=input_file, output_file=output_file, threads=parameters["threads"], prefix=parameters["prefix"], reference=parameters["reference"], dependencies=parameters["dependencies"]) if not self.options["Aligners"]["BWA"]["UseSeed"]: node.commands["aln"].set_option("-l", 2 ** 16 - 1) if self.options["QualityOffset"] in (64, "Solexa"): node.commands["aln"].set_option("-I") apply_options(node.commands["aln"], self.options["Aligners"]["BWA"]) return node.build_node()
def __init__( self, input_file, output_file, reference, prefix, threads=1, mapping_options={}, dependencies=(), ): threads = _get_max_threads(reference, threads) aln = _new_bwa_command( ("bwa", "aln"), prefix, IN_FILE=input_file, OUT_STDOUT=output_file, ) aln.add_value(prefix) aln.add_value("%(IN_FILE)s") aln.set_option("-t", threads) apply_options(aln, mapping_options) description = _get_node_description( name="BWA", algorithm="Backtrack", input_files_1=input_file, prefix=prefix, threads=threads, ) CommandNode.__init__( self, command=aln.finalize(), description=description, threads=threads, dependencies=dependencies, )
def __init__( self, input_file_fq, input_file_sai, output_file, reference, prefix, mapping_options={}, cleanup_options={}, dependencies=(), ): samse = _new_bwa_command( ("bwa", "samse"), prefix, IN_FILE_SAI=input_file_sai, IN_FILE_FQ=input_file_fq, OUT_STDOUT=AtomicCmd.PIPE, ) samse.add_value(prefix) samse.add_value("%(IN_FILE_SAI)s") samse.add_value("%(IN_FILE_FQ)s") cleanup = _new_cleanup_command(samse, output_file, reference) apply_options(samse, mapping_options) apply_options(cleanup, cleanup_options) CommandNode.__init__( self, command=ParallelCmds([samse.finalize(), cleanup.finalize()]), description=_get_node_description(name="BWA Samse", input_files_1=input_file_fq, prefix=prefix), dependencies=dependencies, )
def test_apply_options__single_option__boolean__set_when_value_is_none(): mock = flexmock() mock.should_receive('set_option').with_args('-v') apply_options(mock, {"-v": None})
def test_apply_options__single_option__user_pred__ignore_when_pred_is_false(): mock = flexmock() apply_options(mock, {"BAR_FOO": 17}, _user_pred)
def test_apply_options__single_option__user_pred__set_when_pred_is_true(): mock = flexmock() mock.should_receive('set_option').with_args('FOO_BAR', 17).once() apply_options(mock, {"FOO_BAR": 17}, _user_pred)
def test_apply_options__single_option__default_pred__ignore_when_pred_is_false(): mock = flexmock() apply_options(mock, {"Other": None})
def test_apply_options__single_option__default_pred__set_when_pred_is_true(): mock = flexmock() mock.should_receive('set_option').with_args('--foo', 17).once() apply_options(mock, {"--foo": 17})
def test_apply_options__multiple_option(): mock = flexmock() mock.should_receive('add_option').with_args('--foo', 3).once() mock.should_receive('add_option').with_args('--foo', 17).once() apply_options(mock, {"--foo": [3, 17]})
def __init__( self, input_file_1, input_file_2, output_file, reference, prefix, threads=2, log_file=None, mapping_options={}, cleanup_options={}, dependencies=(), ): # Setting IN_FILE_2 to None makes AtomicCmd ignore this key aln = _bowtie2_template( ("bowtie2", ), prefix, OUT_STDOUT=AtomicCmd.PIPE, CHECK_VERSION=BOWTIE2_VERSION, ) aln.set_option("-x", prefix) if log_file is not None: aln.set_kwargs(OUT_STDERR=log_file) if input_file_1 and not input_file_2: aln.add_option("-U", input_file_1) elif input_file_1 and input_file_2: aln.add_option("-1", input_file_1) aln.add_option("-2", input_file_2) else: raise NodeError("Input 1, OR both input 1 and input 2 must " "be specified for Bowtie2 node") max_threads = _get_max_threads(reference, threads) aln.set_option("--threads", max_threads) cleanup = _new_cleanup_command(aln, output_file, reference, paired_end=input_file_1 and input_file_2) apply_options(aln, mapping_options) apply_options(cleanup, cleanup_options) algorithm = "PE" if input_file_2 else "SE" description = _get_node_description( name="Bowtie2", algorithm=algorithm, input_files_1=input_file_1, input_files_2=input_file_2, prefix=prefix, threads=threads, ) CommandNode.__init__( self, command=ParallelCmds([aln.finalize(), cleanup.finalize()]), description=description, threads=threads, dependencies=dependencies, )
def test_apply_options__single_option__boolean__pop_when_value_is_false(): mock = flexmock() mock.should_receive('pop_option').with_args('-v') apply_options(mock, {"-v": False})
def test_apply_options__single_option__default_pred__ignore_false_pred(): mock = flexmock() apply_options(mock, {"Other": None})