biopipen 0.21.0__py3-none-any.whl → 0.34.26__py3-none-any.whl

biopipen/scripts/plot/Manhattan.R

@@ -0,0 +1,147 @@
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
+
+library(rlang)
+library(ggmanh)
+
+infile <- {{in.infile | r}}
+outfile <- {{out.outfile | r}}
+chrom_col <- {{envs.chrom_col | r}}
+pos_col <- {{envs.pos_col | r}}
+pval_col <- {{envs.pval_col | r}}
+label_col <- {{envs.label_col | r}}
+devpars <- {{envs.devpars | r}}
+title <- {{envs.title | r}}
+ylabel <- {{envs.ylabel | r}}
+rescale <- {{envs.rescale | r}}
+rescale_ratio_threshold <- {{envs.rescale_ratio_threshold | r}}
+signif <- {{envs.signif | r}}
+hicolors <- {{envs.hicolors | r}}
+thin_n <- {{envs.thin_n | r}}
+thin_bins <- {{envs.thin_bins | r}}
+zoom <- {{envs.zoom | r}}
+zoom_devpars <- {{envs.zoom_devpars | r}}
+chroms <- {{envs.chroms | r}}
+args <- {{envs.args | r: todot="-"}}
+
+data <- read.table(infile, header=TRUE, sep="\t", stringsAsFactors=FALSE, check.names = FALSE)
+
+# normalize columns
+cnames <- colnames(data)
+if (is.numeric(chrom_col)) { chrom_col <- cnames[chrom_col] }
+if (is.numeric(pos_col)) { pos_col <- cnames[pos_col] }
+if (is.numeric(pval_col)) { pval_col <- cnames[pval_col] }
+if (is.numeric(label_col)) { label_col <- cnames[label_col] }
+
+# normalize chroms
+norm_chroms <- function(chrs) {
+    chrs <- as.character(chrs)
+    if (length(chrs) == 1 && grepl(",", chrs)) {
+        chrs <- trimws(unlist(strsplit(chrs, ",")))
+    }
+    if (length(chrs) > 1) {
+        return(unique(unlist(sapply(chrs, function(chr) norm_chroms(chr)))))
+    }
+    if (!grepl("-", chrs)) { return(chrs) }
+
+    # expand chr1-22 -> chr1, chr2, ..., chr22
+    # chr1-22 -> 'chr1', '22'
+    chrs <- unlist(strsplit(chrs, "-"))
+    if (length(chrs) != 2) {
+        stop(paste0("Invalid chroms: ", chrs))
+    }
+    # detect prefix
+    prefix1 <- gsub("[0-9]", "", chrs[1])
+    prefix2 <- gsub("[0-9]", "", chrs[2])
+    if (nchar(prefix2) > 0 && prefix1 != prefix2) {
+        stop(paste0("Invalid chroms: ", chrs, " (prefix mismatch)"))
+    }
+    chr_a <- as.integer(substring(chrs[1], nchar(prefix1) + 1))
+    chr_b <- as.integer(substring(chrs[2], nchar(prefix2) + 1))
+    chr_min <- min(chr_a, chr_b)
+    chr_max <- max(chr_a, chr_b)
+    return(paste0(prefix1, chr_min:chr_max))
+}
+
+log_info("Preparing data for plotting ...")
+if (length(chroms) == 1 && chroms == "auto") {
+    chroms <- unique(data[[chrom_col]])
+} else {
+    chroms <- norm_chroms(chroms)
+}
+
+# prepare data
+mp_prep_args = list()
+if (length(signif) == 1 && is.character(signif)) {
+    signif <- as.numeric(trimws(unlist(strsplit(signif, ","))))
+}
+siglevel <- min(signif)
+if (!is.null(label_col)) {
+    data$.label <- ifelse(data[[pval_col]] < siglevel, data[[label_col]], "")
+}
+if (!is.null(hicolors)) {
+    sig_str <- "Significant"
+    nsig_str <- "Not significant"
+    data$.highlight <- ifelse(data[[pval_col]] < siglevel, sig_str, nsig_str)
+    if (length(hicolors) == 1) { hicolors <- c(hicolors, "grey") }
+    names(hicolors) <- c(sig_str, nsig_str)
+    mp_prep_args$highlight.colname <- ".highlight"
+    mp_prep_args$highlight.col <- hicolors
+}
+mp_prep_args$x <- data
+mp_prep_args$chr.colname <- chrom_col
+mp_prep_args$pos.colname <- pos_col
+mp_prep_args$pval.colname <- pval_col
+mp_prep_args$chr.order <- chroms
+if (!is.null(thin_n) && thin_n > 0) {
+    mp_prep_args$thin.n <- thin_n
+    mp_prep_args$thin.bins <- thin_bins
+}
+
+mpdata <- do_call(manhattan_data_preprocess, mp_prep_args)
+
+# plot
+log_info("Plotting Manhattan plot ...")
+args$x <- mpdata
+args$signif <- signif
+args$plot.title <- title
+args$rescale <- rescale
+args$rescale.ratio.threshold <- rescale_ratio_threshold
+args$y.label <- ylabel
+if (!is.null(hicolors)) { args$color.by.highlight <- TRUE }
+if (!is.null(label_col)) { args$label.colname <- ".label" }
+g <- do_call(manhattan_plot, args)
+
+png(outfile, width=devpars$width, height=devpars$height, res=devpars$res)
+print(g)
+dev.off()
+
+# zoom into chromosomes
+all_chroms <- as.character(unique(mpdata$data[[mpdata$chr.colname]]))
+if (!is.null(zoom)) {
+    log_info("Zooming into chromosomes ...")
+    zoom <- norm_chroms(zoom)
+    for (z in zoom) {
+        if (!z %in% all_chroms) {
+            log_warn("- {z}: not found in data")
+            next
+        }
+        log_info("- {z}")
+        args_z <- args
+        args_z$chromosome <- z
+        args_z$plot.title <- paste0(title, " (", z, ")")
+        args_z$x.label <- "Position"
+        g_z <- do_call(manhattan_plot, args_z)
+        outfile_z <- gsub("\\.png$", paste0("-", z, ".png"), outfile)
+        zm_devpars <- zoom_devpars
+        zm_devpars$res <- zm_devpars$res %||% devpars$res
+        zm_devpars$height <- zm_devpars$height %||% devpars$height
+        png(
+            outfile_z,
+            width=zm_devpars$width,
+            height=zm_devpars$height,
+            res=zm_devpars$res
+        )
+        print(g_z)
+        dev.off()
+    }
+}

