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

biopipen/scripts/scrna/MarkersFinder.R

@@ -7,34 +7,35 @@ library(biopipen.utils)
 log <- get_logger()
 reporter <- get_reporter()
 
-srtfile <- {{ in.srtobj | quote }}
-outdir <- {{ out.outdir | quote }}
-joboutdir <- {{ job.outdir | quote }}
+srtfile <- {{ in.srtobj | r }}
+outdir <- {{ out.outdir | r }}
+joboutdir <- {{ job.outdir | r }}
+
 ncores <- {{ envs.ncores | int }}
 mutaters <- {{ envs.mutaters | r }}
+group.by <- {{ envs["group-by"] | r }}
 ident.1 <- {{ envs["ident-1"] | r }}
 ident.2 <- {{ envs["ident-2"] | r }}
-group.by <- {{ envs["group-by"] | r }}
 each <- {{ envs.each | r }}
-prefix_each <- {{ envs.prefix_each | r }}
-prefix_group <- {{ envs.prefix_group | r }}
-assay <- {{ envs.assay | r }}
-subset <- {{ envs.subset | r }}
-error <- {{ envs.error | r }}
-site <- {{ envs.site | r }}
-rest <- {{ envs.rest | r: todot="-" }}
 dbs <- {{ envs.dbs | r }}
 sigmarkers <- {{ envs.sigmarkers | r }}
+enrich_style <- {{ envs.enrich_style | r }}
+assay <- {{ envs.assay | r }}
+error <- {{ envs.error | r }}
+subset <- {{ envs.subset | r }}
 cache <- {{ envs.cache | r }}
+rest <- {{ envs.rest | r: todot="-" }}
 allmarker_plots_defaults <- {{ envs.allmarker_plots_defaults | r }}
 allmarker_plots <- {{ envs.allmarker_plots | r }}
+allenrich_plots_defaults <- {{ envs.allenrich_plots_defaults | r }}
+allenrich_plots <- {{ envs.allenrich_plots | r }}
 marker_plots_defaults <- {{ envs.marker_plots_defaults | r }}
 marker_plots <- {{ envs.marker_plots | r }}
 enrich_plots_defaults <- {{ envs.enrich_plots_defaults | r }}
 enrich_plots <- {{ envs.enrich_plots | r }}
-cases <- {{ envs.cases | r: todot="-", skip=1 }}
 overlaps_defaults <- {{ envs.overlaps_defaults | r }}
 overlaps <- {{ envs.overlaps | r }}
+cases <- {{ envs.cases | r: todot="-", skip=1 }}
 
 if (isTRUE(cache)) { cache <- joboutdir }
 
@@ -45,7 +46,11 @@ if (ncores > 1) {
 }
 
 log$info("Reading Seurat object ...")
