biopipen 0.23.8__tar.gz → 0.24.1__tar.gz

{biopipen-0.23.8 → biopipen-0.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biopipen
-Version: 0.23.8
+Version: 0.24.1
 Summary: Bioinformatics processes/pipelines that can be run from `pipen run`
 License: MIT
 Author: pwwang
@@ -14,9 +14,10 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: runinfo
-Requires-Dist: datar[pandas] (>=0.15.2,<0.16.0)
-Requires-Dist: pipen-board[report] (>=0.13,<0.14)
-Requires-Dist: pipen-cli-run (>=0.11,<0.12)
-Requires-Dist: pipen-filters (>=0.10,<0.11)
-Requires-Dist: pipen-runinfo (>=0.4,<0.5) ; extra == "runinfo"
-Requires-Dist: pipen-verbose (>=0.9,<0.10)
+Requires-Dist: datar[pandas] (>=0.15.3,<0.16.0)
+Requires-Dist: pipen-board[report] (>=0.14,<0.15)
+Requires-Dist: pipen-cli-run (>=0.12,<0.13)
+Requires-Dist: pipen-filters (>=0.11,<0.12)
+Requires-Dist: pipen-poplog (>=0.0.2,<0.0.3)
+Requires-Dist: pipen-runinfo (>=0.5,<0.6) ; extra == "runinfo"
+Requires-Dist: pipen-verbose (>=0.10,<0.11)

biopipen-0.24.1/biopipen/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.24.1"

{biopipen-0.23.8 → biopipen-0.24.1}/biopipen/core/proc.py

@@ -25,3 +25,10 @@ class Proc(PipenProc):
         "filters": {**FILTERS, **filtermanager.filters},
         "search_paths": SEARCH_PATHS + [str(REPORT_DIR)],
     }
+
+    plugin_opts = {
+        "poplog_pattern": (
+            r"^(?P<level>INFO|WARN|WARNING|CRITICAL|ERROR|DEBUG?)\s*"
+            r"\[\d+-\d+-\d+ \d+:\d+:\d+\] (?P<message>.*)$"
+        )
+    }

{biopipen-0.23.8 → biopipen-0.24.1}/biopipen/ns/cellranger.py

@@ -35,7 +35,7 @@ class CellRangerCount(Proc):
             {%- set fastqs = fastqs[0] | glob: "*.fastq.gz" -%}
         {%- endif -%}
         {%- set sample = commonprefix(*fastqs) |
-            regex_replace: "_L\\d+_$", "" |
+            regex_replace: "_L\\d+_?$", "" |
             regex_replace: "_S\\d+$", "" -%}
         {{- sample -}}
     """
@@ -84,7 +84,7 @@ class CellRangerVdj(Proc):
             {%- set fastqs = fastqs[0] | glob: "*.fastq.gz" -%}
         {%- endif -%}
         {%- set sample = commonprefix(*fastqs) |
-            regex_replace: "_L\\d+_$", "" |
+            regex_replace: "_L\\d+_?$", "" |
             regex_replace: "_S\\d+$", "" -%}
         {{- sample -}}
     """

{biopipen-0.23.8 → biopipen-0.24.1}/biopipen/ns/scrna.py

@@ -278,18 +278,14 @@ class SeuratClustering(Proc):
                 The results will be saved in `seurat_clusters_<resolution>`.
                 The final resolution will be used to define the clusters at `seurat_clusters`.
             - <more>: See <https://satijalab.org/seurat/reference/findclusters>
-        cache (type=auto): Whether to cache the seurat object with cluster information.
+        cache (type=auto): Whether to cache the information at different steps.
             If `True`, the seurat object will be cached in the job output directory, which will be not cleaned up when job is rerunning.
-            The cached seurat object will be saved as `<signature>.cached.RDS` file, where `<signature>` is the signature determined by
+            The cached seurat object will be saved as `<signature>.<kind>.RDS` file, where `<signature>` is the signature determined by
             the input and envs of the process.
