biopipen 0.28.1__py3-none-any.whl → 0.29.0__py3-none-any.whl

biopipen/scripts/regulation/MotifAffinityTest.R

@@ -0,0 +1,226 @@
+# Script for regulation.MotifAffinityTest
+
+source("{{biopipen_dir}}/utils/misc.R")
+library(BiocParallel)
+library(BSgenome)
+library(universalmotif)
+
+motiffile <- {{in.motiffile | r}}
+varfile <- {{in.varfile | r}}
+outdir <- {{out.outdir | r}}
+ncores <- {{envs.ncores | r}}
+tool <- {{envs.tool | r}}
+bcftools <- {{envs.bcftools | r}}
+genome <- {{envs.genome | r}}
+motif_col <- {{envs.motif_col | r}}
+regulator_col <- {{envs.regulator_col | r}}
+notfound <- {{envs.notfound | r}}
+motifdb <- {{envs.motifdb | r}}
+regmotifs <- {{envs.regmotifs | r}}
+devpars <- {{envs.devpars | r}}
+plot_nvars <- {{envs.plot_nvars | r}}
+plots <- {{envs.plots | r}}
+cutoff <- {{envs.cutoff | r}}
+
+if (is.null(motifdb) || !file.exists(motifdb)) {
+    stop("Motif database (envs.motifdb) is required and must exist")
+}
+
+if (is.null(genome)) {
+    stop("Reference genome (envs.ref) is required and must exist")
+}
+
+if (is.null(motiffile) || !file.exists(motiffile)) {
+    stop("Motif file (in.motiffile) is required and must exist")
+}
+
+if (is.null(varfile) || !file.exists(varfile)) {
+    stop("Variant file (in.varfile) is required and must exist")
+}
+
+if (is.null(motif_col) && is.null(regulator_col)) {
+    stop("Either motif (envs.motif_col) or regulator (envs.regulator_col) column must be provided")
+}
+
+log_info("Reading input regulator/motif file ...")
+in_motifs <- read.table(motiffile, header=TRUE, sep="\t", stringsAsFactors=FALSE, check.names = FALSE)
+
+if (is.null(motif_col)) {
+    log_info("Inferring motifs from regulators ...")
+    if (is.null(regmotifs) || !file.exists(regmotifs)) {
+        stop("Regulator motifs (envs.regmotifs) is required and must exist when no motif column (envs.motif_col) is provided")
+    }
+    regmotifs <- read.table(regmotifs, header=TRUE, sep="\t", stringsAsFactors=FALSE, check.names = FALSE)
+    rm_motif_col <- c('Motif', 'motif', 'MOTIF', 'Model', 'model', 'MODEL')
+    rm_reg_col <- c('Regulator', 'regulator', 'REGULATOR', 'TF', 'tf', 'TF', 'Transcription factor', 'transcription factor', 'Transcription Factor')
+    rm_motif_col <- intersect(rm_motif_col, colnames(regmotifs))
+    rm_reg_col <- intersect(rm_reg_col, colnames(regmotifs))
+    if (length(rm_motif_col) == 0) {
+        stop("No motif column found in envs.regmotifs, provide one of: ", paste(rm_motif_col, collapse = ", "))
+    }
+    if (length(rm_reg_col) == 0) {
+        stop("No regulator column found in envs.regmotifs, provide one of: ", paste(rm_reg_col, collapse = ", "))
+    }
+    rm_motif_col <- rm_motif_col[1]
+    rm_reg_col <- rm_reg_col[1]
+    # check regulators
+    rm_regs <- regmotifs[, rm_reg_col, drop = TRUE]
+    regulators <- in_motifs[, regulator_col, drop = TRUE]
+    notfound_regs <- setdiff(regulators, rm_regs)
+    if (length(notfound_regs) > 0 && notfound == "error") {
+        first_notfound <- head(notfound_regs, 3)
+        if (length(notfound_regs) > 3) {
+            first_notfound <- c(first_notfound, "...")
+            notfound_file <- file.path(outdir, "notfound_regulators.txt")
+            writeLines(notfound_regs, notfound_file)
+            msg1 <- paste0("The following regulators were not found in the envs.regmotifs file: ", paste(first_notfound, collapse = ", "))
+            msg2 <- paste0("Check the full list in ", notfound_file)
+            stop(msg1, "\n", msg2)
+        } else {
+            msg <- paste0("The following regulators were not found in the regmotifs file: ", paste(first_notfound, collapse = ", "))
+            stop(msg)
+        }
+    }
+    in_motifs <- in_motifs[in_motifs[, regulator_col] %in% rm_regs, , drop = FALSE]
+    # add motif column
+    in_motifs <- merge(in_motifs, regmotifs, by.x = regulator_col, by.y = rm_reg_col, all.x = TRUE, suffixes = c("", "_db"))
+    motif_col <- rm_motif_col
+}
+if (is.null(regulator_col)) {
+    # make motifs unique
+    in_moitfs <- in_motifs[!duplicated(in_motifs[, motif_col]), , drop = FALSE]
+} else {
+    in_motifs <- in_motifs[!duplicated(in_motifs[, c(regulator_col, motif_col)]), , drop = FALSE]
+}
+
+
+if (!grepl(".", genome, fixed = TRUE)) {
+    genome_pkg = sprintf("BSgenome.Hsapiens.UCSC.%s", genome)
+} else {
+    genome_pkg = genome
+}
+if (!requireNamespace(genome_pkg, quietly = TRUE)) {
+    stop(sprintf("Genome package %s is not installed", genome_pkg))
+}
+
+log_info("Reading variant file ...")
+if (grepl("\\.vcf$", varfile) || grepl("\\.vcf\\.gz$", varfile)) {
+    log_info("Converting VCF file to BED file ...")
+    varfile_bed <- file.path(outdir, gsub("\\.vcf(\\.gz)?$", ".bed", basename(varfile)))
+    cmd <- c(
+        bcftools, "query",
+        "-f", "%CHROM\\t%POS0\\t%END\\t%ID\\t0\\t+\\t%REF\\t%ALT{0}\\n",
+        "-i", 'FILTER="PASS" || FILTER="." || FILTER=""',
+        "-o", varfile_bed,
+        varfile
+    )
+    run_command(cmd, fg = TRUE)
+
+    varfile <- varfile_bed
+}
+
+# `chrom`, `start`, `end`, `name`, `score`, `strand`, `ref`, `alt`.
+snpinfo <- read.table(varfile, header=FALSE, stringsAsFactors=FALSE)
+colnames(snpinfo) <- c("chrom", "start", "end", "name", "score", "strand", "ref", "alt")
+
+log_info("Reading motif database ...")
+meme <- read_meme(motifdb)
+
+check_motifs <- function(motifdb_names) {
+    motifs <- in_motifs[, motif_col, drop = TRUE]
+    notfound_motifs <- setdiff(motifs, motifdb_names)
+    if (length(notfound_motifs) > 0) {
+        first_notfound <- head(notfound_motifs, 3)
+        if (length(notfound_motifs) > 3) {
+            first_notfound <- c(first_notfound, "...")
+            notfound_file <- file.path(outdir, "notfound_motifs.txt")
+            writeLines(notfound_motifs, notfound_file)
+            msg1 <- paste0("The following motifs were not found in the motif database: ", paste(first_notfound, collapse = ", "))
+            msg2 <- paste0("Check the full list in ", notfound_file)
+
+            if (notfound == "error") {
+                stop(msg1, "\n", msg2)
+            } else if (notfound == "ignore") {
+                log_warn(msg1)
+                log_warn(msg2)
+            }
+        } else {
+            msg <- paste0("The following motifs were not found in the motif database: ", paste(first_notfound, collapse = ", "))
+            if (notfound == "error") {
+                stop(msg)
+            } else if (notfound == "ignore") {
+                log_warn(msg)
+            }
+        }
+
+        motifs <- setdiff(motifs, notfound_motifs)
+    }
+    return(motifs)
+}
+
+plot_variant <- function(motifbreakr_results) {
+    log_info("Plotting variants ...")
+    plotdir <- file.path(outdir, "plots")
+    dir.create(plotdir, showWarnings = FALSE)
+    results <- motifbreakr_results
+    if (is.null(plots) || length(plots) == 0) {
+        results <- results[order(-abs(results$alleleDiff)), , drop = FALSE]
+        results <- results[1:min(plot_nvars, length(results)), , drop = FALSE]
+        variants <- unique(results$SNP_id)
+    } else {
+        variants <- names(plots)
+    }
+    for (variant in variants) {
+        log_info("- Variant: {variant}")
+        if (is.null(plots[[variant]])) {
+            plots[[variant]] <- list(devpars = devpars, which = "TRUE")
+        }
+        if (is.null(plots[[variant]]$which)) {
+            plots[[variant]]$which <- "TRUE"
+        }
+        if (is.null(plots[[variant]]$devpars)) {
+            plots[[variant]]$devpars <- devpars
+        }
+        if (is.null(plots[[variant]]$devpars$res)) {
+            plots[[variant]]$devpars$res <- 100
+        }
+        res <- results[results$SNP_id == variant, , drop = FALSE]
+        if (length(res) == 0) {
+            stop(sprintf("Variant %s not found in results", variant))
+        }
+        res <- subset(res, subset = eval(parse(text = plots[[variant]]$which)))
+        if (length(res) == 0) {
+            stop(sprintf("No variants to plot for %s", variant))
+        }
+        plotfile <- file.path(plotdir, sprintf("%s.png", slugify(variant)))
+        # fix motifBreakR 2.12 using names to filter in plotMB
+        names(res) <- res$SNP_id
+        dv <- plots[[variant]]$devpars
+        if (is.null(dv$height)) {
+            dv$height <- 2.4 * dv$res + length(res) * 1.2 * dv$res
+        }
+        if (is.null(dv$width)) {
+            left <- min(sapply(res$motifPos, `[`, 1))
+            right <- max(sapply(res$motifPos, `[`, 2))
+            dv$width <- 1.5 * dv$res + (right - left) * 0.3 * dv$res
+        }
+        png(plotfile, width = dv$width, height = dv$height, res = dv$res)
+        motifbreakR::plotMB(res, variant)
+        dev.off()
+    }
+}
+
+tool <- tolower(tool)
+tool <- match.arg(tool, c("motifbreakr", "atsnp"))
+
+if (tool == "motifbreakr") {
+    motifbreakr_args <- {{envs.motifbreakr_args | r}}
+    {% set sourcefile = biopipen_dir | joinpaths: "scripts", "regulation", "MotifAffinityTest_MotifBreakR.R" %}
+    # {{ sourcefile | getmtime }}
+    source("{{sourcefile}}")
+} else {  # atsnp
+    atsnp_args <- {{envs.atsnp_args | r}}
+    {% set sourcefile = biopipen_dir | joinpaths: "scripts", "regulation", "MotifAffinityTest_AtSNP.R" %}
+    # {{ sourcefile | getmtime }}
+    source("{{sourcefile}}")
+}