biopipen/scripts/plot/QQPlot.R

@@ -0,0 +1,146 @@
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
+
+library(rlang)
+library(stats)
+library(ggplot2)
+library(ggprism)
+library(qqplotr)
+
+theme_set(theme_prism())
+
+infile <- {{in.infile | r}}
+theorfile <- {{in.theorfile | r}}
+outfile <- {{out.outfile | r}}
+val_col <- {{envs.val_col | r}}
+theor_col <- {{envs.theor_col | r}}
+theor_trans <- {{envs.theor_trans | r}}
+theor_funs <- {{envs.theor_funs | r}}
+devpars <- {{envs.devpars | r}}
+title <- {{envs.title | r}}
+xlabel <- {{envs.xlabel | r}}
+ylabel <- {{envs.ylabel | r}}
+kind <- {{envs.kind | r}}
+trans <- {{envs.trans | r}}
+args <- {{envs.args | r}}
+band_args <- {{envs.band | r}}
+line_args <- {{envs.line | r}}
+point_args <- {{envs.point | r}}
+ggs <- {{envs.ggs | r}}
+
+.eval_fun <- function(fun) {
+    if (is.character(fun)) {
+        fun <- trimws(fun)
+        if (grepl("^-\\s*[a-zA-Z\\.][0-9a-zA-Z\\._]*$", fun)) {
+            fun <- trimws(substring(fun, 2))
+            fun <- eval(parse(text = fun))
+            return(function(x) -fun(x))
+        } else {
+            return(eval(parse(text = fun)))
+        }
+    } else {
+        return(fun)
+    }
+}
+
+indata <- read.table(infile, header=TRUE, sep="\t", stringsAsFactors=FALSE, check.names = FALSE)
+if (is.numeric(val_col)) {
+    val_col <- colnames(indata)[val_col]
+}
+if (!is.null(trans)) {
+    trans <- .eval_fun(trans)
+    indata[[val_col]] <- trans(indata[[val_col]])
+}
+
+if (!is.null(theor_col)) {
+    if (is.numeric(theor_col)) {
+        theor_col <- colnames(theor)[theor_col]
+    }
+
+    if (!is.null(theorfile)) {
+        theor <- read.table(theorfile, header=TRUE, sep="\t", stringsAsFactors=FALSE, check.names = FALSE)
+        theor_vals <- theor[[theor_col]]
+    } else {
+        theor_vals <- indata[[theor_col]]
+    }
+
+    if (!is.null(theor_trans)) {
+        theor_trans <- .eval_fun(theor_trans)
+        theor_vals <- theor_trans(theor_vals)
+    }
+    theor_vals <- sort(na.omit(theor_vals))
+}
+
+band_fun <- ifelse(kind == "pp", stat_pp_band, stat_qq_band)
+line_fun <- ifelse(kind == "pp", stat_pp_line, stat_qq_line)
+point_fun <- ifelse(kind == "pp", stat_pp_point, stat_qq_point)
+
+for (fun in names(theor_funs)) {
+    assign(fun, .eval_fun(theor_funs[[fun]]))
+}
+
+if (!is.null(band_args) || isFALSE(band_args)) {
+    if (isTRUE(band_args$disabled)) {
+        band_args <- NULL
+    } else {
+        band_args$disabled <- NULL
+        band_args <- list_update(band_args, args)
+        if (band_args$distribution == "custom") {
+            band_args$dparams <- band_args$dparams %||% list()
+            band_args$dparams$values <- theor_vals
+        }
+    }
+}
+if (!is.null(line_args) || isFALSE(line_args)) {
+    if (isTRUE(line_args$disabled)) {
+        line_args <- NULL
+    } else {
+        line_args$disabled <- NULL
+        line_args <- list_update(line_args, args)
+        if (line_args$distribution == "custom") {
+            line_args$dparams <- line_args$dparams %||% list()
+            line_args$dparams$values <- theor_vals
+        }
+    }
+}
+if (!is.null(point_args) || isFALSE(point_args)) {
+    if (isTRUE(point_args$disabled)) {
+        point_args <- NULL
+    } else {
+        point_args$disabled <- NULL
+        point_args <- list_update(point_args, args)
+        if (point_args$distribution == "custom") {
+            point_args$dparams <- point_args$dparams %||% list()
+            point_args$dparams$values <- theor_vals
+        }
+    }
+}
+
+title <- title %||% waiver()
+xlabel <- xlabel %||% waiver()
+ylabel <- ylabel %||% waiver()
+
+indata <- indata[complete.cases(indata), , drop = FALSE]
+indata <- indata[order(indata[[val_col]]), , drop = FALSE]
+
+p <- ggplot(data = indata, mapping = aes(sample = !!sym(val_col))) +
+    labs(title = title, x = xlabel, y = ylabel)
+
+if (!is.null(band_args)) {
+    p <- p + do_call(band_fun, band_args)
+}
+if (!is.null(line_args)) {
+    p <- p + do_call(line_fun, line_args)
+}
+if (!is.null(point_args)) {
+    p <- p + do_call(point_fun, point_args)
+}
+
+if (!is.null(ggs)) {
+    for (gg in ggs) {
+        p <- p + eval(parse(text = gg))
+    }
+}
+
+png(outfile, width=devpars$width, height=devpars$height, res=devpars$res)
+print(p)
+dev.off()

