biopipen 0.29.2__py3-none-any.whl → 0.31.0__py3-none-any.whl

biopipen/scripts/scrna/ScSimulation.R

@@ -0,0 +1,64 @@
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
+
+library(rlang)
+library(splatter)
+library(scater)
+
+# Load template variables
+seed <- {{ in.seed | r }}
+outfile <- {{ out.outfile | r }}
+ngenes <- {{ envs.ngenes | r }}
+ncells <- {{ envs.ncells | r }}
+nspikes <- {{ envs.nspikes | r }}
+outtype <- {{ envs.outtype | r }}
+method <- {{ envs.method | r }}
+user_params <- {{ envs.params | r: todot="-" }}
+
+log_info("Generating simulation parameters ...")
+
+seed <- seed %||% 1
+if (length(seed) > 1) {
+    log_warn("- multiple seeds provided, using the first one")
+    seed <- seed[1]
+}
+if (is.character(seed)) {
+    library(digest)
+    proj <- seed
+    seed <- digest2int(seed)
+} else {
+    proj <- paste0("S", seed)
+}
+
+set.seed(seed)
+mock_sce_params <- list()
+if (!is.null(ngenes)) mock_sce_params$ngenes <- ngenes
+if (!is.null(ncells)) mock_sce_params$ncells <- ncells
+if (!is.null(nspikes)) mock_sce_params$nspikes <- nspikes
+sce <- do.call(mockSCE, mock_sce_params)
+params <- splatEstimate(sce)
+user_params$seed <- seed
+user_params$object = params
+do_call(setParams, user_params)
+
+
+log_info("Saving simulation parameters to file ...")
+
+sim <- splatSimulate(params, method = method, verbose = TRUE)
+
+outtype <- tolower(outtype)
+if (outtype == "sce") outtype <- "singlecellexperiment"
+
+if (outtype == "singlecellexperiment") {
+    log_info("Saving simulation to file ...")
+    saveRDS(sim, file = outfile)
+} else {
+    log_info("Converting simulation to Seurat object ...")
+    cnts <- SingleCellExperiment::counts(sim)
+    sobj <- Seurat::CreateSeuratObject(counts = cnts, project = proj)
+    rm(sim)
+    rm(cnts)
+    gc()
+
+    log_info("Saving simulation to file ...")
+    saveRDS(sobj, file = outfile)
+}

biopipen/scripts/scrna/Seurat2AnnData.R

@@ -1,4 +1,4 @@
-source("{{biopipen_dir}}/utils/misc.R")
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
 
 library(rlang)
 library(Seurat)

biopipen/scripts/scrna/SeuratClusterStats-clustree.R