biopipen/scripts/regulation/MotifAffinityTest_AtSNP.R

@@ -0,0 +1,126 @@
+library(atSNP)
+library(rtracklayer)
+
+log_info("Converting universalmotif object to motif_library ...")
+
+motifdb_names <- sapply(meme, function(m) m@name)
+motifs <- check_motifs(motifdb_names)
+meme <- filter_motifs(meme, name = motifs)
+# Get the right order of motif names
+motifs <- sapply(meme, function(m) m@name)
+
+# used for atSNP
+mdb <- lapply(meme, function(m) t(m@motif))
+names(mdb) <- motifs
+
+# compose one used for plotting using motifbreakR
+motifdb_matrices <- lapply(meme, function(m) m@motif)
+names(motifdb_matrices) <- motifs
+motifdb_meta <- do.call(rbind, lapply(meme, function(m) {
+    ats <- attributes(m)
+    ats$dataSource <- basename(motifdb)
+    ats$class <- NULL
+    ats$motif <- NULL
+    ats$gapinfo <- NULL
+    ats$sequenceCount <- ats$nsites
+    ats$providerId <- ats$name
+    ats$providerName <- ats$name
+    ats$organism <- if (is.null(ats$organism) || length(ats$organism) == 0) "Unknown" else ats$organism
+    unlist(ats)
+}))
+rownames(motifdb_meta) <- motifs
+pmotifs <- MotifDb:::MotifList(motifdb_matrices, tbl.metadata = motifdb_meta)
+
+log_info("Converting snpinfo to atSNP object ...")
+
+# c("chrom", "start", "end", "name", "score", "strand", "ref", "alt", "ref_seq", "alt_seq")
+if (any(nchar(snpinfo$ref) != 1) || any(nchar(snpinfo$alt) != 1)) {
+    stop("Only SNVs are supported by atSNP. Consider using motifbreakR instead if you have indels.")
+}
+atsnp_bed <- file.path(outdir, gsub("\\.vcf(\\.gz)?$|\\.bed$", ".atsnp.txt", basename(varfile)))
+snpinfo$name <- ifelse(
+    snpinfo$name == "." | is.na(snpinfo$name) | nchar(snpinfo$name) == 0,
+    sprintf("%s:%s", snpinfo$chrom, snpinfo$end),
+    snpinfo$name
+)
+snpinfo$a1 <- snpinfo$ref
+snpinfo$a2 <- snpinfo$alt
+snpinfo$chr <- snpinfo$chrom
+snpinfo$snp <- snpinfo$end
+snpinfo$snpid <- snpinfo$name
+write.table(
+    snpinfo[, c("snpid", "a1", "a2", "chr", "snp")],
+    file = atsnp_bed,
+    sep = "\t", quote = FALSE, row.names = FALSE, col.names = TRUE
+)
+k <- max(sapply(mdb, nrow))
+snps <- LoadSNPData(
+    atsnp_bed,
+    genome.lib = genome_pkg,
+    mutation = TRUE,  # force using given ref and alt
+    default.par = nrow(snpinfo) < 1000,
+    half.window.size = k
+)
+
+# run motifbreakR
+log_info("Running atSNP ...")
+atsnp_scores <- ComputeMotifScore(mdb, snps, ncores = ncores)
+
+log_info("Calculating p values ...")
+atsnp_result <- ComputePValues(
+    motif.lib = mdb,
+    snp.info = snps,
+    motif.scores = atsnp_scores$motif.scores,
+    ncores = ncores,
+    testing.mc = TRUE
+)
+
+padj_col <- paste0(atsnp_args$p, "_adj")
+atsnp_result[[padj_col]] <- p.adjust(atsnp_result[[atsnp_args$p]], method = atsnp_args$padj)
+cutoff_col <- if (atsnp_args$padj_cutoff) padj_col else atsnp_args$p
+atsnp_result <- atsnp_result[atsnp_result[[cutoff_col]] < cutoff, , drop = FALSE]
+# order by p value
+atsnp_result <- atsnp_result[order(atsnp_result[[cutoff_col]]), , drop = FALSE]
+snpinfo <- snpinfo[match(atsnp_result$snpid, snpinfo$snpid), , drop = FALSE]
+atsnp_result$chr <- snpinfo$chr
+atsnp_result$start <- snpinfo$start
+atsnp_result$end <- snpinfo$end
+atsnp_result$SNP_id <- snpinfo$snpid
+atsnp_result$snpid <- NULL
+atsnp_result$REF <- snpinfo$ref
+atsnp_result$ALT <- snpinfo$alt
+atsnp_result$providerName <- atsnp_result$motif
+atsnp_result$providerId <- atsnp_result$providerName <- atsnp_result$motif
+atsnp_result$motif <- NULL
+atsnp_result$strand <- snpinfo$strand
+atsnp_result$score <- snpinfo$score
+atsnp_result$snpbase <- NULL
+atsnp_result$altPos <- 1
+atsnp_result$varType <- "SNV"
+atsnp_result$motifPos <- sapply(1:nrow(atsnp_result), function(i) {
+    paste(c(atsnp_result$ref_start[i] - k, atsnp_result$ref_end[i] - k), collapse = ",")
+})
+if (!is.null(regulator_col)) {
+    atsnp_result$Regulator <- in_motifs[
+        match(atsnp_result$providerId, in_motifs[[motif_col]]),
+        regulator_col,
+        drop = TRUE
+    ]
+}
+
+write.table(
+    atsnp_result,
+    file = file.path(outdir, "atsnp.txt"),
+    sep = "\t", quote = FALSE, row.names = FALSE
+)
+
+log_info("Plotting variants ...")
+# Convert result to GRanges object
+atsnp_result$alleleDiff <- -atsnp_result[[cutoff_col]]
+atsnp_result$effect <- "strong"
+atsnp_result$motifPos <- lapply(atsnp_result$motifPos, function(x) as.integer(unlist(strsplit(x, ","))))
+atsnp_result <- makeGRangesFromDataFrame(atsnp_result, keep.extra.columns = TRUE, starts.in.df.are.0based = TRUE)
+attributes(atsnp_result)$genome.package <- genome_pkg
+attributes(atsnp_result)$motifs <- pmotifs
+
+plot_variant(atsnp_result)

