id int32 0 252k | repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1
value | code stringlengths 51 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 |
|---|---|---|---|---|---|---|---|---|---|---|---|
237,000 | bcbio/bcbio-nextgen | scripts/utils/hlas_to_pgroups.py | read_hlas | def read_hlas(fasta_fai):
"""Get HLA alleles from the hg38 fasta fai file.
"""
out = []
with open(fasta_fai) as in_handle:
for line in in_handle:
if line.startswith("HLA"):
out.append(line.split()[0])
return out | python | def read_hlas(fasta_fai):
out = []
with open(fasta_fai) as in_handle:
for line in in_handle:
if line.startswith("HLA"):
out.append(line.split()[0])
return out | [
"def",
"read_hlas",
"(",
"fasta_fai",
")",
":",
"out",
"=",
"[",
"]",
"with",
"open",
"(",
"fasta_fai",
")",
"as",
"in_handle",
":",
"for",
"line",
"in",
"in_handle",
":",
"if",
"line",
".",
"startswith",
"(",
"\"HLA\"",
")",
":",
"out",
".",
"append... | Get HLA alleles from the hg38 fasta fai file. | [
"Get",
"HLA",
"alleles",
"from",
"the",
"hg38",
"fasta",
"fai",
"file",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/scripts/utils/hlas_to_pgroups.py#L58-L66 |
237,001 | bcbio/bcbio-nextgen | bcbio/variation/split.py | split_vcf | def split_vcf(in_file, ref_file, config, out_dir=None):
"""Split a VCF file into separate files by chromosome.
"""
if out_dir is None:
out_dir = os.path.join(os.path.dirname(in_file), "split")
out_files = []
with open(ref.fasta_idx(ref_file, config)) as in_handle:
for line in in_handle:
chrom, size = line.split()[:2]
out_file = os.path.join(out_dir,
os.path.basename(replace_suffix(append_stem(in_file, "-%s" % chrom), ".vcf")))
subset_vcf(in_file, (chrom, 0, size), out_file, config)
out_files.append(out_file)
return out_files | python | def split_vcf(in_file, ref_file, config, out_dir=None):
if out_dir is None:
out_dir = os.path.join(os.path.dirname(in_file), "split")
out_files = []
with open(ref.fasta_idx(ref_file, config)) as in_handle:
for line in in_handle:
chrom, size = line.split()[:2]
out_file = os.path.join(out_dir,
os.path.basename(replace_suffix(append_stem(in_file, "-%s" % chrom), ".vcf")))
subset_vcf(in_file, (chrom, 0, size), out_file, config)
out_files.append(out_file)
return out_files | [
"def",
"split_vcf",
"(",
"in_file",
",",
"ref_file",
",",
"config",
",",
"out_dir",
"=",
"None",
")",
":",
"if",
"out_dir",
"is",
"None",
":",
"out_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"in_file",
"... | Split a VCF file into separate files by chromosome. | [
"Split",
"a",
"VCF",
"file",
"into",
"separate",
"files",
"by",
"chromosome",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/split.py#L12-L25 |
237,002 | bcbio/bcbio-nextgen | bcbio/variation/split.py | subset_vcf | def subset_vcf(in_file, region, out_file, config):
"""Subset VCF in the given region, handling bgzip and indexing of input.
"""
work_file = vcfutils.bgzip_and_index(in_file, config)
if not file_exists(out_file):
with file_transaction(config, out_file) as tx_out_file:
bcftools = config_utils.get_program("bcftools", config)
region_str = bamprep.region_to_gatk(region)
cmd = "{bcftools} view -r {region_str} {work_file} > {tx_out_file}"
do.run(cmd.format(**locals()), "subset %s: %s" % (os.path.basename(work_file), region_str))
return out_file | python | def subset_vcf(in_file, region, out_file, config):
work_file = vcfutils.bgzip_and_index(in_file, config)
if not file_exists(out_file):
with file_transaction(config, out_file) as tx_out_file:
bcftools = config_utils.get_program("bcftools", config)
region_str = bamprep.region_to_gatk(region)
cmd = "{bcftools} view -r {region_str} {work_file} > {tx_out_file}"
do.run(cmd.format(**locals()), "subset %s: %s" % (os.path.basename(work_file), region_str))
return out_file | [
"def",
"subset_vcf",
"(",
"in_file",
",",
"region",
",",
"out_file",
",",
"config",
")",
":",
"work_file",
"=",
"vcfutils",
".",
"bgzip_and_index",
"(",
"in_file",
",",
"config",
")",
"if",
"not",
"file_exists",
"(",
"out_file",
")",
":",
"with",
"file_tra... | Subset VCF in the given region, handling bgzip and indexing of input. | [
"Subset",
"VCF",
"in",
"the",
"given",
"region",
"handling",
"bgzip",
"and",
"indexing",
"of",
"input",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/split.py#L27-L37 |
237,003 | bcbio/bcbio-nextgen | bcbio/variation/recalibrate.py | prep_recal | def prep_recal(data):
"""Do pre-BQSR recalibration, calculation of recalibration tables.
"""
if dd.get_recalibrate(data) in [True, "gatk"]:
logger.info("Prepare BQSR tables with GATK: %s " % str(dd.get_sample_name(data)))
dbsnp_file = tz.get_in(("genome_resources", "variation", "dbsnp"), data)
if not dbsnp_file:
logger.info("Skipping GATK BaseRecalibrator because no VCF file of known variants was found.")
return data
broad_runner = broad.runner_from_config(data["config"])
data["prep_recal"] = _gatk_base_recalibrator(broad_runner, dd.get_align_bam(data),
dd.get_ref_file(data), dd.get_platform(data),
dbsnp_file,
dd.get_variant_regions(data) or dd.get_sample_callable(data),
data)
elif dd.get_recalibrate(data) == "sentieon":
logger.info("Prepare BQSR tables with sentieon: %s " % str(dd.get_sample_name(data)))
data["prep_recal"] = sentieon.bqsr_table(data)
elif dd.get_recalibrate(data):
raise NotImplementedError("Unsupported recalibration type: %s" % (dd.get_recalibrate(data)))
return data | python | def prep_recal(data):
if dd.get_recalibrate(data) in [True, "gatk"]:
logger.info("Prepare BQSR tables with GATK: %s " % str(dd.get_sample_name(data)))
dbsnp_file = tz.get_in(("genome_resources", "variation", "dbsnp"), data)
if not dbsnp_file:
logger.info("Skipping GATK BaseRecalibrator because no VCF file of known variants was found.")
return data
broad_runner = broad.runner_from_config(data["config"])
data["prep_recal"] = _gatk_base_recalibrator(broad_runner, dd.get_align_bam(data),
dd.get_ref_file(data), dd.get_platform(data),
dbsnp_file,
dd.get_variant_regions(data) or dd.get_sample_callable(data),
data)
elif dd.get_recalibrate(data) == "sentieon":
logger.info("Prepare BQSR tables with sentieon: %s " % str(dd.get_sample_name(data)))
data["prep_recal"] = sentieon.bqsr_table(data)
elif dd.get_recalibrate(data):
raise NotImplementedError("Unsupported recalibration type: %s" % (dd.get_recalibrate(data)))
return data | [
"def",
"prep_recal",
"(",
"data",
")",
":",
"if",
"dd",
".",
"get_recalibrate",
"(",
"data",
")",
"in",
"[",
"True",
",",
"\"gatk\"",
"]",
":",
"logger",
".",
"info",
"(",
"\"Prepare BQSR tables with GATK: %s \"",
"%",
"str",
"(",
"dd",
".",
"get_sample_na... | Do pre-BQSR recalibration, calculation of recalibration tables. | [
"Do",
"pre",
"-",
"BQSR",
"recalibration",
"calculation",
"of",
"recalibration",
"tables",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/recalibrate.py#L21-L41 |
237,004 | bcbio/bcbio-nextgen | bcbio/variation/recalibrate.py | apply_recal | def apply_recal(data):
"""Apply recalibration tables to the sorted aligned BAM, producing recalibrated BAM.
"""
orig_bam = dd.get_align_bam(data) or dd.get_work_bam(data)
had_work_bam = "work_bam" in data
if dd.get_recalibrate(data) in [True, "gatk"]:
if data.get("prep_recal"):
logger.info("Applying BQSR recalibration with GATK: %s " % str(dd.get_sample_name(data)))
data["work_bam"] = _gatk_apply_bqsr(data)
elif dd.get_recalibrate(data) == "sentieon":
if data.get("prep_recal"):
logger.info("Applying BQSR recalibration with sentieon: %s " % str(dd.get_sample_name(data)))
data["work_bam"] = sentieon.apply_bqsr(data)
elif dd.get_recalibrate(data):
raise NotImplementedError("Unsupported recalibration type: %s" % (dd.get_recalibrate(data)))
# CWL does not have work/alignment BAM separation
if not had_work_bam and dd.get_work_bam(data):
data["align_bam"] = dd.get_work_bam(data)
if orig_bam != dd.get_work_bam(data) and orig_bam != dd.get_align_bam(data):
utils.save_diskspace(orig_bam, "BAM recalibrated to %s" % dd.get_work_bam(data), data["config"])
return data | python | def apply_recal(data):
orig_bam = dd.get_align_bam(data) or dd.get_work_bam(data)
had_work_bam = "work_bam" in data
if dd.get_recalibrate(data) in [True, "gatk"]:
if data.get("prep_recal"):
logger.info("Applying BQSR recalibration with GATK: %s " % str(dd.get_sample_name(data)))
data["work_bam"] = _gatk_apply_bqsr(data)
elif dd.get_recalibrate(data) == "sentieon":
if data.get("prep_recal"):
logger.info("Applying BQSR recalibration with sentieon: %s " % str(dd.get_sample_name(data)))
data["work_bam"] = sentieon.apply_bqsr(data)
elif dd.get_recalibrate(data):
raise NotImplementedError("Unsupported recalibration type: %s" % (dd.get_recalibrate(data)))
# CWL does not have work/alignment BAM separation
if not had_work_bam and dd.get_work_bam(data):
data["align_bam"] = dd.get_work_bam(data)
if orig_bam != dd.get_work_bam(data) and orig_bam != dd.get_align_bam(data):
utils.save_diskspace(orig_bam, "BAM recalibrated to %s" % dd.get_work_bam(data), data["config"])
return data | [
"def",
"apply_recal",
"(",
"data",
")",
":",
"orig_bam",
"=",
"dd",
".",
"get_align_bam",
"(",
"data",
")",
"or",
"dd",
".",
"get_work_bam",
"(",
"data",
")",
"had_work_bam",
"=",
"\"work_bam\"",
"in",
"data",
"if",
"dd",
".",
"get_recalibrate",
"(",
"da... | Apply recalibration tables to the sorted aligned BAM, producing recalibrated BAM. | [
"Apply",
"recalibration",
"tables",
"to",
"the",
"sorted",
"aligned",
"BAM",
"producing",
"recalibrated",
"BAM",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/recalibrate.py#L43-L63 |
237,005 | bcbio/bcbio-nextgen | bcbio/variation/recalibrate.py | _gatk_base_recalibrator | def _gatk_base_recalibrator(broad_runner, dup_align_bam, ref_file, platform,
dbsnp_file, intervals, data):
"""Step 1 of GATK recalibration process, producing table of covariates.
For GATK 4 we use local multicore spark runs:
https://github.com/broadinstitute/gatk/issues/2345
For GATK3, Large whole genome BAM files take an excessively long time to recalibrate and
the extra inputs don't help much beyond a certain point. See the 'Downsampling analysis'
plots in the GATK documentation:
http://gatkforums.broadinstitute.org/discussion/44/base-quality-score-recalibrator#latest
This identifies large files and calculates the fraction to downsample to.
spark host and timeout settings help deal with runs on restricted systems
where we encounter network and timeout errors
"""
target_counts = 1e8 # 100 million reads per read group, 20x the plotted max
out_file = os.path.join(dd.get_work_dir(data), "align", dd.get_sample_name(data),
"%s-recal.grp" % utils.splitext_plus(os.path.basename(dup_align_bam))[0])
if not utils.file_exists(out_file):
if has_aligned_reads(dup_align_bam, intervals):
with file_transaction(data, out_file) as tx_out_file:
gatk_type = broad_runner.gatk_type()
assert gatk_type in ["restricted", "gatk4"], \
"Require full version of GATK 2.4+ or GATK4 for BQSR"
params = ["-I", dup_align_bam]
cores = dd.get_num_cores(data)
if gatk_type == "gatk4":
resources = config_utils.get_resources("gatk-spark", data["config"])
spark_opts = [str(x) for x in resources.get("options", [])]
params += ["-T", "BaseRecalibratorSpark",
"--output", tx_out_file, "--reference", dd.get_ref_file(data)]
if spark_opts:
params += spark_opts
else:
params += ["--spark-master", "local[%s]" % cores,
"--conf", "spark.driver.host=localhost", "--conf", "spark.network.timeout=800",
"--conf", "spark.executor.heartbeatInterval=100",
"--conf", "spark.local.dir=%s" % os.path.dirname(tx_out_file)]
if dbsnp_file:
params += ["--known-sites", dbsnp_file]
if intervals:
params += ["-L", intervals, "--interval-set-rule", "INTERSECTION"]
else:
params += ["-T", "BaseRecalibrator",
"-o", tx_out_file, "-R", ref_file]
downsample_pct = bam.get_downsample_pct(dup_align_bam, target_counts, data)
if downsample_pct:
params += ["--downsample_to_fraction", str(downsample_pct),
"--downsampling_type", "ALL_READS"]
if platform.lower() == "solid":
params += ["--solid_nocall_strategy", "PURGE_READ",
"--solid_recal_mode", "SET_Q_ZERO_BASE_N"]
if dbsnp_file:
params += ["--knownSites", dbsnp_file]
if intervals:
params += ["-L", intervals, "--interval_set_rule", "INTERSECTION"]
memscale = {"magnitude": 0.9 * cores, "direction": "increase"} if cores > 1 else None
broad_runner.run_gatk(params, os.path.dirname(tx_out_file), memscale=memscale,
parallel_gc=True)
else:
with open(out_file, "w") as out_handle:
out_handle.write("# No aligned reads")
return out_file | python | def _gatk_base_recalibrator(broad_runner, dup_align_bam, ref_file, platform,
dbsnp_file, intervals, data):
target_counts = 1e8 # 100 million reads per read group, 20x the plotted max
out_file = os.path.join(dd.get_work_dir(data), "align", dd.get_sample_name(data),
"%s-recal.grp" % utils.splitext_plus(os.path.basename(dup_align_bam))[0])
if not utils.file_exists(out_file):
if has_aligned_reads(dup_align_bam, intervals):
with file_transaction(data, out_file) as tx_out_file:
gatk_type = broad_runner.gatk_type()
assert gatk_type in ["restricted", "gatk4"], \
"Require full version of GATK 2.4+ or GATK4 for BQSR"
params = ["-I", dup_align_bam]
cores = dd.get_num_cores(data)
if gatk_type == "gatk4":
resources = config_utils.get_resources("gatk-spark", data["config"])
spark_opts = [str(x) for x in resources.get("options", [])]
params += ["-T", "BaseRecalibratorSpark",
"--output", tx_out_file, "--reference", dd.get_ref_file(data)]
if spark_opts:
params += spark_opts
else:
params += ["--spark-master", "local[%s]" % cores,
"--conf", "spark.driver.host=localhost", "--conf", "spark.network.timeout=800",
"--conf", "spark.executor.heartbeatInterval=100",
"--conf", "spark.local.dir=%s" % os.path.dirname(tx_out_file)]
if dbsnp_file:
params += ["--known-sites", dbsnp_file]
if intervals:
params += ["-L", intervals, "--interval-set-rule", "INTERSECTION"]
else:
params += ["-T", "BaseRecalibrator",
"-o", tx_out_file, "-R", ref_file]
downsample_pct = bam.get_downsample_pct(dup_align_bam, target_counts, data)
if downsample_pct:
params += ["--downsample_to_fraction", str(downsample_pct),
"--downsampling_type", "ALL_READS"]
if platform.lower() == "solid":
params += ["--solid_nocall_strategy", "PURGE_READ",
"--solid_recal_mode", "SET_Q_ZERO_BASE_N"]
if dbsnp_file:
params += ["--knownSites", dbsnp_file]
if intervals:
params += ["-L", intervals, "--interval_set_rule", "INTERSECTION"]
memscale = {"magnitude": 0.9 * cores, "direction": "increase"} if cores > 1 else None
broad_runner.run_gatk(params, os.path.dirname(tx_out_file), memscale=memscale,
parallel_gc=True)
else:
with open(out_file, "w") as out_handle:
out_handle.write("# No aligned reads")
return out_file | [
"def",
"_gatk_base_recalibrator",
"(",
"broad_runner",
",",
"dup_align_bam",
",",
"ref_file",
",",
"platform",
",",
"dbsnp_file",
",",
"intervals",
",",
"data",
")",
":",
"target_counts",
"=",
"1e8",
"# 100 million reads per read group, 20x the plotted max",
"out_file",
... | Step 1 of GATK recalibration process, producing table of covariates.
For GATK 4 we use local multicore spark runs:
https://github.com/broadinstitute/gatk/issues/2345
For GATK3, Large whole genome BAM files take an excessively long time to recalibrate and
the extra inputs don't help much beyond a certain point. See the 'Downsampling analysis'
plots in the GATK documentation:
http://gatkforums.broadinstitute.org/discussion/44/base-quality-score-recalibrator#latest
This identifies large files and calculates the fraction to downsample to.
spark host and timeout settings help deal with runs on restricted systems
where we encounter network and timeout errors | [
"Step",
"1",
"of",
"GATK",
"recalibration",
"process",
"producing",
"table",
"of",
"covariates",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/recalibrate.py#L67-L132 |
237,006 | bcbio/bcbio-nextgen | bcbio/variation/recalibrate.py | _gatk_apply_bqsr | def _gatk_apply_bqsr(data):
"""Parallel BQSR support for GATK4.
Normalized qualities to 3 bin outputs at 10, 20 and 30 based on pipeline standard
recommendations, which will help with output file sizes:
https://github.com/CCDG/Pipeline-Standardization/blob/master/PipelineStandard.md#base-quality-score-binning-scheme
https://github.com/gatk-workflows/broad-prod-wgs-germline-snps-indels/blob/5585cdf7877104f2c61b2720ddfe7235f2fad577/PairedEndSingleSampleWf.gatk4.0.wdl#L1081
spark host and timeout settings help deal with runs on restricted systems
where we encounter network and timeout errors
"""
in_file = dd.get_align_bam(data) or dd.get_work_bam(data)
out_file = os.path.join(dd.get_work_dir(data), "align", dd.get_sample_name(data),
"%s-recal.bam" % utils.splitext_plus(os.path.basename(in_file))[0])
if not utils.file_uptodate(out_file, in_file):
with file_transaction(data, out_file) as tx_out_file:
broad_runner = broad.runner_from_config(data["config"])
gatk_type = broad_runner.gatk_type()
cores = dd.get_num_cores(data)
if gatk_type == "gatk4":
resources = config_utils.get_resources("gatk-spark", data["config"])
spark_opts = [str(x) for x in resources.get("options", [])]
params = ["-T", "ApplyBQSRSpark",
"--input", in_file, "--output", tx_out_file, "--bqsr-recal-file", data["prep_recal"],
"--static-quantized-quals", "10", "--static-quantized-quals", "20",
"--static-quantized-quals", "30"]
if spark_opts:
params += spark_opts
else:
params += ["--spark-master", "local[%s]" % cores,
"--conf", "spark.local.dir=%s" % os.path.dirname(tx_out_file),
"--conf", "spark.driver.host=localhost", "--conf", "spark.network.timeout=800"]
else:
params = ["-T", "PrintReads", "-R", dd.get_ref_file(data), "-I", in_file,
"-BQSR", data["prep_recal"], "-o", tx_out_file]
# Avoid problems with intel deflater for GATK 3.8 and GATK4
# https://github.com/bcbio/bcbio-nextgen/issues/2145#issuecomment-343095357
if gatk_type == "gatk4":
params += ["--jdk-deflater", "--jdk-inflater"]
elif LooseVersion(broad_runner.gatk_major_version()) > LooseVersion("3.7"):
params += ["-jdk_deflater", "-jdk_inflater"]
memscale = {"magnitude": 0.9 * cores, "direction": "increase"} if cores > 1 else None
broad_runner.run_gatk(params, os.path.dirname(tx_out_file), memscale=memscale,
parallel_gc=True)
bam.index(out_file, data["config"])
return out_file | python | def _gatk_apply_bqsr(data):
in_file = dd.get_align_bam(data) or dd.get_work_bam(data)
out_file = os.path.join(dd.get_work_dir(data), "align", dd.get_sample_name(data),
"%s-recal.bam" % utils.splitext_plus(os.path.basename(in_file))[0])
if not utils.file_uptodate(out_file, in_file):
with file_transaction(data, out_file) as tx_out_file:
broad_runner = broad.runner_from_config(data["config"])
gatk_type = broad_runner.gatk_type()
cores = dd.get_num_cores(data)
if gatk_type == "gatk4":
resources = config_utils.get_resources("gatk-spark", data["config"])
spark_opts = [str(x) for x in resources.get("options", [])]
params = ["-T", "ApplyBQSRSpark",
"--input", in_file, "--output", tx_out_file, "--bqsr-recal-file", data["prep_recal"],
"--static-quantized-quals", "10", "--static-quantized-quals", "20",
"--static-quantized-quals", "30"]
if spark_opts:
params += spark_opts
else:
params += ["--spark-master", "local[%s]" % cores,
"--conf", "spark.local.dir=%s" % os.path.dirname(tx_out_file),
"--conf", "spark.driver.host=localhost", "--conf", "spark.network.timeout=800"]
else:
params = ["-T", "PrintReads", "-R", dd.get_ref_file(data), "-I", in_file,
"-BQSR", data["prep_recal"], "-o", tx_out_file]
# Avoid problems with intel deflater for GATK 3.8 and GATK4
# https://github.com/bcbio/bcbio-nextgen/issues/2145#issuecomment-343095357
if gatk_type == "gatk4":
params += ["--jdk-deflater", "--jdk-inflater"]
elif LooseVersion(broad_runner.gatk_major_version()) > LooseVersion("3.7"):
params += ["-jdk_deflater", "-jdk_inflater"]
memscale = {"magnitude": 0.9 * cores, "direction": "increase"} if cores > 1 else None
broad_runner.run_gatk(params, os.path.dirname(tx_out_file), memscale=memscale,
parallel_gc=True)
bam.index(out_file, data["config"])
return out_file | [
"def",
"_gatk_apply_bqsr",
"(",
"data",
")",
":",
"in_file",
"=",
"dd",
".",
"get_align_bam",
"(",
"data",
")",
"or",
"dd",
".",
"get_work_bam",
"(",
"data",
")",
"out_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"dd",
".",
"get_work_dir",
"(",
"... | Parallel BQSR support for GATK4.
Normalized qualities to 3 bin outputs at 10, 20 and 30 based on pipeline standard
recommendations, which will help with output file sizes:
https://github.com/CCDG/Pipeline-Standardization/blob/master/PipelineStandard.md#base-quality-score-binning-scheme
https://github.com/gatk-workflows/broad-prod-wgs-germline-snps-indels/blob/5585cdf7877104f2c61b2720ddfe7235f2fad577/PairedEndSingleSampleWf.gatk4.0.wdl#L1081
spark host and timeout settings help deal with runs on restricted systems
where we encounter network and timeout errors | [
"Parallel",
"BQSR",
"support",
"for",
"GATK4",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/recalibrate.py#L134-L179 |
237,007 | bcbio/bcbio-nextgen | bcbio/log/__init__.py | create_base_logger | def create_base_logger(config=None, parallel=None):
"""Setup base logging configuration, also handling remote logging.
Correctly sets up for local, multiprocessing and distributed runs.
Creates subscribers for non-local runs that will be references from
local logging.
Retrieves IP address using tips from http://stackoverflow.com/a/1267524/252589
"""
if parallel is None: parallel = {}
parallel_type = parallel.get("type", "local")
cores = parallel.get("cores", 1)
if parallel_type == "ipython":
from bcbio.log import logbook_zmqpush
fqdn_ip = socket.gethostbyname(socket.getfqdn())
ips = [fqdn_ip] if (fqdn_ip and not fqdn_ip.startswith("127.")) else []
if not ips:
ips = [ip for ip in socket.gethostbyname_ex(socket.gethostname())[2]
if not ip.startswith("127.")]
if not ips:
ips += [(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close())[1] for s in
[socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]]
if not ips:
sys.stderr.write("Cannot resolve a local IP address that isn't 127.x.x.x "
"Your machines might not have a local IP address "
"assigned or are not able to resolve it.\n")
sys.exit(1)
uri = "tcp://%s" % ips[0]
subscriber = logbook_zmqpush.ZeroMQPullSubscriber()
mport = subscriber.socket.bind_to_random_port(uri)
wport_uri = "%s:%s" % (uri, mport)
parallel["log_queue"] = wport_uri
subscriber.dispatch_in_background(_create_log_handler(config, True))
elif cores > 1:
subscriber = IOSafeMultiProcessingSubscriber(mpq)
subscriber.dispatch_in_background(_create_log_handler(config))
else:
# Do not need to setup anything for local logging
pass
return parallel | python | def create_base_logger(config=None, parallel=None):
if parallel is None: parallel = {}
parallel_type = parallel.get("type", "local")
cores = parallel.get("cores", 1)
if parallel_type == "ipython":
from bcbio.log import logbook_zmqpush
fqdn_ip = socket.gethostbyname(socket.getfqdn())
ips = [fqdn_ip] if (fqdn_ip and not fqdn_ip.startswith("127.")) else []
if not ips:
ips = [ip for ip in socket.gethostbyname_ex(socket.gethostname())[2]
if not ip.startswith("127.")]
if not ips:
ips += [(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close())[1] for s in
[socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]]
if not ips:
sys.stderr.write("Cannot resolve a local IP address that isn't 127.x.x.x "
"Your machines might not have a local IP address "
"assigned or are not able to resolve it.\n")
sys.exit(1)
uri = "tcp://%s" % ips[0]
subscriber = logbook_zmqpush.ZeroMQPullSubscriber()
mport = subscriber.socket.bind_to_random_port(uri)
wport_uri = "%s:%s" % (uri, mport)
parallel["log_queue"] = wport_uri
subscriber.dispatch_in_background(_create_log_handler(config, True))
elif cores > 1:
subscriber = IOSafeMultiProcessingSubscriber(mpq)
subscriber.dispatch_in_background(_create_log_handler(config))
else:
# Do not need to setup anything for local logging
pass
return parallel | [
"def",
"create_base_logger",
"(",
"config",
"=",
"None",
",",
"parallel",
"=",
"None",
")",
":",
"if",
"parallel",
"is",
"None",
":",
"parallel",
"=",
"{",
"}",
"parallel_type",
"=",
"parallel",
".",
"get",
"(",
"\"type\"",
",",
"\"local\"",
")",
"cores"... | Setup base logging configuration, also handling remote logging.
Correctly sets up for local, multiprocessing and distributed runs.
Creates subscribers for non-local runs that will be references from
local logging.
Retrieves IP address using tips from http://stackoverflow.com/a/1267524/252589 | [
"Setup",
"base",
"logging",
"configuration",
"also",
"handling",
"remote",
"logging",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/log/__init__.py#L91-L130 |
237,008 | bcbio/bcbio-nextgen | bcbio/log/__init__.py | setup_local_logging | def setup_local_logging(config=None, parallel=None):
"""Setup logging for a local context, directing messages to appropriate base loggers.
Handles local, multiprocessing and distributed setup, connecting
to handlers created by the base logger.
"""
if config is None: config = {}
if parallel is None: parallel = {}
parallel_type = parallel.get("type", "local")
cores = parallel.get("cores", 1)
wrapper = parallel.get("wrapper", None)
if parallel_type == "ipython":
from bcbio.log import logbook_zmqpush
handler = logbook_zmqpush.ZeroMQPushHandler(parallel["log_queue"])
elif cores > 1:
handler = logbook.queues.MultiProcessingHandler(mpq)
else:
handler = _create_log_handler(config, direct_hostname=wrapper is not None, write_toterm=wrapper is None)
handler.push_thread()
return handler | python | def setup_local_logging(config=None, parallel=None):
if config is None: config = {}
if parallel is None: parallel = {}
parallel_type = parallel.get("type", "local")
cores = parallel.get("cores", 1)
wrapper = parallel.get("wrapper", None)
if parallel_type == "ipython":
from bcbio.log import logbook_zmqpush
handler = logbook_zmqpush.ZeroMQPushHandler(parallel["log_queue"])
elif cores > 1:
handler = logbook.queues.MultiProcessingHandler(mpq)
else:
handler = _create_log_handler(config, direct_hostname=wrapper is not None, write_toterm=wrapper is None)
handler.push_thread()
return handler | [
"def",
"setup_local_logging",
"(",
"config",
"=",
"None",
",",
"parallel",
"=",
"None",
")",
":",
"if",
"config",
"is",
"None",
":",
"config",
"=",
"{",
"}",
"if",
"parallel",
"is",
"None",
":",
"parallel",
"=",
"{",
"}",
"parallel_type",
"=",
"paralle... | Setup logging for a local context, directing messages to appropriate base loggers.
Handles local, multiprocessing and distributed setup, connecting
to handlers created by the base logger. | [
"Setup",
"logging",
"for",
"a",
"local",
"context",
"directing",
"messages",
"to",
"appropriate",
"base",
"loggers",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/log/__init__.py#L132-L151 |
237,009 | bcbio/bcbio-nextgen | bcbio/log/__init__.py | setup_script_logging | def setup_script_logging():
"""
Use this logger for standalone scripts, or script-like subcommands,
such as bcbio_prepare_samples and bcbio_nextgen.py -w template.
"""
handlers = [logbook.NullHandler()]
format_str = ("[{record.time:%Y-%m-%dT%H:%MZ}] "
"{record.level_name}: {record.message}")
handler = logbook.StreamHandler(sys.stderr, format_string=format_str,
level="DEBUG")
handler.push_thread()
return handler | python | def setup_script_logging():
handlers = [logbook.NullHandler()]
format_str = ("[{record.time:%Y-%m-%dT%H:%MZ}] "
"{record.level_name}: {record.message}")
handler = logbook.StreamHandler(sys.stderr, format_string=format_str,
level="DEBUG")
handler.push_thread()
return handler | [
"def",
"setup_script_logging",
"(",
")",
":",
"handlers",
"=",
"[",
"logbook",
".",
"NullHandler",
"(",
")",
"]",
"format_str",
"=",
"(",
"\"[{record.time:%Y-%m-%dT%H:%MZ}] \"",
"\"{record.level_name}: {record.message}\"",
")",
"handler",
"=",
"logbook",
".",
"StreamH... | Use this logger for standalone scripts, or script-like subcommands,
such as bcbio_prepare_samples and bcbio_nextgen.py -w template. | [
"Use",
"this",
"logger",
"for",
"standalone",
"scripts",
"or",
"script",
"-",
"like",
"subcommands",
"such",
"as",
"bcbio_prepare_samples",
"and",
"bcbio_nextgen",
".",
"py",
"-",
"w",
"template",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/log/__init__.py#L153-L165 |
237,010 | bcbio/bcbio-nextgen | scripts/cwltool2wdl.py | _validate | def _validate(wdl_file):
"""Run validation on the generated WDL output using wdltool.
"""
start_dir = os.getcwd()
os.chdir(os.path.dirname(wdl_file))
print("Validating", wdl_file)
subprocess.check_call(["wdltool", "validate", wdl_file])
os.chdir(start_dir) | python | def _validate(wdl_file):
start_dir = os.getcwd()
os.chdir(os.path.dirname(wdl_file))
print("Validating", wdl_file)
subprocess.check_call(["wdltool", "validate", wdl_file])
os.chdir(start_dir) | [
"def",
"_validate",
"(",
"wdl_file",
")",
":",
"start_dir",
"=",
"os",
".",
"getcwd",
"(",
")",
"os",
".",
"chdir",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"wdl_file",
")",
")",
"print",
"(",
"\"Validating\"",
",",
"wdl_file",
")",
"subprocess",
... | Run validation on the generated WDL output using wdltool. | [
"Run",
"validation",
"on",
"the",
"generated",
"WDL",
"output",
"using",
"wdltool",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/scripts/cwltool2wdl.py#L53-L60 |
237,011 | bcbio/bcbio-nextgen | scripts/cwltool2wdl.py | _wf_to_dict | def _wf_to_dict(wf, records):
"""Parse a workflow into cwl2wdl style dictionaries for base and sub-workflows.
"""
inputs, outputs, records = _get_wf_inout(wf, records)
out = {"name": _id_to_name(_clean_id(wf.tool["id"])), "inputs": inputs,
"outputs": outputs, "steps": [], "subworkflows": [],
"requirements": []}
for step in wf.steps:
is_subworkflow = isinstance(step.embedded_tool, cwltool.workflow.Workflow)
inputs, outputs, remapped, prescatter = _get_step_inout(step)
inputs, scatter = _organize_step_scatter(step, inputs, remapped)
if is_subworkflow:
wf_def, records = _wf_to_dict(step.embedded_tool, records)
out["subworkflows"].append({"id": "%s.%s" % (wf_def["name"], wf_def["name"]), "definition": wf_def,
"inputs": inputs, "outputs": outputs, "scatter": scatter,
"prescatter": prescatter})
else:
task_def, records = _tool_to_dict(step.embedded_tool, records, remapped)
out["steps"].append({"task_id": task_def["name"], "task_definition": task_def,
"inputs": inputs, "outputs": outputs, "scatter": scatter,
"prescatter": prescatter})
return out, records | python | def _wf_to_dict(wf, records):
inputs, outputs, records = _get_wf_inout(wf, records)
out = {"name": _id_to_name(_clean_id(wf.tool["id"])), "inputs": inputs,
"outputs": outputs, "steps": [], "subworkflows": [],
"requirements": []}
for step in wf.steps:
is_subworkflow = isinstance(step.embedded_tool, cwltool.workflow.Workflow)
inputs, outputs, remapped, prescatter = _get_step_inout(step)
inputs, scatter = _organize_step_scatter(step, inputs, remapped)
if is_subworkflow:
wf_def, records = _wf_to_dict(step.embedded_tool, records)
out["subworkflows"].append({"id": "%s.%s" % (wf_def["name"], wf_def["name"]), "definition": wf_def,
"inputs": inputs, "outputs": outputs, "scatter": scatter,
"prescatter": prescatter})
else:
task_def, records = _tool_to_dict(step.embedded_tool, records, remapped)
out["steps"].append({"task_id": task_def["name"], "task_definition": task_def,
"inputs": inputs, "outputs": outputs, "scatter": scatter,
"prescatter": prescatter})
return out, records | [
"def",
"_wf_to_dict",
"(",
"wf",
",",
"records",
")",
":",
"inputs",
",",
"outputs",
",",
"records",
"=",
"_get_wf_inout",
"(",
"wf",
",",
"records",
")",
"out",
"=",
"{",
"\"name\"",
":",
"_id_to_name",
"(",
"_clean_id",
"(",
"wf",
".",
"tool",
"[",
... | Parse a workflow into cwl2wdl style dictionaries for base and sub-workflows. | [
"Parse",
"a",
"workflow",
"into",
"cwl2wdl",
"style",
"dictionaries",
"for",
"base",
"and",
"sub",
"-",
"workflows",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/scripts/cwltool2wdl.py#L62-L83 |
237,012 | bcbio/bcbio-nextgen | scripts/cwltool2wdl.py | _organize_step_scatter | def _organize_step_scatter(step, inputs, remapped):
"""Add scattering information from inputs, remapping input variables.
"""
def extract_scatter_id(inp):
_, ns_var = inp.split("#")
_, var = ns_var.split("/")
return var
scatter_local = {}
if "scatter" in step.tool:
assert step.tool["scatterMethod"] == "dotproduct", \
"Only support dotproduct scattering in conversion to WDL"
inp_val = collections.OrderedDict()
for x in inputs:
inp_val[x["id"]] = x["value"]
for scatter_key in [extract_scatter_id(x) for x in step.tool["scatter"]]:
scatter_key = remapped.get(scatter_key) or scatter_key
val = inp_val[scatter_key]
if len(val.split(".")) in [1, 2]:
base_key = val
attr = None
elif len(val.split(".")) == 3:
orig_location, record, attr = val.split(".")
base_key = "%s.%s" % (orig_location, record)
else:
raise ValueError("Unexpected scatter input: %s" % val)
local_ref = base_key.split(".")[-1] + "_local"
scatter_local[base_key] = local_ref
if attr:
local_ref += ".%s" % attr
inp_val[scatter_key] = local_ref
inputs = [{"id": iid, "value": ival} for iid, ival in inp_val.items()]
return inputs, [(v, k) for k, v in scatter_local.items()] | python | def _organize_step_scatter(step, inputs, remapped):
def extract_scatter_id(inp):
_, ns_var = inp.split("#")
_, var = ns_var.split("/")
return var
scatter_local = {}
if "scatter" in step.tool:
assert step.tool["scatterMethod"] == "dotproduct", \
"Only support dotproduct scattering in conversion to WDL"
inp_val = collections.OrderedDict()
for x in inputs:
inp_val[x["id"]] = x["value"]
for scatter_key in [extract_scatter_id(x) for x in step.tool["scatter"]]:
scatter_key = remapped.get(scatter_key) or scatter_key
val = inp_val[scatter_key]
if len(val.split(".")) in [1, 2]:
base_key = val
attr = None
elif len(val.split(".")) == 3:
orig_location, record, attr = val.split(".")
base_key = "%s.%s" % (orig_location, record)
else:
raise ValueError("Unexpected scatter input: %s" % val)
local_ref = base_key.split(".")[-1] + "_local"
scatter_local[base_key] = local_ref
if attr:
local_ref += ".%s" % attr
inp_val[scatter_key] = local_ref
inputs = [{"id": iid, "value": ival} for iid, ival in inp_val.items()]
return inputs, [(v, k) for k, v in scatter_local.items()] | [
"def",
"_organize_step_scatter",
"(",
"step",
",",
"inputs",
",",
"remapped",
")",
":",
"def",
"extract_scatter_id",
"(",
"inp",
")",
":",
"_",
",",
"ns_var",
"=",
"inp",
".",
"split",
"(",
"\"#\"",
")",
"_",
",",
"var",
"=",
"ns_var",
".",
"split",
... | Add scattering information from inputs, remapping input variables. | [
"Add",
"scattering",
"information",
"from",
"inputs",
"remapping",
"input",
"variables",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/scripts/cwltool2wdl.py#L133-L164 |
237,013 | bcbio/bcbio-nextgen | scripts/cwltool2wdl.py | _variable_type_to_read_fn | def _variable_type_to_read_fn(vartype, records):
"""Convert variant types into corresponding WDL standard library functions.
"""
fn_map = {"String": "read_string", "Array[String]": "read_lines",
"Array[Array[String]]": "read_tsv",
"Object": "read_object", "Array[Object]": "read_objects",
"Array[Array[Object]]": "read_objects",
"Int": "read_int", "Float": "read_float"}
for rec_name in records.keys():
fn_map["%s" % rec_name] = "read_struct"
fn_map["Array[%s]" % rec_name] = "read_struct"
fn_map["Array[Array[%s]]" % rec_name] = "read_struct"
# Read in Files as Strings
vartype = vartype.replace("File", "String")
# Can't read arrays of Ints/Floats
vartype = vartype.replace("Array[Int]", "Array[String]")
vartype = vartype.replace("Array[Float]", "Array[String]")
return fn_map[vartype] | python | def _variable_type_to_read_fn(vartype, records):
fn_map = {"String": "read_string", "Array[String]": "read_lines",
"Array[Array[String]]": "read_tsv",
"Object": "read_object", "Array[Object]": "read_objects",
"Array[Array[Object]]": "read_objects",
"Int": "read_int", "Float": "read_float"}
for rec_name in records.keys():
fn_map["%s" % rec_name] = "read_struct"
fn_map["Array[%s]" % rec_name] = "read_struct"
fn_map["Array[Array[%s]]" % rec_name] = "read_struct"
# Read in Files as Strings
vartype = vartype.replace("File", "String")
# Can't read arrays of Ints/Floats
vartype = vartype.replace("Array[Int]", "Array[String]")
vartype = vartype.replace("Array[Float]", "Array[String]")
return fn_map[vartype] | [
"def",
"_variable_type_to_read_fn",
"(",
"vartype",
",",
"records",
")",
":",
"fn_map",
"=",
"{",
"\"String\"",
":",
"\"read_string\"",
",",
"\"Array[String]\"",
":",
"\"read_lines\"",
",",
"\"Array[Array[String]]\"",
":",
"\"read_tsv\"",
",",
"\"Object\"",
":",
"\"... | Convert variant types into corresponding WDL standard library functions. | [
"Convert",
"variant",
"types",
"into",
"corresponding",
"WDL",
"standard",
"library",
"functions",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/scripts/cwltool2wdl.py#L216-L233 |
237,014 | bcbio/bcbio-nextgen | scripts/cwltool2wdl.py | _requirements_to_dict | def _requirements_to_dict(rs):
"""Convert supported requirements into dictionary for output.
"""
out = []
added = set([])
for r in rs:
if r["class"] == "DockerRequirement" and "docker" not in added:
added.add("docker")
out.append({"requirement_type": "docker", "value": r["dockerImageId"]})
elif r["class"] == "ResourceRequirement":
if "coresMin" in r and "cpu" not in added:
added.add("cpu")
out.append({"requirement_type": "cpu", "value": r["coresMin"]})
if "ramMin" in r and "memory" not in added:
added.add("memory")
out.append({"requirement_type": "memory", "value": "%s MB" % r["ramMin"]})
if "tmpdirMin" in r and "disks" not in added:
added.add("disks")
out.append({"requirement_type": "disks", "value": "local-disk %s HDD" % r["tmpdirMin"]})
return out | python | def _requirements_to_dict(rs):
out = []
added = set([])
for r in rs:
if r["class"] == "DockerRequirement" and "docker" not in added:
added.add("docker")
out.append({"requirement_type": "docker", "value": r["dockerImageId"]})
elif r["class"] == "ResourceRequirement":
if "coresMin" in r and "cpu" not in added:
added.add("cpu")
out.append({"requirement_type": "cpu", "value": r["coresMin"]})
if "ramMin" in r and "memory" not in added:
added.add("memory")
out.append({"requirement_type": "memory", "value": "%s MB" % r["ramMin"]})
if "tmpdirMin" in r and "disks" not in added:
added.add("disks")
out.append({"requirement_type": "disks", "value": "local-disk %s HDD" % r["tmpdirMin"]})
return out | [
"def",
"_requirements_to_dict",
"(",
"rs",
")",
":",
"out",
"=",
"[",
"]",
"added",
"=",
"set",
"(",
"[",
"]",
")",
"for",
"r",
"in",
"rs",
":",
"if",
"r",
"[",
"\"class\"",
"]",
"==",
"\"DockerRequirement\"",
"and",
"\"docker\"",
"not",
"in",
"added... | Convert supported requirements into dictionary for output. | [
"Convert",
"supported",
"requirements",
"into",
"dictionary",
"for",
"output",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/scripts/cwltool2wdl.py#L306-L325 |
237,015 | bcbio/bcbio-nextgen | bcbio/structural/purple.py | _get_jvm_opts | def _get_jvm_opts(out_file, data):
"""Retrieve Java options, adjusting memory for available cores.
"""
resources = config_utils.get_resources("purple", data["config"])
jvm_opts = resources.get("jvm_opts", ["-Xms750m", "-Xmx3500m"])
jvm_opts = config_utils.adjust_opts(jvm_opts, {"algorithm": {"memory_adjust":
{"direction": "increase",
"maximum": "30000M",
"magnitude": dd.get_cores(data)}}})
jvm_opts += broad.get_default_jvm_opts(os.path.dirname(out_file))
return jvm_opts | python | def _get_jvm_opts(out_file, data):
resources = config_utils.get_resources("purple", data["config"])
jvm_opts = resources.get("jvm_opts", ["-Xms750m", "-Xmx3500m"])
jvm_opts = config_utils.adjust_opts(jvm_opts, {"algorithm": {"memory_adjust":
{"direction": "increase",
"maximum": "30000M",
"magnitude": dd.get_cores(data)}}})
jvm_opts += broad.get_default_jvm_opts(os.path.dirname(out_file))
return jvm_opts | [
"def",
"_get_jvm_opts",
"(",
"out_file",
",",
"data",
")",
":",
"resources",
"=",
"config_utils",
".",
"get_resources",
"(",
"\"purple\"",
",",
"data",
"[",
"\"config\"",
"]",
")",
"jvm_opts",
"=",
"resources",
".",
"get",
"(",
"\"jvm_opts\"",
",",
"[",
"\... | Retrieve Java options, adjusting memory for available cores. | [
"Retrieve",
"Java",
"options",
"adjusting",
"memory",
"for",
"available",
"cores",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/purple.py#L43-L53 |
237,016 | bcbio/bcbio-nextgen | bcbio/structural/purple.py | _counts_to_amber | def _counts_to_amber(t_vals, n_vals):
"""Converts a line of CollectAllelicCounts into AMBER line.
"""
t_depth = int(t_vals["REF_COUNT"]) + int(t_vals["ALT_COUNT"])
n_depth = int(n_vals["REF_COUNT"]) + int(n_vals["ALT_COUNT"])
if n_depth > 0 and t_depth > 0:
t_baf = float(t_vals["ALT_COUNT"]) / float(t_depth)
n_baf = float(n_vals["ALT_COUNT"]) / float(n_depth)
return [t_vals["CONTIG"], t_vals["POSITION"], t_baf, _normalize_baf(t_baf), t_depth,
n_baf, _normalize_baf(n_baf), n_depth] | python | def _counts_to_amber(t_vals, n_vals):
t_depth = int(t_vals["REF_COUNT"]) + int(t_vals["ALT_COUNT"])
n_depth = int(n_vals["REF_COUNT"]) + int(n_vals["ALT_COUNT"])
if n_depth > 0 and t_depth > 0:
t_baf = float(t_vals["ALT_COUNT"]) / float(t_depth)
n_baf = float(n_vals["ALT_COUNT"]) / float(n_depth)
return [t_vals["CONTIG"], t_vals["POSITION"], t_baf, _normalize_baf(t_baf), t_depth,
n_baf, _normalize_baf(n_baf), n_depth] | [
"def",
"_counts_to_amber",
"(",
"t_vals",
",",
"n_vals",
")",
":",
"t_depth",
"=",
"int",
"(",
"t_vals",
"[",
"\"REF_COUNT\"",
"]",
")",
"+",
"int",
"(",
"t_vals",
"[",
"\"ALT_COUNT\"",
"]",
")",
"n_depth",
"=",
"int",
"(",
"n_vals",
"[",
"\"REF_COUNT\""... | Converts a line of CollectAllelicCounts into AMBER line. | [
"Converts",
"a",
"line",
"of",
"CollectAllelicCounts",
"into",
"AMBER",
"line",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/purple.py#L113-L122 |
237,017 | bcbio/bcbio-nextgen | bcbio/structural/purple.py | _count_files_to_amber | def _count_files_to_amber(tumor_counts, normal_counts, work_dir, data):
"""Converts tumor and normal counts from GATK CollectAllelicCounts into Amber format.
"""
amber_dir = utils.safe_makedir(os.path.join(work_dir, "amber"))
out_file = os.path.join(amber_dir, "%s.amber.baf" % dd.get_sample_name(data))
if not utils.file_uptodate(out_file, tumor_counts):
with file_transaction(data, out_file) as tx_out_file:
with open(tumor_counts) as tumor_handle:
with open(normal_counts) as normal_handle:
with open(tx_out_file, "w") as out_handle:
writer = csv.writer(out_handle, delimiter="\t")
writer.writerow(["Chromosome", "Position", "TumorBAF", "TumorModifiedBAF", "TumorDepth",
"NormalBAF", "NormalModifiedBAF", "NormalDepth"])
header = None
for t, n in zip(tumor_handle, normal_handle):
if header is None and t.startswith("CONTIG"):
header = t.strip().split()
elif header is not None:
t_vals = dict(zip(header, t.strip().split()))
n_vals = dict(zip(header, n.strip().split()))
amber_line = _counts_to_amber(t_vals, n_vals)
if amber_line:
writer.writerow(amber_line)
return out_file | python | def _count_files_to_amber(tumor_counts, normal_counts, work_dir, data):
amber_dir = utils.safe_makedir(os.path.join(work_dir, "amber"))
out_file = os.path.join(amber_dir, "%s.amber.baf" % dd.get_sample_name(data))
if not utils.file_uptodate(out_file, tumor_counts):
with file_transaction(data, out_file) as tx_out_file:
with open(tumor_counts) as tumor_handle:
with open(normal_counts) as normal_handle:
with open(tx_out_file, "w") as out_handle:
writer = csv.writer(out_handle, delimiter="\t")
writer.writerow(["Chromosome", "Position", "TumorBAF", "TumorModifiedBAF", "TumorDepth",
"NormalBAF", "NormalModifiedBAF", "NormalDepth"])
header = None
for t, n in zip(tumor_handle, normal_handle):
if header is None and t.startswith("CONTIG"):
header = t.strip().split()
elif header is not None:
t_vals = dict(zip(header, t.strip().split()))
n_vals = dict(zip(header, n.strip().split()))
amber_line = _counts_to_amber(t_vals, n_vals)
if amber_line:
writer.writerow(amber_line)
return out_file | [
"def",
"_count_files_to_amber",
"(",
"tumor_counts",
",",
"normal_counts",
",",
"work_dir",
",",
"data",
")",
":",
"amber_dir",
"=",
"utils",
".",
"safe_makedir",
"(",
"os",
".",
"path",
".",
"join",
"(",
"work_dir",
",",
"\"amber\"",
")",
")",
"out_file",
... | Converts tumor and normal counts from GATK CollectAllelicCounts into Amber format. | [
"Converts",
"tumor",
"and",
"normal",
"counts",
"from",
"GATK",
"CollectAllelicCounts",
"into",
"Amber",
"format",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/purple.py#L124-L148 |
237,018 | bcbio/bcbio-nextgen | bcbio/structural/purple.py | _amber_het_file | def _amber_het_file(method, vrn_files, work_dir, paired):
"""Create file of BAFs in normal heterozygous positions compatible with AMBER.
Two available methods:
- pon -- Use panel of normals with likely heterozygous sites.
- variants -- Use pre-existing variant calls, filtered to likely heterozygotes.
https://github.com/hartwigmedical/hmftools/tree/master/amber
https://github.com/hartwigmedical/hmftools/blob/637e3db1a1a995f4daefe2d0a1511a5bdadbeb05/hmf-common/src/test/resources/amber/new.amber.baf
"""
assert vrn_files, "Did not find compatible variant calling files for PURPLE inputs"
from bcbio.heterogeneity import bubbletree
if method == "variants":
amber_dir = utils.safe_makedir(os.path.join(work_dir, "amber"))
out_file = os.path.join(amber_dir, "%s.amber.baf" % dd.get_sample_name(paired.tumor_data))
prep_file = bubbletree.prep_vrn_file(vrn_files[0]["vrn_file"], vrn_files[0]["variantcaller"],
work_dir, paired, AmberWriter)
utils.symlink_plus(prep_file, out_file)
pcf_file = out_file + ".pcf"
if not utils.file_exists(pcf_file):
with file_transaction(paired.tumor_data, pcf_file) as tx_out_file:
r_file = os.path.join(os.path.dirname(tx_out_file), "bafSegmentation.R")
with open(r_file, "w") as out_handle:
out_handle.write(_amber_seg_script)
cmd = "%s && %s --no-environ %s %s %s" % (utils.get_R_exports(), utils.Rscript_cmd(), r_file,
out_file, pcf_file)
do.run(cmd, "PURPLE: AMBER baf segmentation")
else:
assert method == "pon"
out_file = _run_amber(paired, work_dir)
return out_file | python | def _amber_het_file(method, vrn_files, work_dir, paired):
assert vrn_files, "Did not find compatible variant calling files for PURPLE inputs"
from bcbio.heterogeneity import bubbletree
if method == "variants":
amber_dir = utils.safe_makedir(os.path.join(work_dir, "amber"))
out_file = os.path.join(amber_dir, "%s.amber.baf" % dd.get_sample_name(paired.tumor_data))
prep_file = bubbletree.prep_vrn_file(vrn_files[0]["vrn_file"], vrn_files[0]["variantcaller"],
work_dir, paired, AmberWriter)
utils.symlink_plus(prep_file, out_file)
pcf_file = out_file + ".pcf"
if not utils.file_exists(pcf_file):
with file_transaction(paired.tumor_data, pcf_file) as tx_out_file:
r_file = os.path.join(os.path.dirname(tx_out_file), "bafSegmentation.R")
with open(r_file, "w") as out_handle:
out_handle.write(_amber_seg_script)
cmd = "%s && %s --no-environ %s %s %s" % (utils.get_R_exports(), utils.Rscript_cmd(), r_file,
out_file, pcf_file)
do.run(cmd, "PURPLE: AMBER baf segmentation")
else:
assert method == "pon"
out_file = _run_amber(paired, work_dir)
return out_file | [
"def",
"_amber_het_file",
"(",
"method",
",",
"vrn_files",
",",
"work_dir",
",",
"paired",
")",
":",
"assert",
"vrn_files",
",",
"\"Did not find compatible variant calling files for PURPLE inputs\"",
"from",
"bcbio",
".",
"heterogeneity",
"import",
"bubbletree",
"if",
"... | Create file of BAFs in normal heterozygous positions compatible with AMBER.
Two available methods:
- pon -- Use panel of normals with likely heterozygous sites.
- variants -- Use pre-existing variant calls, filtered to likely heterozygotes.
https://github.com/hartwigmedical/hmftools/tree/master/amber
https://github.com/hartwigmedical/hmftools/blob/637e3db1a1a995f4daefe2d0a1511a5bdadbeb05/hmf-common/src/test/resources/amber/new.amber.baf | [
"Create",
"file",
"of",
"BAFs",
"in",
"normal",
"heterozygous",
"positions",
"compatible",
"with",
"AMBER",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/purple.py#L166-L197 |
237,019 | bcbio/bcbio-nextgen | bcbio/structural/purple.py | _run_cobalt | def _run_cobalt(paired, work_dir):
"""Run Cobalt for counting read depth across genomic windows.
PURPLE requires even 1000bp windows so use integrated counting solution
directly rather than converting from CNVkit calculations. If this approach
is useful should be moved upstream to be available to other tools as
an input comparison.
https://github.com/hartwigmedical/hmftools/tree/master/count-bam-lines
"""
cobalt_dir = utils.safe_makedir(os.path.join(work_dir, "cobalt"))
out_file = os.path.join(cobalt_dir, "%s.cobalt" % dd.get_sample_name(paired.tumor_data))
if not utils.file_exists(out_file):
with file_transaction(paired.tumor_data, out_file) as tx_out_file:
cmd = ["COBALT"] + _get_jvm_opts(tx_out_file, paired.tumor_data) + \
["-reference", paired.normal_name, "-reference_bam", paired.normal_bam,
"-tumor", paired.tumor_name, "-tumor_bam", paired.tumor_bam,
"-threads", dd.get_num_cores(paired.tumor_data),
"-output_dir", os.path.dirname(tx_out_file),
"-gc_profile", dd.get_variation_resources(paired.tumor_data)["gc_profile"]]
cmd = "%s && %s" % (utils.get_R_exports(), " ".join([str(x) for x in cmd]))
do.run(cmd, "PURPLE: COBALT read depth normalization")
for f in os.listdir(os.path.dirname(tx_out_file)):
if f != os.path.basename(tx_out_file):
shutil.move(os.path.join(os.path.dirname(tx_out_file), f),
os.path.join(cobalt_dir, f))
return out_file | python | def _run_cobalt(paired, work_dir):
cobalt_dir = utils.safe_makedir(os.path.join(work_dir, "cobalt"))
out_file = os.path.join(cobalt_dir, "%s.cobalt" % dd.get_sample_name(paired.tumor_data))
if not utils.file_exists(out_file):
with file_transaction(paired.tumor_data, out_file) as tx_out_file:
cmd = ["COBALT"] + _get_jvm_opts(tx_out_file, paired.tumor_data) + \
["-reference", paired.normal_name, "-reference_bam", paired.normal_bam,
"-tumor", paired.tumor_name, "-tumor_bam", paired.tumor_bam,
"-threads", dd.get_num_cores(paired.tumor_data),
"-output_dir", os.path.dirname(tx_out_file),
"-gc_profile", dd.get_variation_resources(paired.tumor_data)["gc_profile"]]
cmd = "%s && %s" % (utils.get_R_exports(), " ".join([str(x) for x in cmd]))
do.run(cmd, "PURPLE: COBALT read depth normalization")
for f in os.listdir(os.path.dirname(tx_out_file)):
if f != os.path.basename(tx_out_file):
shutil.move(os.path.join(os.path.dirname(tx_out_file), f),
os.path.join(cobalt_dir, f))
return out_file | [
"def",
"_run_cobalt",
"(",
"paired",
",",
"work_dir",
")",
":",
"cobalt_dir",
"=",
"utils",
".",
"safe_makedir",
"(",
"os",
".",
"path",
".",
"join",
"(",
"work_dir",
",",
"\"cobalt\"",
")",
")",
"out_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
... | Run Cobalt for counting read depth across genomic windows.
PURPLE requires even 1000bp windows so use integrated counting solution
directly rather than converting from CNVkit calculations. If this approach
is useful should be moved upstream to be available to other tools as
an input comparison.
https://github.com/hartwigmedical/hmftools/tree/master/count-bam-lines | [
"Run",
"Cobalt",
"for",
"counting",
"read",
"depth",
"across",
"genomic",
"windows",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/purple.py#L259-L285 |
237,020 | bcbio/bcbio-nextgen | bcbio/structural/purple.py | _cobalt_ratio_file | def _cobalt_ratio_file(paired, work_dir):
"""Convert CNVkit binning counts into cobalt ratio output.
This contains read counts plus normalization for GC, from section 7.2
"Determine read depth ratios for tumor and reference genomes"
https://www.biorxiv.org/content/biorxiv/early/2018/09/20/415133.full.pdf
Since CNVkit cnr files already have GC bias correction, we re-center
the existing log2 ratios to be around 1, rather than zero, which matches
the cobalt expectations.
XXX This doesn't appear to be a worthwhile direction since PURPLE requires
1000bp even binning. We'll leave this here as a starting point for future
work but work on using cobalt directly.
"""
cobalt_dir = utils.safe_makedir(os.path.join(work_dir, "cobalt"))
out_file = os.path.join(cobalt_dir, "%s.cobalt" % dd.get_sample_name(paired.tumor_data))
if not utils.file_exists(out_file):
cnr_file = tz.get_in(["depth", "bins", "normalized"], paired.tumor_data)
with file_transaction(paired.tumor_data, out_file) as tx_out_file:
with open(tx_out_file, "w") as out_handle:
writer = csv.writer(out_handle, delimiter="\t")
writer.writerow(["Chromosome", "Position", "ReferenceReadCount", "TumorReadCount",
"ReferenceGCRatio", "TumorGCRatio", "ReferenceGCDiploidRatio"])
raise NotImplementedError
return out_file | python | def _cobalt_ratio_file(paired, work_dir):
cobalt_dir = utils.safe_makedir(os.path.join(work_dir, "cobalt"))
out_file = os.path.join(cobalt_dir, "%s.cobalt" % dd.get_sample_name(paired.tumor_data))
if not utils.file_exists(out_file):
cnr_file = tz.get_in(["depth", "bins", "normalized"], paired.tumor_data)
with file_transaction(paired.tumor_data, out_file) as tx_out_file:
with open(tx_out_file, "w") as out_handle:
writer = csv.writer(out_handle, delimiter="\t")
writer.writerow(["Chromosome", "Position", "ReferenceReadCount", "TumorReadCount",
"ReferenceGCRatio", "TumorGCRatio", "ReferenceGCDiploidRatio"])
raise NotImplementedError
return out_file | [
"def",
"_cobalt_ratio_file",
"(",
"paired",
",",
"work_dir",
")",
":",
"cobalt_dir",
"=",
"utils",
".",
"safe_makedir",
"(",
"os",
".",
"path",
".",
"join",
"(",
"work_dir",
",",
"\"cobalt\"",
")",
")",
"out_file",
"=",
"os",
".",
"path",
".",
"join",
... | Convert CNVkit binning counts into cobalt ratio output.
This contains read counts plus normalization for GC, from section 7.2
"Determine read depth ratios for tumor and reference genomes"
https://www.biorxiv.org/content/biorxiv/early/2018/09/20/415133.full.pdf
Since CNVkit cnr files already have GC bias correction, we re-center
the existing log2 ratios to be around 1, rather than zero, which matches
the cobalt expectations.
XXX This doesn't appear to be a worthwhile direction since PURPLE requires
1000bp even binning. We'll leave this here as a starting point for future
work but work on using cobalt directly. | [
"Convert",
"CNVkit",
"binning",
"counts",
"into",
"cobalt",
"ratio",
"output",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/purple.py#L287-L313 |
237,021 | bcbio/bcbio-nextgen | bcbio/structural/purple.py | _export_to_vcf | def _export_to_vcf(cur):
"""Convert PURPLE custom output into VCF.
"""
if float(cur["copyNumber"]) > 2.0:
svtype = "DUP"
elif float(cur["copyNumber"]) < 2.0:
svtype = "DEL"
else:
svtype = None
if svtype:
info = ["END=%s" % cur["end"], "SVLEN=%s" % (int(cur["end"]) - int(cur["start"])),
"SVTYPE=%s" % svtype, "CN=%s" % cur["copyNumber"], "PROBES=%s" % cur["depthWindowCount"]]
return [cur["chromosome"], cur["start"], ".", "N", "<%s>" % svtype, ".", ".",
";".join(info), "GT", "0/1"] | python | def _export_to_vcf(cur):
if float(cur["copyNumber"]) > 2.0:
svtype = "DUP"
elif float(cur["copyNumber"]) < 2.0:
svtype = "DEL"
else:
svtype = None
if svtype:
info = ["END=%s" % cur["end"], "SVLEN=%s" % (int(cur["end"]) - int(cur["start"])),
"SVTYPE=%s" % svtype, "CN=%s" % cur["copyNumber"], "PROBES=%s" % cur["depthWindowCount"]]
return [cur["chromosome"], cur["start"], ".", "N", "<%s>" % svtype, ".", ".",
";".join(info), "GT", "0/1"] | [
"def",
"_export_to_vcf",
"(",
"cur",
")",
":",
"if",
"float",
"(",
"cur",
"[",
"\"copyNumber\"",
"]",
")",
">",
"2.0",
":",
"svtype",
"=",
"\"DUP\"",
"elif",
"float",
"(",
"cur",
"[",
"\"copyNumber\"",
"]",
")",
"<",
"2.0",
":",
"svtype",
"=",
"\"DEL... | Convert PURPLE custom output into VCF. | [
"Convert",
"PURPLE",
"custom",
"output",
"into",
"VCF",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/purple.py#L324-L337 |
237,022 | bcbio/bcbio-nextgen | bcbio/rnaseq/pizzly.py | make_pizzly_gtf | def make_pizzly_gtf(gtf_file, out_file, data):
"""
pizzly needs the GTF to be in gene -> transcript -> exon order for each
gene. it also wants the gene biotype set as the source
"""
if file_exists(out_file):
return out_file
db = gtf.get_gtf_db(gtf_file)
with file_transaction(data, out_file) as tx_out_file:
with open(tx_out_file, "w") as out_handle:
for gene in db.features_of_type("gene"):
children = [x for x in db.children(id=gene)]
for child in children:
if child.attributes.get("gene_biotype", None):
gene_biotype = child.attributes.get("gene_biotype")
gene.attributes['gene_biotype'] = gene_biotype
gene.source = gene_biotype[0]
print(gene, file=out_handle)
for child in children:
child.source = gene_biotype[0]
# gffread produces a version-less FASTA file
child.attributes.pop("transcript_version", None)
print(child, file=out_handle)
return out_file | python | def make_pizzly_gtf(gtf_file, out_file, data):
if file_exists(out_file):
return out_file
db = gtf.get_gtf_db(gtf_file)
with file_transaction(data, out_file) as tx_out_file:
with open(tx_out_file, "w") as out_handle:
for gene in db.features_of_type("gene"):
children = [x for x in db.children(id=gene)]
for child in children:
if child.attributes.get("gene_biotype", None):
gene_biotype = child.attributes.get("gene_biotype")
gene.attributes['gene_biotype'] = gene_biotype
gene.source = gene_biotype[0]
print(gene, file=out_handle)
for child in children:
child.source = gene_biotype[0]
# gffread produces a version-less FASTA file
child.attributes.pop("transcript_version", None)
print(child, file=out_handle)
return out_file | [
"def",
"make_pizzly_gtf",
"(",
"gtf_file",
",",
"out_file",
",",
"data",
")",
":",
"if",
"file_exists",
"(",
"out_file",
")",
":",
"return",
"out_file",
"db",
"=",
"gtf",
".",
"get_gtf_db",
"(",
"gtf_file",
")",
"with",
"file_transaction",
"(",
"data",
","... | pizzly needs the GTF to be in gene -> transcript -> exon order for each
gene. it also wants the gene biotype set as the source | [
"pizzly",
"needs",
"the",
"GTF",
"to",
"be",
"in",
"gene",
"-",
">",
"transcript",
"-",
">",
"exon",
"order",
"for",
"each",
"gene",
".",
"it",
"also",
"wants",
"the",
"gene",
"biotype",
"set",
"as",
"the",
"source"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/rnaseq/pizzly.py#L82-L105 |
237,023 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | _validate_caller_vcf | def _validate_caller_vcf(call_vcf, truth_vcf, callable_bed, svcaller, work_dir, data):
"""Validate a caller VCF against truth within callable regions using SURVIVOR.
Combines files with SURIVOR merge and counts (https://github.com/fritzsedlazeck/SURVIVOR/)
"""
stats = _calculate_comparison_stats(truth_vcf)
call_vcf = _prep_vcf(call_vcf, callable_bed, dd.get_sample_name(data), dd.get_sample_name(data),
stats, work_dir, data)
truth_vcf = _prep_vcf(truth_vcf, callable_bed, vcfutils.get_samples(truth_vcf)[0],
"%s-truth" % dd.get_sample_name(data), stats, work_dir, data)
cmp_vcf = _survivor_merge(call_vcf, truth_vcf, stats, work_dir, data)
return _comparison_stats_from_merge(cmp_vcf, stats, svcaller, data) | python | def _validate_caller_vcf(call_vcf, truth_vcf, callable_bed, svcaller, work_dir, data):
stats = _calculate_comparison_stats(truth_vcf)
call_vcf = _prep_vcf(call_vcf, callable_bed, dd.get_sample_name(data), dd.get_sample_name(data),
stats, work_dir, data)
truth_vcf = _prep_vcf(truth_vcf, callable_bed, vcfutils.get_samples(truth_vcf)[0],
"%s-truth" % dd.get_sample_name(data), stats, work_dir, data)
cmp_vcf = _survivor_merge(call_vcf, truth_vcf, stats, work_dir, data)
return _comparison_stats_from_merge(cmp_vcf, stats, svcaller, data) | [
"def",
"_validate_caller_vcf",
"(",
"call_vcf",
",",
"truth_vcf",
",",
"callable_bed",
",",
"svcaller",
",",
"work_dir",
",",
"data",
")",
":",
"stats",
"=",
"_calculate_comparison_stats",
"(",
"truth_vcf",
")",
"call_vcf",
"=",
"_prep_vcf",
"(",
"call_vcf",
","... | Validate a caller VCF against truth within callable regions using SURVIVOR.
Combines files with SURIVOR merge and counts (https://github.com/fritzsedlazeck/SURVIVOR/) | [
"Validate",
"a",
"caller",
"VCF",
"against",
"truth",
"within",
"callable",
"regions",
"using",
"SURVIVOR",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L44-L55 |
237,024 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | _survivor_merge | def _survivor_merge(call_vcf, truth_vcf, stats, work_dir, data):
"""Perform a merge of two callsets using SURVIVOR,
"""
out_file = os.path.join(work_dir, "eval-merge.vcf")
if not utils.file_uptodate(out_file, call_vcf):
in_call_vcf = call_vcf.replace(".vcf.gz", ".vcf")
if not utils.file_exists(in_call_vcf):
with file_transaction(data, in_call_vcf) as tx_in_call_vcf:
do.run("gunzip -c {call_vcf} > {tx_in_call_vcf}".format(**locals()))
in_truth_vcf = truth_vcf.replace(".vcf.gz", ".vcf")
if not utils.file_exists(in_truth_vcf):
with file_transaction(data, in_truth_vcf) as tx_in_truth_vcf:
do.run("gunzip -c {truth_vcf} > {tx_in_truth_vcf}".format(**locals()))
in_list_file = os.path.join(work_dir, "eval-inputs.txt")
with open(in_list_file, "w") as out_handle:
out_handle.write("%s\n%s\n" % (in_call_vcf, in_truth_vcf))
with file_transaction(data, out_file) as tx_out_file:
cmd = ("SURVIVOR merge {in_list_file} {stats[merge_size]} 1 0 0 0 {stats[min_size]} {tx_out_file}")
do.run(cmd.format(**locals()), "Merge SV files for validation: %s" % dd.get_sample_name(data))
return out_file | python | def _survivor_merge(call_vcf, truth_vcf, stats, work_dir, data):
out_file = os.path.join(work_dir, "eval-merge.vcf")
if not utils.file_uptodate(out_file, call_vcf):
in_call_vcf = call_vcf.replace(".vcf.gz", ".vcf")
if not utils.file_exists(in_call_vcf):
with file_transaction(data, in_call_vcf) as tx_in_call_vcf:
do.run("gunzip -c {call_vcf} > {tx_in_call_vcf}".format(**locals()))
in_truth_vcf = truth_vcf.replace(".vcf.gz", ".vcf")
if not utils.file_exists(in_truth_vcf):
with file_transaction(data, in_truth_vcf) as tx_in_truth_vcf:
do.run("gunzip -c {truth_vcf} > {tx_in_truth_vcf}".format(**locals()))
in_list_file = os.path.join(work_dir, "eval-inputs.txt")
with open(in_list_file, "w") as out_handle:
out_handle.write("%s\n%s\n" % (in_call_vcf, in_truth_vcf))
with file_transaction(data, out_file) as tx_out_file:
cmd = ("SURVIVOR merge {in_list_file} {stats[merge_size]} 1 0 0 0 {stats[min_size]} {tx_out_file}")
do.run(cmd.format(**locals()), "Merge SV files for validation: %s" % dd.get_sample_name(data))
return out_file | [
"def",
"_survivor_merge",
"(",
"call_vcf",
",",
"truth_vcf",
",",
"stats",
",",
"work_dir",
",",
"data",
")",
":",
"out_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"work_dir",
",",
"\"eval-merge.vcf\"",
")",
"if",
"not",
"utils",
".",
"file_uptodate",... | Perform a merge of two callsets using SURVIVOR, | [
"Perform",
"a",
"merge",
"of",
"two",
"callsets",
"using",
"SURVIVOR"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L77-L96 |
237,025 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | _calculate_comparison_stats | def _calculate_comparison_stats(truth_vcf):
"""Identify calls to validate from the input truth VCF.
"""
# Avoid very small events for average calculations
min_stat_size = 50
min_median_size = 250
sizes = []
svtypes = set([])
with utils.open_gzipsafe(truth_vcf) as in_handle:
for call in (l.rstrip().split("\t") for l in in_handle if not l.startswith("#")):
stats = _summarize_call(call)
if stats["size"] > min_stat_size:
sizes.append(stats["size"])
svtypes.add(stats["svtype"])
pct10 = int(np.percentile(sizes, 10))
pct25 = int(np.percentile(sizes, 25))
pct50 = int(np.percentile(sizes, 50))
pct75 = int(np.percentile(sizes, 75))
ranges_detailed = [(int(min(sizes)), pct10), (pct10, pct25), (pct25, pct50),
(pct50, pct75), (pct75, max(sizes))]
ranges_split = [(int(min(sizes)), pct50), (pct50, max(sizes))]
return {"min_size": int(min(sizes) * 0.95), "max_size": int(max(sizes) + 1.05),
"svtypes": svtypes, "merge_size": int(np.percentile([x for x in sizes if x > min_median_size], 50)),
"ranges": []} | python | def _calculate_comparison_stats(truth_vcf):
# Avoid very small events for average calculations
min_stat_size = 50
min_median_size = 250
sizes = []
svtypes = set([])
with utils.open_gzipsafe(truth_vcf) as in_handle:
for call in (l.rstrip().split("\t") for l in in_handle if not l.startswith("#")):
stats = _summarize_call(call)
if stats["size"] > min_stat_size:
sizes.append(stats["size"])
svtypes.add(stats["svtype"])
pct10 = int(np.percentile(sizes, 10))
pct25 = int(np.percentile(sizes, 25))
pct50 = int(np.percentile(sizes, 50))
pct75 = int(np.percentile(sizes, 75))
ranges_detailed = [(int(min(sizes)), pct10), (pct10, pct25), (pct25, pct50),
(pct50, pct75), (pct75, max(sizes))]
ranges_split = [(int(min(sizes)), pct50), (pct50, max(sizes))]
return {"min_size": int(min(sizes) * 0.95), "max_size": int(max(sizes) + 1.05),
"svtypes": svtypes, "merge_size": int(np.percentile([x for x in sizes if x > min_median_size], 50)),
"ranges": []} | [
"def",
"_calculate_comparison_stats",
"(",
"truth_vcf",
")",
":",
"# Avoid very small events for average calculations",
"min_stat_size",
"=",
"50",
"min_median_size",
"=",
"250",
"sizes",
"=",
"[",
"]",
"svtypes",
"=",
"set",
"(",
"[",
"]",
")",
"with",
"utils",
"... | Identify calls to validate from the input truth VCF. | [
"Identify",
"calls",
"to",
"validate",
"from",
"the",
"input",
"truth",
"VCF",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L110-L133 |
237,026 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | _get_start_end | def _get_start_end(parts, index=7):
"""Retrieve start and end for a VCF record, skips BNDs without END coords
"""
start = parts[1]
end = [x.split("=")[-1] for x in parts[index].split(";") if x.startswith("END=")]
if end:
end = end[0]
return start, end
return None, None | python | def _get_start_end(parts, index=7):
start = parts[1]
end = [x.split("=")[-1] for x in parts[index].split(";") if x.startswith("END=")]
if end:
end = end[0]
return start, end
return None, None | [
"def",
"_get_start_end",
"(",
"parts",
",",
"index",
"=",
"7",
")",
":",
"start",
"=",
"parts",
"[",
"1",
"]",
"end",
"=",
"[",
"x",
".",
"split",
"(",
"\"=\"",
")",
"[",
"-",
"1",
"]",
"for",
"x",
"in",
"parts",
"[",
"index",
"]",
".",
"spli... | Retrieve start and end for a VCF record, skips BNDs without END coords | [
"Retrieve",
"start",
"and",
"end",
"for",
"a",
"VCF",
"record",
"skips",
"BNDs",
"without",
"END",
"coords"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L135-L143 |
237,027 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | _summarize_call | def _summarize_call(parts):
"""Provide summary metrics on size and svtype for a SV call.
"""
svtype = [x.split("=")[1] for x in parts[7].split(";") if x.startswith("SVTYPE=")]
svtype = svtype[0] if svtype else ""
start, end = _get_start_end(parts)
return {"svtype": svtype, "size": int(end) - int(start)} | python | def _summarize_call(parts):
svtype = [x.split("=")[1] for x in parts[7].split(";") if x.startswith("SVTYPE=")]
svtype = svtype[0] if svtype else ""
start, end = _get_start_end(parts)
return {"svtype": svtype, "size": int(end) - int(start)} | [
"def",
"_summarize_call",
"(",
"parts",
")",
":",
"svtype",
"=",
"[",
"x",
".",
"split",
"(",
"\"=\"",
")",
"[",
"1",
"]",
"for",
"x",
"in",
"parts",
"[",
"7",
"]",
".",
"split",
"(",
"\";\"",
")",
"if",
"x",
".",
"startswith",
"(",
"\"SVTYPE=\""... | Provide summary metrics on size and svtype for a SV call. | [
"Provide",
"summary",
"metrics",
"on",
"size",
"and",
"svtype",
"for",
"a",
"SV",
"call",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L145-L151 |
237,028 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | _prep_callable_bed | def _prep_callable_bed(in_file, work_dir, stats, data):
"""Sort and merge callable BED regions to prevent SV double counting
"""
out_file = os.path.join(work_dir, "%s-merge.bed.gz" % utils.splitext_plus(os.path.basename(in_file))[0])
gsort = config_utils.get_program("gsort", data)
if not utils.file_uptodate(out_file, in_file):
with file_transaction(data, out_file) as tx_out_file:
fai_file = ref.fasta_idx(dd.get_ref_file(data))
cmd = ("{gsort} {in_file} {fai_file} | bedtools merge -i - -d {stats[merge_size]} | "
"bgzip -c > {tx_out_file}")
do.run(cmd.format(**locals()), "Prepare SV callable BED regions")
return vcfutils.bgzip_and_index(out_file, data["config"]) | python | def _prep_callable_bed(in_file, work_dir, stats, data):
out_file = os.path.join(work_dir, "%s-merge.bed.gz" % utils.splitext_plus(os.path.basename(in_file))[0])
gsort = config_utils.get_program("gsort", data)
if not utils.file_uptodate(out_file, in_file):
with file_transaction(data, out_file) as tx_out_file:
fai_file = ref.fasta_idx(dd.get_ref_file(data))
cmd = ("{gsort} {in_file} {fai_file} | bedtools merge -i - -d {stats[merge_size]} | "
"bgzip -c > {tx_out_file}")
do.run(cmd.format(**locals()), "Prepare SV callable BED regions")
return vcfutils.bgzip_and_index(out_file, data["config"]) | [
"def",
"_prep_callable_bed",
"(",
"in_file",
",",
"work_dir",
",",
"stats",
",",
"data",
")",
":",
"out_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"work_dir",
",",
"\"%s-merge.bed.gz\"",
"%",
"utils",
".",
"splitext_plus",
"(",
"os",
".",
"path",
"... | Sort and merge callable BED regions to prevent SV double counting | [
"Sort",
"and",
"merge",
"callable",
"BED",
"regions",
"to",
"prevent",
"SV",
"double",
"counting"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L176-L187 |
237,029 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | _get_anns_to_remove | def _get_anns_to_remove(in_file):
"""Find larger annotations, if present in VCF, that slow down processing.
"""
to_remove = ["ANN", "LOF"]
to_remove_str = tuple(["##INFO=<ID=%s" % x for x in to_remove])
cur_remove = []
with utils.open_gzipsafe(in_file) as in_handle:
for line in in_handle:
if not line.startswith("#"):
break
elif line.startswith(to_remove_str):
cur_id = line.split("ID=")[-1].split(",")[0]
cur_remove.append("INFO/%s" % cur_id)
return ",".join(cur_remove) | python | def _get_anns_to_remove(in_file):
to_remove = ["ANN", "LOF"]
to_remove_str = tuple(["##INFO=<ID=%s" % x for x in to_remove])
cur_remove = []
with utils.open_gzipsafe(in_file) as in_handle:
for line in in_handle:
if not line.startswith("#"):
break
elif line.startswith(to_remove_str):
cur_id = line.split("ID=")[-1].split(",")[0]
cur_remove.append("INFO/%s" % cur_id)
return ",".join(cur_remove) | [
"def",
"_get_anns_to_remove",
"(",
"in_file",
")",
":",
"to_remove",
"=",
"[",
"\"ANN\"",
",",
"\"LOF\"",
"]",
"to_remove_str",
"=",
"tuple",
"(",
"[",
"\"##INFO=<ID=%s\"",
"%",
"x",
"for",
"x",
"in",
"to_remove",
"]",
")",
"cur_remove",
"=",
"[",
"]",
"... | Find larger annotations, if present in VCF, that slow down processing. | [
"Find",
"larger",
"annotations",
"if",
"present",
"in",
"VCF",
"that",
"slow",
"down",
"processing",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L189-L202 |
237,030 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | cnv_to_event | def cnv_to_event(name, data):
"""Convert a CNV to an event name.
"""
cur_ploidy = ploidy.get_ploidy([data])
if name.startswith("cnv"):
num = max([int(x) for x in name.split("_")[0].replace("cnv", "").split(";")])
if num < cur_ploidy:
return "DEL"
elif num > cur_ploidy:
return "DUP"
else:
return name
else:
return name | python | def cnv_to_event(name, data):
cur_ploidy = ploidy.get_ploidy([data])
if name.startswith("cnv"):
num = max([int(x) for x in name.split("_")[0].replace("cnv", "").split(";")])
if num < cur_ploidy:
return "DEL"
elif num > cur_ploidy:
return "DUP"
else:
return name
else:
return name | [
"def",
"cnv_to_event",
"(",
"name",
",",
"data",
")",
":",
"cur_ploidy",
"=",
"ploidy",
".",
"get_ploidy",
"(",
"[",
"data",
"]",
")",
"if",
"name",
".",
"startswith",
"(",
"\"cnv\"",
")",
":",
"num",
"=",
"max",
"(",
"[",
"int",
"(",
"x",
")",
"... | Convert a CNV to an event name. | [
"Convert",
"a",
"CNV",
"to",
"an",
"event",
"name",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L216-L229 |
237,031 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | _evaluate_one | def _evaluate_one(caller, svtype, size_range, ensemble, truth, data):
"""Compare a ensemble results for a caller against a specific caller and SV type.
"""
def cnv_matches(name):
return cnv_to_event(name, data) == svtype
def is_breakend(name):
return name.startswith("BND")
def in_size_range(max_buffer=0):
def _work(feat):
minf, maxf = size_range
buffer = min(max_buffer, int(((maxf + minf) / 2.0) / 10.0))
size = feat.end - feat.start
return size >= max([0, minf - buffer]) and size < maxf + buffer
return _work
def is_caller_svtype(feat):
for name in feat.name.split(","):
if ((name.startswith(svtype) or cnv_matches(name) or is_breakend(name))
and (caller == "sv-ensemble" or name.endswith(caller))):
return True
return False
minf, maxf = size_range
efeats = pybedtools.BedTool(ensemble).filter(in_size_range(0)).filter(is_caller_svtype).saveas().sort().merge()
tfeats = pybedtools.BedTool(truth).filter(in_size_range(0)).sort().merge().saveas()
etotal = efeats.count()
ttotal = tfeats.count()
match = efeats.intersect(tfeats, u=True).sort().merge().saveas().count()
return {"sensitivity": _stat_str(match, ttotal),
"precision": _stat_str(match, etotal)} | python | def _evaluate_one(caller, svtype, size_range, ensemble, truth, data):
def cnv_matches(name):
return cnv_to_event(name, data) == svtype
def is_breakend(name):
return name.startswith("BND")
def in_size_range(max_buffer=0):
def _work(feat):
minf, maxf = size_range
buffer = min(max_buffer, int(((maxf + minf) / 2.0) / 10.0))
size = feat.end - feat.start
return size >= max([0, minf - buffer]) and size < maxf + buffer
return _work
def is_caller_svtype(feat):
for name in feat.name.split(","):
if ((name.startswith(svtype) or cnv_matches(name) or is_breakend(name))
and (caller == "sv-ensemble" or name.endswith(caller))):
return True
return False
minf, maxf = size_range
efeats = pybedtools.BedTool(ensemble).filter(in_size_range(0)).filter(is_caller_svtype).saveas().sort().merge()
tfeats = pybedtools.BedTool(truth).filter(in_size_range(0)).sort().merge().saveas()
etotal = efeats.count()
ttotal = tfeats.count()
match = efeats.intersect(tfeats, u=True).sort().merge().saveas().count()
return {"sensitivity": _stat_str(match, ttotal),
"precision": _stat_str(match, etotal)} | [
"def",
"_evaluate_one",
"(",
"caller",
",",
"svtype",
",",
"size_range",
",",
"ensemble",
",",
"truth",
",",
"data",
")",
":",
"def",
"cnv_matches",
"(",
"name",
")",
":",
"return",
"cnv_to_event",
"(",
"name",
",",
"data",
")",
"==",
"svtype",
"def",
... | Compare a ensemble results for a caller against a specific caller and SV type. | [
"Compare",
"a",
"ensemble",
"results",
"for",
"a",
"caller",
"against",
"a",
"specific",
"caller",
"and",
"SV",
"type",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L231-L258 |
237,032 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | _plot_evaluation_event | def _plot_evaluation_event(df_csv, svtype):
"""Provide plot of evaluation metrics for an SV event, stratified by event size.
"""
titles = {"INV": "Inversions", "DEL": "Deletions", "DUP": "Duplications",
"INS": "Insertions"}
out_file = "%s-%s.png" % (os.path.splitext(df_csv)[0], svtype)
sns.set(style='white')
if not utils.file_uptodate(out_file, df_csv):
metrics = ["sensitivity", "precision"]
df = pd.read_csv(df_csv).fillna("0%")
df = df[(df["svtype"] == svtype)]
event_sizes = _find_events_to_include(df, EVENT_SIZES)
fig, axs = plt.subplots(len(event_sizes), len(metrics), tight_layout=True)
if len(event_sizes) == 1:
axs = [axs]
callers = sorted(df["caller"].unique())
if "sv-ensemble" in callers:
callers.remove("sv-ensemble")
callers.append("sv-ensemble")
for i, size in enumerate(event_sizes):
size_label = "%s to %sbp" % size
size = "%s-%s" % size
for j, metric in enumerate(metrics):
ax = axs[i][j]
ax.get_xaxis().set_ticks([])
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.set_xlim(0, 125.0)
if i == 0:
ax.set_title(metric, size=12, y=1.2)
vals, labels = _get_plot_val_labels(df, size, metric, callers)
ax.barh(range(1,len(vals)+1), vals)
if j == 0:
ax.tick_params(axis='y', which='major', labelsize=8)
ax.locator_params(axis="y", tight=True)
ax.set_yticks(range(1,len(callers)+1,1))
ax.set_yticklabels(callers, va="center")
ax.text(100, len(callers)+1, size_label, fontsize=10)
else:
ax.get_yaxis().set_ticks([])
for ai, (val, label) in enumerate(zip(vals, labels)):
ax.annotate(label, (val + 0.75, ai + 1), va='center', size=7)
if svtype in titles:
fig.text(0.025, 0.95, titles[svtype], size=14)
fig.set_size_inches(7, len(event_sizes) + 1)
fig.savefig(out_file)
return out_file | python | def _plot_evaluation_event(df_csv, svtype):
titles = {"INV": "Inversions", "DEL": "Deletions", "DUP": "Duplications",
"INS": "Insertions"}
out_file = "%s-%s.png" % (os.path.splitext(df_csv)[0], svtype)
sns.set(style='white')
if not utils.file_uptodate(out_file, df_csv):
metrics = ["sensitivity", "precision"]
df = pd.read_csv(df_csv).fillna("0%")
df = df[(df["svtype"] == svtype)]
event_sizes = _find_events_to_include(df, EVENT_SIZES)
fig, axs = plt.subplots(len(event_sizes), len(metrics), tight_layout=True)
if len(event_sizes) == 1:
axs = [axs]
callers = sorted(df["caller"].unique())
if "sv-ensemble" in callers:
callers.remove("sv-ensemble")
callers.append("sv-ensemble")
for i, size in enumerate(event_sizes):
size_label = "%s to %sbp" % size
size = "%s-%s" % size
for j, metric in enumerate(metrics):
ax = axs[i][j]
ax.get_xaxis().set_ticks([])
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.set_xlim(0, 125.0)
if i == 0:
ax.set_title(metric, size=12, y=1.2)
vals, labels = _get_plot_val_labels(df, size, metric, callers)
ax.barh(range(1,len(vals)+1), vals)
if j == 0:
ax.tick_params(axis='y', which='major', labelsize=8)
ax.locator_params(axis="y", tight=True)
ax.set_yticks(range(1,len(callers)+1,1))
ax.set_yticklabels(callers, va="center")
ax.text(100, len(callers)+1, size_label, fontsize=10)
else:
ax.get_yaxis().set_ticks([])
for ai, (val, label) in enumerate(zip(vals, labels)):
ax.annotate(label, (val + 0.75, ai + 1), va='center', size=7)
if svtype in titles:
fig.text(0.025, 0.95, titles[svtype], size=14)
fig.set_size_inches(7, len(event_sizes) + 1)
fig.savefig(out_file)
return out_file | [
"def",
"_plot_evaluation_event",
"(",
"df_csv",
",",
"svtype",
")",
":",
"titles",
"=",
"{",
"\"INV\"",
":",
"\"Inversions\"",
",",
"\"DEL\"",
":",
"\"Deletions\"",
",",
"\"DUP\"",
":",
"\"Duplications\"",
",",
"\"INS\"",
":",
"\"Insertions\"",
"}",
"out_file",
... | Provide plot of evaluation metrics for an SV event, stratified by event size. | [
"Provide",
"plot",
"of",
"evaluation",
"metrics",
"for",
"an",
"SV",
"event",
"stratified",
"by",
"event",
"size",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L300-L348 |
237,033 | bcbio/bcbio-nextgen | bcbio/structural/validate.py | evaluate | def evaluate(data):
"""Provide evaluations for multiple callers split by structural variant type.
"""
work_dir = utils.safe_makedir(os.path.join(data["dirs"]["work"], "structural",
dd.get_sample_name(data), "validate"))
truth_sets = tz.get_in(["config", "algorithm", "svvalidate"], data)
if truth_sets and data.get("sv"):
if isinstance(truth_sets, dict):
val_summary, df_csv = _evaluate_multi(data["sv"], truth_sets, work_dir, data)
summary_plots = _plot_evaluation(df_csv)
data["sv-validate"] = {"csv": val_summary, "plot": summary_plots, "df": df_csv}
else:
assert isinstance(truth_sets, six.string_types) and utils.file_exists(truth_sets), truth_sets
val_summary = _evaluate_vcf(data["sv"], truth_sets, work_dir, data)
title = "%s structural variants" % dd.get_sample_name(data)
summary_plots = validateplot.classifyplot_from_valfile(val_summary, outtype="png", title=title)
data["sv-validate"] = {"csv": val_summary, "plot": summary_plots[0] if len(summary_plots) > 0 else None}
return data | python | def evaluate(data):
work_dir = utils.safe_makedir(os.path.join(data["dirs"]["work"], "structural",
dd.get_sample_name(data), "validate"))
truth_sets = tz.get_in(["config", "algorithm", "svvalidate"], data)
if truth_sets and data.get("sv"):
if isinstance(truth_sets, dict):
val_summary, df_csv = _evaluate_multi(data["sv"], truth_sets, work_dir, data)
summary_plots = _plot_evaluation(df_csv)
data["sv-validate"] = {"csv": val_summary, "plot": summary_plots, "df": df_csv}
else:
assert isinstance(truth_sets, six.string_types) and utils.file_exists(truth_sets), truth_sets
val_summary = _evaluate_vcf(data["sv"], truth_sets, work_dir, data)
title = "%s structural variants" % dd.get_sample_name(data)
summary_plots = validateplot.classifyplot_from_valfile(val_summary, outtype="png", title=title)
data["sv-validate"] = {"csv": val_summary, "plot": summary_plots[0] if len(summary_plots) > 0 else None}
return data | [
"def",
"evaluate",
"(",
"data",
")",
":",
"work_dir",
"=",
"utils",
".",
"safe_makedir",
"(",
"os",
".",
"path",
".",
"join",
"(",
"data",
"[",
"\"dirs\"",
"]",
"[",
"\"work\"",
"]",
",",
"\"structural\"",
",",
"dd",
".",
"get_sample_name",
"(",
"data"... | Provide evaluations for multiple callers split by structural variant type. | [
"Provide",
"evaluations",
"for",
"multiple",
"callers",
"split",
"by",
"structural",
"variant",
"type",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/validate.py#L375-L392 |
237,034 | bcbio/bcbio-nextgen | bcbio/variation/mutect2.py | _add_region_params | def _add_region_params(region, out_file, items, gatk_type):
"""Add parameters for selecting by region to command line.
"""
params = []
variant_regions = bedutils.population_variant_regions(items)
region = subset_variant_regions(variant_regions, region, out_file, items)
if region:
if gatk_type == "gatk4":
params += ["-L", bamprep.region_to_gatk(region), "--interval-set-rule", "INTERSECTION"]
else:
params += ["-L", bamprep.region_to_gatk(region), "--interval_set_rule", "INTERSECTION"]
params += gatk.standard_cl_params(items)
return params | python | def _add_region_params(region, out_file, items, gatk_type):
params = []
variant_regions = bedutils.population_variant_regions(items)
region = subset_variant_regions(variant_regions, region, out_file, items)
if region:
if gatk_type == "gatk4":
params += ["-L", bamprep.region_to_gatk(region), "--interval-set-rule", "INTERSECTION"]
else:
params += ["-L", bamprep.region_to_gatk(region), "--interval_set_rule", "INTERSECTION"]
params += gatk.standard_cl_params(items)
return params | [
"def",
"_add_region_params",
"(",
"region",
",",
"out_file",
",",
"items",
",",
"gatk_type",
")",
":",
"params",
"=",
"[",
"]",
"variant_regions",
"=",
"bedutils",
".",
"population_variant_regions",
"(",
"items",
")",
"region",
"=",
"subset_variant_regions",
"("... | Add parameters for selecting by region to command line. | [
"Add",
"parameters",
"for",
"selecting",
"by",
"region",
"to",
"command",
"line",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/mutect2.py#L48-L60 |
237,035 | bcbio/bcbio-nextgen | bcbio/variation/mutect2.py | _prep_inputs | def _prep_inputs(align_bams, ref_file, items):
"""Ensure inputs to calling are indexed as expected.
"""
broad_runner = broad.runner_from_path("picard", items[0]["config"])
broad_runner.run_fn("picard_index_ref", ref_file)
for x in align_bams:
bam.index(x, items[0]["config"]) | python | def _prep_inputs(align_bams, ref_file, items):
broad_runner = broad.runner_from_path("picard", items[0]["config"])
broad_runner.run_fn("picard_index_ref", ref_file)
for x in align_bams:
bam.index(x, items[0]["config"]) | [
"def",
"_prep_inputs",
"(",
"align_bams",
",",
"ref_file",
",",
"items",
")",
":",
"broad_runner",
"=",
"broad",
".",
"runner_from_path",
"(",
"\"picard\"",
",",
"items",
"[",
"0",
"]",
"[",
"\"config\"",
"]",
")",
"broad_runner",
".",
"run_fn",
"(",
"\"pi... | Ensure inputs to calling are indexed as expected. | [
"Ensure",
"inputs",
"to",
"calling",
"are",
"indexed",
"as",
"expected",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/mutect2.py#L70-L76 |
237,036 | bcbio/bcbio-nextgen | bcbio/variation/mutect2.py | mutect2_caller | def mutect2_caller(align_bams, items, ref_file, assoc_files,
region=None, out_file=None):
"""Call variation with GATK's MuTect2.
This requires the full non open-source version of GATK 3.5+.
"""
if out_file is None:
out_file = "%s-variants.vcf.gz" % utils.splitext_plus(align_bams[0])[0]
if not utils.file_exists(out_file):
paired = vcfutils.get_paired_bams(align_bams, items)
broad_runner = broad.runner_from_config(items[0]["config"])
gatk_type = broad_runner.gatk_type()
_prep_inputs(align_bams, ref_file, items)
with file_transaction(items[0], out_file) as tx_out_file:
params = ["-T", "Mutect2" if gatk_type == "gatk4" else "MuTect2",
"--annotation", "ClippingRankSumTest",
"--annotation", "DepthPerSampleHC"]
if gatk_type == "gatk4":
params += ["--reference", ref_file]
else:
params += ["-R", ref_file]
for a in annotation.get_gatk_annotations(items[0]["config"], include_baseqranksum=False):
params += ["--annotation", a]
# Avoid issues with BAM CIGAR reads that GATK doesn't like
if gatk_type == "gatk4":
params += ["--read-validation-stringency", "LENIENT"]
params += _add_tumor_params(paired, items, gatk_type)
params += _add_region_params(region, out_file, items, gatk_type)
# Avoid adding dbSNP/Cosmic so they do not get fed to variant filtering algorithm
# Not yet clear how this helps or hurts in a general case.
#params += _add_assoc_params(assoc_files)
resources = config_utils.get_resources("mutect2", items[0]["config"])
if "options" in resources:
params += [str(x) for x in resources.get("options", [])]
assert LooseVersion(broad_runner.gatk_major_version()) >= LooseVersion("3.5"), \
"Require full version of GATK 3.5+ for mutect2 calling"
broad_runner.new_resources("mutect2")
gatk_cmd = broad_runner.cl_gatk(params, os.path.dirname(tx_out_file))
if gatk_type == "gatk4":
tx_raw_prefilt_file = "%s-raw%s" % utils.splitext_plus(tx_out_file)
tx_raw_file = "%s-raw-filt%s" % utils.splitext_plus(tx_out_file)
filter_cmd = _mutect2_filter(broad_runner, tx_raw_prefilt_file, tx_raw_file, ref_file)
cmd = "{gatk_cmd} -O {tx_raw_prefilt_file} && {filter_cmd}"
else:
tx_raw_file = "%s-raw%s" % utils.splitext_plus(tx_out_file)
cmd = "{gatk_cmd} > {tx_raw_file}"
do.run(cmd.format(**locals()), "MuTect2")
out_file = _af_filter(paired.tumor_data, tx_raw_file, out_file)
return vcfutils.bgzip_and_index(out_file, items[0]["config"]) | python | def mutect2_caller(align_bams, items, ref_file, assoc_files,
region=None, out_file=None):
if out_file is None:
out_file = "%s-variants.vcf.gz" % utils.splitext_plus(align_bams[0])[0]
if not utils.file_exists(out_file):
paired = vcfutils.get_paired_bams(align_bams, items)
broad_runner = broad.runner_from_config(items[0]["config"])
gatk_type = broad_runner.gatk_type()
_prep_inputs(align_bams, ref_file, items)
with file_transaction(items[0], out_file) as tx_out_file:
params = ["-T", "Mutect2" if gatk_type == "gatk4" else "MuTect2",
"--annotation", "ClippingRankSumTest",
"--annotation", "DepthPerSampleHC"]
if gatk_type == "gatk4":
params += ["--reference", ref_file]
else:
params += ["-R", ref_file]
for a in annotation.get_gatk_annotations(items[0]["config"], include_baseqranksum=False):
params += ["--annotation", a]
# Avoid issues with BAM CIGAR reads that GATK doesn't like
if gatk_type == "gatk4":
params += ["--read-validation-stringency", "LENIENT"]
params += _add_tumor_params(paired, items, gatk_type)
params += _add_region_params(region, out_file, items, gatk_type)
# Avoid adding dbSNP/Cosmic so they do not get fed to variant filtering algorithm
# Not yet clear how this helps or hurts in a general case.
#params += _add_assoc_params(assoc_files)
resources = config_utils.get_resources("mutect2", items[0]["config"])
if "options" in resources:
params += [str(x) for x in resources.get("options", [])]
assert LooseVersion(broad_runner.gatk_major_version()) >= LooseVersion("3.5"), \
"Require full version of GATK 3.5+ for mutect2 calling"
broad_runner.new_resources("mutect2")
gatk_cmd = broad_runner.cl_gatk(params, os.path.dirname(tx_out_file))
if gatk_type == "gatk4":
tx_raw_prefilt_file = "%s-raw%s" % utils.splitext_plus(tx_out_file)
tx_raw_file = "%s-raw-filt%s" % utils.splitext_plus(tx_out_file)
filter_cmd = _mutect2_filter(broad_runner, tx_raw_prefilt_file, tx_raw_file, ref_file)
cmd = "{gatk_cmd} -O {tx_raw_prefilt_file} && {filter_cmd}"
else:
tx_raw_file = "%s-raw%s" % utils.splitext_plus(tx_out_file)
cmd = "{gatk_cmd} > {tx_raw_file}"
do.run(cmd.format(**locals()), "MuTect2")
out_file = _af_filter(paired.tumor_data, tx_raw_file, out_file)
return vcfutils.bgzip_and_index(out_file, items[0]["config"]) | [
"def",
"mutect2_caller",
"(",
"align_bams",
",",
"items",
",",
"ref_file",
",",
"assoc_files",
",",
"region",
"=",
"None",
",",
"out_file",
"=",
"None",
")",
":",
"if",
"out_file",
"is",
"None",
":",
"out_file",
"=",
"\"%s-variants.vcf.gz\"",
"%",
"utils",
... | Call variation with GATK's MuTect2.
This requires the full non open-source version of GATK 3.5+. | [
"Call",
"variation",
"with",
"GATK",
"s",
"MuTect2",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/mutect2.py#L78-L126 |
237,037 | bcbio/bcbio-nextgen | bcbio/variation/mutect2.py | _mutect2_filter | def _mutect2_filter(broad_runner, in_file, out_file, ref_file):
"""Filter of MuTect2 calls, a separate step in GATK4.
"""
params = ["-T", "FilterMutectCalls", "--reference", ref_file, "--variant", in_file, "--output", out_file]
return broad_runner.cl_gatk(params, os.path.dirname(out_file)) | python | def _mutect2_filter(broad_runner, in_file, out_file, ref_file):
params = ["-T", "FilterMutectCalls", "--reference", ref_file, "--variant", in_file, "--output", out_file]
return broad_runner.cl_gatk(params, os.path.dirname(out_file)) | [
"def",
"_mutect2_filter",
"(",
"broad_runner",
",",
"in_file",
",",
"out_file",
",",
"ref_file",
")",
":",
"params",
"=",
"[",
"\"-T\"",
",",
"\"FilterMutectCalls\"",
",",
"\"--reference\"",
",",
"ref_file",
",",
"\"--variant\"",
",",
"in_file",
",",
"\"--output... | Filter of MuTect2 calls, a separate step in GATK4. | [
"Filter",
"of",
"MuTect2",
"calls",
"a",
"separate",
"step",
"in",
"GATK4",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/mutect2.py#L128-L132 |
237,038 | bcbio/bcbio-nextgen | bcbio/upload/irods.py | update_file | def update_file(finfo, sample_info, config):
"""
Update the file to an iRODS repository.
"""
ffinal = filesystem.update_file(finfo, sample_info, config, pass_uptodate=True)
_upload_dir_icommands_cli(config.get("dir"), config.get("folder"), config) | python | def update_file(finfo, sample_info, config):
ffinal = filesystem.update_file(finfo, sample_info, config, pass_uptodate=True)
_upload_dir_icommands_cli(config.get("dir"), config.get("folder"), config) | [
"def",
"update_file",
"(",
"finfo",
",",
"sample_info",
",",
"config",
")",
":",
"ffinal",
"=",
"filesystem",
".",
"update_file",
"(",
"finfo",
",",
"sample_info",
",",
"config",
",",
"pass_uptodate",
"=",
"True",
")",
"_upload_dir_icommands_cli",
"(",
"config... | Update the file to an iRODS repository. | [
"Update",
"the",
"file",
"to",
"an",
"iRODS",
"repository",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/upload/irods.py#L25-L31 |
237,039 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | _get_callers | def _get_callers(items, stage, special_cases=False):
"""Retrieve available callers for the provided stage.
Handles special cases like CNVkit that can be in initial or standard
depending on if fed into Lumpy analysis.
"""
callers = utils.deepish_copy(_CALLERS[stage])
if special_cases and "cnvkit" in callers:
has_lumpy = any("lumpy" in get_svcallers(d) or "lumpy" in d["config"]["algorithm"].get("svcaller_orig", [])
for d in items)
if has_lumpy and any("lumpy_usecnv" in dd.get_tools_on(d) for d in items):
if stage != "initial":
del callers["cnvkit"]
else:
if stage != "standard":
del callers["cnvkit"]
return callers | python | def _get_callers(items, stage, special_cases=False):
callers = utils.deepish_copy(_CALLERS[stage])
if special_cases and "cnvkit" in callers:
has_lumpy = any("lumpy" in get_svcallers(d) or "lumpy" in d["config"]["algorithm"].get("svcaller_orig", [])
for d in items)
if has_lumpy and any("lumpy_usecnv" in dd.get_tools_on(d) for d in items):
if stage != "initial":
del callers["cnvkit"]
else:
if stage != "standard":
del callers["cnvkit"]
return callers | [
"def",
"_get_callers",
"(",
"items",
",",
"stage",
",",
"special_cases",
"=",
"False",
")",
":",
"callers",
"=",
"utils",
".",
"deepish_copy",
"(",
"_CALLERS",
"[",
"stage",
"]",
")",
"if",
"special_cases",
"and",
"\"cnvkit\"",
"in",
"callers",
":",
"has_l... | Retrieve available callers for the provided stage.
Handles special cases like CNVkit that can be in initial or standard
depending on if fed into Lumpy analysis. | [
"Retrieve",
"available",
"callers",
"for",
"the",
"provided",
"stage",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L38-L54 |
237,040 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | _handle_multiple_svcallers | def _handle_multiple_svcallers(data, stage):
"""Retrieve configured structural variation caller, handling multiple.
"""
svs = get_svcallers(data)
# special cases -- prioritization
if stage == "ensemble" and dd.get_svprioritize(data):
svs.append("prioritize")
out = []
for svcaller in svs:
if svcaller in _get_callers([data], stage):
base = copy.deepcopy(data)
# clean SV callers present in multiple rounds and not this caller
final_svs = []
for sv in data.get("sv", []):
if (stage == "ensemble" or sv["variantcaller"] == svcaller or sv["variantcaller"] not in svs
or svcaller not in _get_callers([data], stage, special_cases=True)):
final_svs.append(sv)
base["sv"] = final_svs
base["config"]["algorithm"]["svcaller"] = svcaller
base["config"]["algorithm"]["svcaller_orig"] = svs
out.append(base)
return out | python | def _handle_multiple_svcallers(data, stage):
svs = get_svcallers(data)
# special cases -- prioritization
if stage == "ensemble" and dd.get_svprioritize(data):
svs.append("prioritize")
out = []
for svcaller in svs:
if svcaller in _get_callers([data], stage):
base = copy.deepcopy(data)
# clean SV callers present in multiple rounds and not this caller
final_svs = []
for sv in data.get("sv", []):
if (stage == "ensemble" or sv["variantcaller"] == svcaller or sv["variantcaller"] not in svs
or svcaller not in _get_callers([data], stage, special_cases=True)):
final_svs.append(sv)
base["sv"] = final_svs
base["config"]["algorithm"]["svcaller"] = svcaller
base["config"]["algorithm"]["svcaller_orig"] = svs
out.append(base)
return out | [
"def",
"_handle_multiple_svcallers",
"(",
"data",
",",
"stage",
")",
":",
"svs",
"=",
"get_svcallers",
"(",
"data",
")",
"# special cases -- prioritization",
"if",
"stage",
"==",
"\"ensemble\"",
"and",
"dd",
".",
"get_svprioritize",
"(",
"data",
")",
":",
"svs",... | Retrieve configured structural variation caller, handling multiple. | [
"Retrieve",
"configured",
"structural",
"variation",
"caller",
"handling",
"multiple",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L64-L85 |
237,041 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | finalize_sv | def finalize_sv(samples, config):
"""Combine results from multiple sv callers into a single ordered 'sv' key.
"""
by_bam = collections.OrderedDict()
for x in samples:
batch = dd.get_batch(x) or [dd.get_sample_name(x)]
try:
by_bam[x["align_bam"], tuple(batch)].append(x)
except KeyError:
by_bam[x["align_bam"], tuple(batch)] = [x]
by_batch = collections.OrderedDict()
lead_batches = {}
for grouped_calls in by_bam.values():
def orig_svcaller_order(x):
orig_callers = tz.get_in(["config", "algorithm", "svcaller_orig"], x)
cur_caller = tz.get_in(["config", "algorithm", "svcaller"], x)
return orig_callers.index(cur_caller)
sorted_svcalls = sorted([x for x in grouped_calls if "sv" in x],
key=orig_svcaller_order)
final = grouped_calls[0]
if len(sorted_svcalls) > 0:
final["sv"] = reduce(operator.add, [x["sv"] for x in sorted_svcalls])
final["config"]["algorithm"]["svcaller"] = final["config"]["algorithm"].pop("svcaller_orig")
batch = dd.get_batch(final) or dd.get_sample_name(final)
batches = batch if isinstance(batch, (list, tuple)) else [batch]
if len(batches) > 1:
lead_batches[(dd.get_sample_name(final), dd.get_phenotype(final) == "germline")] = batches[0]
for batch in batches:
try:
by_batch[batch].append(final)
except KeyError:
by_batch[batch] = [final]
out = []
for batch, items in by_batch.items():
if any("svplots" in dd.get_tools_on(d) for d in items):
items = plot.by_regions(items)
for data in items:
if lead_batches.get((dd.get_sample_name(data), dd.get_phenotype(data) == "germline")) in [batch, None]:
out.append([data])
return out | python | def finalize_sv(samples, config):
by_bam = collections.OrderedDict()
for x in samples:
batch = dd.get_batch(x) or [dd.get_sample_name(x)]
try:
by_bam[x["align_bam"], tuple(batch)].append(x)
except KeyError:
by_bam[x["align_bam"], tuple(batch)] = [x]
by_batch = collections.OrderedDict()
lead_batches = {}
for grouped_calls in by_bam.values():
def orig_svcaller_order(x):
orig_callers = tz.get_in(["config", "algorithm", "svcaller_orig"], x)
cur_caller = tz.get_in(["config", "algorithm", "svcaller"], x)
return orig_callers.index(cur_caller)
sorted_svcalls = sorted([x for x in grouped_calls if "sv" in x],
key=orig_svcaller_order)
final = grouped_calls[0]
if len(sorted_svcalls) > 0:
final["sv"] = reduce(operator.add, [x["sv"] for x in sorted_svcalls])
final["config"]["algorithm"]["svcaller"] = final["config"]["algorithm"].pop("svcaller_orig")
batch = dd.get_batch(final) or dd.get_sample_name(final)
batches = batch if isinstance(batch, (list, tuple)) else [batch]
if len(batches) > 1:
lead_batches[(dd.get_sample_name(final), dd.get_phenotype(final) == "germline")] = batches[0]
for batch in batches:
try:
by_batch[batch].append(final)
except KeyError:
by_batch[batch] = [final]
out = []
for batch, items in by_batch.items():
if any("svplots" in dd.get_tools_on(d) for d in items):
items = plot.by_regions(items)
for data in items:
if lead_batches.get((dd.get_sample_name(data), dd.get_phenotype(data) == "germline")) in [batch, None]:
out.append([data])
return out | [
"def",
"finalize_sv",
"(",
"samples",
",",
"config",
")",
":",
"by_bam",
"=",
"collections",
".",
"OrderedDict",
"(",
")",
"for",
"x",
"in",
"samples",
":",
"batch",
"=",
"dd",
".",
"get_batch",
"(",
"x",
")",
"or",
"[",
"dd",
".",
"get_sample_name",
... | Combine results from multiple sv callers into a single ordered 'sv' key. | [
"Combine",
"results",
"from",
"multiple",
"sv",
"callers",
"into",
"a",
"single",
"ordered",
"sv",
"key",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L87-L126 |
237,042 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | batch_for_sv | def batch_for_sv(samples):
"""Prepare a set of samples for parallel structural variant calling.
CWL input target -- groups samples into batches and structural variant
callers for parallel processing.
"""
samples = cwlutils.assign_complex_to_samples(samples)
to_process, extras, background = _batch_split_by_sv(samples, "standard")
out = [cwlutils.samples_to_records(xs) for xs in to_process.values()] + extras
return out | python | def batch_for_sv(samples):
samples = cwlutils.assign_complex_to_samples(samples)
to_process, extras, background = _batch_split_by_sv(samples, "standard")
out = [cwlutils.samples_to_records(xs) for xs in to_process.values()] + extras
return out | [
"def",
"batch_for_sv",
"(",
"samples",
")",
":",
"samples",
"=",
"cwlutils",
".",
"assign_complex_to_samples",
"(",
"samples",
")",
"to_process",
",",
"extras",
",",
"background",
"=",
"_batch_split_by_sv",
"(",
"samples",
",",
"\"standard\"",
")",
"out",
"=",
... | Prepare a set of samples for parallel structural variant calling.
CWL input target -- groups samples into batches and structural variant
callers for parallel processing. | [
"Prepare",
"a",
"set",
"of",
"samples",
"for",
"parallel",
"structural",
"variant",
"calling",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L133-L142 |
237,043 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | run | def run(samples, run_parallel, stage):
"""Run structural variation detection.
The stage indicates which level of structural variant calling to run.
- initial, callers that can be used in subsequent structural variation steps (cnvkit -> lumpy)
- standard, regular batch calling
- ensemble, post-calling, combine other callers or prioritize results
"""
to_process, extras, background = _batch_split_by_sv(samples, stage)
processed = run_parallel("detect_sv", ([xs, background, stage]
for xs in to_process.values()))
finalized = (run_parallel("finalize_sv", [([xs[0] for xs in processed], processed[0][0]["config"])])
if len(processed) > 0 else [])
return extras + finalized | python | def run(samples, run_parallel, stage):
to_process, extras, background = _batch_split_by_sv(samples, stage)
processed = run_parallel("detect_sv", ([xs, background, stage]
for xs in to_process.values()))
finalized = (run_parallel("finalize_sv", [([xs[0] for xs in processed], processed[0][0]["config"])])
if len(processed) > 0 else [])
return extras + finalized | [
"def",
"run",
"(",
"samples",
",",
"run_parallel",
",",
"stage",
")",
":",
"to_process",
",",
"extras",
",",
"background",
"=",
"_batch_split_by_sv",
"(",
"samples",
",",
"stage",
")",
"processed",
"=",
"run_parallel",
"(",
"\"detect_sv\"",
",",
"(",
"[",
... | Run structural variation detection.
The stage indicates which level of structural variant calling to run.
- initial, callers that can be used in subsequent structural variation steps (cnvkit -> lumpy)
- standard, regular batch calling
- ensemble, post-calling, combine other callers or prioritize results | [
"Run",
"structural",
"variation",
"detection",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L174-L187 |
237,044 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | detect_sv | def detect_sv(items, all_items=None, stage="standard"):
"""Top level parallel target for examining structural variation.
"""
items = [utils.to_single_data(x) for x in items]
items = cwlutils.unpack_tarballs(items, items[0])
svcaller = items[0]["config"]["algorithm"].get("svcaller")
caller_fn = _get_callers(items, stage, special_cases=True).get(svcaller)
out = []
if svcaller and caller_fn:
if (all_items and svcaller in _NEEDS_BACKGROUND and
not vcfutils.is_paired_analysis([x.get("align_bam") for x in items], items)):
names = set([dd.get_sample_name(x) for x in items])
background = [x for x in all_items if dd.get_sample_name(x) not in names]
for svdata in caller_fn(items, background):
out.append([svdata])
else:
for svdata in caller_fn(items):
out.append([svdata])
else:
for data in items:
out.append([data])
# Avoid nesting of callers for CWL runs for easier extraction
if cwlutils.is_cwl_run(items[0]):
out_cwl = []
for data in [utils.to_single_data(x) for x in out]:
# Run validation directly from CWL runs since we're single stage
data = validate.evaluate(data)
data["svvalidate"] = {"summary": tz.get_in(["sv-validate", "csv"], data)}
svs = data.get("sv")
if svs:
assert len(svs) == 1, svs
data["sv"] = svs[0]
else:
data["sv"] = {}
data = _add_supplemental(data)
out_cwl.append([data])
return out_cwl
return out | python | def detect_sv(items, all_items=None, stage="standard"):
items = [utils.to_single_data(x) for x in items]
items = cwlutils.unpack_tarballs(items, items[0])
svcaller = items[0]["config"]["algorithm"].get("svcaller")
caller_fn = _get_callers(items, stage, special_cases=True).get(svcaller)
out = []
if svcaller and caller_fn:
if (all_items and svcaller in _NEEDS_BACKGROUND and
not vcfutils.is_paired_analysis([x.get("align_bam") for x in items], items)):
names = set([dd.get_sample_name(x) for x in items])
background = [x for x in all_items if dd.get_sample_name(x) not in names]
for svdata in caller_fn(items, background):
out.append([svdata])
else:
for svdata in caller_fn(items):
out.append([svdata])
else:
for data in items:
out.append([data])
# Avoid nesting of callers for CWL runs for easier extraction
if cwlutils.is_cwl_run(items[0]):
out_cwl = []
for data in [utils.to_single_data(x) for x in out]:
# Run validation directly from CWL runs since we're single stage
data = validate.evaluate(data)
data["svvalidate"] = {"summary": tz.get_in(["sv-validate", "csv"], data)}
svs = data.get("sv")
if svs:
assert len(svs) == 1, svs
data["sv"] = svs[0]
else:
data["sv"] = {}
data = _add_supplemental(data)
out_cwl.append([data])
return out_cwl
return out | [
"def",
"detect_sv",
"(",
"items",
",",
"all_items",
"=",
"None",
",",
"stage",
"=",
"\"standard\"",
")",
":",
"items",
"=",
"[",
"utils",
".",
"to_single_data",
"(",
"x",
")",
"for",
"x",
"in",
"items",
"]",
"items",
"=",
"cwlutils",
".",
"unpack_tarba... | Top level parallel target for examining structural variation. | [
"Top",
"level",
"parallel",
"target",
"for",
"examining",
"structural",
"variation",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L189-L226 |
237,045 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | _add_supplemental | def _add_supplemental(data):
"""Add additional supplemental files to CWL sv output, give useful names.
"""
if "supplemental" not in data["sv"]:
data["sv"]["supplemental"] = []
if data["sv"].get("variantcaller"):
cur_name = _useful_basename(data)
for k in ["cns", "vrn_bed"]:
if data["sv"].get(k) and os.path.exists(data["sv"][k]):
dname, orig = os.path.split(data["sv"][k])
orig_base, orig_ext = utils.splitext_plus(orig)
orig_base = _clean_name(orig_base, data)
if orig_base:
fname = "%s-%s%s" % (cur_name, orig_base, orig_ext)
else:
fname = "%s%s" % (cur_name, orig_ext)
sup_out_file = os.path.join(dname, fname)
utils.symlink_plus(data["sv"][k], sup_out_file)
data["sv"]["supplemental"].append(sup_out_file)
return data | python | def _add_supplemental(data):
if "supplemental" not in data["sv"]:
data["sv"]["supplemental"] = []
if data["sv"].get("variantcaller"):
cur_name = _useful_basename(data)
for k in ["cns", "vrn_bed"]:
if data["sv"].get(k) and os.path.exists(data["sv"][k]):
dname, orig = os.path.split(data["sv"][k])
orig_base, orig_ext = utils.splitext_plus(orig)
orig_base = _clean_name(orig_base, data)
if orig_base:
fname = "%s-%s%s" % (cur_name, orig_base, orig_ext)
else:
fname = "%s%s" % (cur_name, orig_ext)
sup_out_file = os.path.join(dname, fname)
utils.symlink_plus(data["sv"][k], sup_out_file)
data["sv"]["supplemental"].append(sup_out_file)
return data | [
"def",
"_add_supplemental",
"(",
"data",
")",
":",
"if",
"\"supplemental\"",
"not",
"in",
"data",
"[",
"\"sv\"",
"]",
":",
"data",
"[",
"\"sv\"",
"]",
"[",
"\"supplemental\"",
"]",
"=",
"[",
"]",
"if",
"data",
"[",
"\"sv\"",
"]",
".",
"get",
"(",
"\"... | Add additional supplemental files to CWL sv output, give useful names. | [
"Add",
"additional",
"supplemental",
"files",
"to",
"CWL",
"sv",
"output",
"give",
"useful",
"names",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L228-L247 |
237,046 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | _clean_name | def _clean_name(fname, data):
"""Remove standard prefixes from a filename before renaming with useful names.
"""
for to_remove in dd.get_batches(data) + [dd.get_sample_name(data), data["sv"]["variantcaller"]]:
for ext in ("-", "_"):
if fname.startswith("%s%s" % (to_remove, ext)):
fname = fname[len(to_remove) + len(ext):]
if fname.startswith(to_remove):
fname = fname[len(to_remove):]
return fname | python | def _clean_name(fname, data):
for to_remove in dd.get_batches(data) + [dd.get_sample_name(data), data["sv"]["variantcaller"]]:
for ext in ("-", "_"):
if fname.startswith("%s%s" % (to_remove, ext)):
fname = fname[len(to_remove) + len(ext):]
if fname.startswith(to_remove):
fname = fname[len(to_remove):]
return fname | [
"def",
"_clean_name",
"(",
"fname",
",",
"data",
")",
":",
"for",
"to_remove",
"in",
"dd",
".",
"get_batches",
"(",
"data",
")",
"+",
"[",
"dd",
".",
"get_sample_name",
"(",
"data",
")",
",",
"data",
"[",
"\"sv\"",
"]",
"[",
"\"variantcaller\"",
"]",
... | Remove standard prefixes from a filename before renaming with useful names. | [
"Remove",
"standard",
"prefixes",
"from",
"a",
"filename",
"before",
"renaming",
"with",
"useful",
"names",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L249-L258 |
237,047 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | _group_by_sample | def _group_by_sample(items):
"""Group a set of items by sample names + multiple callers for prioritization
"""
by_sample = collections.defaultdict(list)
for d in items:
by_sample[dd.get_sample_name(d)].append(d)
out = []
for sample_group in by_sample.values():
cur = utils.deepish_copy(sample_group[0])
svs = []
for d in sample_group:
svs.append(d["sv"])
cur["sv"] = svs
out.append(cur)
return out | python | def _group_by_sample(items):
by_sample = collections.defaultdict(list)
for d in items:
by_sample[dd.get_sample_name(d)].append(d)
out = []
for sample_group in by_sample.values():
cur = utils.deepish_copy(sample_group[0])
svs = []
for d in sample_group:
svs.append(d["sv"])
cur["sv"] = svs
out.append(cur)
return out | [
"def",
"_group_by_sample",
"(",
"items",
")",
":",
"by_sample",
"=",
"collections",
".",
"defaultdict",
"(",
"list",
")",
"for",
"d",
"in",
"items",
":",
"by_sample",
"[",
"dd",
".",
"get_sample_name",
"(",
"d",
")",
"]",
".",
"append",
"(",
"d",
")",
... | Group a set of items by sample names + multiple callers for prioritization | [
"Group",
"a",
"set",
"of",
"items",
"by",
"sample",
"names",
"+",
"multiple",
"callers",
"for",
"prioritization"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L269-L283 |
237,048 | bcbio/bcbio-nextgen | bcbio/structural/__init__.py | standardize_cnv_reference | def standardize_cnv_reference(data):
"""Standardize cnv_reference background to support multiple callers.
"""
out = tz.get_in(["config", "algorithm", "background", "cnv_reference"], data, {})
cur_callers = set(data["config"]["algorithm"].get("svcaller")) & _CNV_REFERENCE
if isinstance(out, six.string_types):
if not len(cur_callers) == 1:
raise ValueError("Multiple CNV callers and single background reference for %s: %s" %
data["description"], list(cur_callers))
else:
out = {cur_callers.pop(): out}
return out | python | def standardize_cnv_reference(data):
out = tz.get_in(["config", "algorithm", "background", "cnv_reference"], data, {})
cur_callers = set(data["config"]["algorithm"].get("svcaller")) & _CNV_REFERENCE
if isinstance(out, six.string_types):
if not len(cur_callers) == 1:
raise ValueError("Multiple CNV callers and single background reference for %s: %s" %
data["description"], list(cur_callers))
else:
out = {cur_callers.pop(): out}
return out | [
"def",
"standardize_cnv_reference",
"(",
"data",
")",
":",
"out",
"=",
"tz",
".",
"get_in",
"(",
"[",
"\"config\"",
",",
"\"algorithm\"",
",",
"\"background\"",
",",
"\"cnv_reference\"",
"]",
",",
"data",
",",
"{",
"}",
")",
"cur_callers",
"=",
"set",
"(",... | Standardize cnv_reference background to support multiple callers. | [
"Standardize",
"cnv_reference",
"background",
"to",
"support",
"multiple",
"callers",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/__init__.py#L324-L335 |
237,049 | bcbio/bcbio-nextgen | bcbio/ngsalign/bowtie2.py | _bowtie2_args_from_config | def _bowtie2_args_from_config(config, curcl):
"""Configurable high level options for bowtie2.
"""
qual_format = config["algorithm"].get("quality_format", "")
if qual_format.lower() == "illumina":
qual_flags = ["--phred64-quals"]
else:
qual_flags = []
num_cores = config["algorithm"].get("num_cores", 1)
core_flags = ["-p", str(num_cores)] if num_cores > 1 else []
user_opts = config_utils.get_resources("bowtie2", config).get("options", [])
for flag_opt in (o for o in user_opts if str(o).startswith("-")):
if flag_opt in curcl:
raise ValueError("Duplicate option %s in resources and bcbio commandline: %s %s" %
flag_opt, user_opts, curcl)
return core_flags + qual_flags + user_opts | python | def _bowtie2_args_from_config(config, curcl):
qual_format = config["algorithm"].get("quality_format", "")
if qual_format.lower() == "illumina":
qual_flags = ["--phred64-quals"]
else:
qual_flags = []
num_cores = config["algorithm"].get("num_cores", 1)
core_flags = ["-p", str(num_cores)] if num_cores > 1 else []
user_opts = config_utils.get_resources("bowtie2", config).get("options", [])
for flag_opt in (o for o in user_opts if str(o).startswith("-")):
if flag_opt in curcl:
raise ValueError("Duplicate option %s in resources and bcbio commandline: %s %s" %
flag_opt, user_opts, curcl)
return core_flags + qual_flags + user_opts | [
"def",
"_bowtie2_args_from_config",
"(",
"config",
",",
"curcl",
")",
":",
"qual_format",
"=",
"config",
"[",
"\"algorithm\"",
"]",
".",
"get",
"(",
"\"quality_format\"",
",",
"\"\"",
")",
"if",
"qual_format",
".",
"lower",
"(",
")",
"==",
"\"illumina\"",
":... | Configurable high level options for bowtie2. | [
"Configurable",
"high",
"level",
"options",
"for",
"bowtie2",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/ngsalign/bowtie2.py#L15-L30 |
237,050 | bcbio/bcbio-nextgen | bcbio/ngsalign/bowtie2.py | align | def align(fastq_file, pair_file, ref_file, names, align_dir, data,
extra_args=None):
"""Alignment with bowtie2.
"""
config = data["config"]
analysis_config = ANALYSIS.get(data["analysis"].lower())
assert analysis_config, "Analysis %s is not supported by bowtie2" % (data["analysis"])
out_file = os.path.join(align_dir, "{0}-sort.bam".format(dd.get_sample_name(data)))
if data.get("align_split"):
final_file = out_file
out_file, data = alignprep.setup_combine(final_file, data)
fastq_file, pair_file = alignprep.split_namedpipe_cls(fastq_file, pair_file, data)
else:
final_file = None
if not utils.file_exists(out_file) and (final_file is None or not utils.file_exists(final_file)):
with postalign.tobam_cl(data, out_file, pair_file is not None) as (tobam_cl, tx_out_file):
cl = [config_utils.get_program("bowtie2", config)]
cl += extra_args if extra_args is not None else []
cl += ["-q",
"-x", ref_file]
cl += analysis_config.get("params", [])
if pair_file:
cl += ["-1", fastq_file, "-2", pair_file]
else:
cl += ["-U", fastq_file]
if names and "rg" in names:
cl += ["--rg-id", names["rg"]]
for key, tag in [("sample", "SM"), ("pl", "PL"), ("pu", "PU"), ("lb", "LB")]:
if names.get(key):
cl += ["--rg", "%s:%s" % (tag, names[key])]
cl += _bowtie2_args_from_config(config, cl)
cl = [str(i) for i in cl]
cmd = "unset JAVA_HOME && " + " ".join(cl) + " | " + tobam_cl
do.run(cmd, "Aligning %s and %s with Bowtie2." % (fastq_file, pair_file))
return out_file | python | def align(fastq_file, pair_file, ref_file, names, align_dir, data,
extra_args=None):
config = data["config"]
analysis_config = ANALYSIS.get(data["analysis"].lower())
assert analysis_config, "Analysis %s is not supported by bowtie2" % (data["analysis"])
out_file = os.path.join(align_dir, "{0}-sort.bam".format(dd.get_sample_name(data)))
if data.get("align_split"):
final_file = out_file
out_file, data = alignprep.setup_combine(final_file, data)
fastq_file, pair_file = alignprep.split_namedpipe_cls(fastq_file, pair_file, data)
else:
final_file = None
if not utils.file_exists(out_file) and (final_file is None or not utils.file_exists(final_file)):
with postalign.tobam_cl(data, out_file, pair_file is not None) as (tobam_cl, tx_out_file):
cl = [config_utils.get_program("bowtie2", config)]
cl += extra_args if extra_args is not None else []
cl += ["-q",
"-x", ref_file]
cl += analysis_config.get("params", [])
if pair_file:
cl += ["-1", fastq_file, "-2", pair_file]
else:
cl += ["-U", fastq_file]
if names and "rg" in names:
cl += ["--rg-id", names["rg"]]
for key, tag in [("sample", "SM"), ("pl", "PL"), ("pu", "PU"), ("lb", "LB")]:
if names.get(key):
cl += ["--rg", "%s:%s" % (tag, names[key])]
cl += _bowtie2_args_from_config(config, cl)
cl = [str(i) for i in cl]
cmd = "unset JAVA_HOME && " + " ".join(cl) + " | " + tobam_cl
do.run(cmd, "Aligning %s and %s with Bowtie2." % (fastq_file, pair_file))
return out_file | [
"def",
"align",
"(",
"fastq_file",
",",
"pair_file",
",",
"ref_file",
",",
"names",
",",
"align_dir",
",",
"data",
",",
"extra_args",
"=",
"None",
")",
":",
"config",
"=",
"data",
"[",
"\"config\"",
"]",
"analysis_config",
"=",
"ANALYSIS",
".",
"get",
"(... | Alignment with bowtie2. | [
"Alignment",
"with",
"bowtie2",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/ngsalign/bowtie2.py#L32-L66 |
237,051 | bcbio/bcbio-nextgen | bcbio/cwl/hpc.py | create_cromwell_config | def create_cromwell_config(args, work_dir, sample_file):
"""Prepare a cromwell configuration within the current working directory.
"""
docker_attrs = ["String? docker", "String? docker_user"]
cwl_attrs = ["Int? cpuMin", "Int? cpuMax", "Int? memoryMin", "Int? memoryMax", "String? outDirMin",
"String? outDirMax", "String? tmpDirMin", "String? tmpDirMax"]
out_file = os.path.join(work_dir, "bcbio-cromwell.conf")
run_config = _load_custom_config(args.runconfig) if args.runconfig else {}
# Avoid overscheduling jobs for local runs by limiting concurrent jobs
# Longer term would like to keep these within defined core window
joblimit = args.joblimit
if joblimit == 0 and not args.scheduler:
joblimit = 1
file_types = _get_filesystem_types(args, sample_file)
std_args = {"docker_attrs": "" if args.no_container else "\n ".join(docker_attrs),
"submit_docker": 'submit-docker: ""' if args.no_container else "",
"joblimit": "concurrent-job-limit = %s" % (joblimit) if joblimit > 0 else "",
"cwl_attrs": "\n ".join(cwl_attrs),
"filesystem": _get_filesystem_config(file_types),
"database": run_config.get("database", DATABASE_CONFIG % {"work_dir": work_dir})}
cl_args, conf_args, scheduler, cloud_type = _args_to_cromwell(args)
std_args["engine"] = _get_engine_filesystem_config(file_types, args, conf_args)
conf_args.update(std_args)
main_config = {"hpc": (HPC_CONFIGS[scheduler] % conf_args) if scheduler else "",
"cloud": (CLOUD_CONFIGS[cloud_type] % conf_args) if cloud_type else "",
"work_dir": work_dir}
main_config.update(std_args)
# Local run always seems to need docker set because of submit-docker in default configuration
# Can we unset submit-docker based on configuration so it doesn't inherit?
# main_config["docker_attrs"] = "\n ".join(docker_attrs)
with open(out_file, "w") as out_handle:
out_handle.write(CROMWELL_CONFIG % main_config)
return out_file | python | def create_cromwell_config(args, work_dir, sample_file):
docker_attrs = ["String? docker", "String? docker_user"]
cwl_attrs = ["Int? cpuMin", "Int? cpuMax", "Int? memoryMin", "Int? memoryMax", "String? outDirMin",
"String? outDirMax", "String? tmpDirMin", "String? tmpDirMax"]
out_file = os.path.join(work_dir, "bcbio-cromwell.conf")
run_config = _load_custom_config(args.runconfig) if args.runconfig else {}
# Avoid overscheduling jobs for local runs by limiting concurrent jobs
# Longer term would like to keep these within defined core window
joblimit = args.joblimit
if joblimit == 0 and not args.scheduler:
joblimit = 1
file_types = _get_filesystem_types(args, sample_file)
std_args = {"docker_attrs": "" if args.no_container else "\n ".join(docker_attrs),
"submit_docker": 'submit-docker: ""' if args.no_container else "",
"joblimit": "concurrent-job-limit = %s" % (joblimit) if joblimit > 0 else "",
"cwl_attrs": "\n ".join(cwl_attrs),
"filesystem": _get_filesystem_config(file_types),
"database": run_config.get("database", DATABASE_CONFIG % {"work_dir": work_dir})}
cl_args, conf_args, scheduler, cloud_type = _args_to_cromwell(args)
std_args["engine"] = _get_engine_filesystem_config(file_types, args, conf_args)
conf_args.update(std_args)
main_config = {"hpc": (HPC_CONFIGS[scheduler] % conf_args) if scheduler else "",
"cloud": (CLOUD_CONFIGS[cloud_type] % conf_args) if cloud_type else "",
"work_dir": work_dir}
main_config.update(std_args)
# Local run always seems to need docker set because of submit-docker in default configuration
# Can we unset submit-docker based on configuration so it doesn't inherit?
# main_config["docker_attrs"] = "\n ".join(docker_attrs)
with open(out_file, "w") as out_handle:
out_handle.write(CROMWELL_CONFIG % main_config)
return out_file | [
"def",
"create_cromwell_config",
"(",
"args",
",",
"work_dir",
",",
"sample_file",
")",
":",
"docker_attrs",
"=",
"[",
"\"String? docker\"",
",",
"\"String? docker_user\"",
"]",
"cwl_attrs",
"=",
"[",
"\"Int? cpuMin\"",
",",
"\"Int? cpuMax\"",
",",
"\"Int? memoryMin\"... | Prepare a cromwell configuration within the current working directory. | [
"Prepare",
"a",
"cromwell",
"configuration",
"within",
"the",
"current",
"working",
"directory",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/cwl/hpc.py#L8-L40 |
237,052 | bcbio/bcbio-nextgen | bcbio/cwl/hpc.py | _get_file_paths | def _get_file_paths(cur):
"""Retrieve a list of file paths, recursively traversing the
"""
out = []
if isinstance(cur, (list, tuple)):
for x in cur:
new = _get_file_paths(x)
if new:
out.extend(new)
elif isinstance(cur, dict):
if "class" in cur:
out.append(cur["path"])
else:
for k, v in cur.items():
new = _get_file_paths(v)
if new:
out.extend(new)
return out | python | def _get_file_paths(cur):
out = []
if isinstance(cur, (list, tuple)):
for x in cur:
new = _get_file_paths(x)
if new:
out.extend(new)
elif isinstance(cur, dict):
if "class" in cur:
out.append(cur["path"])
else:
for k, v in cur.items():
new = _get_file_paths(v)
if new:
out.extend(new)
return out | [
"def",
"_get_file_paths",
"(",
"cur",
")",
":",
"out",
"=",
"[",
"]",
"if",
"isinstance",
"(",
"cur",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"for",
"x",
"in",
"cur",
":",
"new",
"=",
"_get_file_paths",
"(",
"x",
")",
"if",
"new",
":",
"... | Retrieve a list of file paths, recursively traversing the | [
"Retrieve",
"a",
"list",
"of",
"file",
"paths",
"recursively",
"traversing",
"the"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/cwl/hpc.py#L42-L59 |
237,053 | bcbio/bcbio-nextgen | bcbio/cwl/hpc.py | _load_custom_config | def _load_custom_config(run_config):
"""Load custom configuration input HOCON file for cromwell.
"""
from pyhocon import ConfigFactory, HOCONConverter, ConfigTree
conf = ConfigFactory.parse_file(run_config)
out = {}
if "database" in conf:
out["database"] = HOCONConverter.to_hocon(ConfigTree({"database": conf.get_config("database")}))
return out | python | def _load_custom_config(run_config):
from pyhocon import ConfigFactory, HOCONConverter, ConfigTree
conf = ConfigFactory.parse_file(run_config)
out = {}
if "database" in conf:
out["database"] = HOCONConverter.to_hocon(ConfigTree({"database": conf.get_config("database")}))
return out | [
"def",
"_load_custom_config",
"(",
"run_config",
")",
":",
"from",
"pyhocon",
"import",
"ConfigFactory",
",",
"HOCONConverter",
",",
"ConfigTree",
"conf",
"=",
"ConfigFactory",
".",
"parse_file",
"(",
"run_config",
")",
"out",
"=",
"{",
"}",
"if",
"\"database\""... | Load custom configuration input HOCON file for cromwell. | [
"Load",
"custom",
"configuration",
"input",
"HOCON",
"file",
"for",
"cromwell",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/cwl/hpc.py#L61-L69 |
237,054 | bcbio/bcbio-nextgen | bcbio/cwl/hpc.py | _args_to_cromwell | def _args_to_cromwell(args):
"""Convert input arguments into cromwell inputs for config and command line.
"""
default_config = {"slurm": {"timelimit": "1-00:00", "account": ""},
"sge": {"memtype": "mem_free", "pename": "smp"},
"lsf": {"walltime": "24:00", "account": ""},
"htcondor": {},
"torque": {"walltime": "24:00:00", "account": ""},
"pbspro": {"walltime": "24:00:00", "account": "",
"cpu_and_mem": "-l select=1:ncpus=${cpu}:mem=${memory_mb}mb"}}
prefixes = {("account", "slurm"): "-A ", ("account", "pbspro"): "-A "}
custom = {("noselect", "pbspro"): ("cpu_and_mem", "-l ncpus=${cpu} -l mem=${memory_mb}mb")}
cl = []
config = {}
# HPC scheduling
if args.scheduler:
if args.scheduler not in default_config:
raise ValueError("Scheduler not yet supported by Cromwell: %s" % args.scheduler)
if not args.queue and args.scheduler not in ["htcondor"]:
raise ValueError("Need to set queue (-q) for running with an HPC scheduler")
config = default_config[args.scheduler]
cl.append("-Dbackend.default=%s" % args.scheduler.upper())
config["queue"] = args.queue
for rs in args.resources:
for r in rs.split(";"):
parts = r.split("=")
if len(parts) == 2:
key, val = parts
config[key] = prefixes.get((key, args.scheduler), "") + val
elif len(parts) == 1 and (parts[0], args.scheduler) in custom:
key, val = custom[(parts[0], args.scheduler)]
config[key] = val
cloud_type = None
if args.cloud_project:
if args.cloud_root and args.cloud_root.startswith("gs:"):
cloud_type = "PAPI"
cloud_root = args.cloud_root
cloud_region = None
elif ((args.cloud_root and args.cloud_root.startswith("s3:")) or
(args.cloud_project and args.cloud_project.startswith("arn:"))):
cloud_type = "AWSBATCH"
cloud_root = args.cloud_root
if not cloud_root.startswith("s3://"):
cloud_root = "s3://%s" % cloud_root
# split region from input Amazon Resource Name, ie arn:aws:batch:us-east-1:
cloud_region = args.cloud_project.split(":")[3]
else:
raise ValueError("Unexpected inputs for Cromwell Cloud support: %s %s" %
(args.cloud_project, args.cloud_root))
config = {"cloud_project": args.cloud_project, "cloud_root": cloud_root, "cloud_region": cloud_region}
cl.append("-Dbackend.default=%s" % cloud_type)
return cl, config, args.scheduler, cloud_type | python | def _args_to_cromwell(args):
default_config = {"slurm": {"timelimit": "1-00:00", "account": ""},
"sge": {"memtype": "mem_free", "pename": "smp"},
"lsf": {"walltime": "24:00", "account": ""},
"htcondor": {},
"torque": {"walltime": "24:00:00", "account": ""},
"pbspro": {"walltime": "24:00:00", "account": "",
"cpu_and_mem": "-l select=1:ncpus=${cpu}:mem=${memory_mb}mb"}}
prefixes = {("account", "slurm"): "-A ", ("account", "pbspro"): "-A "}
custom = {("noselect", "pbspro"): ("cpu_and_mem", "-l ncpus=${cpu} -l mem=${memory_mb}mb")}
cl = []
config = {}
# HPC scheduling
if args.scheduler:
if args.scheduler not in default_config:
raise ValueError("Scheduler not yet supported by Cromwell: %s" % args.scheduler)
if not args.queue and args.scheduler not in ["htcondor"]:
raise ValueError("Need to set queue (-q) for running with an HPC scheduler")
config = default_config[args.scheduler]
cl.append("-Dbackend.default=%s" % args.scheduler.upper())
config["queue"] = args.queue
for rs in args.resources:
for r in rs.split(";"):
parts = r.split("=")
if len(parts) == 2:
key, val = parts
config[key] = prefixes.get((key, args.scheduler), "") + val
elif len(parts) == 1 and (parts[0], args.scheduler) in custom:
key, val = custom[(parts[0], args.scheduler)]
config[key] = val
cloud_type = None
if args.cloud_project:
if args.cloud_root and args.cloud_root.startswith("gs:"):
cloud_type = "PAPI"
cloud_root = args.cloud_root
cloud_region = None
elif ((args.cloud_root and args.cloud_root.startswith("s3:")) or
(args.cloud_project and args.cloud_project.startswith("arn:"))):
cloud_type = "AWSBATCH"
cloud_root = args.cloud_root
if not cloud_root.startswith("s3://"):
cloud_root = "s3://%s" % cloud_root
# split region from input Amazon Resource Name, ie arn:aws:batch:us-east-1:
cloud_region = args.cloud_project.split(":")[3]
else:
raise ValueError("Unexpected inputs for Cromwell Cloud support: %s %s" %
(args.cloud_project, args.cloud_root))
config = {"cloud_project": args.cloud_project, "cloud_root": cloud_root, "cloud_region": cloud_region}
cl.append("-Dbackend.default=%s" % cloud_type)
return cl, config, args.scheduler, cloud_type | [
"def",
"_args_to_cromwell",
"(",
"args",
")",
":",
"default_config",
"=",
"{",
"\"slurm\"",
":",
"{",
"\"timelimit\"",
":",
"\"1-00:00\"",
",",
"\"account\"",
":",
"\"\"",
"}",
",",
"\"sge\"",
":",
"{",
"\"memtype\"",
":",
"\"mem_free\"",
",",
"\"pename\"",
... | Convert input arguments into cromwell inputs for config and command line. | [
"Convert",
"input",
"arguments",
"into",
"cromwell",
"inputs",
"for",
"config",
"and",
"command",
"line",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/cwl/hpc.py#L77-L128 |
237,055 | bcbio/bcbio-nextgen | bcbio/cwl/hpc.py | _get_filesystem_types | def _get_filesystem_types(args, sample_file):
"""Retrieve the types of inputs and staging based on sample JSON and arguments.
"""
out = set([])
ext = "" if args.no_container else "_container"
with open(sample_file) as in_handle:
for f in _get_file_paths(json.load(in_handle)):
if f.startswith("gs:"):
out.add("gcp%s" % ext)
elif f.startswith("s3:"):
out.add("s3%s" % ext)
elif f.startswith(("https:", "http:")):
out.add("http%s" % ext)
else:
out.add("local%s" % ext)
return out | python | def _get_filesystem_types(args, sample_file):
out = set([])
ext = "" if args.no_container else "_container"
with open(sample_file) as in_handle:
for f in _get_file_paths(json.load(in_handle)):
if f.startswith("gs:"):
out.add("gcp%s" % ext)
elif f.startswith("s3:"):
out.add("s3%s" % ext)
elif f.startswith(("https:", "http:")):
out.add("http%s" % ext)
else:
out.add("local%s" % ext)
return out | [
"def",
"_get_filesystem_types",
"(",
"args",
",",
"sample_file",
")",
":",
"out",
"=",
"set",
"(",
"[",
"]",
")",
"ext",
"=",
"\"\"",
"if",
"args",
".",
"no_container",
"else",
"\"_container\"",
"with",
"open",
"(",
"sample_file",
")",
"as",
"in_handle",
... | Retrieve the types of inputs and staging based on sample JSON and arguments. | [
"Retrieve",
"the",
"types",
"of",
"inputs",
"and",
"staging",
"based",
"on",
"sample",
"JSON",
"and",
"arguments",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/cwl/hpc.py#L130-L145 |
237,056 | bcbio/bcbio-nextgen | bcbio/cwl/hpc.py | _get_filesystem_config | def _get_filesystem_config(file_types):
"""Retrieve filesystem configuration, including support for specified file types.
"""
out = " filesystems {\n"
for file_type in sorted(list(file_types)):
if file_type in _FILESYSTEM_CONFIG:
out += _FILESYSTEM_CONFIG[file_type]
out += " }\n"
return out | python | def _get_filesystem_config(file_types):
out = " filesystems {\n"
for file_type in sorted(list(file_types)):
if file_type in _FILESYSTEM_CONFIG:
out += _FILESYSTEM_CONFIG[file_type]
out += " }\n"
return out | [
"def",
"_get_filesystem_config",
"(",
"file_types",
")",
":",
"out",
"=",
"\" filesystems {\\n\"",
"for",
"file_type",
"in",
"sorted",
"(",
"list",
"(",
"file_types",
")",
")",
":",
"if",
"file_type",
"in",
"_FILESYSTEM_CONFIG",
":",
"out",
"+=",
"_FILESYSTE... | Retrieve filesystem configuration, including support for specified file types. | [
"Retrieve",
"filesystem",
"configuration",
"including",
"support",
"for",
"specified",
"file",
"types",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/cwl/hpc.py#L147-L155 |
237,057 | bcbio/bcbio-nextgen | bcbio/cwl/hpc.py | _get_engine_filesystem_config | def _get_engine_filesystem_config(file_types, args, conf_args):
"""Retriever authorization and engine filesystem configuration.
"""
file_types = [x.replace("_container", "") for x in list(file_types)]
out = ""
if "gcp" in file_types:
out += _AUTH_CONFIG_GOOGLE
if "s3" in file_types:
out += _AUTH_CONFIG_AWS % conf_args["cloud_region"]
if "gcp" in file_types or "http" in file_types or "s3" in file_types:
out += "engine {\n"
out += " filesystems {\n"
if "gcp" in file_types:
out += ' gcs {\n'
out += ' auth = "gcp-auth"\n'
if args.cloud_project:
out += ' project = "%s"\n' % args.cloud_project
out += ' }\n'
if "http" in file_types:
out += ' http {}\n'
if "s3" in file_types:
out += ' s3 { auth = "default" }'
out += " }\n"
out += "}\n"
return out | python | def _get_engine_filesystem_config(file_types, args, conf_args):
file_types = [x.replace("_container", "") for x in list(file_types)]
out = ""
if "gcp" in file_types:
out += _AUTH_CONFIG_GOOGLE
if "s3" in file_types:
out += _AUTH_CONFIG_AWS % conf_args["cloud_region"]
if "gcp" in file_types or "http" in file_types or "s3" in file_types:
out += "engine {\n"
out += " filesystems {\n"
if "gcp" in file_types:
out += ' gcs {\n'
out += ' auth = "gcp-auth"\n'
if args.cloud_project:
out += ' project = "%s"\n' % args.cloud_project
out += ' }\n'
if "http" in file_types:
out += ' http {}\n'
if "s3" in file_types:
out += ' s3 { auth = "default" }'
out += " }\n"
out += "}\n"
return out | [
"def",
"_get_engine_filesystem_config",
"(",
"file_types",
",",
"args",
",",
"conf_args",
")",
":",
"file_types",
"=",
"[",
"x",
".",
"replace",
"(",
"\"_container\"",
",",
"\"\"",
")",
"for",
"x",
"in",
"list",
"(",
"file_types",
")",
"]",
"out",
"=",
"... | Retriever authorization and engine filesystem configuration. | [
"Retriever",
"authorization",
"and",
"engine",
"filesystem",
"configuration",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/cwl/hpc.py#L212-L237 |
237,058 | bcbio/bcbio-nextgen | bcbio/variation/normalize.py | normalize | def normalize(in_file, data, passonly=False, normalize_indels=True, split_biallelic=True,
rerun_effects=True, remove_oldeffects=False, nonrefonly=False, work_dir=None):
"""Normalizes variants and reruns SnpEFF for resulting VCF
"""
if remove_oldeffects:
out_file = "%s-noeff-nomultiallelic%s" % utils.splitext_plus(in_file)
else:
out_file = "%s-nomultiallelic%s" % utils.splitext_plus(in_file)
if work_dir:
out_file = os.path.join(work_dir, os.path.basename(out_file))
if not utils.file_exists(out_file):
if vcfutils.vcf_has_variants(in_file):
ready_ma_file = _normalize(in_file, data, passonly=passonly,
normalize_indels=normalize_indels,
split_biallelic=split_biallelic,
remove_oldeffects=remove_oldeffects,
nonrefonly=nonrefonly,
work_dir=work_dir)
if rerun_effects:
ann_ma_file, _ = effects.add_to_vcf(ready_ma_file, data)
if ann_ma_file:
ready_ma_file = ann_ma_file
utils.symlink_plus(ready_ma_file, out_file)
else:
utils.symlink_plus(in_file, out_file)
return vcfutils.bgzip_and_index(out_file, data["config"]) | python | def normalize(in_file, data, passonly=False, normalize_indels=True, split_biallelic=True,
rerun_effects=True, remove_oldeffects=False, nonrefonly=False, work_dir=None):
if remove_oldeffects:
out_file = "%s-noeff-nomultiallelic%s" % utils.splitext_plus(in_file)
else:
out_file = "%s-nomultiallelic%s" % utils.splitext_plus(in_file)
if work_dir:
out_file = os.path.join(work_dir, os.path.basename(out_file))
if not utils.file_exists(out_file):
if vcfutils.vcf_has_variants(in_file):
ready_ma_file = _normalize(in_file, data, passonly=passonly,
normalize_indels=normalize_indels,
split_biallelic=split_biallelic,
remove_oldeffects=remove_oldeffects,
nonrefonly=nonrefonly,
work_dir=work_dir)
if rerun_effects:
ann_ma_file, _ = effects.add_to_vcf(ready_ma_file, data)
if ann_ma_file:
ready_ma_file = ann_ma_file
utils.symlink_plus(ready_ma_file, out_file)
else:
utils.symlink_plus(in_file, out_file)
return vcfutils.bgzip_and_index(out_file, data["config"]) | [
"def",
"normalize",
"(",
"in_file",
",",
"data",
",",
"passonly",
"=",
"False",
",",
"normalize_indels",
"=",
"True",
",",
"split_biallelic",
"=",
"True",
",",
"rerun_effects",
"=",
"True",
",",
"remove_oldeffects",
"=",
"False",
",",
"nonrefonly",
"=",
"Fal... | Normalizes variants and reruns SnpEFF for resulting VCF | [
"Normalizes",
"variants",
"and",
"reruns",
"SnpEFF",
"for",
"resulting",
"VCF"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/normalize.py#L59-L84 |
237,059 | bcbio/bcbio-nextgen | bcbio/variation/normalize.py | _normalize | def _normalize(in_file, data, passonly=False, normalize_indels=True, split_biallelic=True,
remove_oldeffects=False, nonrefonly=False, work_dir=None):
"""Convert multi-allelic variants into single allelic.
`vt normalize` has the -n flag passed (skipping reference checks) because
of errors where the reference genome has non GATCN ambiguous bases. These
are not supported in VCF, so you'll have a mismatch of N in VCF versus R
(or other ambiguous bases) in the genome.
"""
if remove_oldeffects:
out_file = "%s-noeff-decompose%s" % utils.splitext_plus(in_file)
old_effects = [a for a in ["CSQ", "ANN"] if a in cyvcf2.VCF(in_file)]
if old_effects:
clean_effects_cmd = " | bcftools annotate -x %s " % (",".join(["INFO/%s" % x for x in old_effects]))
else:
clean_effects_cmd = ""
else:
clean_effects_cmd = ""
out_file = "%s-decompose%s" % utils.splitext_plus(in_file)
if passonly or nonrefonly:
subset_vcf_cmd = " | bcftools view "
if passonly:
subset_vcf_cmd += "-f 'PASS,.' "
if nonrefonly:
subset_vcf_cmd += "--min-ac 1:nref "
else:
subset_vcf_cmd = ""
if work_dir:
out_file = os.path.join(work_dir, os.path.basename(out_file))
if not utils.file_exists(out_file):
ref_file = dd.get_ref_file(data)
assert out_file.endswith(".vcf.gz")
with file_transaction(data, out_file) as tx_out_file:
cmd = ("gunzip -c " + in_file +
subset_vcf_cmd + clean_effects_cmd +
(" | vcfallelicprimitives -t DECOMPOSED --keep-geno" if split_biallelic else "") +
" | sed 's/ID=AD,Number=./ID=AD,Number=R/'" +
" | vt decompose -s - " +
((" | vt normalize -n -r " + ref_file + " - ") if normalize_indels else "") +
" | awk '{ gsub(\"./-65\", \"./.\"); print $0 }'" +
" | sed -e 's/Number=A/Number=1/g'" +
" | bgzip -c > " + tx_out_file
)
do.run(cmd, "Multi-allelic to single allele")
return vcfutils.bgzip_and_index(out_file, data["config"]) | python | def _normalize(in_file, data, passonly=False, normalize_indels=True, split_biallelic=True,
remove_oldeffects=False, nonrefonly=False, work_dir=None):
if remove_oldeffects:
out_file = "%s-noeff-decompose%s" % utils.splitext_plus(in_file)
old_effects = [a for a in ["CSQ", "ANN"] if a in cyvcf2.VCF(in_file)]
if old_effects:
clean_effects_cmd = " | bcftools annotate -x %s " % (",".join(["INFO/%s" % x for x in old_effects]))
else:
clean_effects_cmd = ""
else:
clean_effects_cmd = ""
out_file = "%s-decompose%s" % utils.splitext_plus(in_file)
if passonly or nonrefonly:
subset_vcf_cmd = " | bcftools view "
if passonly:
subset_vcf_cmd += "-f 'PASS,.' "
if nonrefonly:
subset_vcf_cmd += "--min-ac 1:nref "
else:
subset_vcf_cmd = ""
if work_dir:
out_file = os.path.join(work_dir, os.path.basename(out_file))
if not utils.file_exists(out_file):
ref_file = dd.get_ref_file(data)
assert out_file.endswith(".vcf.gz")
with file_transaction(data, out_file) as tx_out_file:
cmd = ("gunzip -c " + in_file +
subset_vcf_cmd + clean_effects_cmd +
(" | vcfallelicprimitives -t DECOMPOSED --keep-geno" if split_biallelic else "") +
" | sed 's/ID=AD,Number=./ID=AD,Number=R/'" +
" | vt decompose -s - " +
((" | vt normalize -n -r " + ref_file + " - ") if normalize_indels else "") +
" | awk '{ gsub(\"./-65\", \"./.\"); print $0 }'" +
" | sed -e 's/Number=A/Number=1/g'" +
" | bgzip -c > " + tx_out_file
)
do.run(cmd, "Multi-allelic to single allele")
return vcfutils.bgzip_and_index(out_file, data["config"]) | [
"def",
"_normalize",
"(",
"in_file",
",",
"data",
",",
"passonly",
"=",
"False",
",",
"normalize_indels",
"=",
"True",
",",
"split_biallelic",
"=",
"True",
",",
"remove_oldeffects",
"=",
"False",
",",
"nonrefonly",
"=",
"False",
",",
"work_dir",
"=",
"None",... | Convert multi-allelic variants into single allelic.
`vt normalize` has the -n flag passed (skipping reference checks) because
of errors where the reference genome has non GATCN ambiguous bases. These
are not supported in VCF, so you'll have a mismatch of N in VCF versus R
(or other ambiguous bases) in the genome. | [
"Convert",
"multi",
"-",
"allelic",
"variants",
"into",
"single",
"allelic",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/variation/normalize.py#L86-L130 |
237,060 | bcbio/bcbio-nextgen | bcbio/rnaseq/sailfish.py | sleuthify_sailfish | def sleuthify_sailfish(sailfish_dir):
"""
if installed, use wasabi to create abundance.h5 output for use with
sleuth
"""
if not R_package_path("wasabi"):
return None
else:
rscript = Rscript_cmd()
cmd = """{rscript} --no-environ -e 'library("wasabi"); prepare_fish_for_sleuth(c("{sailfish_dir}"))'"""
do.run(cmd.format(**locals()), "Converting Sailfish to Sleuth format.")
return os.path.join(sailfish_dir, "abundance.h5") | python | def sleuthify_sailfish(sailfish_dir):
if not R_package_path("wasabi"):
return None
else:
rscript = Rscript_cmd()
cmd = """{rscript} --no-environ -e 'library("wasabi"); prepare_fish_for_sleuth(c("{sailfish_dir}"))'"""
do.run(cmd.format(**locals()), "Converting Sailfish to Sleuth format.")
return os.path.join(sailfish_dir, "abundance.h5") | [
"def",
"sleuthify_sailfish",
"(",
"sailfish_dir",
")",
":",
"if",
"not",
"R_package_path",
"(",
"\"wasabi\"",
")",
":",
"return",
"None",
"else",
":",
"rscript",
"=",
"Rscript_cmd",
"(",
")",
"cmd",
"=",
"\"\"\"{rscript} --no-environ -e 'library(\"wasabi\"); prepare_f... | if installed, use wasabi to create abundance.h5 output for use with
sleuth | [
"if",
"installed",
"use",
"wasabi",
"to",
"create",
"abundance",
".",
"h5",
"output",
"for",
"use",
"with",
"sleuth"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/rnaseq/sailfish.py#L66-L77 |
237,061 | bcbio/bcbio-nextgen | bcbio/rnaseq/sailfish.py | create_combined_fasta | def create_combined_fasta(data):
"""
if there are genomes to be disambiguated, create a FASTA file of
all of the transcripts for all genomes
"""
out_dir = os.path.join(dd.get_work_dir(data), "inputs", "transcriptome")
items = disambiguate.split([data])
fasta_files = []
for i in items:
odata = i[0]
gtf_file = dd.get_gtf_file(odata)
ref_file = dd.get_ref_file(odata)
out_file = os.path.join(out_dir, dd.get_genome_build(odata) + ".fa")
if file_exists(out_file):
fasta_files.append(out_file)
else:
out_file = gtf.gtf_to_fasta(gtf_file, ref_file, out_file=out_file)
fasta_files.append(out_file)
out_stem = os.path.join(out_dir, dd.get_genome_build(data))
if dd.get_disambiguate(data):
out_stem = "-".join([out_stem] + (dd.get_disambiguate(data) or []))
combined_file = out_stem + ".fa"
if file_exists(combined_file):
return combined_file
fasta_file_string = " ".join(fasta_files)
cmd = "cat {fasta_file_string} > {tx_out_file}"
with file_transaction(data, combined_file) as tx_out_file:
do.run(cmd.format(**locals()), "Combining transcriptome FASTA files.")
return combined_file | python | def create_combined_fasta(data):
out_dir = os.path.join(dd.get_work_dir(data), "inputs", "transcriptome")
items = disambiguate.split([data])
fasta_files = []
for i in items:
odata = i[0]
gtf_file = dd.get_gtf_file(odata)
ref_file = dd.get_ref_file(odata)
out_file = os.path.join(out_dir, dd.get_genome_build(odata) + ".fa")
if file_exists(out_file):
fasta_files.append(out_file)
else:
out_file = gtf.gtf_to_fasta(gtf_file, ref_file, out_file=out_file)
fasta_files.append(out_file)
out_stem = os.path.join(out_dir, dd.get_genome_build(data))
if dd.get_disambiguate(data):
out_stem = "-".join([out_stem] + (dd.get_disambiguate(data) or []))
combined_file = out_stem + ".fa"
if file_exists(combined_file):
return combined_file
fasta_file_string = " ".join(fasta_files)
cmd = "cat {fasta_file_string} > {tx_out_file}"
with file_transaction(data, combined_file) as tx_out_file:
do.run(cmd.format(**locals()), "Combining transcriptome FASTA files.")
return combined_file | [
"def",
"create_combined_fasta",
"(",
"data",
")",
":",
"out_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"dd",
".",
"get_work_dir",
"(",
"data",
")",
",",
"\"inputs\"",
",",
"\"transcriptome\"",
")",
"items",
"=",
"disambiguate",
".",
"split",
"(",
"[... | if there are genomes to be disambiguated, create a FASTA file of
all of the transcripts for all genomes | [
"if",
"there",
"are",
"genomes",
"to",
"be",
"disambiguated",
"create",
"a",
"FASTA",
"file",
"of",
"all",
"of",
"the",
"transcripts",
"for",
"all",
"genomes"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/rnaseq/sailfish.py#L79-L108 |
237,062 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | prep_samples_and_config | def prep_samples_and_config(run_folder, ldetails, fastq_dir, config):
"""Prepare sample fastq files and provide global sample configuration for the flowcell.
Handles merging of fastq files split by lane and also by the bcl2fastq
preparation process.
"""
fastq_final_dir = utils.safe_makedir(os.path.join(fastq_dir, "merged"))
cores = utils.get_in(config, ("algorithm", "num_cores"), 1)
ldetails = joblib.Parallel(cores)(joblib.delayed(_prep_sample_and_config)(x, fastq_dir, fastq_final_dir)
for x in _group_same_samples(ldetails))
config_file = _write_sample_config(run_folder, [x for x in ldetails if x])
return config_file, fastq_final_dir | python | def prep_samples_and_config(run_folder, ldetails, fastq_dir, config):
fastq_final_dir = utils.safe_makedir(os.path.join(fastq_dir, "merged"))
cores = utils.get_in(config, ("algorithm", "num_cores"), 1)
ldetails = joblib.Parallel(cores)(joblib.delayed(_prep_sample_and_config)(x, fastq_dir, fastq_final_dir)
for x in _group_same_samples(ldetails))
config_file = _write_sample_config(run_folder, [x for x in ldetails if x])
return config_file, fastq_final_dir | [
"def",
"prep_samples_and_config",
"(",
"run_folder",
",",
"ldetails",
",",
"fastq_dir",
",",
"config",
")",
":",
"fastq_final_dir",
"=",
"utils",
".",
"safe_makedir",
"(",
"os",
".",
"path",
".",
"join",
"(",
"fastq_dir",
",",
"\"merged\"",
")",
")",
"cores"... | Prepare sample fastq files and provide global sample configuration for the flowcell.
Handles merging of fastq files split by lane and also by the bcl2fastq
preparation process. | [
"Prepare",
"sample",
"fastq",
"files",
"and",
"provide",
"global",
"sample",
"configuration",
"for",
"the",
"flowcell",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L23-L34 |
237,063 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | _prep_sample_and_config | def _prep_sample_and_config(ldetail_group, fastq_dir, fastq_final_dir):
"""Prepare output fastq file and configuration for a single sample.
Only passes non-empty files through for processing.
"""
files = []
print("->", ldetail_group[0]["name"], len(ldetail_group))
for read in ["R1", "R2"]:
fastq_inputs = sorted(list(set(reduce(operator.add,
(_get_fastq_files(x, read, fastq_dir) for x in ldetail_group)))))
if len(fastq_inputs) > 0:
files.append(_concat_bgzip_fastq(fastq_inputs, fastq_final_dir, read, ldetail_group[0]))
if len(files) > 0:
if _non_empty(files[0]):
out = ldetail_group[0]
out["files"] = files
return out | python | def _prep_sample_and_config(ldetail_group, fastq_dir, fastq_final_dir):
files = []
print("->", ldetail_group[0]["name"], len(ldetail_group))
for read in ["R1", "R2"]:
fastq_inputs = sorted(list(set(reduce(operator.add,
(_get_fastq_files(x, read, fastq_dir) for x in ldetail_group)))))
if len(fastq_inputs) > 0:
files.append(_concat_bgzip_fastq(fastq_inputs, fastq_final_dir, read, ldetail_group[0]))
if len(files) > 0:
if _non_empty(files[0]):
out = ldetail_group[0]
out["files"] = files
return out | [
"def",
"_prep_sample_and_config",
"(",
"ldetail_group",
",",
"fastq_dir",
",",
"fastq_final_dir",
")",
":",
"files",
"=",
"[",
"]",
"print",
"(",
"\"->\"",
",",
"ldetail_group",
"[",
"0",
"]",
"[",
"\"name\"",
"]",
",",
"len",
"(",
"ldetail_group",
")",
")... | Prepare output fastq file and configuration for a single sample.
Only passes non-empty files through for processing. | [
"Prepare",
"output",
"fastq",
"file",
"and",
"configuration",
"for",
"a",
"single",
"sample",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L36-L52 |
237,064 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | _write_sample_config | def _write_sample_config(run_folder, ldetails):
"""Generate a bcbio-nextgen YAML configuration file for processing a sample.
"""
out_file = os.path.join(run_folder, "%s.yaml" % os.path.basename(run_folder))
with open(out_file, "w") as out_handle:
fc_name, fc_date = flowcell.parse_dirname(run_folder)
out = {"details": sorted([_prepare_sample(x, run_folder) for x in ldetails],
key=operator.itemgetter("name", "description")),
"fc_name": fc_name,
"fc_date": fc_date}
yaml.safe_dump(out, out_handle, default_flow_style=False, allow_unicode=False)
return out_file | python | def _write_sample_config(run_folder, ldetails):
out_file = os.path.join(run_folder, "%s.yaml" % os.path.basename(run_folder))
with open(out_file, "w") as out_handle:
fc_name, fc_date = flowcell.parse_dirname(run_folder)
out = {"details": sorted([_prepare_sample(x, run_folder) for x in ldetails],
key=operator.itemgetter("name", "description")),
"fc_name": fc_name,
"fc_date": fc_date}
yaml.safe_dump(out, out_handle, default_flow_style=False, allow_unicode=False)
return out_file | [
"def",
"_write_sample_config",
"(",
"run_folder",
",",
"ldetails",
")",
":",
"out_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"run_folder",
",",
"\"%s.yaml\"",
"%",
"os",
".",
"path",
".",
"basename",
"(",
"run_folder",
")",
")",
"with",
"open",
"("... | Generate a bcbio-nextgen YAML configuration file for processing a sample. | [
"Generate",
"a",
"bcbio",
"-",
"nextgen",
"YAML",
"configuration",
"file",
"for",
"processing",
"a",
"sample",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L60-L71 |
237,065 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | _prepare_sample | def _prepare_sample(data, run_folder):
"""Extract passed keywords from input LIMS information.
"""
want = set(["description", "files", "genome_build", "name", "analysis", "upload", "algorithm"])
out = {}
for k, v in data.items():
if k in want:
out[k] = _relative_paths(v, run_folder)
if "algorithm" not in out:
analysis, algorithm = _select_default_algorithm(out.get("analysis"))
out["algorithm"] = algorithm
out["analysis"] = analysis
description = "%s-%s" % (out["name"], clean_name(out["description"]))
out["name"] = [out["name"], description]
out["description"] = description
return out | python | def _prepare_sample(data, run_folder):
want = set(["description", "files", "genome_build", "name", "analysis", "upload", "algorithm"])
out = {}
for k, v in data.items():
if k in want:
out[k] = _relative_paths(v, run_folder)
if "algorithm" not in out:
analysis, algorithm = _select_default_algorithm(out.get("analysis"))
out["algorithm"] = algorithm
out["analysis"] = analysis
description = "%s-%s" % (out["name"], clean_name(out["description"]))
out["name"] = [out["name"], description]
out["description"] = description
return out | [
"def",
"_prepare_sample",
"(",
"data",
",",
"run_folder",
")",
":",
"want",
"=",
"set",
"(",
"[",
"\"description\"",
",",
"\"files\"",
",",
"\"genome_build\"",
",",
"\"name\"",
",",
"\"analysis\"",
",",
"\"upload\"",
",",
"\"algorithm\"",
"]",
")",
"out",
"=... | Extract passed keywords from input LIMS information. | [
"Extract",
"passed",
"keywords",
"from",
"input",
"LIMS",
"information",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L73-L88 |
237,066 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | _select_default_algorithm | def _select_default_algorithm(analysis):
"""Provide default algorithm sections from templates or standard
"""
if not analysis or analysis == "Standard":
return "Standard", {"aligner": "bwa", "platform": "illumina", "quality_format": "Standard",
"recalibrate": False, "realign": False, "mark_duplicates": True,
"variantcaller": False}
elif "variant" in analysis:
try:
config, _ = template.name_to_config(analysis)
except ValueError:
config, _ = template.name_to_config("freebayes-variant")
return "variant", config["details"][0]["algorithm"]
else:
return analysis, {} | python | def _select_default_algorithm(analysis):
if not analysis or analysis == "Standard":
return "Standard", {"aligner": "bwa", "platform": "illumina", "quality_format": "Standard",
"recalibrate": False, "realign": False, "mark_duplicates": True,
"variantcaller": False}
elif "variant" in analysis:
try:
config, _ = template.name_to_config(analysis)
except ValueError:
config, _ = template.name_to_config("freebayes-variant")
return "variant", config["details"][0]["algorithm"]
else:
return analysis, {} | [
"def",
"_select_default_algorithm",
"(",
"analysis",
")",
":",
"if",
"not",
"analysis",
"or",
"analysis",
"==",
"\"Standard\"",
":",
"return",
"\"Standard\"",
",",
"{",
"\"aligner\"",
":",
"\"bwa\"",
",",
"\"platform\"",
":",
"\"illumina\"",
",",
"\"quality_format... | Provide default algorithm sections from templates or standard | [
"Provide",
"default",
"algorithm",
"sections",
"from",
"templates",
"or",
"standard"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L90-L104 |
237,067 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | _relative_paths | def _relative_paths(xs, base_path):
"""Adjust paths to be relative to the provided base path.
"""
if isinstance(xs, six.string_types):
if xs.startswith(base_path):
return xs.replace(base_path + "/", "", 1)
else:
return xs
elif isinstance(xs, (list, tuple)):
return [_relative_paths(x, base_path) for x in xs]
elif isinstance(xs, dict):
out = {}
for k, v in xs.items():
out[k] = _relative_paths(v, base_path)
return out
else:
return xs | python | def _relative_paths(xs, base_path):
if isinstance(xs, six.string_types):
if xs.startswith(base_path):
return xs.replace(base_path + "/", "", 1)
else:
return xs
elif isinstance(xs, (list, tuple)):
return [_relative_paths(x, base_path) for x in xs]
elif isinstance(xs, dict):
out = {}
for k, v in xs.items():
out[k] = _relative_paths(v, base_path)
return out
else:
return xs | [
"def",
"_relative_paths",
"(",
"xs",
",",
"base_path",
")",
":",
"if",
"isinstance",
"(",
"xs",
",",
"six",
".",
"string_types",
")",
":",
"if",
"xs",
".",
"startswith",
"(",
"base_path",
")",
":",
"return",
"xs",
".",
"replace",
"(",
"base_path",
"+",... | Adjust paths to be relative to the provided base path. | [
"Adjust",
"paths",
"to",
"be",
"relative",
"to",
"the",
"provided",
"base",
"path",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L106-L122 |
237,068 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | _get_fastq_files | def _get_fastq_files(ldetail, read, fastq_dir):
"""Retrieve fastq files corresponding to the sample and read number.
"""
return glob.glob(os.path.join(fastq_dir, "Project_%s" % ldetail["project_name"],
"Sample_%s" % ldetail["name"],
"%s_*_%s_*.fastq.gz" % (ldetail["name"], read))) | python | def _get_fastq_files(ldetail, read, fastq_dir):
return glob.glob(os.path.join(fastq_dir, "Project_%s" % ldetail["project_name"],
"Sample_%s" % ldetail["name"],
"%s_*_%s_*.fastq.gz" % (ldetail["name"], read))) | [
"def",
"_get_fastq_files",
"(",
"ldetail",
",",
"read",
",",
"fastq_dir",
")",
":",
"return",
"glob",
".",
"glob",
"(",
"os",
".",
"path",
".",
"join",
"(",
"fastq_dir",
",",
"\"Project_%s\"",
"%",
"ldetail",
"[",
"\"project_name\"",
"]",
",",
"\"Sample_%s... | Retrieve fastq files corresponding to the sample and read number. | [
"Retrieve",
"fastq",
"files",
"corresponding",
"to",
"the",
"sample",
"and",
"read",
"number",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L124-L129 |
237,069 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | _concat_bgzip_fastq | def _concat_bgzip_fastq(finputs, out_dir, read, ldetail):
"""Concatenate multiple input fastq files, preparing a bgzipped output file.
"""
out_file = os.path.join(out_dir, "%s_%s.fastq.gz" % (ldetail["name"], read))
if not utils.file_exists(out_file):
with file_transaction(out_file) as tx_out_file:
subprocess.check_call("zcat %s | bgzip -c > %s" % (" ".join(finputs), tx_out_file), shell=True)
return out_file | python | def _concat_bgzip_fastq(finputs, out_dir, read, ldetail):
out_file = os.path.join(out_dir, "%s_%s.fastq.gz" % (ldetail["name"], read))
if not utils.file_exists(out_file):
with file_transaction(out_file) as tx_out_file:
subprocess.check_call("zcat %s | bgzip -c > %s" % (" ".join(finputs), tx_out_file), shell=True)
return out_file | [
"def",
"_concat_bgzip_fastq",
"(",
"finputs",
",",
"out_dir",
",",
"read",
",",
"ldetail",
")",
":",
"out_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"out_dir",
",",
"\"%s_%s.fastq.gz\"",
"%",
"(",
"ldetail",
"[",
"\"name\"",
"]",
",",
"read",
")",
... | Concatenate multiple input fastq files, preparing a bgzipped output file. | [
"Concatenate",
"multiple",
"input",
"fastq",
"files",
"preparing",
"a",
"bgzipped",
"output",
"file",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L131-L138 |
237,070 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | get_runinfo | def get_runinfo(galaxy_url, galaxy_apikey, run_folder, storedir):
"""Retrieve flattened run information for a processed directory from Galaxy nglims API.
"""
galaxy_api = GalaxyApiAccess(galaxy_url, galaxy_apikey)
fc_name, fc_date = flowcell.parse_dirname(run_folder)
galaxy_info = galaxy_api.run_details(fc_name, fc_date)
if "error" in galaxy_info:
return galaxy_info
if not galaxy_info["run_name"].startswith(fc_date) and not galaxy_info["run_name"].endswith(fc_name):
raise ValueError("Galaxy NGLIMS information %s does not match flowcell %s %s" %
(galaxy_info["run_name"], fc_date, fc_name))
ldetails = _flatten_lane_details(galaxy_info)
out = []
for item in ldetails:
# Do uploads for all non-controls
if item["description"] != "control" or item["project_name"] != "control":
item["upload"] = {"method": "galaxy", "run_id": galaxy_info["run_id"],
"fc_name": fc_name, "fc_date": fc_date,
"dir": storedir,
"galaxy_url": galaxy_url, "galaxy_api_key": galaxy_apikey}
for k in ["lab_association", "private_libs", "researcher", "researcher_id", "sample_id",
"galaxy_library", "galaxy_role"]:
item["upload"][k] = item.pop(k, "")
out.append(item)
return out | python | def get_runinfo(galaxy_url, galaxy_apikey, run_folder, storedir):
galaxy_api = GalaxyApiAccess(galaxy_url, galaxy_apikey)
fc_name, fc_date = flowcell.parse_dirname(run_folder)
galaxy_info = galaxy_api.run_details(fc_name, fc_date)
if "error" in galaxy_info:
return galaxy_info
if not galaxy_info["run_name"].startswith(fc_date) and not galaxy_info["run_name"].endswith(fc_name):
raise ValueError("Galaxy NGLIMS information %s does not match flowcell %s %s" %
(galaxy_info["run_name"], fc_date, fc_name))
ldetails = _flatten_lane_details(galaxy_info)
out = []
for item in ldetails:
# Do uploads for all non-controls
if item["description"] != "control" or item["project_name"] != "control":
item["upload"] = {"method": "galaxy", "run_id": galaxy_info["run_id"],
"fc_name": fc_name, "fc_date": fc_date,
"dir": storedir,
"galaxy_url": galaxy_url, "galaxy_api_key": galaxy_apikey}
for k in ["lab_association", "private_libs", "researcher", "researcher_id", "sample_id",
"galaxy_library", "galaxy_role"]:
item["upload"][k] = item.pop(k, "")
out.append(item)
return out | [
"def",
"get_runinfo",
"(",
"galaxy_url",
",",
"galaxy_apikey",
",",
"run_folder",
",",
"storedir",
")",
":",
"galaxy_api",
"=",
"GalaxyApiAccess",
"(",
"galaxy_url",
",",
"galaxy_apikey",
")",
"fc_name",
",",
"fc_date",
"=",
"flowcell",
".",
"parse_dirname",
"("... | Retrieve flattened run information for a processed directory from Galaxy nglims API. | [
"Retrieve",
"flattened",
"run",
"information",
"for",
"a",
"processed",
"directory",
"from",
"Galaxy",
"nglims",
"API",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L148-L172 |
237,071 | bcbio/bcbio-nextgen | bcbio/galaxy/nglims.py | _flatten_lane_details | def _flatten_lane_details(runinfo):
"""Provide flattened lane information with multiplexed barcodes separated.
"""
out = []
for ldetail in runinfo["details"]:
# handle controls
if "project_name" not in ldetail and ldetail["description"] == "control":
ldetail["project_name"] = "control"
for i, barcode in enumerate(ldetail.get("multiplex", [{}])):
cur = copy.deepcopy(ldetail)
cur["name"] = "%s-%s" % (ldetail["name"], i + 1)
cur["description"] = barcode.get("name", ldetail["description"])
cur["bc_index"] = barcode.get("sequence", "")
cur["project_name"] = clean_name(ldetail["project_name"])
out.append(cur)
return out | python | def _flatten_lane_details(runinfo):
out = []
for ldetail in runinfo["details"]:
# handle controls
if "project_name" not in ldetail and ldetail["description"] == "control":
ldetail["project_name"] = "control"
for i, barcode in enumerate(ldetail.get("multiplex", [{}])):
cur = copy.deepcopy(ldetail)
cur["name"] = "%s-%s" % (ldetail["name"], i + 1)
cur["description"] = barcode.get("name", ldetail["description"])
cur["bc_index"] = barcode.get("sequence", "")
cur["project_name"] = clean_name(ldetail["project_name"])
out.append(cur)
return out | [
"def",
"_flatten_lane_details",
"(",
"runinfo",
")",
":",
"out",
"=",
"[",
"]",
"for",
"ldetail",
"in",
"runinfo",
"[",
"\"details\"",
"]",
":",
"# handle controls",
"if",
"\"project_name\"",
"not",
"in",
"ldetail",
"and",
"ldetail",
"[",
"\"description\"",
"]... | Provide flattened lane information with multiplexed barcodes separated. | [
"Provide",
"flattened",
"lane",
"information",
"with",
"multiplexed",
"barcodes",
"separated",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/galaxy/nglims.py#L174-L189 |
237,072 | bcbio/bcbio-nextgen | bcbio/distributed/split.py | grouped_parallel_split_combine | def grouped_parallel_split_combine(args, split_fn, group_fn, parallel_fn,
parallel_name, combine_name,
file_key, combine_arg_keys,
split_outfile_i=-1):
"""Parallel split runner that allows grouping of samples during processing.
This builds on parallel_split_combine to provide the additional ability to
group samples and subsequently split them back apart. This allows analysis
of related samples together. In addition to the arguments documented in
parallel_split_combine, this needs:
group_fn: A function that groups samples together given their configuration
details.
"""
grouped_args = group_fn(args)
split_args, combine_map, finished_out, extras = _get_split_tasks(grouped_args, split_fn, file_key,
split_outfile_i)
final_output = parallel_fn(parallel_name, split_args)
combine_args, final_args = _organize_output(final_output, combine_map,
file_key, combine_arg_keys)
parallel_fn(combine_name, combine_args)
return finished_out + final_args + extras | python | def grouped_parallel_split_combine(args, split_fn, group_fn, parallel_fn,
parallel_name, combine_name,
file_key, combine_arg_keys,
split_outfile_i=-1):
grouped_args = group_fn(args)
split_args, combine_map, finished_out, extras = _get_split_tasks(grouped_args, split_fn, file_key,
split_outfile_i)
final_output = parallel_fn(parallel_name, split_args)
combine_args, final_args = _organize_output(final_output, combine_map,
file_key, combine_arg_keys)
parallel_fn(combine_name, combine_args)
return finished_out + final_args + extras | [
"def",
"grouped_parallel_split_combine",
"(",
"args",
",",
"split_fn",
",",
"group_fn",
",",
"parallel_fn",
",",
"parallel_name",
",",
"combine_name",
",",
"file_key",
",",
"combine_arg_keys",
",",
"split_outfile_i",
"=",
"-",
"1",
")",
":",
"grouped_args",
"=",
... | Parallel split runner that allows grouping of samples during processing.
This builds on parallel_split_combine to provide the additional ability to
group samples and subsequently split them back apart. This allows analysis
of related samples together. In addition to the arguments documented in
parallel_split_combine, this needs:
group_fn: A function that groups samples together given their configuration
details. | [
"Parallel",
"split",
"runner",
"that",
"allows",
"grouping",
"of",
"samples",
"during",
"processing",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/distributed/split.py#L18-L39 |
237,073 | bcbio/bcbio-nextgen | bcbio/distributed/split.py | parallel_split_combine | def parallel_split_combine(args, split_fn, parallel_fn,
parallel_name, combiner,
file_key, combine_arg_keys, split_outfile_i=-1):
"""Split, run split items in parallel then combine to output file.
split_fn: Split an input file into parts for processing. Returns
the name of the combined output file along with the individual
split output names and arguments for the parallel function.
parallel_fn: Reference to run_parallel function that will run
single core, multicore, or distributed as needed.
parallel_name: The name of the function, defined in
bcbio.distributed.tasks/multitasks/ipythontasks to run in parallel.
combiner: The name of the function, also from tasks, that combines
the split output files into a final ready to run file. Can also
be a callable function if combining is delayed.
split_outfile_i: the location of the output file in the arguments
generated by the split function. Defaults to the last item in the list.
"""
args = [x[0] for x in args]
split_args, combine_map, finished_out, extras = _get_split_tasks(args, split_fn, file_key,
split_outfile_i)
split_output = parallel_fn(parallel_name, split_args)
if isinstance(combiner, six.string_types):
combine_args, final_args = _organize_output(split_output, combine_map,
file_key, combine_arg_keys)
parallel_fn(combiner, combine_args)
elif callable(combiner):
final_args = combiner(split_output, combine_map, file_key)
return finished_out + final_args + extras | python | def parallel_split_combine(args, split_fn, parallel_fn,
parallel_name, combiner,
file_key, combine_arg_keys, split_outfile_i=-1):
args = [x[0] for x in args]
split_args, combine_map, finished_out, extras = _get_split_tasks(args, split_fn, file_key,
split_outfile_i)
split_output = parallel_fn(parallel_name, split_args)
if isinstance(combiner, six.string_types):
combine_args, final_args = _organize_output(split_output, combine_map,
file_key, combine_arg_keys)
parallel_fn(combiner, combine_args)
elif callable(combiner):
final_args = combiner(split_output, combine_map, file_key)
return finished_out + final_args + extras | [
"def",
"parallel_split_combine",
"(",
"args",
",",
"split_fn",
",",
"parallel_fn",
",",
"parallel_name",
",",
"combiner",
",",
"file_key",
",",
"combine_arg_keys",
",",
"split_outfile_i",
"=",
"-",
"1",
")",
":",
"args",
"=",
"[",
"x",
"[",
"0",
"]",
"for"... | Split, run split items in parallel then combine to output file.
split_fn: Split an input file into parts for processing. Returns
the name of the combined output file along with the individual
split output names and arguments for the parallel function.
parallel_fn: Reference to run_parallel function that will run
single core, multicore, or distributed as needed.
parallel_name: The name of the function, defined in
bcbio.distributed.tasks/multitasks/ipythontasks to run in parallel.
combiner: The name of the function, also from tasks, that combines
the split output files into a final ready to run file. Can also
be a callable function if combining is delayed.
split_outfile_i: the location of the output file in the arguments
generated by the split function. Defaults to the last item in the list. | [
"Split",
"run",
"split",
"items",
"in",
"parallel",
"then",
"combine",
"to",
"output",
"file",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/distributed/split.py#L41-L69 |
237,074 | bcbio/bcbio-nextgen | bcbio/distributed/split.py | _get_extra_args | def _get_extra_args(extra_args, arg_keys):
"""Retrieve extra arguments to pass along to combine function.
Special cases like reference files and configuration information
are passed as single items, the rest as lists mapping to each data
item combined.
"""
# XXX back compatible hack -- should have a way to specify these.
single_keys = set(["sam_ref", "config"])
out = []
for i, arg_key in enumerate(arg_keys):
vals = [xs[i] for xs in extra_args]
if arg_key in single_keys:
out.append(vals[-1])
else:
out.append(vals)
return out | python | def _get_extra_args(extra_args, arg_keys):
# XXX back compatible hack -- should have a way to specify these.
single_keys = set(["sam_ref", "config"])
out = []
for i, arg_key in enumerate(arg_keys):
vals = [xs[i] for xs in extra_args]
if arg_key in single_keys:
out.append(vals[-1])
else:
out.append(vals)
return out | [
"def",
"_get_extra_args",
"(",
"extra_args",
",",
"arg_keys",
")",
":",
"# XXX back compatible hack -- should have a way to specify these.",
"single_keys",
"=",
"set",
"(",
"[",
"\"sam_ref\"",
",",
"\"config\"",
"]",
")",
"out",
"=",
"[",
"]",
"for",
"i",
",",
"ar... | Retrieve extra arguments to pass along to combine function.
Special cases like reference files and configuration information
are passed as single items, the rest as lists mapping to each data
item combined. | [
"Retrieve",
"extra",
"arguments",
"to",
"pass",
"along",
"to",
"combine",
"function",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/distributed/split.py#L71-L87 |
237,075 | bcbio/bcbio-nextgen | bcbio/distributed/split.py | _organize_output | def _organize_output(output, combine_map, file_key, combine_arg_keys):
"""Combine output details for parallelization.
file_key is the key name of the output file used in merging. We extract
this file from the output data.
combine_arg_keys are extra items to pass along to the combine function.
"""
out_map = collections.defaultdict(list)
extra_args = collections.defaultdict(list)
final_args = collections.OrderedDict()
extras = []
for data in output:
cur_file = data.get(file_key)
if not cur_file:
extras.append([data])
else:
cur_out = combine_map[cur_file]
out_map[cur_out].append(cur_file)
extra_args[cur_out].append([data[x] for x in combine_arg_keys])
data[file_key] = cur_out
if cur_out not in final_args:
final_args[cur_out] = [data]
else:
extras.append([data])
combine_args = [[v, k] + _get_extra_args(extra_args[k], combine_arg_keys)
for (k, v) in out_map.items()]
return combine_args, list(final_args.values()) + extras | python | def _organize_output(output, combine_map, file_key, combine_arg_keys):
out_map = collections.defaultdict(list)
extra_args = collections.defaultdict(list)
final_args = collections.OrderedDict()
extras = []
for data in output:
cur_file = data.get(file_key)
if not cur_file:
extras.append([data])
else:
cur_out = combine_map[cur_file]
out_map[cur_out].append(cur_file)
extra_args[cur_out].append([data[x] for x in combine_arg_keys])
data[file_key] = cur_out
if cur_out not in final_args:
final_args[cur_out] = [data]
else:
extras.append([data])
combine_args = [[v, k] + _get_extra_args(extra_args[k], combine_arg_keys)
for (k, v) in out_map.items()]
return combine_args, list(final_args.values()) + extras | [
"def",
"_organize_output",
"(",
"output",
",",
"combine_map",
",",
"file_key",
",",
"combine_arg_keys",
")",
":",
"out_map",
"=",
"collections",
".",
"defaultdict",
"(",
"list",
")",
"extra_args",
"=",
"collections",
".",
"defaultdict",
"(",
"list",
")",
"fina... | Combine output details for parallelization.
file_key is the key name of the output file used in merging. We extract
this file from the output data.
combine_arg_keys are extra items to pass along to the combine function. | [
"Combine",
"output",
"details",
"for",
"parallelization",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/distributed/split.py#L89-L116 |
237,076 | bcbio/bcbio-nextgen | bcbio/distributed/split.py | _get_split_tasks | def _get_split_tasks(args, split_fn, file_key, outfile_i=-1):
"""Split up input files and arguments, returning arguments for parallel processing.
outfile_i specifies the location of the output file in the arguments to
the processing function. Defaults to the last item in the list.
"""
split_args = []
combine_map = {}
finished_map = collections.OrderedDict()
extras = []
for data in args:
out_final, out_parts = split_fn(data)
for parts in out_parts:
split_args.append([utils.deepish_copy(data)] + list(parts))
for part_file in [x[outfile_i] for x in out_parts]:
combine_map[part_file] = out_final
if len(out_parts) == 0:
if out_final is not None:
if out_final not in finished_map:
data[file_key] = out_final
finished_map[out_final] = [data]
else:
extras.append([data])
else:
extras.append([data])
return split_args, combine_map, list(finished_map.values()), extras | python | def _get_split_tasks(args, split_fn, file_key, outfile_i=-1):
split_args = []
combine_map = {}
finished_map = collections.OrderedDict()
extras = []
for data in args:
out_final, out_parts = split_fn(data)
for parts in out_parts:
split_args.append([utils.deepish_copy(data)] + list(parts))
for part_file in [x[outfile_i] for x in out_parts]:
combine_map[part_file] = out_final
if len(out_parts) == 0:
if out_final is not None:
if out_final not in finished_map:
data[file_key] = out_final
finished_map[out_final] = [data]
else:
extras.append([data])
else:
extras.append([data])
return split_args, combine_map, list(finished_map.values()), extras | [
"def",
"_get_split_tasks",
"(",
"args",
",",
"split_fn",
",",
"file_key",
",",
"outfile_i",
"=",
"-",
"1",
")",
":",
"split_args",
"=",
"[",
"]",
"combine_map",
"=",
"{",
"}",
"finished_map",
"=",
"collections",
".",
"OrderedDict",
"(",
")",
"extras",
"=... | Split up input files and arguments, returning arguments for parallel processing.
outfile_i specifies the location of the output file in the arguments to
the processing function. Defaults to the last item in the list. | [
"Split",
"up",
"input",
"files",
"and",
"arguments",
"returning",
"arguments",
"for",
"parallel",
"processing",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/distributed/split.py#L118-L143 |
237,077 | bcbio/bcbio-nextgen | bcbio/ngsalign/snap.py | remap_index_fn | def remap_index_fn(ref_file):
"""Map sequence references to snap reference directory, using standard layout.
"""
snap_dir = os.path.join(os.path.dirname(ref_file), os.pardir, "snap")
assert os.path.exists(snap_dir) and os.path.isdir(snap_dir), snap_dir
return snap_dir | python | def remap_index_fn(ref_file):
snap_dir = os.path.join(os.path.dirname(ref_file), os.pardir, "snap")
assert os.path.exists(snap_dir) and os.path.isdir(snap_dir), snap_dir
return snap_dir | [
"def",
"remap_index_fn",
"(",
"ref_file",
")",
":",
"snap_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"ref_file",
")",
",",
"os",
".",
"pardir",
",",
"\"snap\"",
")",
"assert",
"os",
".",
"path",
".",
"ex... | Map sequence references to snap reference directory, using standard layout. | [
"Map",
"sequence",
"references",
"to",
"snap",
"reference",
"directory",
"using",
"standard",
"layout",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/ngsalign/snap.py#L81-L86 |
237,078 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | use_general_sv_bins | def use_general_sv_bins(data):
"""Check if we should use a general binning approach for a sample.
Checks if CNVkit is enabled and we haven't already run CNVkit.
"""
if any([c in dd.get_svcaller(data) for c in ["cnvkit", "titancna", "purecn", "gatk-cnv"]]):
if not _get_original_coverage(data):
return True
return False | python | def use_general_sv_bins(data):
if any([c in dd.get_svcaller(data) for c in ["cnvkit", "titancna", "purecn", "gatk-cnv"]]):
if not _get_original_coverage(data):
return True
return False | [
"def",
"use_general_sv_bins",
"(",
"data",
")",
":",
"if",
"any",
"(",
"[",
"c",
"in",
"dd",
".",
"get_svcaller",
"(",
"data",
")",
"for",
"c",
"in",
"[",
"\"cnvkit\"",
",",
"\"titancna\"",
",",
"\"purecn\"",
",",
"\"gatk-cnv\"",
"]",
"]",
")",
":",
... | Check if we should use a general binning approach for a sample.
Checks if CNVkit is enabled and we haven't already run CNVkit. | [
"Check",
"if",
"we",
"should",
"use",
"a",
"general",
"binning",
"approach",
"for",
"a",
"sample",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L31-L39 |
237,079 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | bin_approach | def bin_approach(data):
"""Check for binning approach from configuration or normalized file.
"""
for approach in ["cnvkit", "gatk-cnv"]:
if approach in dd.get_svcaller(data):
return approach
norm_file = tz.get_in(["depth", "bins", "normalized"], data)
if norm_file.endswith(("-crstandardized.tsv", "-crdenoised.tsv")):
return "gatk-cnv"
if norm_file.endswith(".cnr"):
return "cnvkit" | python | def bin_approach(data):
for approach in ["cnvkit", "gatk-cnv"]:
if approach in dd.get_svcaller(data):
return approach
norm_file = tz.get_in(["depth", "bins", "normalized"], data)
if norm_file.endswith(("-crstandardized.tsv", "-crdenoised.tsv")):
return "gatk-cnv"
if norm_file.endswith(".cnr"):
return "cnvkit" | [
"def",
"bin_approach",
"(",
"data",
")",
":",
"for",
"approach",
"in",
"[",
"\"cnvkit\"",
",",
"\"gatk-cnv\"",
"]",
":",
"if",
"approach",
"in",
"dd",
".",
"get_svcaller",
"(",
"data",
")",
":",
"return",
"approach",
"norm_file",
"=",
"tz",
".",
"get_in"... | Check for binning approach from configuration or normalized file. | [
"Check",
"for",
"binning",
"approach",
"from",
"configuration",
"or",
"normalized",
"file",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L41-L51 |
237,080 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _cnvkit_by_type | def _cnvkit_by_type(items, background):
"""Dispatch to specific CNVkit functionality based on input type.
"""
if len(items + background) == 1:
return _run_cnvkit_single(items[0])
elif vcfutils.get_paired_phenotype(items[0]):
return _run_cnvkit_cancer(items, background)
else:
return _run_cnvkit_population(items, background) | python | def _cnvkit_by_type(items, background):
if len(items + background) == 1:
return _run_cnvkit_single(items[0])
elif vcfutils.get_paired_phenotype(items[0]):
return _run_cnvkit_cancer(items, background)
else:
return _run_cnvkit_population(items, background) | [
"def",
"_cnvkit_by_type",
"(",
"items",
",",
"background",
")",
":",
"if",
"len",
"(",
"items",
"+",
"background",
")",
"==",
"1",
":",
"return",
"_run_cnvkit_single",
"(",
"items",
"[",
"0",
"]",
")",
"elif",
"vcfutils",
".",
"get_paired_phenotype",
"(",
... | Dispatch to specific CNVkit functionality based on input type. | [
"Dispatch",
"to",
"specific",
"CNVkit",
"functionality",
"based",
"on",
"input",
"type",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L63-L71 |
237,081 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _associate_cnvkit_out | def _associate_cnvkit_out(ckouts, items, is_somatic=False):
"""Associate cnvkit output with individual items.
"""
assert len(ckouts) == len(items)
out = []
upload_counts = collections.defaultdict(int)
for ckout, data in zip(ckouts, items):
ckout = copy.deepcopy(ckout)
ckout["variantcaller"] = "cnvkit"
if utils.file_exists(ckout["cns"]) and _cna_has_values(ckout["cns"]):
ckout = _add_seg_to_output(ckout, data)
ckout = _add_gainloss_to_output(ckout, data)
ckout = _add_segmetrics_to_output(ckout, data)
ckout = _add_variantcalls_to_output(ckout, data, items, is_somatic)
# ckout = _add_coverage_bedgraph_to_output(ckout, data)
ckout = _add_cnr_bedgraph_and_bed_to_output(ckout, data)
if "svplots" in dd.get_tools_on(data):
ckout = _add_plots_to_output(ckout, data)
ckout["do_upload"] = upload_counts[ckout.get("vrn_file")] == 0
if "sv" not in data:
data["sv"] = []
data["sv"].append(ckout)
if ckout.get("vrn_file"):
upload_counts[ckout["vrn_file"]] += 1
out.append(data)
return out | python | def _associate_cnvkit_out(ckouts, items, is_somatic=False):
assert len(ckouts) == len(items)
out = []
upload_counts = collections.defaultdict(int)
for ckout, data in zip(ckouts, items):
ckout = copy.deepcopy(ckout)
ckout["variantcaller"] = "cnvkit"
if utils.file_exists(ckout["cns"]) and _cna_has_values(ckout["cns"]):
ckout = _add_seg_to_output(ckout, data)
ckout = _add_gainloss_to_output(ckout, data)
ckout = _add_segmetrics_to_output(ckout, data)
ckout = _add_variantcalls_to_output(ckout, data, items, is_somatic)
# ckout = _add_coverage_bedgraph_to_output(ckout, data)
ckout = _add_cnr_bedgraph_and_bed_to_output(ckout, data)
if "svplots" in dd.get_tools_on(data):
ckout = _add_plots_to_output(ckout, data)
ckout["do_upload"] = upload_counts[ckout.get("vrn_file")] == 0
if "sv" not in data:
data["sv"] = []
data["sv"].append(ckout)
if ckout.get("vrn_file"):
upload_counts[ckout["vrn_file"]] += 1
out.append(data)
return out | [
"def",
"_associate_cnvkit_out",
"(",
"ckouts",
",",
"items",
",",
"is_somatic",
"=",
"False",
")",
":",
"assert",
"len",
"(",
"ckouts",
")",
"==",
"len",
"(",
"items",
")",
"out",
"=",
"[",
"]",
"upload_counts",
"=",
"collections",
".",
"defaultdict",
"(... | Associate cnvkit output with individual items. | [
"Associate",
"cnvkit",
"output",
"with",
"individual",
"items",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L73-L98 |
237,082 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _run_cnvkit_single | def _run_cnvkit_single(data, background=None):
"""Process a single input file with BAM or uniform background.
"""
if not background:
background = []
ckouts = _run_cnvkit_shared([data], background)
if not ckouts:
return [data]
else:
assert len(ckouts) == 1
return _associate_cnvkit_out(ckouts, [data]) | python | def _run_cnvkit_single(data, background=None):
if not background:
background = []
ckouts = _run_cnvkit_shared([data], background)
if not ckouts:
return [data]
else:
assert len(ckouts) == 1
return _associate_cnvkit_out(ckouts, [data]) | [
"def",
"_run_cnvkit_single",
"(",
"data",
",",
"background",
"=",
"None",
")",
":",
"if",
"not",
"background",
":",
"background",
"=",
"[",
"]",
"ckouts",
"=",
"_run_cnvkit_shared",
"(",
"[",
"data",
"]",
",",
"background",
")",
"if",
"not",
"ckouts",
":... | Process a single input file with BAM or uniform background. | [
"Process",
"a",
"single",
"input",
"file",
"with",
"BAM",
"or",
"uniform",
"background",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L100-L110 |
237,083 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _run_cnvkit_population | def _run_cnvkit_population(items, background):
"""Run CNVkit on a population of samples.
Tries to calculate background based on case/controls, otherwise
uses samples from the same batch as background.
"""
if background and len(background) > 0:
inputs = items
else:
inputs, background = shared.find_case_control(items)
# if we have case/control organized background or a single sample
if len(inputs) == 1 or len(background) > 0:
ckouts = _run_cnvkit_shared(inputs, background)
return _associate_cnvkit_out(ckouts, inputs) + background
# otherwise run each sample with the others in the batch as background
else:
out = []
for cur_input in items:
background = [d for d in items if dd.get_sample_name(d) != dd.get_sample_name(cur_input)]
ckouts = _run_cnvkit_shared([cur_input], background)
out.extend(_associate_cnvkit_out(ckouts, [cur_input]))
return out | python | def _run_cnvkit_population(items, background):
if background and len(background) > 0:
inputs = items
else:
inputs, background = shared.find_case_control(items)
# if we have case/control organized background or a single sample
if len(inputs) == 1 or len(background) > 0:
ckouts = _run_cnvkit_shared(inputs, background)
return _associate_cnvkit_out(ckouts, inputs) + background
# otherwise run each sample with the others in the batch as background
else:
out = []
for cur_input in items:
background = [d for d in items if dd.get_sample_name(d) != dd.get_sample_name(cur_input)]
ckouts = _run_cnvkit_shared([cur_input], background)
out.extend(_associate_cnvkit_out(ckouts, [cur_input]))
return out | [
"def",
"_run_cnvkit_population",
"(",
"items",
",",
"background",
")",
":",
"if",
"background",
"and",
"len",
"(",
"background",
")",
">",
"0",
":",
"inputs",
"=",
"items",
"else",
":",
"inputs",
",",
"background",
"=",
"shared",
".",
"find_case_control",
... | Run CNVkit on a population of samples.
Tries to calculate background based on case/controls, otherwise
uses samples from the same batch as background. | [
"Run",
"CNVkit",
"on",
"a",
"population",
"of",
"samples",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L141-L163 |
237,084 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _prep_cmd | def _prep_cmd(cmd, tx_out_file):
"""Wrap CNVkit commands ensuring we use local temporary directories.
"""
cmd = " ".join(cmd) if isinstance(cmd, (list, tuple)) else cmd
return "export TMPDIR=%s && %s" % (os.path.dirname(tx_out_file), cmd) | python | def _prep_cmd(cmd, tx_out_file):
cmd = " ".join(cmd) if isinstance(cmd, (list, tuple)) else cmd
return "export TMPDIR=%s && %s" % (os.path.dirname(tx_out_file), cmd) | [
"def",
"_prep_cmd",
"(",
"cmd",
",",
"tx_out_file",
")",
":",
"cmd",
"=",
"\" \"",
".",
"join",
"(",
"cmd",
")",
"if",
"isinstance",
"(",
"cmd",
",",
"(",
"list",
",",
"tuple",
")",
")",
"else",
"cmd",
"return",
"\"export TMPDIR=%s && %s\"",
"%",
"(",
... | Wrap CNVkit commands ensuring we use local temporary directories. | [
"Wrap",
"CNVkit",
"commands",
"ensuring",
"we",
"use",
"local",
"temporary",
"directories",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L168-L172 |
237,085 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _bam_to_outbase | def _bam_to_outbase(bam_file, work_dir, data):
"""Convert an input BAM file into CNVkit expected output.
Handles previous non-batch cases to avoid re-calculating,
returning both new and old values:
"""
batch = dd.get_batch(data) or dd.get_sample_name(data)
out_base = os.path.splitext(os.path.basename(bam_file))[0].split(".")[0]
base = os.path.join(work_dir, out_base)
return "%s-%s" % (base, batch), base | python | def _bam_to_outbase(bam_file, work_dir, data):
batch = dd.get_batch(data) or dd.get_sample_name(data)
out_base = os.path.splitext(os.path.basename(bam_file))[0].split(".")[0]
base = os.path.join(work_dir, out_base)
return "%s-%s" % (base, batch), base | [
"def",
"_bam_to_outbase",
"(",
"bam_file",
",",
"work_dir",
",",
"data",
")",
":",
"batch",
"=",
"dd",
".",
"get_batch",
"(",
"data",
")",
"or",
"dd",
".",
"get_sample_name",
"(",
"data",
")",
"out_base",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
... | Convert an input BAM file into CNVkit expected output.
Handles previous non-batch cases to avoid re-calculating,
returning both new and old values: | [
"Convert",
"an",
"input",
"BAM",
"file",
"into",
"CNVkit",
"expected",
"output",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L174-L183 |
237,086 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _run_cnvkit_shared | def _run_cnvkit_shared(inputs, backgrounds):
"""Shared functionality to run CNVkit, parallelizing over multiple BAM files.
Handles new style cases where we have pre-normalized inputs and
old cases where we run CNVkit individually.
"""
if tz.get_in(["depth", "bins", "normalized"], inputs[0]):
ckouts = []
for data in inputs:
cnr_file = tz.get_in(["depth", "bins", "normalized"], data)
cns_file = os.path.join(_sv_workdir(data), "%s.cns" % dd.get_sample_name(data))
cns_file = _cnvkit_segment(cnr_file, dd.get_coverage_interval(data), data,
inputs + backgrounds, cns_file)
ckouts.append({"cnr": cnr_file, "cns": cns_file,
"background": tz.get_in(["depth", "bins", "background"], data)})
return ckouts
else:
return _run_cnvkit_shared_orig(inputs, backgrounds) | python | def _run_cnvkit_shared(inputs, backgrounds):
if tz.get_in(["depth", "bins", "normalized"], inputs[0]):
ckouts = []
for data in inputs:
cnr_file = tz.get_in(["depth", "bins", "normalized"], data)
cns_file = os.path.join(_sv_workdir(data), "%s.cns" % dd.get_sample_name(data))
cns_file = _cnvkit_segment(cnr_file, dd.get_coverage_interval(data), data,
inputs + backgrounds, cns_file)
ckouts.append({"cnr": cnr_file, "cns": cns_file,
"background": tz.get_in(["depth", "bins", "background"], data)})
return ckouts
else:
return _run_cnvkit_shared_orig(inputs, backgrounds) | [
"def",
"_run_cnvkit_shared",
"(",
"inputs",
",",
"backgrounds",
")",
":",
"if",
"tz",
".",
"get_in",
"(",
"[",
"\"depth\"",
",",
"\"bins\"",
",",
"\"normalized\"",
"]",
",",
"inputs",
"[",
"0",
"]",
")",
":",
"ckouts",
"=",
"[",
"]",
"for",
"data",
"... | Shared functionality to run CNVkit, parallelizing over multiple BAM files.
Handles new style cases where we have pre-normalized inputs and
old cases where we run CNVkit individually. | [
"Shared",
"functionality",
"to",
"run",
"CNVkit",
"parallelizing",
"over",
"multiple",
"BAM",
"files",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L201-L218 |
237,087 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _get_general_coverage | def _get_general_coverage(data, itype):
"""Retrieve coverage information from new shared SV bins.
"""
work_bam = dd.get_align_bam(data) or dd.get_work_bam(data)
return [{"bam": work_bam, "file": tz.get_in(["depth", "bins", "target"], data),
"cnntype": "target", "itype": itype, "sample": dd.get_sample_name(data)},
{"bam": work_bam, "file": tz.get_in(["depth", "bins", "antitarget"], data),
"cnntype": "antitarget", "itype": itype, "sample": dd.get_sample_name(data)}] | python | def _get_general_coverage(data, itype):
work_bam = dd.get_align_bam(data) or dd.get_work_bam(data)
return [{"bam": work_bam, "file": tz.get_in(["depth", "bins", "target"], data),
"cnntype": "target", "itype": itype, "sample": dd.get_sample_name(data)},
{"bam": work_bam, "file": tz.get_in(["depth", "bins", "antitarget"], data),
"cnntype": "antitarget", "itype": itype, "sample": dd.get_sample_name(data)}] | [
"def",
"_get_general_coverage",
"(",
"data",
",",
"itype",
")",
":",
"work_bam",
"=",
"dd",
".",
"get_align_bam",
"(",
"data",
")",
"or",
"dd",
".",
"get_work_bam",
"(",
"data",
")",
"return",
"[",
"{",
"\"bam\"",
":",
"work_bam",
",",
"\"file\"",
":",
... | Retrieve coverage information from new shared SV bins. | [
"Retrieve",
"coverage",
"information",
"from",
"new",
"shared",
"SV",
"bins",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L228-L235 |
237,088 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _cnvkit_segment | def _cnvkit_segment(cnr_file, cov_interval, data, items, out_file=None, detailed=False):
"""Perform segmentation and copy number calling on normalized inputs
"""
if not out_file:
out_file = "%s.cns" % os.path.splitext(cnr_file)[0]
if not utils.file_uptodate(out_file, cnr_file):
with file_transaction(data, out_file) as tx_out_file:
if not _cna_has_values(cnr_file):
with open(tx_out_file, "w") as out_handle:
out_handle.write("chromosome\tstart\tend\tgene\tlog2\tprobes\tCN1\tCN2\tbaf\tweight\n")
else:
# Scale cores to avoid memory issues with segmentation
# https://github.com/etal/cnvkit/issues/346
if cov_interval == "genome":
cores = max(1, dd.get_cores(data) // 2)
else:
cores = dd.get_cores(data)
cmd = [_get_cmd(), "segment", "-p", str(cores), "-o", tx_out_file, cnr_file]
small_vrn_files = _compatible_small_variants(data, items)
if len(small_vrn_files) > 0 and _cna_has_values(cnr_file) and cov_interval != "genome":
cmd += ["--vcf", small_vrn_files[0].name, "--sample-id", small_vrn_files[0].sample]
if small_vrn_files[0].normal:
cmd += ["--normal-id", small_vrn_files[0].normal]
resources = config_utils.get_resources("cnvkit_segment", data["config"])
user_options = resources.get("options", [])
cmd += [str(x) for x in user_options]
if cov_interval == "genome" and "--threshold" not in user_options:
cmd += ["--threshold", "0.00001"]
# For tumors, remove very low normalized regions, avoiding upcaptured noise
# https://github.com/bcbio/bcbio-nextgen/issues/2171#issuecomment-348333650
# unless we want detailed segmentation for downstream tools
paired = vcfutils.get_paired(items)
if paired:
#if detailed:
# cmd += ["-m", "hmm-tumor"]
if "--drop-low-coverage" not in user_options:
cmd += ["--drop-low-coverage"]
# preferentially use conda installed Rscript
export_cmd = ("%s && export TMPDIR=%s && "
% (utils.get_R_exports(), os.path.dirname(tx_out_file)))
do.run(export_cmd + " ".join(cmd), "CNVkit segment")
return out_file | python | def _cnvkit_segment(cnr_file, cov_interval, data, items, out_file=None, detailed=False):
if not out_file:
out_file = "%s.cns" % os.path.splitext(cnr_file)[0]
if not utils.file_uptodate(out_file, cnr_file):
with file_transaction(data, out_file) as tx_out_file:
if not _cna_has_values(cnr_file):
with open(tx_out_file, "w") as out_handle:
out_handle.write("chromosome\tstart\tend\tgene\tlog2\tprobes\tCN1\tCN2\tbaf\tweight\n")
else:
# Scale cores to avoid memory issues with segmentation
# https://github.com/etal/cnvkit/issues/346
if cov_interval == "genome":
cores = max(1, dd.get_cores(data) // 2)
else:
cores = dd.get_cores(data)
cmd = [_get_cmd(), "segment", "-p", str(cores), "-o", tx_out_file, cnr_file]
small_vrn_files = _compatible_small_variants(data, items)
if len(small_vrn_files) > 0 and _cna_has_values(cnr_file) and cov_interval != "genome":
cmd += ["--vcf", small_vrn_files[0].name, "--sample-id", small_vrn_files[0].sample]
if small_vrn_files[0].normal:
cmd += ["--normal-id", small_vrn_files[0].normal]
resources = config_utils.get_resources("cnvkit_segment", data["config"])
user_options = resources.get("options", [])
cmd += [str(x) for x in user_options]
if cov_interval == "genome" and "--threshold" not in user_options:
cmd += ["--threshold", "0.00001"]
# For tumors, remove very low normalized regions, avoiding upcaptured noise
# https://github.com/bcbio/bcbio-nextgen/issues/2171#issuecomment-348333650
# unless we want detailed segmentation for downstream tools
paired = vcfutils.get_paired(items)
if paired:
#if detailed:
# cmd += ["-m", "hmm-tumor"]
if "--drop-low-coverage" not in user_options:
cmd += ["--drop-low-coverage"]
# preferentially use conda installed Rscript
export_cmd = ("%s && export TMPDIR=%s && "
% (utils.get_R_exports(), os.path.dirname(tx_out_file)))
do.run(export_cmd + " ".join(cmd), "CNVkit segment")
return out_file | [
"def",
"_cnvkit_segment",
"(",
"cnr_file",
",",
"cov_interval",
",",
"data",
",",
"items",
",",
"out_file",
"=",
"None",
",",
"detailed",
"=",
"False",
")",
":",
"if",
"not",
"out_file",
":",
"out_file",
"=",
"\"%s.cns\"",
"%",
"os",
".",
"path",
".",
... | Perform segmentation and copy number calling on normalized inputs | [
"Perform",
"segmentation",
"and",
"copy",
"number",
"calling",
"on",
"normalized",
"inputs"
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L297-L338 |
237,089 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _cnvkit_metrics | def _cnvkit_metrics(cnns, target_bed, antitarget_bed, cov_interval, items):
"""Estimate noise of a sample using a flat background.
Only used for panel/targeted data due to memory issues with whole genome
samples.
"""
if cov_interval == "genome":
return cnns
target_cnn = [x["file"] for x in cnns if x["cnntype"] == "target"][0]
background_file = "%s-flatbackground.cnn" % utils.splitext_plus(target_cnn)[0]
background_file = cnvkit_background([], background_file, items, target_bed, antitarget_bed)
cnr_file, data = _cnvkit_fix_base(cnns, background_file, items, "-flatbackground")
cns_file = _cnvkit_segment(cnr_file, cov_interval, data)
metrics_file = "%s-metrics.txt" % utils.splitext_plus(target_cnn)[0]
if not utils.file_exists(metrics_file):
with file_transaction(data, metrics_file) as tx_metrics_file:
cmd = [_get_cmd(), "metrics", "-o", tx_metrics_file, "-s", cns_file, "--", cnr_file]
do.run(_prep_cmd(cmd, tx_metrics_file), "CNVkit metrics")
metrics = _read_metrics_file(metrics_file)
out = []
for cnn in cnns:
cnn["metrics"] = metrics
out.append(cnn)
return out | python | def _cnvkit_metrics(cnns, target_bed, antitarget_bed, cov_interval, items):
if cov_interval == "genome":
return cnns
target_cnn = [x["file"] for x in cnns if x["cnntype"] == "target"][0]
background_file = "%s-flatbackground.cnn" % utils.splitext_plus(target_cnn)[0]
background_file = cnvkit_background([], background_file, items, target_bed, antitarget_bed)
cnr_file, data = _cnvkit_fix_base(cnns, background_file, items, "-flatbackground")
cns_file = _cnvkit_segment(cnr_file, cov_interval, data)
metrics_file = "%s-metrics.txt" % utils.splitext_plus(target_cnn)[0]
if not utils.file_exists(metrics_file):
with file_transaction(data, metrics_file) as tx_metrics_file:
cmd = [_get_cmd(), "metrics", "-o", tx_metrics_file, "-s", cns_file, "--", cnr_file]
do.run(_prep_cmd(cmd, tx_metrics_file), "CNVkit metrics")
metrics = _read_metrics_file(metrics_file)
out = []
for cnn in cnns:
cnn["metrics"] = metrics
out.append(cnn)
return out | [
"def",
"_cnvkit_metrics",
"(",
"cnns",
",",
"target_bed",
",",
"antitarget_bed",
",",
"cov_interval",
",",
"items",
")",
":",
"if",
"cov_interval",
"==",
"\"genome\"",
":",
"return",
"cnns",
"target_cnn",
"=",
"[",
"x",
"[",
"\"file\"",
"]",
"for",
"x",
"i... | Estimate noise of a sample using a flat background.
Only used for panel/targeted data due to memory issues with whole genome
samples. | [
"Estimate",
"noise",
"of",
"a",
"sample",
"using",
"a",
"flat",
"background",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L340-L364 |
237,090 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _cnvkit_fix | def _cnvkit_fix(cnns, background_cnn, items, ckouts):
"""Normalize samples, correcting sources of bias.
"""
return [_cnvkit_fix_base(cnns, background_cnn, items, ckouts)] | python | def _cnvkit_fix(cnns, background_cnn, items, ckouts):
return [_cnvkit_fix_base(cnns, background_cnn, items, ckouts)] | [
"def",
"_cnvkit_fix",
"(",
"cnns",
",",
"background_cnn",
",",
"items",
",",
"ckouts",
")",
":",
"return",
"[",
"_cnvkit_fix_base",
"(",
"cnns",
",",
"background_cnn",
",",
"items",
",",
"ckouts",
")",
"]"
] | Normalize samples, correcting sources of bias. | [
"Normalize",
"samples",
"correcting",
"sources",
"of",
"bias",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L374-L377 |
237,091 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _select_background_cnns | def _select_background_cnns(cnns):
"""Select cnns to use for background calculations.
Uses background samples in cohort, and will remove CNNs with high
on target variability. Uses (number of segments * biweight midvariance) as metric
for variability with higher numbers being more unreliable.
"""
min_for_variability_analysis = 20
pct_keep = 0.10
b_cnns = [x for x in cnns if x["itype"] == "background" and x.get("metrics")]
assert len(b_cnns) % 2 == 0, "Expect even set of target/antitarget cnns for background"
if len(b_cnns) >= min_for_variability_analysis:
b_cnns_w_metrics = []
for b_cnn in b_cnns:
unreliability = b_cnn["metrics"]["segments"] * b_cnn["metrics"]["bivar"]
b_cnns_w_metrics.append((unreliability, b_cnn))
b_cnns_w_metrics.sort()
to_keep = int(math.ceil(pct_keep * len(b_cnns) / 2.0) * 2)
b_cnns = [x[1] for x in b_cnns_w_metrics][:to_keep]
assert len(b_cnns) % 2 == 0, "Expect even set of target/antitarget cnns for background"
return [x["file"] for x in b_cnns] | python | def _select_background_cnns(cnns):
min_for_variability_analysis = 20
pct_keep = 0.10
b_cnns = [x for x in cnns if x["itype"] == "background" and x.get("metrics")]
assert len(b_cnns) % 2 == 0, "Expect even set of target/antitarget cnns for background"
if len(b_cnns) >= min_for_variability_analysis:
b_cnns_w_metrics = []
for b_cnn in b_cnns:
unreliability = b_cnn["metrics"]["segments"] * b_cnn["metrics"]["bivar"]
b_cnns_w_metrics.append((unreliability, b_cnn))
b_cnns_w_metrics.sort()
to_keep = int(math.ceil(pct_keep * len(b_cnns) / 2.0) * 2)
b_cnns = [x[1] for x in b_cnns_w_metrics][:to_keep]
assert len(b_cnns) % 2 == 0, "Expect even set of target/antitarget cnns for background"
return [x["file"] for x in b_cnns] | [
"def",
"_select_background_cnns",
"(",
"cnns",
")",
":",
"min_for_variability_analysis",
"=",
"20",
"pct_keep",
"=",
"0.10",
"b_cnns",
"=",
"[",
"x",
"for",
"x",
"in",
"cnns",
"if",
"x",
"[",
"\"itype\"",
"]",
"==",
"\"background\"",
"and",
"x",
".",
"get"... | Select cnns to use for background calculations.
Uses background samples in cohort, and will remove CNNs with high
on target variability. Uses (number of segments * biweight midvariance) as metric
for variability with higher numbers being more unreliable. | [
"Select",
"cnns",
"to",
"use",
"for",
"background",
"calculations",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L400-L420 |
237,092 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | cnvkit_background | def cnvkit_background(background_cnns, out_file, items, target_bed=None, antitarget_bed=None):
"""Calculate background reference, handling flat case with no normal sample.
"""
if not utils.file_exists(out_file):
with file_transaction(items[0], out_file) as tx_out_file:
cmd = [_get_cmd(), "reference", "-f", dd.get_ref_file(items[0]), "-o", tx_out_file]
gender = _get_batch_gender(items)
if gender:
cmd += ["--sample-sex", gender]
if len(background_cnns) == 0:
assert target_bed and antitarget_bed, "Missing CNNs and target BEDs for flat background"
cmd += ["-t", target_bed, "-a", antitarget_bed]
else:
cmd += background_cnns
do.run(_prep_cmd(cmd, tx_out_file), "CNVkit background")
return out_file | python | def cnvkit_background(background_cnns, out_file, items, target_bed=None, antitarget_bed=None):
if not utils.file_exists(out_file):
with file_transaction(items[0], out_file) as tx_out_file:
cmd = [_get_cmd(), "reference", "-f", dd.get_ref_file(items[0]), "-o", tx_out_file]
gender = _get_batch_gender(items)
if gender:
cmd += ["--sample-sex", gender]
if len(background_cnns) == 0:
assert target_bed and antitarget_bed, "Missing CNNs and target BEDs for flat background"
cmd += ["-t", target_bed, "-a", antitarget_bed]
else:
cmd += background_cnns
do.run(_prep_cmd(cmd, tx_out_file), "CNVkit background")
return out_file | [
"def",
"cnvkit_background",
"(",
"background_cnns",
",",
"out_file",
",",
"items",
",",
"target_bed",
"=",
"None",
",",
"antitarget_bed",
"=",
"None",
")",
":",
"if",
"not",
"utils",
".",
"file_exists",
"(",
"out_file",
")",
":",
"with",
"file_transaction",
... | Calculate background reference, handling flat case with no normal sample. | [
"Calculate",
"background",
"reference",
"handling",
"flat",
"case",
"with",
"no",
"normal",
"sample",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L422-L437 |
237,093 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _get_batch_gender | def _get_batch_gender(items):
"""Retrieve gender for a batch of items if consistent.
Better not to specify for mixed populations, CNVkit will work
it out
https://github.com/bcbio/bcbio-nextgen/commit/1a0e217c8a4d3cee10fa890fb3cfd4db5034281d#r26279752
"""
genders = set([population.get_gender(x) for x in items])
if len(genders) == 1:
gender = genders.pop()
if gender != "unknown":
return gender | python | def _get_batch_gender(items):
genders = set([population.get_gender(x) for x in items])
if len(genders) == 1:
gender = genders.pop()
if gender != "unknown":
return gender | [
"def",
"_get_batch_gender",
"(",
"items",
")",
":",
"genders",
"=",
"set",
"(",
"[",
"population",
".",
"get_gender",
"(",
"x",
")",
"for",
"x",
"in",
"items",
"]",
")",
"if",
"len",
"(",
"genders",
")",
"==",
"1",
":",
"gender",
"=",
"genders",
".... | Retrieve gender for a batch of items if consistent.
Better not to specify for mixed populations, CNVkit will work
it out
https://github.com/bcbio/bcbio-nextgen/commit/1a0e217c8a4d3cee10fa890fb3cfd4db5034281d#r26279752 | [
"Retrieve",
"gender",
"for",
"a",
"batch",
"of",
"items",
"if",
"consistent",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L440-L451 |
237,094 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | targets_w_bins | def targets_w_bins(cnv_file, access_file, target_anti_fn, work_dir, data):
"""Calculate target and anti-target files with pre-determined bins.
"""
target_file = os.path.join(work_dir, "%s-target.bed" % dd.get_sample_name(data))
anti_file = os.path.join(work_dir, "%s-antitarget.bed" % dd.get_sample_name(data))
if not utils.file_exists(target_file):
target_bin, _ = target_anti_fn()
with file_transaction(data, target_file) as tx_out_file:
cmd = [_get_cmd(), "target", cnv_file, "--split", "-o", tx_out_file,
"--avg-size", str(target_bin)]
do.run(_prep_cmd(cmd, tx_out_file), "CNVkit target")
if not os.path.exists(anti_file):
_, anti_bin = target_anti_fn()
with file_transaction(data, anti_file) as tx_out_file:
# Create access file without targets to avoid overlap
# antitarget in cnvkit is meant to do this but appears to not always happen
# after chromosome 1
tx_access_file = os.path.join(os.path.dirname(tx_out_file), os.path.basename(access_file))
pybedtools.BedTool(access_file).subtract(cnv_file).saveas(tx_access_file)
cmd = [_get_cmd(), "antitarget", "-g", tx_access_file, cnv_file, "-o", tx_out_file,
"--avg-size", str(anti_bin)]
do.run(_prep_cmd(cmd, tx_out_file), "CNVkit antitarget")
return target_file, anti_file | python | def targets_w_bins(cnv_file, access_file, target_anti_fn, work_dir, data):
target_file = os.path.join(work_dir, "%s-target.bed" % dd.get_sample_name(data))
anti_file = os.path.join(work_dir, "%s-antitarget.bed" % dd.get_sample_name(data))
if not utils.file_exists(target_file):
target_bin, _ = target_anti_fn()
with file_transaction(data, target_file) as tx_out_file:
cmd = [_get_cmd(), "target", cnv_file, "--split", "-o", tx_out_file,
"--avg-size", str(target_bin)]
do.run(_prep_cmd(cmd, tx_out_file), "CNVkit target")
if not os.path.exists(anti_file):
_, anti_bin = target_anti_fn()
with file_transaction(data, anti_file) as tx_out_file:
# Create access file without targets to avoid overlap
# antitarget in cnvkit is meant to do this but appears to not always happen
# after chromosome 1
tx_access_file = os.path.join(os.path.dirname(tx_out_file), os.path.basename(access_file))
pybedtools.BedTool(access_file).subtract(cnv_file).saveas(tx_access_file)
cmd = [_get_cmd(), "antitarget", "-g", tx_access_file, cnv_file, "-o", tx_out_file,
"--avg-size", str(anti_bin)]
do.run(_prep_cmd(cmd, tx_out_file), "CNVkit antitarget")
return target_file, anti_file | [
"def",
"targets_w_bins",
"(",
"cnv_file",
",",
"access_file",
",",
"target_anti_fn",
",",
"work_dir",
",",
"data",
")",
":",
"target_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"work_dir",
",",
"\"%s-target.bed\"",
"%",
"dd",
".",
"get_sample_name",
"("... | Calculate target and anti-target files with pre-determined bins. | [
"Calculate",
"target",
"and",
"anti",
"-",
"target",
"files",
"with",
"pre",
"-",
"determined",
"bins",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L453-L475 |
237,095 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | targets_from_background | def targets_from_background(back_cnn, work_dir, data):
"""Retrieve target and antitarget BEDs from background CNN file.
"""
target_file = os.path.join(work_dir, "%s.target.bed" % dd.get_sample_name(data))
anti_file = os.path.join(work_dir, "%s.antitarget.bed" % dd.get_sample_name(data))
if not utils.file_exists(target_file):
with file_transaction(data, target_file) as tx_out_file:
out_base = tx_out_file.replace(".target.bed", "")
cmd = [_get_cmd("reference2targets.py"), "-o", out_base, back_cnn]
do.run(_prep_cmd(cmd, tx_out_file), "CNVkit targets from background")
shutil.copy(out_base + ".antitarget.bed", anti_file)
return target_file, anti_file | python | def targets_from_background(back_cnn, work_dir, data):
target_file = os.path.join(work_dir, "%s.target.bed" % dd.get_sample_name(data))
anti_file = os.path.join(work_dir, "%s.antitarget.bed" % dd.get_sample_name(data))
if not utils.file_exists(target_file):
with file_transaction(data, target_file) as tx_out_file:
out_base = tx_out_file.replace(".target.bed", "")
cmd = [_get_cmd("reference2targets.py"), "-o", out_base, back_cnn]
do.run(_prep_cmd(cmd, tx_out_file), "CNVkit targets from background")
shutil.copy(out_base + ".antitarget.bed", anti_file)
return target_file, anti_file | [
"def",
"targets_from_background",
"(",
"back_cnn",
",",
"work_dir",
",",
"data",
")",
":",
"target_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"work_dir",
",",
"\"%s.target.bed\"",
"%",
"dd",
".",
"get_sample_name",
"(",
"data",
")",
")",
"anti_file",
... | Retrieve target and antitarget BEDs from background CNN file. | [
"Retrieve",
"target",
"and",
"antitarget",
"BEDs",
"from",
"background",
"CNN",
"file",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L477-L488 |
237,096 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _add_seg_to_output | def _add_seg_to_output(out, data, enumerate_chroms=False):
"""Export outputs to 'seg' format compatible with IGV and GenePattern.
"""
out_file = "%s.seg" % os.path.splitext(out["cns"])[0]
if not utils.file_exists(out_file):
with file_transaction(data, out_file) as tx_out_file:
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "export",
"seg"]
if enumerate_chroms:
cmd += ["--enumerate-chroms"]
cmd += ["-o", tx_out_file, out["cns"]]
do.run(cmd, "CNVkit export seg")
out["seg"] = out_file
return out | python | def _add_seg_to_output(out, data, enumerate_chroms=False):
out_file = "%s.seg" % os.path.splitext(out["cns"])[0]
if not utils.file_exists(out_file):
with file_transaction(data, out_file) as tx_out_file:
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "export",
"seg"]
if enumerate_chroms:
cmd += ["--enumerate-chroms"]
cmd += ["-o", tx_out_file, out["cns"]]
do.run(cmd, "CNVkit export seg")
out["seg"] = out_file
return out | [
"def",
"_add_seg_to_output",
"(",
"out",
",",
"data",
",",
"enumerate_chroms",
"=",
"False",
")",
":",
"out_file",
"=",
"\"%s.seg\"",
"%",
"os",
".",
"path",
".",
"splitext",
"(",
"out",
"[",
"\"cns\"",
"]",
")",
"[",
"0",
"]",
"if",
"not",
"utils",
... | Export outputs to 'seg' format compatible with IGV and GenePattern. | [
"Export",
"outputs",
"to",
"seg",
"format",
"compatible",
"with",
"IGV",
"and",
"GenePattern",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L490-L503 |
237,097 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _add_variantcalls_to_output | def _add_variantcalls_to_output(out, data, items, is_somatic=False):
"""Call ploidy and convert into VCF and BED representations.
"""
call_file = "%s-call%s" % os.path.splitext(out["cns"])
if not utils.file_exists(call_file):
with file_transaction(data, call_file) as tx_call_file:
filters = ["--filter", "cn"]
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "call"] + \
filters + \
["--ploidy", str(ploidy.get_ploidy([data])),
"-o", tx_call_file, out["cns"]]
small_vrn_files = _compatible_small_variants(data, items)
if len(small_vrn_files) > 0 and _cna_has_values(out["cns"]):
cmd += ["--vcf", small_vrn_files[0].name, "--sample-id", small_vrn_files[0].sample]
if small_vrn_files[0].normal:
cmd += ["--normal-id", small_vrn_files[0].normal]
if not is_somatic:
cmd += ["-m", "clonal"]
gender = _get_batch_gender(items)
if gender:
cmd += ["--sample-sex", gender]
do.run(cmd, "CNVkit call ploidy")
calls = {}
for outformat in ["bed", "vcf"]:
out_file = "%s.%s" % (os.path.splitext(call_file)[0], outformat)
calls[outformat] = out_file
if not os.path.exists(out_file):
with file_transaction(data, out_file) as tx_out_file:
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "export",
outformat, "--sample-id", dd.get_sample_name(data),
"--ploidy", str(ploidy.get_ploidy([data])),
"-o", tx_out_file, call_file]
do.run(cmd, "CNVkit export %s" % outformat)
out["call_file"] = call_file
out["vrn_bed"] = annotate.add_genes(calls["bed"], data)
effects_vcf, _ = effects.add_to_vcf(calls["vcf"], data, "snpeff")
out["vrn_file"] = effects_vcf or calls["vcf"]
out["vrn_file"] = shared.annotate_with_depth(out["vrn_file"], items)
return out | python | def _add_variantcalls_to_output(out, data, items, is_somatic=False):
call_file = "%s-call%s" % os.path.splitext(out["cns"])
if not utils.file_exists(call_file):
with file_transaction(data, call_file) as tx_call_file:
filters = ["--filter", "cn"]
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "call"] + \
filters + \
["--ploidy", str(ploidy.get_ploidy([data])),
"-o", tx_call_file, out["cns"]]
small_vrn_files = _compatible_small_variants(data, items)
if len(small_vrn_files) > 0 and _cna_has_values(out["cns"]):
cmd += ["--vcf", small_vrn_files[0].name, "--sample-id", small_vrn_files[0].sample]
if small_vrn_files[0].normal:
cmd += ["--normal-id", small_vrn_files[0].normal]
if not is_somatic:
cmd += ["-m", "clonal"]
gender = _get_batch_gender(items)
if gender:
cmd += ["--sample-sex", gender]
do.run(cmd, "CNVkit call ploidy")
calls = {}
for outformat in ["bed", "vcf"]:
out_file = "%s.%s" % (os.path.splitext(call_file)[0], outformat)
calls[outformat] = out_file
if not os.path.exists(out_file):
with file_transaction(data, out_file) as tx_out_file:
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "export",
outformat, "--sample-id", dd.get_sample_name(data),
"--ploidy", str(ploidy.get_ploidy([data])),
"-o", tx_out_file, call_file]
do.run(cmd, "CNVkit export %s" % outformat)
out["call_file"] = call_file
out["vrn_bed"] = annotate.add_genes(calls["bed"], data)
effects_vcf, _ = effects.add_to_vcf(calls["vcf"], data, "snpeff")
out["vrn_file"] = effects_vcf or calls["vcf"]
out["vrn_file"] = shared.annotate_with_depth(out["vrn_file"], items)
return out | [
"def",
"_add_variantcalls_to_output",
"(",
"out",
",",
"data",
",",
"items",
",",
"is_somatic",
"=",
"False",
")",
":",
"call_file",
"=",
"\"%s-call%s\"",
"%",
"os",
".",
"path",
".",
"splitext",
"(",
"out",
"[",
"\"cns\"",
"]",
")",
"if",
"not",
"utils"... | Call ploidy and convert into VCF and BED representations. | [
"Call",
"ploidy",
"and",
"convert",
"into",
"VCF",
"and",
"BED",
"representations",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L538-L576 |
237,098 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _add_segmetrics_to_output | def _add_segmetrics_to_output(out, data):
"""Add metrics for measuring reliability of CNV estimates.
"""
out_file = "%s-segmetrics.txt" % os.path.splitext(out["cns"])[0]
if not utils.file_exists(out_file):
with file_transaction(data, out_file) as tx_out_file:
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "segmetrics",
"--median", "--iqr", "--ci", "--pi",
"-s", out["cns"], "-o", tx_out_file, out["cnr"]]
# Use less fine grained bootstrapping intervals for whole genome runs
if dd.get_coverage_interval(data) == "genome":
cmd += ["--alpha", "0.1", "--bootstrap", "50"]
else:
cmd += ["--alpha", "0.01", "--bootstrap", "500"]
do.run(cmd, "CNVkit segmetrics")
out["segmetrics"] = out_file
return out | python | def _add_segmetrics_to_output(out, data):
out_file = "%s-segmetrics.txt" % os.path.splitext(out["cns"])[0]
if not utils.file_exists(out_file):
with file_transaction(data, out_file) as tx_out_file:
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "segmetrics",
"--median", "--iqr", "--ci", "--pi",
"-s", out["cns"], "-o", tx_out_file, out["cnr"]]
# Use less fine grained bootstrapping intervals for whole genome runs
if dd.get_coverage_interval(data) == "genome":
cmd += ["--alpha", "0.1", "--bootstrap", "50"]
else:
cmd += ["--alpha", "0.01", "--bootstrap", "500"]
do.run(cmd, "CNVkit segmetrics")
out["segmetrics"] = out_file
return out | [
"def",
"_add_segmetrics_to_output",
"(",
"out",
",",
"data",
")",
":",
"out_file",
"=",
"\"%s-segmetrics.txt\"",
"%",
"os",
".",
"path",
".",
"splitext",
"(",
"out",
"[",
"\"cns\"",
"]",
")",
"[",
"0",
"]",
"if",
"not",
"utils",
".",
"file_exists",
"(",
... | Add metrics for measuring reliability of CNV estimates. | [
"Add",
"metrics",
"for",
"measuring",
"reliability",
"of",
"CNV",
"estimates",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L578-L594 |
237,099 | bcbio/bcbio-nextgen | bcbio/structural/cnvkit.py | _add_gainloss_to_output | def _add_gainloss_to_output(out, data):
"""Add gainloss based on genes, helpful for identifying changes in smaller genes.
"""
out_file = "%s-gainloss.txt" % os.path.splitext(out["cns"])[0]
if not utils.file_exists(out_file):
with file_transaction(data, out_file) as tx_out_file:
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "gainloss",
"-s", out["cns"], "-o", tx_out_file, out["cnr"]]
gender = _get_batch_gender([data])
if gender:
cmd += ["--sample-sex", gender]
do.run(cmd, "CNVkit gainloss")
out["gainloss"] = out_file
return out | python | def _add_gainloss_to_output(out, data):
out_file = "%s-gainloss.txt" % os.path.splitext(out["cns"])[0]
if not utils.file_exists(out_file):
with file_transaction(data, out_file) as tx_out_file:
cmd = [os.path.join(os.path.dirname(sys.executable), "cnvkit.py"), "gainloss",
"-s", out["cns"], "-o", tx_out_file, out["cnr"]]
gender = _get_batch_gender([data])
if gender:
cmd += ["--sample-sex", gender]
do.run(cmd, "CNVkit gainloss")
out["gainloss"] = out_file
return out | [
"def",
"_add_gainloss_to_output",
"(",
"out",
",",
"data",
")",
":",
"out_file",
"=",
"\"%s-gainloss.txt\"",
"%",
"os",
".",
"path",
".",
"splitext",
"(",
"out",
"[",
"\"cns\"",
"]",
")",
"[",
"0",
"]",
"if",
"not",
"utils",
".",
"file_exists",
"(",
"o... | Add gainloss based on genes, helpful for identifying changes in smaller genes. | [
"Add",
"gainloss",
"based",
"on",
"genes",
"helpful",
"for",
"identifying",
"changes",
"in",
"smaller",
"genes",
"."
] | 6a9348c0054ccd5baffd22f1bb7d0422f6978b20 | https://github.com/bcbio/bcbio-nextgen/blob/6a9348c0054ccd5baffd22f1bb7d0422f6978b20/bcbio/structural/cnvkit.py#L596-L609 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.