biopipen 0.32.3__py3-none-any.whl → 0.33.1__py3-none-any.whl

biopipen/utils/misc.R

@@ -114,6 +114,70 @@ do_call <- function (what, args, quote = FALSE, envir = parent.frame())  {
 
 }
 
+#' Save the plot into multiple formats
+#'
+#' @param plot The plot object
+#' @param prefix The prefix of the file
+#' @param formats The formats to save
+#' @param bg The background color
+#' @param devpars The device parameters
+#' @export
+save_plot <- function(plot, prefix, devpars = NULL, bg = "white", formats = c("png", "pdf")) {
+    devpars <- devpars %||% list()
+    devpars$res <- devpars$res %||% 100
+    if (!is.null(attr(plot, "width"))) {
+        devpars$width <- devpars$width %||% (attr(plot, "width") * devpars$res)
+        devpars$height <- devpars$height %||% (attr(plot, "height") * devpars$res)
+    } else {
+        devpars$width <- devpars$width %||% 800
+        devpars$height <- devpars$height %||% 600
+    }
+
+    old_dev <- grDevices::dev.cur()
+    for (fmt in formats) {
+        filename = paste0(prefix, ".", fmt)
+        dev <- ggplot2:::plot_dev(fmt, filename, dpi = devpars$res)
+        dim <- ggplot2:::plot_dim(c(devpars$width, devpars$height), units = "px", limitsize = FALSE, dpi = devpars$res)
+        dev(filename = filename, width = dim[1], height = dim[2], bg = bg)
+        print(plot)
+        grDevices::dev.off()
+    }
+    on.exit(utils::capture.output({
+        if (old_dev > 1) grDevices::dev.set(old_dev) # restore old device unless null device
+    }))
+}
+
+#' Save the code to generate the data
+#'
+#' @param code The code
+#' @param plot The plot object
+#' @param setup The setup code to generate the plot
+#' @param prefix The prefix of the file
+#' @param ... Additional data frame to save
+#'
+#' @export
+save_plotcode <- function(...) UseMethod("save_plotcode")
+
+save_plotcode.character <- function(code, prefix, ..., envir = parent.frame()) {
+    codedir <- paste0(prefix, ".code")
+    dir.create(codedir, showWarnings = FALSE)
+    codefile <- file.path(codedir, "plot.R")
+    writeLines(code, codefile)
+    save(..., file = file.path(codedir, "data.RData"), envir = envir)
+
+    zip_file <- paste0(prefix, ".code.zip")
+    zip::zip(zip_file, c("plot.R", "data.RData"), root = codedir)
+    unlink(codedir, recursive = TRUE)
+}
+
+save_plotcode.ggplot <- function(plot, setup, prefix, ..., envir = parent.frame()) {
+    if (is.null(plot$logs)) {
+        stop("The plot object does not have logs, did you use gglogger?")
+    }
+    code <- plot$logs$gen_code(setup = setup)
+    save_plotcode(code, prefix, ..., envir = envir)
+}
+
 #' Set the default value of a key in a list
 #'
 #' @param x A list
@@ -302,10 +366,13 @@ expand_cases <- function(cases, defaults, expand_each = NULL) {
 casename_info <- function(
     casename, cases, outdir,
     section_key = "section",
-    section = "DEFAULT",
+    section = NULL,
     sep = "::",
+    case_type = c("dir", "prefix"),
     create = FALSE
 ) {
+    section <- section %||% "DEFAULT"
+    case_type <- match.arg(case_type)
     # CR_vs_PD_in_BL:seurat_clusters - IM IL1
     sec_case_names <- strsplit(casename, sep)[[1]]
     # seurat_clusters - IM IL1
@@ -336,13 +403,25 @@ casename_info <- function(
             ifelse(single_section, "#", html_escape(cname))
         )
     )
-    if (single_section && section == "DEFAULT") {
-        out$casedir <- file.path(outdir, out$case_slug)
+
+    if (case_type == "dir") {
+        if (single_section && section == "DEFAULT") {
+            out$casedir <- file.path(outdir, out$case_slug)
+        } else {
+            out$casedir <- file.path(outdir, out$section_slug, out$case_slug)
+        }
+        if (create) {
+            dir.create(out$casedir, showWarnings = FALSE, recursive = TRUE)
+        }
     } else {
-        out$casedir <- file.path(outdir, out$section_slug, out$case_slug)
-    }
-    if (create) {
-        dir.create(out$casedir, showWarnings = FALSE, recursive = TRUE)
+        if (single_section && section == "DEFAULT") {
+            out$caseprefix <- file.path(outdir, out$case_slug)
+        } else {
+            out$caseprefix <- file.path(outdir, out$section_slug, out$case_slug)
+            if (create) {
+                dir.create(file.path(outdir, out$section_slug), showWarnings = FALSE, recursive = TRUE)
+            }
+        }
     }
     out
 }
@@ -402,3 +481,122 @@ run_command <- function(
         return(out)
     }
 }