biopipen/scripts/regulation/MotifAffinityTest_MotifBreakR.R

@@ -0,0 +1,96 @@
+library(motifbreakR)
+bsgenome <- getBSgenome(genome_pkg)
+
+log_info("Converting universalmotif object to MotifDb object ...")
+
+motifdb_names <- sapply(meme, function(m) m@name)
+motifs <- check_motifs(motifdb_names)
+meme <- filter_motifs(meme, name = motifs)
+# Get the right order of motif names
+motifs <- sapply(meme, function(m) m@name)
+motifdb_matrices <- lapply(meme, function(m) m@motif)
+names(motifdb_matrices) <- motifs
+
+motifdb_meta <- do.call(rbind, lapply(meme, function(m) {
+    ats <- attributes(m)
+    ats$dataSource <- basename(motifdb)
+    ats$class <- NULL
+    ats$motif <- NULL
+    ats$gapinfo <- NULL
+    ats$sequenceCount <- ats$nsites
+    ats$providerId <- ats$name
+    ats$providerName <- ats$name
+    ats$organism <- if (is.null(ats$organism) || length(ats$organism) == 0) "Unknown" else ats$organism
+    unlist(ats)
+}))
+rownames(motifdb_meta) <- motifs
+mdb <- MotifDb:::MotifList(motifdb_matrices, tbl.metadata = motifdb_meta)
+
+# `chrom`, `start`, `end`, `name`, `score`, `strand`, `ref`, `alt`.
+is_indel <- nchar(snpinfo$ref) != 1 | nchar(snpinfo$alt) != 1
+snpinfo$coordname <- ifelse(
+    is_indel,
+    sprintf("%s:%s-%s:%s:%s", snpinfo$chrom, snpinfo$start + 1, snpinfo$end, snpinfo$ref, snpinfo$alt),
+    sprintf("%s:%s:%s:%s", snpinfo$chrom, snpinfo$end, snpinfo$ref, snpinfo$alt)
+)
+motifbreakr_bed <- file.path(outdir, gsub("\\.vcf(\\.gz)?$|\\.bed$", ".motifbreakr.bed", basename(varfile)))
+write.table(
+    snpinfo[, c("chrom", "start", "end", "coordname", "score", "strand")],
+    file = motifbreakr_bed,
+    sep = "\t", quote = FALSE, row.names = FALSE, col.names = FALSE
+)
+snps <- snps.from.file(motifbreakr_bed, search.genome = bsgenome, format = "bed", indels = any(is_indel))
+snpinfo <- snpinfo[snpinfo$coordname == snps$SNP_id, , drop = FALSE]
+snps@elementMetadata$SNP_id <- ifelse(
+    snpinfo$name == "." | is.na(snpinfo$name) | nchar(snpinfo$name) == 0,
+    snpinfo$coordname,
+    snpinfo$name
+)
+
+# prepare PWMs
+get_bkg <- function(base) {
+    base_col <- paste0("bkg.", base)
+    base_bkg <- mdb@elementMetadata[[base_col]]
+    if (is.null(base_bkg) || length(base_bkg) == 0 || is.na(base_bkg[1])) {
+        base_bkg <- 0.25
+    } else {
+        base_bkg <- as.numeric(base_bkg[1])
+    }
+}
+bkg <- c(A = get_bkg("A"), C = get_bkg("C"), G = get_bkg("G"), T = get_bkg("T"))
+
+# run motifbreakR
+log_info("Running motifbreakR ...")
+results <- motifbreakR(
+    snpList = snps,
+    pwmList = mdb,
+    threshold = cutoff,
+    method = motifbreakr_args$method,
+    bkg = bkg,
+    filterp = TRUE,
+    show.neutral = FALSE,
+    BPPARAM = MulticoreParam(ncores)
+)
+
+log_info("Calculating p values ...")
+results <- calculatePvalue(results)
+results_to_save <- as.data.frame(unname(results))
+results_to_save$motifPos <- lapply(results_to_save$motifPos, function(x) paste(x, collapse = ","))
+results_to_save$altPos <- lapply(results_to_save$altPos, function(x) paste(x, collapse = ","))
+if (!is.null(regulator_col)) {
+    results_to_save$Regulator <- in_motifs[
+        match(results_to_save$providerId, in_motifs[[motif_col]]),
+        regulator_col,
+        drop = TRUE
+    ]
+}
+results_to_save <- apply(results_to_save, 2, as.character)
+
+write.table(
+    results_to_save,
+    file = file.path(outdir, "motifbreakr.txt"),
+    sep = "\t", quote = FALSE, row.names = FALSE
+)
+rm(results_to_save)
+
+plot_variant(results)