-            See -
-            * <https://github.com/satijalab/seurat/issues/7849>
-            * <https://github.com/satijalab/seurat/issues/5358> and
-            * <https://github.com/satijalab/seurat/issues/6748> for more details.
+            See <https://github.com/satijalab/seurat/issues/7849>, <https://github.com/satijalab/seurat/issues/5358> and
+            <https://github.com/satijalab/seurat/issues/6748> for more details also about reproducibility issues.
             To not use the cached seurat object, you can either set `cache` to `False` or delete the cached file at
-            `<signature>.cached.RDS` in the cache directory.
-            If `True`, the cache directory is `.pipen/<Pipeline>/SeuratClustering/0/output/`
-            You can also specify customized directory to save the cached seurat object by setting `cache` to the directory path.
+            `<signature>.RDS` in the cache directory.
 
     Requires:
         r-seurat:
@@ -309,7 +305,7 @@ class SeuratClustering(Proc):
         "RunUMAP": {"dims": 30},
         "FindNeighbors": {},
         "FindClusters": {"resolution": 0.8},
-        "cache": False,
+        "cache": config.path.tmpdir,
     }
     script = "file://../scripts/scrna/SeuratClustering.R"
 
@@ -361,18 +357,14 @@ class SeuratSubClustering(Proc):
                 The results will be saved in `<casename>_<resolution>`.
                 The final resolution will be used to define the clusters at `<casename>`.
             - <more>: See <https://satijalab.org/seurat/reference/findclusters>
-        cache (type=auto): Whether to cache the seurat object with cluster information.
+        cache (type=auto): Whether to cache the information at different steps.
             If `True`, the seurat object will be cached in the job output directory, which will be not cleaned up when job is rerunning.
-            The cached seurat object will be saved as `<signature>.cached.RDS` file, where `<signature>` is the signature determined by
+            The cached seurat object will be saved as `<signature>.<kind>.RDS` file, where `<signature>` is the signature determined by
             the input and envs of the process.
-            See -
-            * <https://github.com/satijalab/seurat/issues/7849>
-            * <https://github.com/satijalab/seurat/issues/5358> and
-            * <https://github.com/satijalab/seurat/issues/6748> for more details.
+            See <https://github.com/satijalab/seurat/issues/7849>, <https://github.com/satijalab/seurat/issues/5358> and
+            <https://github.com/satijalab/seurat/issues/6748> for more details also about reproducibility issues.
             To not use the cached seurat object, you can either set `cache` to `False` or delete the cached file at
-            `<signature>.cached.RDS` in the cache directory.
-            If `True`, the cache directory is `.pipen/<Pipeline>/SeuratClustering/0/output/`
-            You can also specify customized directory to save the cached seurat object by setting `cache` to the directory path.
+            `<signature>.RDS` in the cache directory.
         cases (type=json): The cases to perform subclustering.
             Keys are the names of the cases and values are the dicts inherited from `envs` except `mutaters` and `cache`.
             If empty, a case with name `subcluster` will be created with default parameters.
@@ -387,7 +379,7 @@ class SeuratSubClustering(Proc):
         "RunUMAP": {"dims": 30},
         "FindNeighbors": {},
         "FindClusters": {"resolution": 0.8},
-        "cache": False,
+        "cache": config.path.tmpdir,
         "cases": {"subcluster": {}},
     }
     script = "file://../scripts/scrna/SeuratSubClustering.R"
@@ -2002,4 +1994,5 @@ class MetaMarkers(Proc):
     plugin_opts = {
         "report": "file://../reports/scrna/MetaMarkers.svelte",
         "report_paging": 8,
+        "poplog_max": 15,
     }

{biopipen-0.23.8 → biopipen-0.24.1}/biopipen/ns/tcr.py

@@ -563,12 +563,13 @@ class Immunarch(Proc):
                     A Gini coefficient of one (or 100 percents) expresses maximal inequality among values (for example where only one person has all the income).
                 - d50: The D50 index.
                     It is the number of types that are needed to cover 50%% of the total abundance.
-                - dxx: The Dxx index.
-                    It is the number of types that are needed to cover xx%% of the total abundance.
-                    The percentage should be specified in the `args` argument using `perc` key.
                 - raref: Species richness from the results of sampling through extrapolation.
             - by: The variables (column names) to group samples.
                 Multiple columns should be separated by `,`.