+
+#' Expand the dims usually used in single-cell analysis to specific dimensions
+#'
+#' @param dims The dimensions to expand
+#' @return A vector of expanded dimensions
+#' @export
+#' @examples
+#' expand_dims(NULL) # c(1, 2)
+#' expand_dims(1:2) # c(1, 2)
+#' expand_dims(1) # c(1)
+#' expand_dims("1:2") # c(1, 2)
+#' expand_dims("1") # c(1)
+#' # dash works as the same as colon
+#' expand_dims("1-3") # c(1, 2, 3)
+#' expand_dims("1,3") # c(1, 3)
+#' expand_dims("1,3:5") # c(1, 3, 4, 5)
+#' expand_dims(c(1, "3:5", 7)) # c(1, 3, 4, 5, 7)
+expand_dims <- function(dims, default = 1:2) {
+    if (is.null(dims)) {
+        return(default)
+    }
+    if (is.numeric(dims)) {
+        return(dims)
+    }
+    dims <- unlist(strsplit(dims, ","))
+    out <- c()
+    for (d in dims) {
+        if (grepl(":", d)) {
+            d <- unlist(strsplit(d, ":"))
+            d <- as.integer(d[1]):as.integer(d[2])
+        } else if (grepl("-", d)) {
+            d <- unlist(strsplit(d, "-"))
+            d <- as.integer(d[1]):as.integer(d[2])
+        } else {
+            d <- as.integer(d)
+        }
+        out <- c(out, d)
+    }
+    out
+}
+
+
+#' Get plotthis function from plot_type
+#'
+#' @param plot_type The plot type
+#' @param gglogger_register Register the plotthis function to gglogger
+#' @param return_name Return the name of the function instead of the function
+#' @return The plotthis function
+#' @export
+get_plotthis_fn <- function(plot_type, gglogger_register = TRUE, return_name = FALSE) {
+    fn_name <- switch(plot_type,
+        hist = "Histogram",
+        histo = "Histogram",
+        histogram = "Histogram",
+        featuredim = "FeatureDimPlot",
+        splitbar = "SplitBarPlot",
+        enrichmap = "EnrichMap",
+        enrichnet = "EnrichNetwork",
+        enrichnetwork = "EnrichNetwork",
+        gsea = "GSEAPlot",
+        gseasummary = "GSEASummaryPlot",
+        gseasum = "GSEASummaryPlot",
+        heatmap = "Heatmap",
+        network = "Network",
+        pie = "PieChart",
+        wordcloud = "WordCloudPlot",
+        venn = "VennDiagram",
+        paste0(tools::toTitleCase(plot_type), "Plot")
+    )
+    if (return_name) {
+        return(fn_name)
+    }
+    fn <- tryCatch({
+        utils::getFromNamespace(fn_name, "plotthis")
+    }, error = function(e) {
+        stop("Unknown plot type: ", plot_type)
+    })
+
+    if (gglogger_register) {
+        gglogger::register(fn, fn_name)
+    } else {
+        fn
+    }
+}
+
+
+#' Extract variables from a named list
+#'
+#' @param x A named list
+#' @param ... The names of the variables
+#' @param keep Keep the extracted variables in the list
+#' @param env The environment to assign the extracted variables
+#' @return The list with/ithout the extracted variables
+#'
+#' @export
+extract_vars <- function(x, ..., keep = FALSE, env = parent.frame()) {
+    stopifnot("extract_vars: 'x' must be a named list" = is.list(x) && !is.null(names(x)))
+    vars <- list(...)
+    if (is.null(names(vars))) {
+        names(vars) <- unlist(vars)
+    }
+    for (i in seq_along(vars)) {
+        if (nchar(names(vars)[i]) == 0) {
+            names(vars)[i] <- vars[[i]]
+        }
+    }
+    # list2env?
+    for (n in names(vars)) {
+        if (!n %in% names(x)) {
+            stop(sprintf("Variable '%s' not found in the list", n))
+        }
+        assign(vars[[n]], x[[n]], envir = env)
+        if (!isTRUE(keep)) {
+            x[[n]] <- NULL
+        }
+    }
+
+    x
+}

biopipen/utils/misc.py

@@ -4,7 +4,8 @@ from pathlib import Path
 import os
 import sys
 import logging
-from typing import List
+from subprocess import Popen
+from typing import List, Callable, Any
 from biopipen.core.filters import dict_to_cli_args  # noqa: F401
 
 logger = logging.getLogger("biopipen_job")