biopipen/scripts/regulation/MotifScan.py

@@ -0,0 +1,159 @@
+"""Script for regulation.MotifScan"""
+import re
+
+# Paths may be passed in args or to motifdb
+from pathlib import PosixPath  # noqa: F401
+from biopipen.utils.misc import run_command, dict_to_cli_args, logger
+
+motiffile = {{in.motiffile | repr}}  # pyright: ignore # noqa: #999
+seqfile = {{in.seqfile | repr}}  # pyright: ignore
+outdir = {{out.outdir | repr}}  # pyright: ignore
+
+tool = {{envs.tool | repr}}  # pyright: ignore
+fimo = {{envs.fimo | repr}}  # pyright: ignore
+motif_col = {{envs.motif_col | repr}}  # pyright: ignore
+regulator_col = {{envs.regulator_col | repr}}  # pyright: ignore
+notfound = {{envs.notfound | repr}}  # pyright: ignore
+motifdb = {{envs.motifdb | repr}}  # pyright: ignore
+cutoff = {{envs.cutoff | repr}}  # pyright: ignore
+q = {{envs.q | repr}}  # pyright: ignore
+q_cutoff = {{envs.q_cutoff | repr}}  # pyright: ignore
+args = {{envs.args | dict | repr}}  # pyright: ignore
+
+# Check if the tool is supported
+if tool != "fimo":
+    raise ValueError(f"Unsupported tool: {tool}, currently only fimo is supported")
+
+# Check if the motif database is provided
+if motifdb is None:
+    raise ValueError("The motif database is required")
+
+# Check if the motif file exists
+if not motiffile:
+    raise FileNotFoundError(f"Motif file in.motiffile must be provided")
+
+# Check if the sequence file exists
+if not seqfile:
+    raise FileNotFoundError(f"Sequence file in.seqfile must be provided")
+
+# Normalize motif_col and regulator_col into 0-based indexes
+if isinstance(motif_col, str) or isinstance(regulator_col, str):
+    with open(motiffile, "r") as f:
+        header = f.readline().strip().split("\t")
+        if isinstance(motif_col, str):
+            motif_col = header.index(motif_col) + 1
+        if isinstance(regulator_col, str):
+            regulator_col = header.index(regulator_col) + 1
+if isinstance(motif_col, int):
+    motif_col -= 1
+if isinstance(regulator_col, int):
+    regulator_col -= 1
+
+# Check if motif names exist in the database
+with open(motiffile, "r") as f:
+    motif_names = set(
+        line.strip().split("\t")[motif_col]
+        for i, line in enumerate(f)
+        if i > 0  # skip header
+    )
+
+with open(motifdb, "r") as f:
+    motif_db_names = set(
+        line[6:].strip()
+        for line in f
+        if line.startswith("MOTIF")
+    )
+
+if notfound == "error":
+    notfound_motifs = motif_names - motif_db_names
+    if notfound_motifs:
+        raise ValueError(f"Motifs not found in the database: {notfound_motifs}")
+
+# Make a new motif database with only the motifs in the motiffile
+motif_names = motif_names & motif_db_names
+motifdb_filtered = f"{outdir}/motif_db.txt"
+with open(motifdb, "r") as f, open(motifdb_filtered, "w") as f_out:
+    should_write = True
+    for line in f:
+        if line.startswith("MOTIF"):
+            motif_name = line[6:].strip()
+            if motif_name in motif_names:
+                should_write = True
+            else:
+                should_write = False
+
+        if should_write:
+            f_out.write(line)
+        else:
+            continue
+
+# Now run fimo
+args[""] = fimo
+args["oc"] = f"{outdir}"
+args["thresh"] = cutoff
+args["qv_thresh"] = q_cutoff
+args["no_qvalue"] = not q
+args["no-pgc"] = True
+args["_"] = [motifdb_filtered, seqfile]
+
+logger.info("Running fimo ...")
+run_command(dict_to_cli_args(args, dashify=True), fg=True)
+
+logger.info("Adding additional information to the output ...")
+# Get the motif to regulator mapping
+motif_regulator_map = {}
+if regulator_col is not None:
+    with open(motiffile, "r") as f:
+        next(f)  # skip header
+        for line in f:
+            line = line.strip().split("\t")
+            motif_name = line[motif_col]
+            regulator = line[regulator_col]
+            motif_regulator_map[motif_name] = regulator
+
+# Get the sequence name information
+seqnames = {}
+seqcoords = {}
+with open(seqfile, "r") as f:
+    for line in f:
+        if not line.startswith(">"):
+            continue
+
+        seqname = line[1:].strip()
+        match = re.match(r"^(.+)::((?:chr)?\d+):(\d+)-(\d+).*$", seqname)
+        if not match:
+            seqnames[seqname] = seqname
+            seqcoords[seqname] = None
+        else:
+            sname, chrom, start, end = match.groups()
+            seqnames[seqname] = sname
+            seqcoords[seqname] = (chrom, int(start), int(end))
+
+# Add additional information to the output
+with open(f"{outdir}/fimo.tsv", "r") as f, open(f"{outdir}/fimo_output.txt", "w") as f_out:
+    header = f.readline().strip().split("\t")
+    f_out.write(
+        "\t".join(header + ["regulator", "seqname", "seqstart", "seqstop"]) + "\n"
+    )
+    for line in f:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        line = line.split("\t")
+        motif_name = line[0]
+        sequence_name = line[2]
+        start = int(line[3])
+        stop = int(line[4])
+        regulator = motif_regulator_map.get(motif_name, motif_name)
+        seqname = seqnames.get(sequence_name, "NA")
+        seqcoord = seqcoords.get(sequence_name)
+        if not seqcoord:
+            seqstart = "NA"
+            seqstop = "NA"
+        else:
+            seqstart = start + seqcoord[1] - 1
+            seqstop = stop + seqcoord[2] - 1
+
+        f_out.write(
+            "\t".join(line + [regulator, seqname, str(seqstart), str(seqstop)]) + "\n"
+        )