+            - plot_type (choice): The type of the plot, works when `by` is specified.
+                Not working for `raref`.
+                - box: Boxplot
+                - bar: Barplot with error bars
             - subset: Subset the data before calculating the clonotype volumes.
                 The whole data will be expanded to cell level, and then subsetted.
                 Clone sizes will be re-calculated based on the subsetted data.
@@ -789,9 +790,9 @@ class Immunarch(Proc):
         },
         # Diversity
         "divs": {
-            "filter": None,
             "method": "gini",
             "by": None,
+            "plot_type": "bar",
             "args": {},
             "order": [],
             "test": {
@@ -805,8 +806,8 @@ class Immunarch(Proc):
             "align_y": False,
             "log": False,
             "devpars": {
-                "width": 1000,
-                "height": 1000,
+                "width": 800,
+                "height": 800,
                 "res": 100,
             },
             "subset": None,
@@ -851,6 +852,7 @@ class Immunarch(Proc):
     plugin_opts = {
         "report": "file://../reports/tcr/Immunarch.svelte",
         "report_paging": 3,
+        "poplog_max": 999,
     }
 
 

biopipen-0.24.1/biopipen/scripts/scrna/SeuratClustering.R

@@ -0,0 +1,174 @@
+source("{{biopipen_dir}}/utils/misc.R")
+source("{{biopipen_dir}}/utils/caching.R")
+
+library(Seurat)
+library(future)
+library(tidyr)
+library(dplyr)
+library(digest)
+
+set.seed(8525)
+
+srtfile <- {{in.srtobj | quote}}
+rdsfile <- {{out.rdsfile | quote}}
+joboutdir <- {{job.outdir | quote}}
+envs <- {{envs | r: todot="-"}}
+
+if (length(envs$ScaleData) > 0 && length(envs$SCTransform) > 0) {
+    stop("Cannot specify both ScaleData and SCTransform")
+}
+
+options(str = strOptions(vec.len = 5, digits.d = 5))
+options(future.globals.maxSize = 80000 * 1024^2)
+plan(strategy = "multicore", workers = envs$ncores)
+
+.expand_dims <- function(args, name = "dims") {
+    # Expand dims from 30 to 1:30
+    if (is.numeric(args[[name]]) && length(args[[name]] == 1)) {
+        args[[name]] <- 1:args[[name]]
+    }
+    args
+}
+
+envs$RunUMAP <- .expand_dims(envs$RunUMAP)
+envs$FindNeighbors <- .expand_dims(envs$FindNeighbors)
+
+log_info("Reading Seurat object ...")
+sobj <- readRDS(srtfile)
+
+if (isTRUE(envs$cache)) { envs$cache <- joboutdir }
+if (length(envs$cache) > 1) {
+    log_warn("Multiple cache directories (envs.cache) detected, using the first one.")
+    envs$cache <- envs$cache[1]
+}
+sobj_sig <- capture.output(str(sobj))
+dig_sig <- digest::digest(sobj_sig, algo = "md5")
+dig_sig <- substr(dig_sig, 1, 8)
+cache_dir <- NULL
+if (is.character(envs$cache)) {
+    cache_dir <- file.path(envs$cache, paste0(dig_sig, ".seurat_cache"))
+    dir.create(cache_dir, recursive = TRUE, showWarnings = FALSE)
+    writeLines(sobj_sig, file.path(cache_dir, "signature.txt"))
+}
+
+if (length(envs$ScaleData) > 0) {
+    if (DefaultAssay(sobj) == "SCT") {
+        stop("SCT assay detected, but ScaleData is specified. Use SCTransform instead.")
+    }
+    cached <- get_cached(envs$ScaleData, "ScaleData", cache_dir)
+    if (is.null(cached$data)) {
+        log_info("Running ScaleData ...")
+        envs$ScaleData$object <- sobj
+        sobj <- do_call(ScaleData, envs$ScaleData)
+        cached$data <- list(assay = sobj@assays$RNA, commands = sobj@commands)
+        save_to_cache(cached, "ScaleData", cache_dir)
+    } else {
+        log_info("Loading cached ScaleData ...")
+        sobj@assays$RNA <- cached$data$assay
+        sobj@commands <- cached$data$commands
+        DefaultAssay(sobj) <- "RNA"
+    }
+} else if (length(envs$SCTransform) > 0) {
+    if (DefaultAssay(sobj) != "SCT") {
+        stop("SCT assay not detected, but SCTransform is specified. Use ScaleData instead.")
+    }
+    cached <- get_cached(envs$SCTransform, "SCTransform", cache_dir)
+    asssay <- envs$SCTransform$new.assay.name %||% "SCT"
+    if (is.null(cached$data)) {
+        log_info("Running SCTransform ...")
+        envs$SCTransform$object <- sobj
+        sobj <- do_call(SCTransform, envs$SCTransform)
+        cached$data <- list(assay = sobj@assays$SCT, commands = sobj@commands)
+        save_to_cache(cached, "SCTransform", cache_dir)
+    } else {
+        log_info("Loading cached SCTransform ...")
+        sobj@assays[[assay]] <- cached$data$assay
+        sobj@commands <- cached$data$commands
+        DefaultAssay(sobj) <- assay
+    }
+}
+
+cached <- get_cached(envs$RunUMAP, "RunUMAP", cache_dir)
+reduc_name <- envs$RunUMAP$reduction.name %||% "umap"
+if (is.null(cached$data)) {
+    log_info("Running RunUMAP ...")
+    umap_args <- list_setdefault(
+        envs$RunUMAP,
+        object = sobj,
+        dims = 1:30,
+        reduction = sobj@misc$integrated_new_reduction %||% "pca"
+    )
+    ncells <- ncol(sobj)
+    umap_args$dims <- 1:min(max(umap_args$dims), ncells - 1)
+    umap_method <- envs$RunUMAP$umap.method %||% "uwot"
+    if (umap_method == "uwot" && is.null(envs$RunUMAP$n.neighbors)) {
+        # https://github.com/satijalab/seurat/issues/4312
+        umap_args$n.neighbors <- min(ncells - 1, 30)
+    }
+    sobj <- do_call(RunUMAP, umap_args)
+    cached$data <- list(reduc = sobj@reductions[[reduc_name]], commands = sobj@commands)
+    save_to_cache(cached, "RunUMAP", cache_dir)
+} else {
+    log_info("Loading cached RunUMAP ...")
+    sobj@reductions[[reduc_name]] <- cached$data$reduc
+    sobj@commands <- cached$data$commands
+}
+
+cached <- get_cached(envs$FindNeighbors, "FindNeighbors", cache_dir)
+if (is.null(cached$data)) {
+    log_info("Running FindNeighbors ...")
+    envs$FindNeighbors$object <- sobj
+    envs$FindNeighbors$reduction <- sobj@misc$integrated_new_reduction %||% "pca"
+    sobj <- do_call(FindNeighbors, envs$FindNeighbors)
+    cached$data <- list(graphs = sobj@graphs, commands = sobj@commands)
+    save_to_cache(cached, "FindNeighbors", cache_dir)
+} else {
+    log_info("Loading cached FindNeighbors ...")
+    sobj@graphs <- cached$data$graphs
+    sobj@commands <- cached$data$commands
+}
+
+envs$FindClusters$random.seed <- envs$FindClusters$random.seed %||% 8525
+resolution <- envs$FindClusters$resolution %||% 0.8
+if (is.character(resolution)) {
+    if (grepl(",", resolution)) {
+        resolution <- as.numeric(trimws(unlist(strsplit(resolution, ","))))
+    } else {
+        resolution <- as.numeric(resolution)
+    }
+}
+
+for (res in resolution) {
+    envs$FindClusters$resolution <- res
+    cached <- get_cached(envs$FindClusters, paste0("FindClusters_", res), cache_dir)
+    res_key <- paste0("seurat_clusters_", res)
+    if (is.null(cached$data)) {
+        log_info("Running FindClusters at resolution: {res} ...")
+        envs$FindClusters$object <- sobj
+        sobj <- do_call(FindClusters, envs$FindClusters)
+        levels(sobj$seurat_clusters) <- paste0("c", as.numeric(levels(sobj$seurat_clusters)) + 1)
+        sobj[[res_key]] <- sobj$seurat_clusters
+        Idents(sobj) <- "seurat_clusters"
+        cached$data <- list(clusters = sobj$seurat_clusters, commands = sobj@commands)
+        save_to_cache(cached, paste0("FindClusters_", res), cache_dir)
+    } else {
+        log_info("Loading cached FindClusters at resolution: {res} ...")
+        sobj@commands <- cached$data$commands
+        sobj[[res_key]] <- cached$data$clusters
+        sobj$seurat_clusters <- cached$data$clusters
+        Idents(sobj) <- "seurat_clusters"
+    }
+    ident_table <- table(Idents(sobj))
+    log_info("- Found {length(ident_table)} clusters")
+    print(ident_table)
+    cat("\n")
+}
+
+if (DefaultAssay(sobj) == "SCT") {
+        # https://github.com/satijalab/seurat/issues/6968
+    log_info("Running PrepSCTFindMarkers ...")
+    sobj <- PrepSCTFindMarkers(sobj)
+}
+
+log_info("Saving results ...")
+saveRDS(sobj, file = rdsfile)

{biopipen-0.23.8 → biopipen-0.24.1}/biopipen/scripts/scrna/SeuratPreparing.R

@@ -301,26 +301,31 @@ log_info("Performing transformation/scaling ...")
 if (envs$use_sct) {
     log_info("- Running SCTransform ...")
     SCTransformArgs <- envs$SCTransform
-    log_info("  SCTransform: {.formatArgs(SCTransformArgs)}")
+    # log to stdout but don't populate it to running log
+    print("  SCTransform: {.formatArgs(SCTransformArgs)}")
+    log_debug("  SCTransform: {.formatArgs(SCTransformArgs)}")
     SCTransformArgs$object <- sobj
     sobj <- do_call(SCTransform, SCTransformArgs)
     # Default is to use the SCT assay
 } else {
     log_info("- Running NormalizeData ...")
     NormalizeDataArgs <- envs$NormalizeData
-    log_info("  NormalizeData: {.formatArgs(NormalizeDataArgs)}")
+    print("  NormalizeData: {.formatArgs(NormalizeDataArgs)}")
+    log_debug("  NormalizeData: {.formatArgs(NormalizeDataArgs)}")
     NormalizeDataArgs$object <- sobj
     sobj <- do_call(NormalizeData, NormalizeDataArgs)
 
     log_info("- Running FindVariableFeatures ...")
     FindVariableFeaturesArgs <- envs$FindVariableFeatures
-    log_info("  FindVariableFeatures: {.formatArgs(FindVariableFeaturesArgs)}")
+    print("  FindVariableFeatures: {.formatArgs(FindVariableFeaturesArgs)}")
+    log_debug("  FindVariableFeatures: {.formatArgs(FindVariableFeaturesArgs)}")
     FindVariableFeaturesArgs$object <- sobj
     sobj <- do_call(FindVariableFeatures, FindVariableFeaturesArgs)
 
     log_info("- Running ScaleData ...")
     ScaleDataArgs <- envs$ScaleData
-    log_info("  ScaleData: {.formatArgs(ScaleDataArgs)}")
+    print("  ScaleData: {.formatArgs(ScaleDataArgs)}")
+    log_debug("  ScaleData: {.formatArgs(ScaleDataArgs)}")
     ScaleDataArgs$object <- sobj
     sobj <- do_call(ScaleData, ScaleDataArgs)
 }
@@ -328,7 +333,8 @@ if (envs$use_sct) {
 log_info("- Running RunPCA ...")
 RunPCAArgs <- envs$RunPCA
 RunPCAArgs$npcs <- if (is.null(RunPCAArgs$npcs)) { 50 } else { min(RunPCAArgs$npcs, ncol(sobj) - 1) }
-log_info("  RunPCA: {.formatArgs(RunPCAArgs)}")
+print("  RunPCA: {.formatArgs(RunPCAArgs)}")
+log_debug("  RunPCA: {.formatArgs(RunPCAArgs)}")
 RunPCAArgs$object <- sobj
 sobj <- do_call(RunPCA, RunPCAArgs)
 
@@ -361,7 +367,8 @@ if (!envs$no_integration) {
     if (is.null(IntegrateLayersArgs$new.reduction)) {
         IntegrateLayersArgs$new.reduction <- new_reductions[[method]]
     }
-    log_info("  IntegrateLayers: {.formatArgs(IntegrateLayersArgs)}")
+    print("  IntegrateLayers: {.formatArgs(IntegrateLayersArgs)}")
+    log_debug("  IntegrateLayers: {.formatArgs(IntegrateLayersArgs)}")
     IntegrateLayersArgs$object <- sobj
     sobj <- do_call(IntegrateLayers, IntegrateLayersArgs)
     # Save it for dimension reduction plots

biopipen-0.24.1/biopipen/scripts/scrna/SeuratSubClustering.R

@@ -0,0 +1,169 @@
+source("{{biopipen_dir}}/utils/misc.R")
+source("{{biopipen_dir}}/utils/caching.R")
+
+library(Seurat)
+library(future)
+library(rlang)
+library(tidyr)
+library(dplyr)
+library(tidyseurat)
+library(digest)
+
+set.seed(8525)
+
+srtfile <- {{in.srtobj | quote}}
+rdsfile <- {{out.rdsfile | quote}}
+joboutdir <- {{job.outdir | quote}}
+envs <- {{envs | r: todot = "-"}}
+
+options(str = strOptions(vec.len = 5, digits.d = 5))
+options(future.globals.maxSize = 80000 * 1024^2)
+plan(strategy = "multicore", workers = envs$ncores)
+
+.expand_dims <- function(args, name = "dims") {
+    # Expand dims from 30 to 1:30
+    if (!is.null(args) && is.numeric(args[[name]]) && length(args[[name]] == 1)) {
+        args[[name]] <- 1:args[[name]]
+    }
+    args
+}
+
+envs$RunUMAP <- .expand_dims(envs$RunUMAP)
+envs$FindNeighbors <- .expand_dims(envs$FindNeighbors)
+
+log_info("Reading Seurat object ...")
+srtobj <- readRDS(srtfile)
+
+if (isTRUE(envs$cache)) { envs$cache <- joboutdir }
+if (length(envs$cache) > 1) {
+    log_warn("Multiple cache directories (envs.cache) detected, using the first one.")
+    envs$cache <- envs$cache[1]
+}
+
+if (!is.null(envs$mutaters) && length(envs$mutaters) > 0) {
+    log_info("Mutating Seurat object ...")
+    srtobj@meta.data <- srtobj@meta.data %>%
+        mutate(!!!lapply(mutaters, parse_expr))
+}
+
+if (length(envs$cases) == 0) {
+    envs$cases <- list(subcluster = list())
+}
+
+for (key in names(envs$cases)) {
+    log_info("")
+    log_info("Running case '{key}' ...")
+    log_info("===========================================")
+    case <- envs$cases[[key]]
+    case$RunUMAP <- .expand_dims(case$RunUMAP)
+    case$FindNeighbors <- .expand_dims(case$FindNeighbors)
+
+    case <- list_update(
+        list(
+            subset = envs$subset,
+            RunUMAP = envs$RunUMAP,
+            FindNeighbors = envs$FindNeighbors,
+            FindClusters = envs$FindClusters
+        ),
+        case
+    )
+
+    if (is.null(case$subset) || length(case$subset) == 0) {
+        stop(paste0("`subset` for case '", key, "' is empty."))
+    }
+
+    log_info("- Subsetting ...")
+    sobj <- tryCatch({
+        srtobj %>% filter(!!parse_expr(case$subset))
+    }, error = function(e) {
+        stop(paste0("  Error in subset: ", e$message))
+    })
+    sobj_sig <- capture.output(str(sobj))
+    dig_sig <- digest::digest(sobj_sig, algo = "md5")
+    dig_sig <- substr(dig_sig, 1, 8)
+    cache_dir <- NULL
+    if (is.character(envs$cache)) {
+        cache_dir <- file.path(envs$cache, paste0(dig_sig, ".seurat_cache"))
+        dir.create(cache_dir, recursive = TRUE, showWarnings = FALSE)
+        writeLines(sobj_sig, file.path(cache_dir, "signature.txt"))
+    }
+
+    cached <- get_cached(case$RunUMAP, "RunUMAP", cache_dir)
+    reduc_name <- case$RunUMAP$reduction.name %||% "umap"
+    if (is.null(cached$data)) {
+        log_info("- Running RunUMAP ...")
+        umap_args <- list_setdefault(
+            case$RunUMAP,
+            object = sobj,
+            dims = 1:30,
+            reduction = sobj@misc$integrated_new_reduction %||% "pca"
+        )
+        ncells <- ncol(sobj)
+        umap_args$dims <- 1:min(max(umap_args$dims), ncells - 1)
+        umap_method <- case$RunUMAP$umap.method %||% "uwot"
+        if (umap_method == "uwot" && is.null(case$RunUMAP$n.neighbors)) {
+            # https://github.com/satijalab/seurat/issues/4312
+            umap_args$n.neighbors <- min(ncells - 1, 30)
+        }
+        sobj <- do_call(RunUMAP, umap_args)
+        cached$data <- list(reduc = sobj@reductions[[reduc_name]], commands = sobj@commands)
+        save_to_cache(cached, "RunUMAP", cache_dir)
+    } else {
+        log_info("- Loading cached RunUMAP ...")
+        sobj@reductions[[reduc_name]] <- cached$data$reduc
+        sobj@commands <- cached$data$commands
+    }
+    reduc <- cached$data$reduc
+
+    cached <- get_cached(case$FindNeighbors, "FindNeighbors", cache_dir)
+    if (is.null(cached$data)) {
+        log_info("- Running FindNeighbors ...")
+        case$FindNeighbors$object <- sobj
+        if (is.null(case$FindNeighbors$reduction)) {
+            case$FindNeighbors$reduction <- sobj@misc$integrated_new_reduction %||% "pca"
+        }
+        sobj <- do_call(FindNeighbors, case$FindNeighbors)
+        cached$data <- list(graphs = sobj@graphs, commands = sobj@commands)
+        save_to_cache(cached, "FindNeighbors", cache_dir)
+    } else {
+        log_info("- Loading cached FindNeighbors ...")
+        sobj@graphs <- cached$data$graphs
+        sobj@commands <- cached$data$commands
+    }
+
+    case$FindClusters$random.seed <- case$FindClusters$random.seed %||% 8525
+    resolution <- case$FindClusters$resolution %||% 0.8
+    if (is.character(resolution)) {
+        if (grepl(",", resolution)) {
+            resolution <- as.numeric(trimws(unlist(strsplit(resolution, ","))))
+        } else {
+            resolution <- as.numeric(resolution)
+        }
+    }
+    for (res in resolution) {
+        case$FindClusters$resolution <- res
+        cached <- get_cached(case$FindClusters, paste0("FindClusters_", res), cache_dir)
+        res_key <- paste0("seurat_clusters_", res)
+        if (is.null(cached$data)) {
+            log_info("- Running FindClusters at resolution: {res} ...")
+            case$FindClusters$object <- sobj
+            sobj1 <- do_call(FindClusters, case$FindClusters)
+            levels(sobj1$seurat_clusters) <- paste0("s", as.numeric(levels(sobj1$seurat_clusters)) + 1)
+            sobj1[[res_key]] <- sobj1$seurat_clusters
+            cached$data <- sobj1@meta.data[, res_key, drop = FALSE]
+            save_to_cache(cached, paste0("FindClusters_", res), cache_dir)
+        } else {
+            log_info("- Using cached FindClusters at resolution: {res} ...")
+        }
+        ident_table <- table(cached$data[[res_key]])
+        log_info("  Found {length(ident_table)} clusters")
+        print(ident_table)
+        cat("\n")
+    }
+    log_info("- Updating meta.data with subclusters...")
+    srtobj <- AddMetaData(srtobj, metadata = cached$data, col.name = key)
+    srtobj[[paste0("sub_umap_", key)]] <- reduc
+}
+
+log_info("Saving results ...")
+saveRDS(srtobj, file = rdsfile)

{biopipen-0.23.8 → biopipen-0.24.1}/biopipen/scripts/scrna_metabolic_landscape/MetabolicFeaturesIntraSubset.R

@@ -54,7 +54,7 @@ do_one_comparison <- function(
     subset_prefix,
     groupname
 ) {
-    print(paste("  Design:", compname, "(", case, ",", control, ")"))
+    log_info(paste("  Design: {compname} ({case}, {control})"))
     case_code = paste0("subset(obj, subset = ", subset_col, " == '", case, "')")
     case_obj = tryCatch({
         eval(parse(text = case_code))
@@ -62,7 +62,7 @@ do_one_comparison <- function(
         NULL
     })
     if (is.null(case_obj)) {
-        print("          Skip (not enough cells in case)")
+        log_warn("          Skip (not enough cells in case)")
         return (NULL)
     }
     control_code = paste0("subset(obj, subset = ", subset_col, " == '", control, "')")
@@ -72,7 +72,7 @@ do_one_comparison <- function(
         NULL
     })
     if (is.null(control_obj)) {
-        print("          Skip (not enough cells in control)")
+        log_warn("          Skip (not enough cells in control)")
         add_report(
             list(kind = "error", content = "Not enough cells in control"),
             h1 = groupname,
@@ -86,7 +86,7 @@ do_one_comparison <- function(
     odir = file.path(groupdir, paste0(subset_prefix, compname))
     dir.create(odir, showWarnings = FALSE)
     if (ncol(exprs_case) < 3 || ncol(exprs_control) < 3) {
-        print("          Skip (not enough cells)")
+        log_warn("          Skip (not enough cells)")
         add_report(
             list(kind = "error", content = "Not enough cells"),
             h1 = groupname,
@@ -131,7 +131,7 @@ do_one_comparison <- function(
 }
 
 do_one_group <- function(group) {
-    print(paste("- Group:", group, "..."))
+    log_info("- Group: {group} ...")
 
     genes = intersect(metabolics, rownames(sobj))
     group_code = paste0(

{biopipen-0.23.8 → biopipen-0.24.1}/biopipen/scripts/scrna_metabolic_landscape/MetabolicPathwayActivity.R

@@ -71,7 +71,7 @@ num_of_pathways <- function(gmtfile, overlapgenes) {
 }
 
 do_one_subset <- function(s, subset_col, subset_prefix) {
-    print(paste0("  Processing subset: ", s, "..."))
+    log_info("  Processing subset: {s} ...")
     if (is.null(s)) {
         subset_dir <- file.path(outdir, "ALL")
         dir.create(subset_dir, showWarnings = FALSE)
@@ -118,7 +118,7 @@ do_one_subset <- function(s, subset_col, subset_prefix) {
 
     for (pi in seq_along(pathway_names)) {
         p <- pathway_names[pi]
-        print(paste0("  * Pathway (", pi, "): ", p, "..."))
+        log_info("  * Pathway ({pi}): {p} ...")
         genes <- pathways[[p]]
         genes_comm <- intersect(genes, rownames(subset_obj))
         genes_expressed <- names(rowSums(subset_obj)[rowSums(subset_obj) > 0])
@@ -312,7 +312,7 @@ do_one_subset <- function(s, subset_col, subset_prefix) {
 }
 
 do_one_subset_col <- function(subset_col, subset_prefix) {
-    print(paste0("- Handling subset column: ", subset_col, " ..."))
+    log_info("- Handling subset column: {subset_col} ...")
     if (is.null(subset_col)) {
         do_one_subset(NULL, subset_col = NULL, subset_prefix = NULL)
     } else {

{biopipen-0.23.8 → biopipen-0.24.1}/biopipen/scripts/tcr/Immunarch-basic.R

@@ -2,9 +2,8 @@
 # immfile, outdir, mutaters, immdata, n_samples
 
 log_info("")
-log_info("#####################################")
-log_info("# Basic analysis                    #")
-log_info("#####################################")
+log_info("# Basic analysis")
+log_info("-----------------------------------")
 
 volumes = {{envs.volumes | r}}
 lens = {{envs.lens | r}}