@@ -0,0 +1,73 @@
+# srtobj, clustrees_defaults, clustrees
+log_info("clustrees:")
+if (
+    (is.null(clustrees) || length(clustrees) == 0) &&
+    (is.null(clustrees_defaults$prefix) || clustrees_defaults$prefix == "")) {
+    log_warn("- no cases, skipping intentionally ...")
+} else {  # clustrees set or prefix is not empty
+    library(clustree)
+    odir = file.path(outdir, "clustrees")
+    dir.create(odir, recursive=TRUE, showWarnings=FALSE)
+
+    if ((is.null(clustrees) || length(clustrees) == 0) && clustrees_defaults$prefix == "_auto") {
+        clustrees <- list()
+        for (key in names(srtobj@commands)) {
+            if (startsWith(key, "FindClusters") && length(srtobj@commands[[key]]$resolution) > 1) {
+                pref <- substring(key, 14)
+                if (pref == "") {
+                    pref <- "seurat_clusters"
+                }
+
+                clustrees[[pref]] <- list(prefix = pref)
+            }
+        }
+    }
+    if (length(clustrees) == 0) {
+        log_warn("- no cases found, skipping ...")
+    } else {
+        reports <- list()
+        for (name in names(clustrees)) {
+            if (is.null(clustrees[[name]]$prefix)) {
+                stop(paste0("clustrees: prefix is required for case: ", name))
+            }
+            case <- list_update(clustrees_defaults, clustrees[[name]])
+
+            devpars <- case$devpars
+            devpars$width <- devpars$width %||% clustrees_defaults$devpars$width %||% 800
+            devpars$height <- devpars$height %||% clustrees_defaults$devpars$height %||% 1000
+            devpars$res <- devpars$res %||% clustrees_defaults$devpars$res %||% 100
+            case$devpars <- NULL
+            prefix <- sub("\\.$", "", case$prefix)
+            log_info("- Case: {name} ...")
+            case$prefix <- paste0(prefix, ".")
+            case$x <- srtobj@meta.data %>% select(starts_with(case$prefix))
+            case$x <- case$x[complete.cases(case$x), , drop = FALSE]
+
+            command <- srtobj@commands[[paste0("FindClusters.", prefix)]] %||%
+                (if(prefix == "seurat_clusters") srtobj@commands$FindClusters else NULL)
+
+            clustree_file <- file.path(odir, paste0(prefix, ".clustree.png"))
+            png(clustree_file, width = devpars$width, height = devpars$height, res = devpars$res)
+            p <- do_call(clustree, case)
+            print(p)
+            dev.off()
+
+            if (is.null(command)) {
+                resolution <- substring(colnames(case$x), nchar(case$prefix) + 1)
+            } else {
+                resolution <- command$resolution
+            }
+            resolution_used <- resolution[length(resolution)]
+
+            reports[[length(reports) + 1]] <- list(
+                kind = "table_image",
+                src = clustree_file,
+                name = name,
+                descr = paste0("Resolutions: ", paste(resolution, collapse = ", "), "; resolution used: ", resolution_used)
+            )
+        }
+        reports$h1 <- "Clustree plots"
+        reports$ui <- "table_of_images"
+        do.call(add_report, reports)
+    }
+}

biopipen/scripts/scrna/SeuratClusterStats-dimplots.R

@@ -1,13 +1,14 @@
 # Loaded variables: srtfile, outdir, srtobj
 
