def create_normal_db(coverage_files_txt, snv_pon, out_dir, genome_build):
"""create normal db
input: coverage files calculated by purecn for each sample
snv_pon - mutect2 SNV PON
output:
mapping_bias_hg38.rds
normalDB_hg38.rds
"""
rscript = utils.Rscript_cmd("r36")
normaldb_r = utils.R_package_script("r36", "PureCN", "extdata/NormalDB.R")
cmd = [rscript, normaldb_r,
"--outdir", out_dir,
"--coveragefiles", coverage_files_txt,
"--normal_panel" , snv_pon,
"--genome", genome_build,
"--force"]
try:
cmd_line = "export R_LIBS_USER=%s && %s && %s" % (utils.R_sitelib(env = "r36"),
utils.get_R_exports(env = "r36"),
" ".join([str(x) for x in cmd]))
do.run(cmd_line, "PureCN normalDB")
except subprocess.CalledProcessError as msg:
logger.info("PureCN failed to create a normal db")
return out_dir
def get_coverage(data):
"""Calculate coverage for a sample.bam, account for GC content
data is single sample
"""
data = utils.to_single_data(data)
bed_file = tz.get_in(["config", "algorithm", "purecn_bed_ready"], data)
sample_name = dd.get_sample_name(data)
work_dir = _sv_workdir(data)
rscript = utils.Rscript_cmd("r36")
coverage_r = utils.R_package_script("r36", "PureCN", "extdata/Coverage.R")
intervals = tz.get_in(["config", "algorithm", "purecn_bed_ready"], data)
# PureCN resolves symlinks and the actual output PureCN coverage file name
# is derived from the end bam not from bam_file
bam_file = os.path.realpath(dd.get_align_bam(data))
bam_name = os.path.basename(bam_file)
(bname, ext) = os.path.splitext(bam_name)
result_file = os.path.join(work_dir, bname + "_coverage_loess.txt.gz")
if not os.path.exists(result_file):
cmd = [rscript, coverage_r,
"--outdir", work_dir,
"--bam", bam_file,
"--intervals", intervals]
try:
cmd_line = "export R_LIBS_USER=%s && %s && %s" % (utils.R_sitelib(env = "r36"),
utils.get_R_exports(env = "r36"),
" ".join([str(x) for x in cmd]))
do.run(cmd_line, "PureCN coverage")
except subprocess.CalledProcessError as msg:
logger.info("PureCN failed to calculate coverage")
logger.debug("Saved PureCN coverage files to " + result_file)
return result_file
def process_intervals(data):
"""Prepare intervals file"""
bed_file = regions.get_sv_bed(data)
if not bed_file:
bed_file = bedutils.clean_file(dd.get_variant_regions(data), data)
if not bed_file:
return None
basename = os.path.splitext(bed_file)[0]
ready_file = basename + ".txt"
if os.path.exists(ready_file):
return ready_file
optimized_bed = basename + ".optimized.bed"
rscript = utils.Rscript_cmd("r36")
interval_file_r = utils.R_package_script("r36", "PureCN", "extdata/IntervalFile.R")
ref_file = dd.get_ref_file(data)
mappability_resource = dd.get_variation_resources(data)["purecn_mappability"]
genome = dd.get_genome_build(data)
cmd = [rscript, interval_file_r, "--infile", bed_file,
"--fasta", ref_file,
"--outfile", ready_file,
"--offtarget",
"--genome", genome,
"--export", optimized_bed,
"--mappability", mappability_resource]
try:
cmd_line = "export R_LIBS_USER=%s && %s && %s" % (utils.R_sitelib(env = "r36"),
utils.get_R_exports(env = "r36"),
" ".join([str(x) for x in cmd]))
do.run(cmd_line, "PureCN intervals")
except subprocess.CalledProcessError as msg:
logger.info("PureCN failed to prepare intervals")
logger.debug("Saved PureCN interval file into " + ready_file)
return ready_file
def _run_purecn_dx(out, paired):
"""Extract signatures and mutational burdens from PureCN rds file."""
# no solution - no signatures
if not "rds" in out:
return out
rscript = utils.Rscript_cmd()
purecndx_r = utils.R_package_script("PureCN", "extdata/Dx.R", env="base")
simple_repeat_bed = dd.get_variation_resources(
paired.tumor_data)["simple_repeat"]
callable_bed = dd.get_sample_callable(paired.tumor_data)
out_base = utils.splitext_plus(out["rds"])[0]
mutation_burden_csv = out_base + "_mutation_burden.csv"
if not utils.file_uptodate(mutation_burden_csv, out["rds"]):
# no signatures - so we generate them
with file_transaction(paired.tumor_data, out_base) as tx_out_base:
cmd = [
rscript, purecndx_r, "--rds", out["rds"], "--callable",
callable_bed, "--signatures", "--exclude", simple_repeat_bed,
"--out", tx_out_base
]
do.run(cmd, "PureCN Dx mutational burden and signatures")
out_base, out, all_files = _get_purecn_dx_files(paired,
out,
require_exist=True)
# if a file was not generated it would not go to the upload
for f in all_files:
if os.path.exists(os.path.join(os.path.dirname(tx_out_base),
f)):
shutil.move(os.path.join(os.path.dirname(tx_out_base), f),
os.path.join(os.path.dirname(out_base), f))
return out
def _run_purecn_normaldb(paired, out):
"""Run PureCN with normaldb and native segmentation
paired is one t/n pair or only """
sample = utils.to_single_data(paired.tumor_data)
bed_file = tz.get_in(["config", "algorithm", "purecn_bed_ready"], sample)
sample_name = dd.get_sample_name(sample)
work_dir = _sv_workdir(sample)
rscript = utils.Rscript_cmd("r36")
purecn_r = utils.R_package_script("r36", "PureCN", "extdata/PureCN.R")
intervals = tz.get_in(["config", "algorithm", "purecn_bed_ready"], sample)
bam_file = dd.get_align_bam(sample)
# termline and somatic - just annotated and filters assigned
variants_vcf = tz.get_in(["variants"], sample)[0].get("germline")
# in a T/N case, there is no germline file - vrn file with all variants
if not variants_vcf:
variants_vcf = tz.get_in(["variants"], sample)[0].get("vrn_file")
normaldb = tz.get_in(["config", "algorithm", "background", "cnv_reference", "purecn_normaldb"], sample)
mappingbiasfile = tz.get_in(["config", "algorithm", "background", "cnv_reference", "purecn_mapping_bias"], sample)
sample_coverage = tz.get_in(["depth", "bins", "purecn"], sample)
simple_repeat_bed = dd.get_variation_resources(sample)["simple_repeat"]
result_file = os.path.join(work_dir, sample_name + ".rds")
genome = dd.get_genome_build(sample)
cmd = [ rscript, purecn_r,
"--out", work_dir,
"--tumor", sample_coverage,
"--sampleid", sample_name,
"--vcf", variants_vcf,
"--normaldb", normaldb,
"--mappingbiasfile", mappingbiasfile,
"--intervals", intervals,
"--snpblacklist", simple_repeat_bed,
"--genome", genome,
"--force",
"--postoptimize",
"--seed", "123",
"--bootstrapn", "500",
"--cores", dd.get_num_cores(sample)]
resources = config_utils.get_resources("purecn", sample)
if "options" in resources:
cmd += [str(x) for x in resources.get("options", [])]
# it is not recommended to use matched normal sample in PureCN analysis,
# because then it skips PON coverage normalization and denoising steps!
# but still, if it is supplied, we useit
if paired.normal_data:
normal_sample = utils.to_single_data(paired.normal_data)
if normal_sample:
normal_coverage = tz.get_in(["depth", "bins", "purecn"], normal_sample)
cmd.extend(["--normal", normal_coverage])
if not os.path.exists(result_file):
try:
cmd_line = "export R_LIBS_USER=%s && %s && %s" % (utils.R_sitelib(env = "r36"),
utils.get_R_exports(env = "r36"),
" ".join([str(x) for x in cmd]))
do.run(cmd_line, "PureCN copy number calling")
logger.debug("Saved PureCN output to " + work_dir)
except subprocess.CalledProcessError as msg:
logger.info("PureCN failed")
out_base, out, all_files = _get_purecn_files(paired, work_dir, require_exist = True)
return out
def _run_purecn_dx(out, paired):
"""Extract signatures and mutational burdens from PureCN rds file."""
out_base, out, all_files = _get_purecn_dx_files(paired, out)
rscript = utils.Rscript_cmd("r36")
purecndx_r = utils.R_package_script("r36", "PureCN", "extdata/Dx.R")
simple_repeat_bed = dd.get_variation_resources(paired.tumor_data)["simple_repeat"]
callable_bed = dd.get_sample_callable(paired.tumor_data)
if not utils.file_uptodate(out["mutation_burden"], out["rds"]):
with file_transaction(paired.tumor_data, out_base) as tx_out_base:
cmd = [rscript, purecndx_r,
"--rds", out["rds"],
"--callable", callable_bed,
"--signatures",
"--exclude", simple_repeat_bed,
"--out", tx_out_base]
do.run(cmd, "PureCN Dx mutational burden and signatures")
for f in all_files:
if os.path.exists(os.path.join(os.path.dirname(tx_out_base), f)):
shutil.move(os.path.join(os.path.dirname(tx_out_base), f),
os.path.join(os.path.dirname(out_base), f))
return out
def _run_purecn(paired, work_dir):
"""Run PureCN.R wrapper with pre-segmented CNVkit or GATK4 inputs.
"""
segfns = {
"cnvkit": _segment_normalized_cnvkit,
"gatk-cnv": _segment_normalized_gatk
}
out_base, out, all_files = _get_purecn_files(paired, work_dir)
failed_file = out_base + "-failed.log"
cnr_file = tz.get_in(["depth", "bins", "normalized"], paired.tumor_data)
if not utils.file_uptodate(
out["rds"], cnr_file) and not utils.file_exists(failed_file):
cnr_file, seg_file = segfns[cnvkit.bin_approach(paired.tumor_data)](
cnr_file, work_dir, paired)
from bcbio import heterogeneity
vcf_file = heterogeneity.get_variants(
paired.tumor_data, include_germline=False)[0]["vrn_file"]
vcf_file = germline.filter_to_pass_and_reject(vcf_file,
paired,
out_dir=work_dir)
with file_transaction(paired.tumor_data, out_base) as tx_out_base:
# Use UCSC style naming for human builds to support BSgenome
genome = ("hg19" if dd.get_genome_build(paired.tumor_data) in [
"GRCh37", "hg19"
] else dd.get_genome_build(paired.tumor_data))
rscript = utils.Rscript_cmd()
purecn_r = utils.R_package_script("PureCN",
"extdata/PureCN.R",
env="base")
cmd = [
rscript, purecn_r, "--seed", "42", "--out", tx_out_base,
"--rds",
"%s.rds" % tx_out_base, "--sampleid",
dd.get_sample_name(paired.tumor_data), "--genome", genome,
"--vcf", vcf_file, "--tumor", cnr_file, "--segfile", seg_file,
"--funsegmentation", "Hclust", "--maxnonclonal", "0.3"
]
if dd.get_num_cores(paired.tumor_data) > 1:
cmd += ["--cores", str(dd.get_num_cores(paired.tumor_data))]
try:
cmd = "export R_LIBS_USER=%s && %s && %s" % (utils.R_sitelib(
env="base"), utils.get_R_exports(env="base"), " ".join(
[str(x) for x in cmd]))
do.run(cmd, "PureCN copy number calling")
except subprocess.CalledProcessError as msg:
if _allowed_errors(str(msg)):
logger.info(
"PureCN failed to find solution for %s: skipping" %
dd.get_sample_name(paired.tumor_data))
with open(failed_file, "w") as out_handle:
out_handle.write(str(msg))
else:
logger.exception()
raise
for f in all_files:
if os.path.exists(os.path.join(os.path.dirname(tx_out_base),
f)):
shutil.move(os.path.join(os.path.dirname(tx_out_base), f),
os.path.join(os.path.dirname(out_base), f))
out = _get_purecn_files(paired, work_dir, require_exist=True)[1]
return out if (out.get("rds") and os.path.exists(out["rds"])) else None