@@ -34,13 +35,13 @@ def exec_code(code, global_vars=None, local_vars=None, return_var=None):
 
 
 def run_command(
-    cmd: str | List[str],
+    cmd: str | List[Any],
     fg: bool = False,
     wait: bool = True,
     print_command: bool = True,
-    print_command_handler: callable = print,
+    print_command_handler: Callable = print,
     **kwargs,
-):
+) -> Popen | str:
     """Run a command.
 
     Args:
@@ -57,7 +58,7 @@ def run_command(
         The `Popen` object, or str when `stdout` is `RETURN` or `return`.
     """
     import shlex
-    from subprocess import Popen, PIPE, STDOUT
+    from subprocess import PIPE, STDOUT
 
     if isinstance(cmd, list):
         cmd = [str(c) for c in cmd]
@@ -110,15 +111,23 @@ def run_command(
     try:
         p = Popen(cmd, **kwargs)
     except Exception as e:
-        raise RuntimeError(f"Failed to run command: {e}")
+        raise RuntimeError(
+            f"Failed to run command: {e}\n"
+            f"Command (list): {cmd}\n"
+            f"Command (str): {shlex.join(cmd)}"
+        )
 
     if fg or wait or return_stdout:
         rc = p.wait()
         if rc != 0:
-            raise RuntimeError(f"Failed to run command: {cmd}")
+            raise RuntimeError(
+                f"Failed to run command: rc={rc}\n"
+                f"Command (list): {cmd}\n"
+                f"Command (str): {shlex.join(cmd)}"
+            )
 
         if return_stdout:
-            return p.stdout.read().decode()
+            return p.stdout.read().decode()  # type: ignore
 
         return p
 

biopipen/utils/reference.py

@@ -26,7 +26,7 @@ def gztype(gzfile):
 def tabix_index(
     infile: str | PathLike,
     preset: Literal["gff", "bed", "sam", "vcf", "gaf"],
-    tmpdir: bool | str | PathLike | None = None,
+    tmpdir: Literal[False] | str | PathLike | None = None,
     tabix: str = config.exe.tabix,
 ) -> str | PathLike:
     """Index input file using tabix
@@ -126,15 +126,15 @@ def _run_bam_index(
 
 
 def bam_index(
-    bam,
-    bamdir=tempfile.gettempdir(),
-    tool="samtools",
-    samtools=config.exe.samtools,
-    sambamba=config.exe.sambamba,
-    ncores=1,
-    ext=".bam.bai",
-    force=False,
-):
+    bam: str | Path,
+    bamdir: Path | str = tempfile.gettempdir(),
+    tool: str = "samtools",
+    samtools: str = config.exe.samtools,
+    sambamba: str = config.exe.sambamba,
+    ncores: int = 1,
+    ext: str = ".bam.bai",
+    force: bool = False,
+) -> Path:
     """Index a bam file
 
     First look for the index file in the same directory as the bam file,
@@ -175,7 +175,7 @@ def bam_index(
         return bam
 
     if indexfile.is_file():
-        return str(bam)
+        return bam
 
     linkfile = Path(bamdir).joinpath(bam.name)
     indexfile = linkfile.with_suffix(ext)

biopipen/utils/repr.R

@@ -0,0 +1,146 @@
+library(rlang)
+
+#' The string representation of an object
+#' @param x An object
+#' @param newline Whether to add newlines to the output for each element
+#' @return The string representation
+#' @export
+repr <- function(x, newline = FALSE, ...) UseMethod("repr")
+
+repr.default <- function(x, newline = FALSE, ...) {
+    klass <- paste0(class(x), collapse = "/")
+    fallback <- paste0("<", klass, ": ", deparse(substitute(x)), ">")
+
+    tryCatch(
+        x$.repr(newline, ...),
+        error = function(e) {
+            fallback
+        }
+    )
+}
+
+repr.numeric <- function(x, newline = FALSE, ...) {
+    if (length(x) == 1) {
+        as.character(x)
+    } else if (!newline) {
+        paste0("c(", paste(x, collapse = paste0(", ")), ")")
+    } else {
+        paste0(
+            "c(\n",
+            paste0(lapply(x, function(y) paste0("  ", y)), collapse = ",\n"),
+            "\n)"
+        )
+    }
+}
+
+repr.character <- function(x, newline = FALSE, ...) {
+    if (length(x) == 1) {
+        paste0("\"", x, "\"")
+    } else if (!newline) {
+        paste0("c(", paste0(lapply(x, function(y) sQuote(y, q = FALSE)), collapse = ", "), ")")
+    } else {
+        paste0(
+            "c(\n",
+            paste0(lapply(x, function(y) paste0("  ", sQuote(y, q = FALSE))), collapse = ",\n"),
+            "\n)"
+        )
+    }
+}
+
+repr.factor <- function(x, newline = FALSE, ...) {
+    if (!newline) {
+        paste0(
+            "factor(", repr(as.character(x), newline, ...), ", levels = ", repr(levels(x), newline, ...), ")"
+        )
+    } else if (!newline) {
+        paste0(
+            "factor(\n",
+            paste0("  ", repr(as.character(x), newline, ...), ",\n"),
+            "  levels = ", repr(levels(x), newline, ...), "\n)"
+        )
+    } else {
+        paste0(
+            "factor(\n",
+            paste0("  ", repr(as.character(x), newline, ...), ",\n"),
+            "  levels = ", repr(levels(x), newline, ...), "\n)"
+        )
+    }
+}
+
+repr.logical <- function(x, newline = FALSE, ...) {
+    if (length(x) == 1) {
+        if (x) "TRUE" else "FALSE"
+    } else if (!newline) {
+        paste0("c(", paste0(x, collapse = ","), ")")
+    } else {
+        paste0(
+            "c(\n",
+            paste0(lapply(x, function(y) paste0("  ", y)), collapse = ",\n"),
+            "\n)"
+        )
+    }
+}
+
+repr.list <- function(x, newline = FALSE, ...) {
+  start <- if (newline) "list(\n" else "list("
+  end <- if (newline) "\n)" else ")"
+  sep <- if (newline) ",\n" else ", "
+  prefix <- if (newline) "  " else ""
+  if (length(names(x)) > 0) {
+    paste0(
+        start,
+        paste0(
+            lapply(seq_along(x), function(i) {
+                name <- names(x)[i]
+                if (identical(name, "")) {
+                  paste0(prefix, repr(x[[i]]))
+                } else {
+                  paste0(prefix, bQuote(name), " = ", repr(x[[name]]))
+                }
+            }), collapse = sep
+        ),
+        end
+    )
+  } else {
+    paste0(
+        start, paste0(lapply(x, repr, newline = newline, ...), collapse = sep), end
+    )
+  }
+}
+
+repr.NULL <- function(x, newline = FALSE, ...) {
+    "NULL"
+}
+
+repr.formula <- function(x, newline = FALSE, ...) {
+  deparse(x)
+}
+
+repr.data.frame <- function(x, newline = FALSE, ...) {
+  paste0(
+      "data.frame(\n",
+      paste0(
+          lapply(names(x), function(name) {
+              paste0("  ", bQuote(name), " = ", repr(x[[name]], newline = newline, ...))
+          }), collapse = ",\n"
+      ),
+      "\n)"
+  )
+}
+
+repr.environment <- function(x, newline = FALSE, ...) {
+    if (!is_environment(x)) {
+        # in case .GlobalEnv is dispatched here
+        NextMethod()
+    } else {
+        nl <- if (newline) "\n" else " "
+        prefix <- if (newline) "  " else ""
+        paste0(
+            "rlang::env(", nl, paste0(
+                lapply(ls(x), function(name) {
+                    paste0(prefix, bQuote(name), " = ", repr(get(name, x), newline = newline, ...))
+                }), collapse = paste0(",", nl)
+            ), nl, ")"
+        )
+    }
+}

biopipen/utils/vcf.py

@@ -326,7 +326,7 @@ class Variant:
         if isinstance(samples, str):
             samples = Samples.from_str(samples, format)
         elif isinstance(samples[0], str):
-            samples = Samples.from_strs(samples, format)
+            samples = Samples.from_strs(samples, format)  # type: ignore
         else:
             samples = Samples.from_strss(samples, format)
 

{biopipen-0.32.3.dist-info → biopipen-0.33.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: biopipen
-Version: 0.32.3
+Version: 0.33.1
 Summary: Bioinformatics processes/pipelines that can be run from `pipen run`
 License: MIT
 Author: pwwang
@@ -14,10 +14,10 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: runinfo
-Requires-Dist: datar[pandas] (>=0.15.6,<0.16.0)
-Requires-Dist: pipen-board[report] (>=0.16,<0.17)
-Requires-Dist: pipen-cli-run (>=0.14,<0.15)
-Requires-Dist: pipen-filters (>=0.14,<0.15)
-Requires-Dist: pipen-poplog (>=0.2.0,<0.3.0)
-Requires-Dist: pipen-runinfo (>=0.8,<0.9) ; extra == "runinfo"
-Requires-Dist: pipen-verbose (>=0.12,<0.13)
+Requires-Dist: datar[pandas] (>=0.15.8,<0.16.0)
+Requires-Dist: pipen-board[report] (>=0.17,<0.18)
+Requires-Dist: pipen-cli-run (>=0.15,<0.16)
+Requires-Dist: pipen-filters (>=0.15,<0.16)
+Requires-Dist: pipen-poplog (>=0.3,<0.4)
+Requires-Dist: pipen-runinfo (>=0.9,<0.10) ; extra == "runinfo"
+Requires-Dist: pipen-verbose (>=0.14,<0.15)