biopipen/scripts/plot/ROC.R

@@ -0,0 +1,88 @@
+
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
+
+library(rlang)
+library(ggplot2)
+library(plotROC)
+
+infile <- {{in.infile | r}}
+outfile <- {{out.outfile | r}}
+joboutdir <- {{job.outdir | r}}
+noids <- {{envs.noids | r}}
+pos_label <- {{envs.pos_label | r}}
+ci <- {{envs.ci | r}}
+devpars <- {{envs.devpars | r}}
+show_auc <- {{envs.show_auc | r}}
+args <- {{envs.args | r: todot="-"}}
+style_roc_args <- {{envs.style_roc | r: todot="-"}}
+if (!is.null(style_roc_args$theme)) {
+    style_roc_args$theme <- eval(parse(text=style_roc_args$theme))
+}
+
+data <- read.table(infile, header=TRUE, sep="\t", row.names = NULL, check.names = FALSE, stringsAsFactors=FALSE)
+if (!noids) {
+    data <- data[, -1]
+}
+
+# Normalize the first column (labels) into 0 and 1.
+# If they are not 0/1, use pos_label to determine the positive class.
+label_col <- colnames(data)[1]
+if (is.character(data[[label_col]])) {
+    data[[label_col]] <- as.numeric(data[[label_col]] == pos_label)
+}
+
+models <- colnames(data)[2:ncol(data)]
+
+if (length(models) > 1) {
+    # pivot longer the models, and put the model names into the column 'model'
+    data <- melt_roc(data, label_col, colnames(data)[2:ncol(data)])
+} else {
+    data <- data.frame(
+        D = data[[label_col]],
+        M = data[[models]],
+        name = rep(models, nrow(data))
+    )
+}
+
+# Plot the ROC curve
+p <- ggplot(data, aes(d = D, m = M, color = name))
+
+if (isTRUE(ci)) {
+    p <- p + do.call(geom_rocci, args)
+} else {
+    p <- p + do.call(geom_roc, args)
+}
+
+p <- p + do.call(style_roc, style_roc_args)
+p <- p + scale_color_biopipen()
+
+if (length(models) > 1) {
+    p <- p + theme(legend.title = element_blank())
+} else {
+    p <- p + theme(legend.position = "none")
+}
+
+aucs = calc_auc(p)
+write.table(aucs, file=file.path(joboutdir, "aucs.tsv"), sep="\t", quote=FALSE, row.names=FALSE)
+
+if (show_auc) {
+    aucs = split(aucs$AUC, aucs$name)
+    if (length(aucs) > 1) {
+        # Add AUC values to the legend items
+        p <- p +
+            scale_color_manual(
+                values = pal_biopipen()(length(models)),
+                labels = sapply(models, function(m) paste(m, " (AUC =", round(aucs[[m]], 2), ")")),
+                breaks = models)
+    } else {
+        p <- p +
+            geom_text(
+                x = 0.8, y = 0.2, label = paste("AUC =", round(unlist(aucs), 2)),
+                color = "black", size = 4)
+    }
+}
+
+devpars$filename <- outfile
+do.call(png, devpars)
+print(p)
+dev.off()