-dimplots_defaults = {{envs.dimplots_defaults | r: todot="-"}}
-dimplots = {{envs.dimplots | r: todot="-", skip=1}}
+# dimplots_defaults = {{envs.dimplots_defaults | r: todot="-"}}
+# dimplots = {{envs.dimplots | r: todot="-", skip=1}}
+log_info("dimplots:")
 
 odir = file.path(outdir, "dimplots")
 dir.create(odir, recursive=TRUE, showWarnings=FALSE)
 
 do_one_dimplot = function(name) {
-    log_info(paste0("Doing dimplots for: ", name))
+    log_info("- Case: {name}")
 
     case = list_update(dimplots_defaults, dimplots[[name]])
     case$devpars = list_update(dimplots_defaults$devpars, dimplots[[name]]$devpars)

biopipen/scripts/scrna/SeuratClusterStats-features.R

@@ -1,7 +1,8 @@
 # Loaded variables: srtfile, outdir, srtobj
 
-features_defaults = {{envs.features_defaults | r: todot="-"}}
-features = {{envs.features | r: todot="-", skip=1}}
+# features_defaults = {{envs.features_defaults | r: todot="-"}}
+# features = {{envs.features | r: todot="-", skip=1}}
+log_info("features:")
 
 odir = file.path(outdir, "features")
 dir.create(odir, recursive=TRUE, showWarnings=FALSE)
@@ -36,7 +37,7 @@ dir.create(odir, recursive=TRUE, showWarnings=FALSE)
 }
 
 do_one_features = function(name) {
-    log_info("Doing features for: {name}")
+    log_info("- Case: {name}")
 
     case = list_update(features_defaults, features[[name]])
     case$devpars = list_update(features_defaults$devpars, features[[name]]$devpars)
@@ -105,7 +106,7 @@ do_one_features = function(name) {
             if (is.null(ncol)) { ncol = 1 }
             list(
                 width = 400 * ncol,
-                height = ceiling(length(features) / ncol + max_nchar_idents * .05) * 150,
+                height = ceiling(length(features) / ncol) * (max_nchar_idents * .1 + 275),
                 res = 100
             )
         }
@@ -398,7 +399,7 @@ do_one_features = function(name) {
     devpars = list_update(default_devpars(case$features, case$ncol), devpars)
     if (kind == "heatmap") {
         if (!exists("downsample") || is.null(downsample)) {
-            log_warn("- `downsample` is not specified for `heatmap`, using `downsample=1000`")
+            log_warn("  'downsample' is not specified for `heatmap`, using `downsample=1000`")
             downsample = 1000
         }
         if (is.numeric(downsample)) {

biopipen/scripts/scrna/SeuratClusterStats-hists.R

@@ -1,7 +1,8 @@
 # Loaded variables: srtfile, outdir, srtobj
 
-hists_defaults <- {{envs.hists_defaults | r: todot="-"}}
-hists <- {{envs.hists | r: todot="-", skip=1}}
+# hists_defaults <- {{envs.hists_defaults | r: todot="-"}}
+# hists <- {{envs.hists | r: todot="-", skip=1}}
+log_info("hists:")
 
 do_one_hists <- function(m, case, odir, h1, each = NULL) {
     ofile <- file.path(odir, paste0(slugify(h1), ifelse(is.null(each), "", paste0("-", slugify(each))), ".png"))
@@ -57,7 +58,7 @@ do_one_hists <- function(m, case, odir, h1, each = NULL) {
 }
 
 if (is.null(hists) || length(hists) == 0) {
-    log_warn("No hists cases specified, skipping ...")
+    log_warn("- no cases specified, skipping ...")
 } else {
 
     for (name in names(hists)) {
@@ -112,12 +113,12 @@ if (is.null(hists) || length(hists) == 0) {
                 h1 = h1
             )
             for (each in eachs) {
-                log_info("Doing hists for: {h1} - {each} ...")
+                log_info("- Case: {h1} - {each} ...")
                 m <- meta %>% filter(!!sym(case$each) == each)
                 do_one_hists(m, case, odir, h1, each)
             }
         } else {
-            log_info("Doing hists for: {h1} ...")
+            log_info("- Case: {h1} ...")
             add_report(
                 list(
                     kind = "descr",

biopipen/scripts/scrna/SeuratClusterStats-ngenes.R

@@ -1,13 +1,14 @@
 # Loaded variables: srtfile, outdir, srtobj
 
-ngenes_defaults <- {{envs.ngenes_defaults | r: todot="-"}}
-ngenes <- {{envs.ngenes | r: todot="-", skip=1}}
+# ngenes_defaults <- {{envs.ngenes_defaults | r: todot="-"}}
+# ngenes <- {{envs.ngenes | r: todot="-", skip=1}}
+log_info("ngenes:")
 
 odir <- file.path(outdir, "ngenes")
 dir.create(odir, recursive=TRUE, showWarnings=FALSE)
 
 do_one_ngenes <- function(name) {
-    log_info("Doing ngenes for: {name}")
+    log_info("- Case: {name}")
 
     case <- list_update(ngenes_defaults, ngenes[[name]])
     case$devpars <- list_update(ngenes_defaults$devpars, case$devpars)

biopipen/scripts/scrna/SeuratClusterStats-stats.R

@@ -1,14 +1,15 @@
 # Loaded variables: srtfile, outdir, srtobj
 library(circlize)
 
-stats_defaults = {{envs.stats_defaults | r: todot="-"}}
-stats = {{envs.stats | r: todot="-", skip=1}}
+# stats_defaults = {{envs.stats_defaults | r: todot="-"}}
+# stats = {{envs.stats | r: todot="-", skip=1}}
+log_info("stats:")
 
 odir = file.path(outdir, "stats")
 dir.create(odir, recursive=TRUE, showWarnings=FALSE)
 
 do_one_stats = function(name) {
-    log_info("Doing stats for: {name}")
+    log_info("- Case: {name}")
 
     case = list_update(stats_defaults, stats[[name]])
     case$devpars = list_update(stats_defaults$devpars, case$devpars)
@@ -17,12 +18,6 @@ do_one_stats = function(name) {
     if (isTRUE(case$pie) && !is.null(case$group.by)) {
         stop(paste0(name, ": pie charts are not supported for group-by"))
     }
-    if (!isTRUE(case$frac) && isTRUE(case$frac_ofall)) {
-        stop(paste0(name, ": frac_ofall is only supported when frac is true"))
-    }
-    if (isTRUE(case$frac_ofall) && is.null(case$group.by)) {
-        stop(paste0(name, ": frac_ofall is only supported for group-by"))
-    }
     if (isTRUE(case$transpose) && is.null(case$group.by)) {
         stop(paste0(name, ": transpose is only supported for group-by"))
     }
@@ -45,28 +40,28 @@ do_one_stats = function(name) {
             !!!syms(case$split.by)
         ), function(df) {
             out <- df %>% group_by(!!!syms(select_cols)) %>% summarise(.n = n(), .groups = "drop")
-            if (!is.null(case$group.by) && isTRUE(case$frac)) {
-                if (isTRUE(case$frac_ofall)) {
+            if (!is.null(case$group.by) && case$frac != "none") {
+                if (case$frac == "all") {
                     out <- out %>% mutate(.frac = .n / sum(.n))
-                } else if (isTRUE(case$transpose)) {
-                    out <- out %>% group_by(!!sym(case$ident)) %>% mutate(.frac = .n / sum(.n))
-                } else {
+                } else if (case$frac == "group") {
                     out <- out %>% group_by(!!sym(case$group.by)) %>% mutate(.frac = .n / sum(.n))
+                } else {  # case$frac == "ident" or "cluster"
+                    out <- out %>% group_by(!!sym(case$ident)) %>% mutate(.frac = .n / sum(.n))
                 }
             }
             out
         }))
-    } else if (!is.null(case$group.by) && isTRUE(case$frac)) {
+    } else if (!is.null(case$group.by) && case$frac != "none") {  # no split.by
         plot_df <- df_cells %>%
             select(all_of(select_cols)) %>%
             group_by(!!!syms(select_cols)) %>%
             summarise(.n = n(), .groups = "drop")
-        if (isTRUE(case$frac_ofall)) {
+        if (case$frac == "all") {
             plot_df = plot_df %>% mutate(.frac = .n / sum(.n))
-        } else {
-            plot_df = plot_df %>%
-                group_by(!!sym(ifelse(isTRUE(case$transpose), case$group.by, case$ident))) %>%
-                mutate(.frac = .n / sum(.n))
+        } else if (case$frac == "group") {
+            plot_df = plot_df %>% group_by(!!sym(case$group.by)) %>% mutate(.frac = .n / sum(.n))
+        } else {  # case$frac == "ident" or "cluster"
+            plot_df = plot_df %>% group_by(!!sym(case$ident)) %>% mutate(.frac = .n / sum(.n))
         }
     } else {
         plot_df <- df_cells %>%
@@ -74,7 +69,7 @@ do_one_stats = function(name) {
             group_by(!!!syms(select_cols)) %>%
             summarise(.n = n(), .groups = "drop")
 
-        if (isTRUE(case$frac) || isTRUE(case$frac_ofall)) {
+        if (case$frac != "none") {
             plot_df <- plot_df %>% mutate(.frac = .n / sum(.n))
         }
     }
@@ -87,13 +82,13 @@ do_one_stats = function(name) {
     p = plot_df %>%
         ggplot(aes(
             x=!!sym(ifelse(case$transpose, case$group.by, case$ident)),
-            y=if (isTRUE(case$frac)) .frac else .n,
+            y=if (case$frac != "none") .frac else .n,
             fill=!!sym(ifelse(is.null(case$group.by) || isTRUE(case$transpose), case$ident, case$group.by))
         )) +
         geom_bar(stat="identity", position=bar_position, alpha=.8) +
         theme_prism(axis_text_angle = 90) +
         scale_fill_biopipen() +
-        ylab(ifelse(isTRUE(case$frac), "Fraction of cells", "Number of cells"))
+        ylab(ifelse(case$frac != "none", "Fraction of cells", "Number of cells"))
 
     if (!is.null(case$split.by)) {
         p = p + facet_wrap(case$split.by)
@@ -108,7 +103,7 @@ do_one_stats = function(name) {
             kind = "descr",
             content = paste0(
                 "Plots showing the ",
-                ifelse(isTRUE(case$frac), "number/faction", "number"),
+                ifelse(case$frac != "none", "number/faction", "number"),
                 " of cells per cluster",
                 ifelse(
                     is.null(case$group.by),
@@ -149,7 +144,7 @@ do_one_stats = function(name) {
             guides(fill = guide_legend(title = case$ident)) +
             theme_void() +
             geom_label(
-                if (isTRUE(case$frac))
+                if (case$frac != "none")
                     aes(label=sprintf("%.1f%%", .frac * 100))
                 else
                     aes(label=.n),

biopipen/scripts/scrna/SeuratClusterStats.R

@@ -1,6 +1,7 @@
-source("{{biopipen_dir}}/utils/misc.R")
-source("{{biopipen_dir}}/utils/mutate_helpers.R")
-source("{{biopipen_dir}}/utils/plot.R")
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
+{{ biopipen_dir | joinpaths: "utils", "mutate_helpers.R" | source_r }}
+{{ biopipen_dir | joinpaths: "utils", "plot.R" | source_r }}
+
 library(Seurat)
 library(rlang)
 library(dplyr)
@@ -26,19 +27,34 @@ if (!is.null(mutaters) && length(mutaters) > 0) {
         mutate(!!!lapply(mutaters, parse_expr))
 }
 
+############## clustree ##############
+clustrees_defaults <- {{envs.clustrees_defaults | r}}
+clustrees <- {{envs.clustrees | r}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-clustree.R" | source_r }}
+
 ############## stats ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-stats.R" %}
+stats_defaults = {{envs.stats_defaults | r: todot="-"}}
+stats = {{envs.stats | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-stats.R" | source_r }}
 
 ############## hists ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-hists.R" %}
+hists_defaults <- {{envs.hists_defaults | r: todot="-"}}
+hists <- {{envs.hists | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-hists.R" | source_r }}
 
 ############## ngenes ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-ngenes.R" %}
+ngenes_defaults <- {{envs.ngenes_defaults | r: todot="-"}}
+ngenes <- {{envs.ngenes | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-ngenes.R" | source_r }}
 
 ############## features ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-features.R" %}
+features_defaults = {{envs.features_defaults | r: todot="-"}}
+features = {{envs.features | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-features.R" | source_r }}
 
 ############## dimplots ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-dimplots.R" %}
+dimplots_defaults = {{envs.dimplots_defaults | r: todot="-"}}
+dimplots = {{envs.dimplots | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-dimplots.R" | source_r }}
 
 save_report(joboutdir)

biopipen/scripts/scrna/SeuratClustering-common.R

@@ -0,0 +1,213 @@
+
+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
+}
+
+expand_resolution <- function(resolution) {
+    expanded_res <- c()
+    for (res in resolution) {
+        if (is.numeric(res)) {
+            expanded_res <- c(expanded_res, res)
+        } else {
+            # is.character
+            parts <- trimws(unlist(strsplit(res, ",")))
+            for (part in parts) {
+                if (grepl(":", part)) {
+                    ps <- trimws(unlist(strsplit(part, ":")))
+                    if (length(ps) == 2) { ps <- c(ps, 0.1) }
+                    if (length(ps) != 3) {
+                        stop("Invalid resolution format: {part}. Expected 2 or 3 parts separated by ':' for a range.")
+                    }
+                    ps <- as.numeric(ps)
+                    expanded_res <- c(expanded_res, seq(ps[1], ps[2], by = ps[3]))
+                } else {
+                    expanded_res <- c(expanded_res, as.numeric(part))
+                }
+            }
+        }
+    }
+    # keep the last resolution at last
+    rev(unique(rev(round(expanded_res, 2))))
+}
+
+# recode clusters from 0, 1, 2, ... to c1, c2, c3, ...
+recode_clusters <- function(clusters) {
+    recode <- function(x) paste0("c", as.integer(as.character(x)) + 1)
+    clusters <- factor(recode(clusters), levels = recode(levels(clusters)))
+    clusters
+}
+
+run_transformation <- function(sobj) {
+    if (length(envs$ScaleData) == 0 && length(envs$SCTransform) == 0) {
+        log_warn("Skipping ScaleData/SCTransform (neither specified) ...")
+        return(sobj)
+    }
+    if (length(envs$ScaleData) > 0 && length(envs$SCTransform) > 0) {
+        stop("Both envs.ScaleData and envs.SCTransform are specified. Please choose either.")
+    }
+    if (length(envs$ScaleData) > 0) {
+        if (DefaultAssay(sobj) == "SCT") {
+            stop("SCT assay detected, but envs.ScaleData is specified. Use envs.SCTransform instead.")
+        }
+        cached <- get_cached(envs$ScaleData, "ScaleData", cache_dir)
+        if (is.null(cached$data)) {
+            log_info("Running ScaleData ...")
+            sobj <- do_call(ScaleData, c(list(object = sobj), 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 envs.SCTransform is specified. Use envs.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 ...")
+            sobj <- do_call(SCTransform, c(list(object = sobj), 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
+        }
+    }
+    sobj
+}
+
+run_umap <- function(sobj) {
+    cached <- get_cached(
+        list(sobj = sobj, RunUMAP = 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
+    }
+
+    sobj
+}
+
+run_findneighbors <- function(sobj) {
+    cached <- get_cached(
+        list(sobj = sobj, FindNeighbors = 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
+    }
+
+    sobj
+}
+
+run_findclusters <- function(sobj) {
+    cached <- get_cached(
+        list(sobj = sobj, FindClusters = envs$FindClusters),
+        "FindClusters",
+        cache_dir
+    )
+    if (is.null(cached$data)) {
+        findclusters_args <- envs$FindClusters
+        findclusters_args$random.seed <- findclusters_args$random.seed %||% 8525
+        resolution <- findclusters_args$resolution <- expand_resolution(findclusters_args$resolution %||% 0.8)
+        log_info("Running FindClusters at resolution: {paste(resolution, collapse=',')} ...")
+
+        findclusters_args$object <- sobj
+        findclusters_args$cluster.name <- paste0("seurat_clusters.", resolution)
+        sobj <- do_call(FindClusters, findclusters_args)
+
+        for (clname in findclusters_args$cluster.name) {
+            sobj@meta.data[[clname]] <- recode_clusters(sobj@meta.data[[clname]])
+        }
+        sobj@meta.data$seurat_clusters <- recode_clusters(sobj@meta.data$seurat_clusters)
+        Idents(sobj) <- "seurat_clusters"
+
+        ident_table <- table(Idents(sobj))
+        log_info("- Found {length(ident_table)} clusters at resolution {resolution[length(resolution)]}")
+        print(ident_table)
+        cat("\n")
+
+        cached$data <- list(
+            clusters = sobj@meta.data[, c(findclusters_args$cluster.name, "seurat_clusters"), drop = FALSE],
+            commands = sobj@commands
+        )
+        save_to_cache(cached, "FindClusters", cache_dir)
+    } else {
+        log_info("Loading cached FindClusters ...")
+
+        sobj <- AddMetaData(sobj, metadata = cached$data$clusters)
+        Idents(sobj) <- "seurat_clusters"
+        sobj@commands <- cached$data$commands
+    }
+
+    sobj
+}
+
+run_prepsctfindmarkers <- function(sobj) {
+    if (DefaultAssay(sobj) == "SCT") {
+        cached <- get_cached(list(sobj = sobj), "PrepSCTFindMarkers", cache_dir)
+        if (is.null(cached$data)) {
+            # https://github.com/satijalab/seurat/issues/6968
+            log_info("Running PrepSCTFindMarkers ...")
+            sobj <- PrepSCTFindMarkers(sobj)
+            # compose a new SeuratCommand to record it to sobj@commands
+            scommand <- sobj@commands$FindClusters
+            scommand@name <- "PrepSCTFindMarkers"
+            scommand@time.stamp <- Sys.time()
+            scommand@assay.used <- "SCT"
+            scommand@call.string <- "PrepSCTFindMarkers(object = sobj)"
+            scommand@params <- list()
+            sobj@commands$PrepSCTFindMarkers <- scommand
+
+            cached$data <- sobj
+            save_to_cache(cached, "PrepSCTFindMarkers", cache_dir)
+        } else {
+            log_info("Loading cached PrepSCTFindMarkers ...")
+            sobj <- cached$data
+        }
+    }
+
+    sobj
+}