-srtobj <- readRDS(srtfile)
+srtobj <- read_obj(srtfile)
+if (!"Identity" %in% colnames(srtobj@meta.data)) {
+    srtobj@meta.data$Identity <- Idents(srtobj)
+}
+
 
 if (!is.null(mutaters) && length(mutaters) > 0) {
     log$info("Mutating meta data ...")
@@ -53,22 +58,43 @@ if (!is.null(mutaters) && length(mutaters) > 0) {
         mutate(!!!lapply(mutaters, parse_expr))
 }
 
+allmarker_plots <- lapply(allmarker_plots, function(x) {
+    list_update(allmarker_plots_defaults, x)
+})
+allenrich_plots <- lapply(allenrich_plots, function(x) {
+    list_update(allenrich_plots_defaults, x)
+})
+marker_plots <- lapply(marker_plots, function(x) {
+    list_update(marker_plots_defaults, x)
+})
+enrich_plots <- lapply(enrich_plots, function(x) {
+    list_update(enrich_plots_defaults, x)
+})
+overlaps <- lapply(overlaps, function(x) {
+    list_update(overlaps_defaults, x)
+})
+
 defaults <- list(
+    group.by = group.by,
     ident.1 = ident.1,
     ident.2 = ident.2,
-    group.by = group.by,
-    each = each,
-    prefix_each = prefix_each,
-    prefix_group = prefix_group,
     dbs = dbs,
+    sigmarkers = sigmarkers,
+    enrich_style = enrich_style,
     assay = assay %||% DefaultAssay(srtobj),
-    subset = subset,
+    each = each,
     error = error,
-    site = site,
-    sigmarkers = sigmarkers,
+    subset = subset,
+    allmarker_plots_defaults = allmarker_plots_defaults,
     allmarker_plots = allmarker_plots,
+    allenrich_plots_defaults = allenrich_plots_defaults,
+    allenrich_plots = allenrich_plots,
+    marker_plots_defaults = marker_plots_defaults,
     marker_plots = marker_plots,
+    enrich_plots_defaults = enrich_plots_defaults,
     enrich_plots = enrich_plots,
+    overlaps_defaults = overlaps_defaults,
+    overlaps = overlaps,
     cache = cache,
     rest = rest
 )
@@ -77,107 +103,171 @@ log$info("Expanding cases ...")
 
 post_casing <- function(name, case) {
     outcases <- list()
-    no_each <- is.null(case$each) || is.na(case$each) || nchar(case$each) == 0
 
-    if (no_each) {
+    case$group.by <- case$group.by %||% "Identity"
+
+    if (is.null(case$each) || is.na(case$each) || nchar(case$each) == 0 || isFALSE(each)) {
         # single cases, no need to expand
+        if (length(case$ident.1) > 0 && length(case$overlaps) > 0) {
+            stop("Cannot perform 'overlaps' with a single comparison (ident-1 is set) in case '", name, "'")
+        }
+        if (length(case$ident.1) > 0 && length(case$allmarker_plots) > 0) {
+            stop("Cannot perform 'allmarker_plots' with a single comparison (ident-1 is set) in case '", name, "'")
+        }
+        if (length(case$ident.1) > 0 && length(case$allenrich_plots) > 0) {
+            stop("Cannot perform 'allenrich_plots' with a single comparison (ident-1 is set) in case '", name, "'")
+        }
+
         case$allmarker_plots <- lapply(
             case$allmarker_plots,
-            function(x) { list_update(allmarker_plots_defaults, x) }
+            function(x) { list_update(case$allmarker_plots_defaults, x) }
         )
+        case$allmarker_plots_defaults <- NULL
+
+        case$allenrich_plots <- lapply(
+            case$allenrich_plots,
+            function(x) { list_update(case$allenrich_plots_defaults, x) }
+        )
+        case$allenrich_plots_defaults <- NULL
+
         case$marker_plots <- lapply(
             case$marker_plots,
-            function(x) { list_update(marker_plots_defaults, x) }
+            function(x) { list_update(case$marker_plots_defaults, x) }
         )
+        case$marker_plots_defaults <- NULL
+
         case$enrich_plots <- lapply(
             case$enrich_plots,
-            function(x) { list_update(enrich_plots_defaults, x) }
+            function(x) { list_update(case$enrich_plots_defaults, x) }
+        )
+        case$enrich_plots_defaults <- NULL
+
+        case$overlaps <- lapply(
+            case$overlaps,
+            function(x) { list_update(case$overlaps_defaults, x) }
         )
+        case$overlaps_defaults <- NULL
+
         outcases[[name]] <- case
     } else {  # !no_each
-        if (!is.null(case$subset)) {
-            sobj <- srtobj %>% filter(!!parse_expr(case$subset))
+        eachs <- if (!is.null(case$subset)) {
+            srtobj@meta.data %>%
+                filter(!!parse_expr(case$subset)) %>%
+                pull(case$each) %>% na.omit() %>% unique() %>% as.vector()
         } else {
-            sobj <- srtobj
+            srtobj@meta.data %>%
+                pull(case$each) %>% na.omit() %>% unique() %>% as.vector()
+        }
+        if (length(case$overlaps) > 0 && is.null(case$ident.1)) {
+            stop("Cannot perform 'overlaps' analysis with 'each' and without 'ident.1' in case '", name, "'")
+        }
+
+        if (length(cases) == 0 && name == "Marker Discovery") {
+            name <- case$each
         }
 
-        eachs <- sobj@meta.data %>% pull(case$each) %>% na.omit() %>% unique() %>% as.vector()
-        case_1 <- case
         for (each in eachs) {
-            each_name <- ifelse(case_1$prefix_each, paste0(case_1$each, " - ", each), each)
-            if (!is.null(case_1$ident.1)) {
-                # Make name a section
-                key <- paste0(name, "::", each_name)
-            } else {
-                key <- paste0(name, ": ", each_name)
-            }
+            newname <- paste0(name, " - ", each)
+            newcase <- case
+
+            newcase$original_case <- name
+            newcase$each_name <- case$each
+            newcase$each <- each
+
             if (!is.null(case$subset)) {
-                case_1$subset <- paste0(case$subset, " & `", case_1$each, "` == '", each, "'")
+                newcase$subset <- paste0(case$subset, " & ", bQuote(case$each), " == '", each, "'")
             } else {
-                case_1$subset <- paste0("`", case_1$each, "` == '", each, "'")
+                newcase$subset <- paste0(bQuote(case$each), " == '", each, "'")
             }
-            case_1$allmarker_plots <- lapply(
-                case_1$allmarker_plots,
-                function(x) { list_update(allmarker_plots_defaults, x) }
+
+            newcase$marker_plots <- lapply(
+                case$marker_plots,
+                function(x) { list_update(case$marker_plots_defaults, x) }
+            )
+            newcase$marker_plots_defaults <- NULL
+
+            newcase$enrich_plots <- lapply(
+                case$enrich_plots,
+                function(x) { list_update(case$enrich_plots_defaults, x) }
+            )
+            newcase$enrich_plots_defaults <- NULL
+
+            # Will be processed by the case itself, which collects the markers
+            newcase$allmarker_plots <- NULL
+            newcase$allmarker_plots_defaults <- NULL
+            newcase$allenrich_plots <- NULL
+            newcase$allenrich_plots_defaults <- NULL
+            newcase$overlaps <- NULL
+            newcase$overlaps_defaults <- NULL
+
+            outcases[[newname]] <- newcase
+        }
+
+        if (length(case$overlaps) > 0 || length(case$allmarker_plots) > 0 || length(case$allenrich_plots) > 0) {
+            ovcase <- case
+
+            ovcase$markers <- list()
+            ovcase$allmarker_plots <- lapply(
+                ovcase$allmarker_plots,
+                function(x) { list_update(ovcase$allmarker_plots_defaults, x) }
             )
-            case_1$marker_plots <- lapply(
-                case_1$marker_plots,
-                function(x) { list_update(marker_plots_defaults, x) }
+            ovcase$allmarker_plots_defaults <- NULL
+
+            ovcase$enriches <- list()
+            ovcase$allenrich_plots <- lapply(
+                ovcase$allenrich_plots,
+                function(x) { list_update(ovcase$allenrich_plots_defaults, x) }
             )
-            case_1$enrich_plots <- lapply(
-                case_1$enrich_plots,
-                function(x) { list_update(enrich_plots_defaults, x) }
+            ovcase$allenrich_plots_defaults <- NULL
+
+            ovcase$overlaps <- lapply(
+                ovcase$overlaps,
+                function(x) { list_update(ovcase$overlaps_defaults, x) }
             )
-            outcases[[key]] <- case_1
+            ovcase$overlaps_defaults <- NULL
+            outcases[[name]] <- ovcase
         }
     }
     outcases
 }
-cases <- expand_cases(cases, defaults, post_casing)
-
-# Checking the overlapping cases
-case_markers <- list()
-if (length(overlaps) > 0) {
-    log$info("Checking overlapping cases ...")
-    overlaps <- expand_cases(overlaps, overlaps_defaults)
-    for (ovname in names(overlaps)) {
-        ov <- overlaps[[ovname]]
-        # check the existence of the cases
-        for (case in ov$cases) {
-            if (is.null(cases[[case]])) {
-                stop(paste0("Case '", case, "' not found in the cases for overlapping case '", ovname, "'"))
-            }
-        }
-        if (length(ov$cases) < 2) {
-            stop("Overlapping cases must have at least 2 cases for overlapping case '", ovname, "'")
-        }
-        for (case in ov$cases) {
-            case_markers[[case]] <- TRUE
-        }
-        if (identical(ov$venn$enabled, "auto")) {
-            overlaps[[ovname]]$venn$enabled <- length(ov$cases) <= 5
-        }
-    }
-}
+cases <- expand_cases(cases, defaults, post_casing, default_case = "Marker Discovery")
 
 log$info("Running cases ...")
 
 process_markers <- function(markers, info, case) {
+    ## Attributes lost
+    # markers <- markers %>%
+    #     mutate(gene = as.character(gene)) %>%
+    #     arrange(p_val_adj, desc(abs(avg_log2FC)))
+    markers$gene <- as.character(markers$gene)
+    markers <- markers[order(markers$p_val_adj, -abs(markers$avg_log2FC)), ]
+
     # Save markers
     write.table(markers, file.path(info$prefix, "markers.tsv"), sep = "\t", quote = FALSE, row.names = FALSE)
+
+    sigmarkers <- markers %>% filter(!!parse_expr(case$sigmarkers))
+    write.table(sigmarkers, file.path(info$prefix, "sigmarkers.tsv"), sep = "\t", quote = FALSE, row.names = FALSE)
     reporter$add2(
         list(
             name = "Table",
-            contents = list(list(kind = "table", src = file.path(info$prefix, "markers.tsv"), data = list(nrows = 100)))
+            contents = list(
+                list(kind = "descr", content = paste0(
+                    "Showing top 100 markers ordered by p_val_adj ascendingly, then abs(avg_log2FC) descendingly. ",
+                    "Use 'Download the entire data' button to download all significant markers by '",
+                    html_escape(case$sigmarkers), "'."
+                )),
+                list(kind = "table", src = file.path(info$prefix, "sigmarkers.tsv"), data = list(nrows = 100))
+            )
         ),
         hs = c(info$section, info$name),
-        hs2 = "Markers",
+        hs2 = ifelse(is.null(case$ident), "Markers", paste0("Markers (", case$ident, ")")),
         ui = "tabs"
     )
 
     for (plotname in names(case$marker_plots)) {
         plotargs <- case$marker_plots[[plotname]]
         plotargs$degs <- markers
+        rownames(plotargs$degs) <- make.unique(markers$gene)
         plotargs$outprefix <- file.path(info$prefix, paste0("markers.", slugify(plotname)))
         do_call(VizDEGs, plotargs)
         reporter$add2(
@@ -185,192 +275,368 @@ process_markers <- function(markers, info, case) {
                 name = plotname,
                 contents = list(reporter$image(plotargs$outprefix, plotargs$more_formats, plotargs$save_code))),
             hs = c(info$section, info$name),
-            hs2 = "Markers",
+            hs2 = ifelse(is.null(case$ident), "Markers", paste0("Markers (", case$ident, ")")),
             ui = "tabs"
         )
     }
 
     # Do enrichment analysis
-    tryCatch({
-        enrich <- RunEnrichment(
-            markers, deg = case$sigmarkers, dbs = case$dbs, cache = case$cache,
-            error = TRUE, site = case$site)
-
-        write.table(enrich, file.path(info$prefix, "enrich.tsv"), sep = "\t", quote = FALSE, row.names = FALSE)
-        reporter$add2(
-            list(
-                name = "Table",
-                contents = list(list(kind = "table", src = file.path(info$prefix, "enrich.tsv"), data = list(nrows = 100)))
-            ),
-            hs = c(info$section, info$name),
-            hs2 = "Enrichment Analysis",
-            ui = "tabs"
+    significant_markers <- unique(sigmarkers$gene)
+    empty <- if (case$enrich_style == "enrichr") {
+        data.frame(
+            Database = character(0),
+            Term = character(0),
+            Overlap = character(0),
+            P.value = numeric(0),
+            Adjusted.P.value = numeric(0),
+            Odds.Ratio = numeric(0),
+            Combined.Score = numeric(0),
+            Genes = character(0),
+            Rank = numeric(0)
         )
+    } else {  # clusterProfiler
+        data.frame(
+            ID = character(0),
+            Description = character(0),
+            GeneRatio = character(0),
+            BgRatio = character(0),
+            Count = integer(0),
+            pvalue = numeric(0),
+            p.adjust = numeric(0),
+            qvalue = numeric(0),
+            geneID = character(0),
+            Database = character(0)
+        )
+    }
 
-        # Visualize enriched terms
-        if (length(case$enrich_plots) > 0) {
-            for (db in case$dbs) {
-                plots <- list()
-                for (plotname in names(case$enrich_plots)) {
-                    plotargs <- case$enrich_plots[[plotname]]
-                    plotargs$enrich <- enrich[enrich$db == db, , drop = FALSE]
-                    plotargs$outprefix <- file.path(info$prefix, paste0("enrich.", slugify(db), ".", slugify(plotname)))
-
-                    do_call(VizEnrich, plotargs)
-
-                    plots[[length(plots) + 1]] <- reporter$image(plotargs$outprefix, plotargs$more_formats, plotargs$save_code)
-                }
-                reporter$add2(
-                    list(name = db, contents = plots),
-                    hs = c(info$section, info$name),
-                    hs2 = "Enrichment Analysis",
-                    ui = "tabs"
-                )
-            }
-        }
-    }, error = function(e) {
+    if (length(significant_markers) < 5) {
         if (case$error) {
-            stop("Error: ", e$message)
+            stop("Error: Not enough significant markers with '", case$sigmarkers, "' in case '", info$name, "' found (< 5) for enrichment analysis.")
         } else {
-            log$warn("  ! Error: {e$message}")
+            message <- paste0("Not enough significant markers with '", case$sigmarkers, "' found (< 5) for enrichment analysis.")
+            log$warn("  ! Error: {message}")
             reporter$add2(
                 list(
                     name = "Warning",
-                    contents = list(list(kind = "error", content = e$message, kind_ = "warning"))),
+                    contents = list(list(kind = "error", content = message, kind_ = "warning"))),
                 hs = c(info$section, info$name),
                 hs2 = "Enrichment Analysis",
                 ui = "tabs"
             )
         }
-    })
-}
+        return(empty)
+    } else {
+        tryCatch({
+            enrich <- RunEnrichment(
+                significant_markers,
+                dbs = case$dbs, style = case$enrich_style)
 
-run_case <- function(name) {
-    case <- cases[[name]]
-    log$info("- Case: {name} ...")
-
-    args <- case$rest %||% list()
-    args$object <- srtobj
-    args$group.by <- case$group.by
-    args$ident.1 <- case$ident.1
-    args$ident.2 <- case$ident.2
-    args$cache <- case$cache
-    args$assay <- case$assay
-    args$error <- case$error
-    args$subset <- case$subset
-
-    markers <- do_call(RunSeuratDEAnalysis, args)
-    if (isTRUE(case_markers[[name]])) {
-        case_markers[[name]] <<- markers
-    }
-    if (is.null(case$ident.1)) {
-        if (!is.null(case_markers[[name]])) {
-            stop("Case '", name, "' for overlapping analysis must have 'ident.1' defined")
-        }
-        all_idents <- unique(markers[[case$group.by]])
-        # Visualize all markers
-        if (length(case$allmarker_plots) > 0) {
-            log$info("  Visualizing all markers ...")
-            casename <- paste0(name, "::", ifelse(case$prefix_group, paste0(case$group.by, " - All Markers"), "All Markers"))
-            info <- case_info(casename, outdir, create = TRUE)
-            for (plotname in names(case$allmarker_plots)) {
-                plotargs <- case$allmarker_plots[[plotname]]
-                plotargs$degs <- markers
-                plotargs$outprefix <- file.path(info$prefix, slugify(plotname))
-                do_call(VizDEGs, plotargs)
+            write.table(enrich, file.path(info$prefix, "enrich.tsv"), sep = "\t", quote = FALSE, row.names = FALSE)
+            reporter$add2(
+                list(
+                    name = "Table",
+                    contents = list(list(kind = "table", src = file.path(info$prefix, "enrich.tsv"), data = list(nrows = 100)))
+                ),
+                hs = c(info$section, info$name),
+                hs2 = "Enrichment Analysis",
+                ui = "tabs"
+            )
+
+            # Visualize enriched terms
+            if (length(case$enrich_plots) > 0) {
+                for (db in case$dbs) {
+                    plots <- list()
+                    for (plotname in names(case$enrich_plots)) {
+                        plotargs <- case$enrich_plots[[plotname]]
+                        plotargs$data <- enrich[enrich$Database == db, , drop = FALSE]
+
+                        p <- do_call(VizEnrichment, plotargs)
+
+                        if (plotargs$plot_type == "bar") {
+                            attr(p, "height") <- attr(p, "height") / 1.5
+                        }
+                        outprefix <- file.path(info$prefix, paste0("enrich.", slugify(db), ".", slugify(plotname)))
+                        save_plot(p, outprefix, plotargs$devpars, formats = "png")
+                        plots[[length(plots) + 1]] <- reporter$image(outprefix, c(), FALSE)
+                    }
+                    reporter$add2(
+                        list(name = db, contents = plots),
+                        hs = c(info$section, info$name),
+                        hs2 = "Enrichment Analysis",
+                        ui = "tabs"
+                    )
+                }
+            }
+            return(enrich)
+        }, error = function(e) {
+            if (case$error) {
+                stop("Error: ", e$message)
+            } else {
+                log$warn("  ! Error: {e$message}")
                 reporter$add2(
                     list(
-                        name = plotname,
-                        contents = list(reporter$image(plotargs$outprefix, plotargs$more_formats, plotargs$save_code))
-                    ),
+                        name = "Warning",
+                        contents = list(list(kind = "error", content = e$message, kind_ = "warning"))),
                     hs = c(info$section, info$name),
+                    hs2 = "Enrichment Analysis",
                     ui = "tabs"
                 )
             }
-        }
-        for (ident in all_idents) {
-            log$info("  {case$group.by}: {ident} ...")
-            ident_markers <- markers[markers[[case$group.by]] == ident, , drop = TRUE]
-            casename <- paste0(name, "::", ifelse(case$prefix_group, paste0(case$group.by, " - ", ident), ident))
-            info <- case_info(casename, outdir, create = TRUE)
+            return(empty)
+        })
+    }
+}
+
+process_allmarkers <- function(markers, plotcases, casename, groupname) {
+    name <- paste0(casename, "::", paste0(groupname, " (All Markers)"))
+    info <- case_info(name, outdir, create = TRUE)
+
+    for (plotname in names(plotcases)) {
+        plotargs <- plotcases[[plotname]]
+        plotargs$degs <- markers
+        plotargs$outprefix <- file.path(info$prefix, slugify(plotname))
+        do_call(VizDEGs, plotargs)
+        reporter$add2(
+            list(
+                name = plotname,
+                contents = list(reporter$image(plotargs$outprefix, plotargs$more_formats, plotargs$save_code))
+            ),
+            hs = c(info$section, info$name),
+            ui = "tabs"
+        )
+    }
+}
+
+process_allenriches <- function(enriches, plotcases, casename, groupname) {
+    name <- paste0(casename, "::", paste0(groupname, " (All Enrichments)"))
+    info <- case_info(name, outdir, create = TRUE)
+    dbs <- unique(as.character(enriches$Database))
+
+    for (db in dbs) {
+        plots <- list()
+        for (plotname in names(plotcases)) {
+            plotargs <- plotcases[[plotname]]
+            plotargs <- extract_vars(plotargs, "devpars")
+            plotargs$data <- enriches[enriches$Database == db, , drop = FALSE]
+            if (plotargs$plot_type == "heatmap") {
+                plotargs$group_by <- groupname
+                plotargs$show_row_names = plotargs$show_row_names %||% TRUE
+                plotargs$show_column_names = plotargs$show_column_names %||% TRUE
+            }
+
+            p <- do_call(VizEnrichment, plotargs)
 
-            process_markers(ident_markers, info = info, case = case)
+            if (plotargs$plot_type == "bar") {
+                attr(p, "height") <- attr(p, "height") / 1.5
+            }
+            outprefix <- file.path(info$prefix, paste0("allenrich.", slugify(db), ".", slugify(plotname)))
+            save_plot(p, outprefix, devpars, formats = "png")
+            plots[[length(plots) + 1]] <- reporter$image(outprefix, c(), FALSE)
         }
-    } else {
-        info <- case_info(name, outdir, create = TRUE)
-        process_markers(markers, info = info, case = case)
+        reporter$add2(
+            list(name = db, contents = plots),
+            hs = c(info$section, info$name),
+            hs2 = plotname,
+            ui = "tabs"
+        )
     }
 }
 
-sapply(names(cases), run_case)
+process_overlaps <- function(markers, ovcases, casename, groupname) {
+    name <- paste0(casename, "::", paste0(groupname, ": Overlaps"))
+    info <- case_info(name, outdir, create = TRUE)
 
-if (length(overlaps) > 0) {
-    log$info("Running overlapping cases ...")
+    for (plotname in names(ovcases)) {
+        args <- extract_vars(
+            ovcases[[plotname]],
+            sigm = "sigmarkers", "more_formats", "save_code", "devpars", "plot_type",
+            allow_nonexisting = TRUE
+        )
 
-    run_overlap <- function(ovname) {
-        ov <- overlaps[[ovname]]
-        ov$sigmarkers <- ov$sigmarkers %||% sigmarkers
-        log$info("- Overlapping case: {ovname} ...")
-        markers <- lapply(ov$cases, function(case) {
-            case_markers[[case]] %>% filter(!!parse_expr(ov$sigmarkers)) %>%
+        sigm <- sigm %||% sigmarkers
+        ugroups <- unique(markers[[groupname]])
+        m <- lapply(ugroups, function(g) {
+            markers[markers[[groupname]] == g, , drop = FALSE] %>%
+                filter(!!parse_expr(sigm)) %>%
                 pull("gene") %>% unique()
         })
-        names(markers) <- ov$cases
-        info <- case_info(paste0("OVERLAPPING::", ovname), outdir, create = TRUE)
-
-        if (ov$venn$enabled) {
-            venn <- extract_vars(ov$venn, "enabled", "more_formats", "save_code", "devpars")
-            venn$data <- markers
-            venn$in_form <- "list"
-            prefix <- file.path(info$prefix, "venn")
-            p <- do_call(gglogger::register(VennDiagram), venn)
+        names(m) <- ugroups
+
+        if (plot_type == "venn") {
+            args$data <- m
+            args$in_form <- "list"
+            prefix <- file.path(info$prefix, slugify(plotname))
+            p <- do_call(gglogger::register(VennDiagram), args)
             save_plot(p, prefix, devpars, formats = c("png", more_formats))
             if (save_code) {
                 save_plotcode(
                     p, prefix,
-                    c("library(plotthis)", "load('data.RData')", "invisible(list2env(venn, .GlobalEnv))"),
-                    "venn",
-                    auto_data_setup = FALSE)
+                    c("library(plotthis)", "load('data.RData')", "invisible(list2env(args, .GlobalEnv))"),
+                    "args",
+                    auto_data_setup = FALSE
+                )
             }
-
-            reporter$add2(
-                list(
-                    name = "Venn Diagram",
-                    contents = list(reporter$image(prefix, more_formats, save_code))
-                ),
-                hs = c(info$section, info$name),
-                ui = "tabs"
-            )
-        }
-
-        if (ov$upset$enabled) {
-            upset <- extract_vars(ov$upset, "enabled", "more_formats", "save_code", "devpars")
-            upset$data <- markers
-            upset$in_form <- "list"
-            prefix <- file.path(info$prefix, "upset")
-            p <- do_call(gglogger::register(UpsetPlot), upset)
+        } else {
+            args$data <- m
+            args$in_form <- "list"
+            prefix <- file.path(info$prefix, slugify(plotname))
+            p <- do_call(gglogger::register(UpsetPlot), args)
             save_plot(p, prefix, devpars, formats = c("png", more_formats))
             if (save_code) {
                 save_plotcode(
                     p, prefix,
-                    c("library(plotthis)", "load('data.RData')", "invisible(list2env(upset, .GlobalEnv))"),
-                    "upset",
-                    auto_data_setup = FALSE)
+                    c("library(plotthis)", "load('data.RData')", "invisible(list2env(args, .GlobalEnv))"),
+                    "args",
+                    auto_data_setup = FALSE
+                )
+            }
+        }
+
+        reporter$add2(
+            list(
+                name = plotname,
+                contents = list(reporter$image(prefix, more_formats, save_code))
+            ),
+            hs = c(info$section, info$name),
+            ui = "tabs"
+        )
+    }
+}
+
+run_case <- function(name) {
+    case <- cases[[name]]
+    log$info("Case: {name} ...")
+
+    case <- extract_vars(
+        case,
+        "dbs", "sigmarkers", "allmarker_plots", "allenrich_plots", "marker_plots", "enrich_plots",
+        "overlaps", "original_case", "markers", "enriches", "each_name", "each", "enrich_style",
+        allow_nonexisting = TRUE
+    )
+
+    if (!is.null(markers) || !is.null(enriches)) {
+        if (!is.null(markers)) {  # It is the overlap/allmarker case
+            log$info("- Summarizing markers in subcases (by each: {each}) ...")
+            # handle the overlaps / allmarkers analysis here
+            if (!is.data.frame(markers)) {
+                each_levels <- names(markers)
+                markers <- do_call(rbind, lapply(each_levels, function(x) {
+                    markers_df <- markers[[x]]
+                    if (nrow(markers_df) > 0) {
+                        markers_df[[each]] <- x
+                    } else {
+                        markers_df[[each]] <- character(0)  # Empty case
+                    }
+                    markers_df
+                }))
+                markers[[each]] <- factor(markers[[each]], levels = each_levels)
+            }
+            # gene, p_val, avg_log2FC, pct.1, pct.2, p_val_adj, diff_pct, <each>
+
+            if (length(allmarker_plots) > 0) {
+                log$info("- Visualizing all markers together ...")
+                attr(markers, "object") <- srtobj
+                attr(markers, "group.by") <- each
+                attr(markers, "ident.1") <- NULL
+                attr(markers, "ident.2") <- NULL
+                process_allmarkers(markers, allmarker_plots, name, each)
+            }
+
+            if (length(overlaps) > 0) {
+                log$info("- Visualizing overlaps between subcases ...")
+                process_overlaps(markers, overlaps, name, each)
             }
 
-            reporter$add2(
-                list(
-                    name = "UpSet Plot",
-                    contents = list(reporter$image(prefix, more_formats, save_code))
-                ),
-                hs = c(info$section, info$name),
-                ui = "tabs"
-            )
         }
 
+        if (!is.null(enriches)) {
+            log$info("- Summarizing enrichments in subcases (by each: {each}) ...")
+            if (!is.data.frame(enriches)) {
+                each_levels <- names(enriches)
+                enriches <- do_call(rbind, lapply(each_levels, function(x) {
+                    enrich_df <- enriches[[x]]
+                    if (nrow(enrich_df) > 0) {
+                        enrich_df[[each]] <- x
+                    } else {
+                        enrich_df[[each]] <- character(0)  # Empty case
+                    }
+                    enrich_df
+                }))
+                enriches[[each]] <- factor(enriches[[each]], levels = each_levels)
+            }
+
+            if (length(allenrich_plots) > 0) {
+                log$info("- Visualizing all enrichments together ...")
+                process_allenriches(enriches, allenrich_plots, name, each)
+            }
+        }
+
+        return(invisible())
+    }
+
+    case$object <- srtobj
+    markers <- do_call(RunSeuratDEAnalysis, case)
+    case$object <- NULL
+    gc()
+
+    if (is.null(case$ident.1)) {
+        all_idents <- unique(as.character(markers[[case$group.by]]))
+        enriches <- list()
+        for (ident in all_idents) {
+            log$info("- {case$group.by}: {ident} ...")
+            ident_markers <- markers[markers[[case$group.by]] == ident, , drop = TRUE]
+            casename <- paste0(name, "::", paste0(case$group.by, ": ", ident))
+            info <- case_info(casename, outdir, create = TRUE)
+
+            attr(ident_markers, "ident.1") <- ident
+            enrich <- process_markers(ident_markers, info = info, case = list(
+                dbs = dbs,
+                sigmarkers = sigmarkers,
+                enrich_style = enrich_style,
+                marker_plots = marker_plots,
+                enrich_plots = enrich_plots,
+                error = case$error,
+                ident = NULL
+            ))
+            enriches[[ident]] <- enrich
+        }
+
+        if (length(allmarker_plots) > 0) {
+            log$info("- Visualizing all markers together ...")
+            process_allmarkers(markers, allmarker_plots, name, case$group.by)
+        }
+
+        if (length(overlaps) > 0) {
+            log$info("- Visualizing overlaps between subcases ...")
+            process_overlaps(markers, overlaps, name, case$group.by)
+        }
+
+        if (length(allenrich_plots) > 0) {
+            log$info("- Visualizing all enrichments together ...")
+            process_allenriches(enriches, allenrich_plots, name, case$group.by)
+        }
+    } else {
+        info <- case_info(name, outdir, create = TRUE)
+        enrich <- process_markers(markers, info = info, case = list(
+            dbs = dbs,
+            sigmarkers = sigmarkers,
+            enrich_style = enrich_style,
+            marker_plots = marker_plots,
+            enrich_plots = enrich_plots,
+            error = case$error,
+            ident = if (is.null(case$ident.2)) case$ident.1 else paste0(case$ident.1, " vs ", case$ident.2)
+        ))
+
+        if (!is.null(original_case) && !is.null(cases[[original_case]])) {
+            markers[[each_name]] <- each
+            cases[[original_case]]$markers[[each]] <<- markers
+            cases[[original_case]]$enriches[[each]] <<- enrich
+        }
     }
 
-    sapply(names(overlaps), run_overlap)
+    invisible()
 }
 
+sapply(names(cases), run_case)
+
 reporter$save(joboutdir)