biopipen/scripts/plot/Scatter.R

@@ -0,0 +1,112 @@
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
+
+library(ggpmisc)
+library(rlang)
+library(ggplot2)
+library(ggprism)
+
+theme_set(theme_prism())
+
+infile <- {{in.infile | r}}
+outfile <- {{out.outfile | r}}
+x_col <- {{envs.x_col | r}}
+y_col <- {{envs.y_col | r}}
+devpars <- {{envs.devpars | r}}
+args <- {{envs.args | r}}
+ggs <- {{envs.ggs | r}}
+formula <- {{envs.formula | r}}
+mapping <- {{envs.mapping | r}}
+stats <- {{envs.stats | r}}
+
+.ensure_r <- function(ex, recursive=TRUE) {
+    if (is.character(ex)) {
+        ex <- trimws(ex)
+        if (grepl("^-\\s*[a-zA-Z\\.][0-9a-zA-Z\\._]*$", ex)) {
+            ex <- trimws(substring(ex, 2))
+            ex <- eval(parse(text = ex))
+            return(function(x) -ex(x))
+        } else {
+            return(eval(parse(text = ex)))
+        }
+    } else if (is.list(ex) && recursive) {
+        return(lapply(ex, .ensure_r, recursive=TRUE))
+    } else {
+        return(ex)
+    }
+}
+
+.merge_aes <- function(aes1, aes2) {
+    if (is.null(aes1)) {
+        return(aes2)
+    }
+    if (is.null(aes2)) {
+        return(aes1)
+    }
+    merged <- c(aes1, aes2)  # list
+    out <- list()
+    for (key in names(merged)) {
+        if (is.null(out[[key]])) {
+            out[[key]] <- merged[[key]]
+        } else {
+            log_warn(paste("Overwriting mapping key:", key))
+        }
+    }
+    return(do.call(aes, out))
+}
+
+if (is.null(formula)) {
+    stop("Formula must be provided")
+}
+if (!is.null(mapping)) {
+    if (startsWith(mapping, "(") && endsWith(mapping, ")")) {
+        mapping <- paste0("aes", mapping)
+    } else if (!startsWith(mapping, "aes(")) {
+        mapping <- paste0("aes(", mapping, ")")
+    }
+    mapping <- .ensure_r(mapping)
+}
+formula <- as.formula(formula)
+
+indata <- read.table(infile, header=TRUE, sep="\t", stringsAsFactors=FALSE, check.names = FALSE)
+if (is.numeric(x_col)) {
+    x_col <- colnames(indata)[x_col]
+}
+if (is.numeric(y_col)) {
+    y_col <- colnames(indata)[y_col]
+}
+
+args <- lapply(args, .ensure_r)
+args$mapping <- .merge_aes(args$mapping, mapping)
+
+if (!is.null(stats)) {
+    stats <- lapply(stats, .ensure_r)
+}
+
+p <- ggplot(indata, aes(x = !!sym(x_col), y = !!sym(y_col))) +
+    do.call(geom_point, args)
+
+for (stat in names(stats)) {
+    if (startsWith(stat, "stat_")) {
+        stat <- substring(stat, 6)
+    }
+    if (grepl("#", stat)) {
+        st <- paste0("stat_", strsplit(stat, "#")[[1]][1])
+    } else {
+        st <- paste0("stat_", stat)
+    }
+    stats[[stat]]$formula <- stats[[stat]]$formula %||% formula
+    stats[[stat]]$mapping <- .merge_aes(stats[[stat]]$mapping, mapping)
+    p <- p + do.call(st, stats[[stat]])
+}
+
+if (!is.null(ggs)) {
+    for (gg in ggs) {
+        p <- p + eval(parse(text = gg))
+    }
+}
+
+p <- p + scale_color_biopipen()
+
+png(outfile, width=devpars$width, height=devpars$height, res=devpars$res)
+print(p)
+dev.off()