biopipen/scripts/regulation/atSNP.R

@@ -0,0 +1,33 @@
+snpinfo2atsnp <- function(snpinfo) {
+    # c("chrom", "start", "end", "name", "score", "strand", "ref", "alt", "ref_seq", "alt_seq")
+    if (any(nchar(snpinfo$ref) != 1) || any(nchar(snpinfo$alt) != 1)) {
+        stop("Only SNVs are supported by atSNP. Consider using motifbreakR instead if you have indels.")
+    }
+    base_encodings <- c(A = 1, C = 2, G = 3, T = 4)
+    transition <- matrix(
+        c(
+            0.3225035, 0.1738422, 0.24915044, 0.2545039,
+            0.3451410, 0.2642147, 0.05245011, 0.3381942,
+            0.2813089, 0.2136604, 0.26749171, 0.2375390,
+            0.2149776, 0.2071733, 0.25309238, 0.3247568
+        ),
+        nrow = 4,
+        byrow = TRUE
+    )
+    rownames(transition) <- colnames(transition) <- names(base_encodings)
+    list(
+        sequence_matrix = unname(sapply(
+            snpinfo$ref_seq,
+            function(s) as.integer(base_encodings[strsplit(s, "")[[1]]])
+        )),
+        ref_base = as.integer(base_encodings[snpinfo$ref]),
+        snp_base = as.integer(base_encodings[snpinfo$alt]),
+        snpids = snpinfo$name,
+        transition = transition,
+        prior = c(A = 0.287, C = 0.211, G = 0.213, T = 0.289),
+        rsid.na = NULL,
+        rsid.rm = NULL,
+        rsid.duplicate = NULL,
+        rsid.missing = NULL
+    )
+}