biopipen/scripts/plot/VennDiagram.R

@@ -1,10 +1,8 @@
-library(dplyr)
+{{ biopipen_dir | joinpaths: "utils", "io.R" | source_r }}
+{{ biopipen_dir | joinpaths: "utils", "plot.R" | source_r }}
 
-source("{{biopipen_dir}}/utils/io.R")
-source("{{biopipen_dir}}/utils/plot.R")
-
-infile = {{in.infile | quote}}
-outfile = {{out.outfile | quote}}
+infile = {{in.infile | r}}
+outfile = {{out.outfile | r}}
 inopts = {{envs.inopts | r}}
 intype = {{envs.intype | r}}
 devpars = {{envs.devpars | r}}
@@ -18,9 +16,7 @@ if (intype == "raw") {
     indata = lapply(indata, function(x) unlist(strsplit(x, ",", fixed=TRUE)))
 } else { # computed
     elems = rownames(indata)
-    indata = indata %>%
-        mutate(across(everything(), function(x) elems[as.logical(x)])) %>%
-        as.list()
+    indata = apply(indata, 2, function(x) elems[as.logical(x)])
 }
 
 plotVenn(

biopipen/scripts/protein/MMCIF2PDB.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+from shutil import which
+from diot import Diot  # noqa: F401
+from biopipen.utils.misc import run_command, dict_to_cli_args
+
+infile: str = {{in.infile | quote}}  # pyright: ignore # noqa
+outfile: str = {{out.outfile | quote}}  # pyright: ignore
+envs: dict = {{envs | repr}}  # pyright: ignore
+tool: str = envs.pop("tool", "maxit")
+maxit: str = envs.pop("maxit", "maxit")
+beem = envs.pop("beem", "BeEM")
+
+if tool == "maxit":
+    maxit_found = which(maxit)
+    if not maxit_found:
+        raise ValueError(f"maxit executable not found: {maxit}")
+
+    maxit_exe = Path(maxit_found).expanduser().resolve()
+    rcsbroot = maxit_exe.parent.parent
+    envs["input"] = infile
+    envs["output"] = outfile
+    envs["o"] = 2
+    envs["log"] = Path(outfile).with_suffix(".log")
+    run_command([maxit, *dict_to_cli_args(envs, prefix="-")], fg=True, env={"RCSBROOT": rcsbroot})
+
+else:
+    outfile: Path = Path(outfile)  # type: ignore
+    envs["_"] = infile
+    envs["p"] = outfile.parent.joinpath(outfile.stem)
+    envs["outfmt"] = 3
+    args = dict_to_cli_args(envs, prefix="-", sep="=")
+
+    run_command([beem, *args], fg=True)

biopipen/scripts/protein/PDB2Fasta.py

@@ -0,0 +1,60 @@
+# """
+# LICENSE
+
+# GNU General Public License v2.0
+
+# The code is based on the script from:
+# https://github.com/kad-ecoli/pdb2fasta/blob/master/pdb2fasta.py
+
+# The original code is licensed under GNU General Public License v2.0.
+# The original code is modified by biopipen developers to fit the biopipen.
+# """
+from __future__ import annotations
+import re
+from collections import defaultdict
+from pathlib import Path
+
+infile: str = {{in.infile | quote}}  # pyright: ignore # noqa: E999
+outfile: str = {{out.outfile | quote}}  # pyright: ignore
+chains: str | list | None = {{envs.chains | repr}}  # pyright: ignore
+wrap: int = {{envs.wrap | repr}}  # pyright: ignore
+
+if isinstance(chains, str):
+    chains = [chain.strip() for chain in chains.split(",")]
+
+aa3to1 = {
+   'ALA':'A', 'VAL':'V', 'PHE':'F', 'PRO':'P', 'MET':'M',
+   'ILE':'I', 'LEU':'L', 'ASP':'D', 'GLU':'E', 'LYS':'K',
+   'ARG':'R', 'SER':'S', 'THR':'T', 'TYR':'Y', 'HIS':'H',
+   'CYS':'C', 'ASN':'N', 'GLN':'Q', 'TRP':'W', 'GLY':'G',
+   'MSE':'M',
+}
+
+ca_pattern = re.compile(
+    r"^ATOM\s{2,6}\d{1,5}\s{2}CA\s[\sA]([A-Z]{3})\s([\s\w])|^HETATM\s{0,4}\d{1,5}\s{2}CA\s[\sA](MSE)\s([\s\w])"  # noqa: W605
+)
+
+filename = Path(infile).stem
+chain_dict = defaultdict(str)
+
+with open(infile, 'r') as fp:
+    for line in fp:
+        if line.startswith("ENDMDL"):
+            break
+
+        match_list = ca_pattern.findall(line)
+        if match_list:
+            resn = match_list[0][0] + match_list[0][2]
+            chain = match_list[0][1] + match_list[0][3]
+            if chains is None or chain in chains:
+                chain_dict[chain] += aa3to1[resn]
+
+with open(outfile, 'w') as fp:
+    for chain in chain_dict:
+        fp.write(f">{filename}:{chain}\n")
+        sequence = chain_dict[chain]
+        if wrap > 0:
+            for i in range(0, len(sequence), 80):
+                fp.write(sequence[i:i+80] + "\n")
+        else:
+            fp.write(sequence + "\n")