biopipen 0.27.6__tar.gz → 0.27.8__tar.gz

{biopipen-0.27.6 → biopipen-0.27.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biopipen
-Version: 0.27.6
+Version: 0.27.8
 Summary: Bioinformatics processes/pipelines that can be run from `pipen run`
 License: MIT
 Author: pwwang

biopipen-0.27.8/biopipen/__init__.py

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

{biopipen-0.27.6 → biopipen-0.27.8}/biopipen/core/filters.py

@@ -235,8 +235,8 @@ def _render_fgsea(
     with Path(cont["dir"]).joinpath("fgsea.txt").open() as f:
         next(f)  # skip header
         for line in f:
-            pathway, _ = line.split("\t", 1)
-            pathways.append(pathway)
+            items = line.strip().split("\t")
+            pathways.append((items[0], items[-1]))
             if len(pathways) >= n_pathways:
                 break
 
@@ -263,6 +263,7 @@ def _render_fgsea(
                         {
                             "kind": "table",
                             "src": str(Path(cont["dir"]).joinpath("fgsea.txt")),
+                            "data": {"excluded": {"slug"}},
                         }
                     ],
                 },
@@ -274,10 +275,10 @@ def _render_fgsea(
             "ui": "table_of_images",
             "contents": [
                 {
-                    "src": str(Path(cont["dir"]) / f"fgsea_{pw.replace('/', '-')}.png"),
+                    "src": str(Path(cont["dir"]) / f"fgsea_{slug}.png"),
                     "title": pw,
                 }
-                for pw in pathways
+                for pw, slug in pathways
             ]
         },
     ]

{biopipen-0.27.6 → biopipen-0.27.8}/biopipen/ns/scrna.py

@@ -1241,7 +1241,7 @@ class TopExpressingGenes(Proc):
     }
 
 
-class ExprImpution(Proc):
+class ExprImputation(Proc):
     """This process imputes the dropout values in scRNA-seq data.
 
     It takes the Seurat object as input and outputs the Seurat object with
@@ -1317,13 +1317,13 @@ class ExprImpution(Proc):
         },
         "alra_args": {},
     }
-    script = "file://../scripts/scrna/ExprImpution.R"
+    script = "file://../scripts/scrna/ExprImputation.R"
 
 
 class SCImpute(Proc):
     """Impute the dropout values in scRNA-seq data.
 
-    Deprecated. Use `ExprImpution` instead.
+    Deprecated. Use `ExprImputation` instead.
 
     Input:
         infile: The input file for imputation
@@ -1769,13 +1769,18 @@ class SeuratMap2Ref(Proc):
         sobjfile: The seurat object
 
     Output:
-        outfile: The rds file of seurat object with cell type annotated
+        outfile: The rds file of seurat object with cell type annotated.
+            Note that the reduction name will be `ref.umap` for the mapping.
+            To visualize the mapping, you should use `ref.umap` as the reduction name.
 
     Envs:
         ncores (type=int;order=-100): Number of cores to use.
-            Used in `future::plan(strategy = "multicore", workers = <ncores>)`
+            When `split_by` is used, this will be the number of cores for each object to map to the reference.
+            When `split_by` is not used, this is used in `future::plan(strategy = "multicore", workers = <ncores>)`
             to parallelize some Seurat procedures.
-            See also: <https://satijalab.org/seurat/articles/future_vignette.html>
+            See also: <https://satijalab.org/seurat/archive/v3.0/future_vignette.html>
+        mutaters (type=json): The mutaters to mutate the metadata.
+            This is helpful when we want to create new columns for `split_by`.
         use: A column name of metadata from the reference
             (e.g. `celltype.l1`, `celltype.l2`) to transfer to the query as the
             cell types (ident) for downstream analysis. This field is required.
@@ -1787,16 +1792,29 @@ class SeuratMap2Ref(Proc):
             `Seurat::LoadH5Seurat()`.
             The file type is determined by the extension. `.rds` or `.RDS` for
             RDS file, `.h5seurat` or `.h5` for h5seurat file.
+        refnorm (choice): Normalization method the reference used. The same method will be used for the query.
+            - NormalizeData: Using [`NormalizeData`](https://satijalab.org/seurat/reference/normalizedata).
+            - SCTransform: Using [`SCTransform`](https://satijalab.org/seurat/reference/sctransform).
+            - auto: Automatically detect the normalization method.
+                If the default assay of reference is `SCT`, then `SCTransform` will be used.
+        split_by: The column name in metadata to split the query into multiple objects.
+            This helps when the original query is too large to process.
         SCTransform (ns): Arguments for [`SCTransform()`](https://satijalab.org/seurat/reference/sctransform)
             - do-correct-umi (flag): Place corrected UMI matrix in assay counts layer?
             - do-scale (flag): Whether to scale residuals to have unit variance?
             - do-center (flag): Whether to center residuals to have mean zero?
             - <more>: See <https://satijalab.org/seurat/reference/sctransform>.
                 Note that the hyphen (`-`) will be transformed into `.` for the keys.
+        NormalizeData (ns): Arguments for [`NormalizeData()`](https://satijalab.org/seurat/reference/normalizedata)
+            - normalization-method: Normalization method.
+            - <more>: See <https://satijalab.org/seurat/reference/normalizedata>.
+                Note that the hyphen (`-`) will be transformed into `.` for the keys.
         FindTransferAnchors (ns): Arguments for [`FindTransferAnchors()`](https://satijalab.org/seurat/reference/findtransferanchors)
             - normalization-method (choice): Name of normalization method used.
                 - LogNormalize: Log-normalize the data matrix
                 - SCT: Scale data using the SCTransform method
+                - auto: Automatically detect the normalization method.
+                    See `envs.refnorm`.
             - reference-reduction: Name of dimensional reduction to use from the reference if running the pcaproject workflow.
                 Optionally enables reuse of precomputed reference dimensional reduction.
             - <more>: See <https://satijalab.org/seurat/reference/findtransferanchors>.
@@ -1822,14 +1840,19 @@ class SeuratMap2Ref(Proc):
         "ncores": config.misc.ncores,
         "use": None,
         "ident": "seurat_clusters",
+        "mutaters": {},
         "ref": None,
+        "refnorm": "auto",
+        "split_by": None,
         "SCTransform": {
             "do-correct-umi": False,
             "do-scale": False,
             "do-center": True,
         },
+        "NormalizeData": {
+            "normalization-method": "LogNormalize",
+        },
         "FindTransferAnchors": {
-            "normalization-method": "SCT",
             "reference-reduction": "spca",
         },
         "MapQuery": {

{biopipen-0.27.6 → biopipen-0.27.8}/biopipen/ns/scrna_metabolic_landscape.py

@@ -566,8 +566,8 @@ class ScrnaMetabolicLandscape(ProcGroup):
             input_data = lambda ch: tibble(
                 srtobj=ch.iloc[:, 0],
                 metafile=[None],
-                mutaters=[self.opts.mutaters],
             )
+            envs = {"mutaters": self.opts.mutaters}
 
         return MetabolicSeuratMetadataMutater
 
@@ -577,10 +577,10 @@ class ScrnaMetabolicLandscape(ProcGroup):
         if self.opts.noimpute:
             return self.p_mutater
 
-        from .scrna import ExprImpution
+        from .scrna import ExprImputation
 
         @annotate.format_doc(indent=3)
-        class MetabolicExprImpution(ExprImpution):
+        class MetabolicExprImputation(ExprImputation):
             """{{Summary}}
 
             You can turn off the imputation by setting the `noimpute` option
@@ -588,7 +588,7 @@ class ScrnaMetabolicLandscape(ProcGroup):
             """
             requires = self.p_mutater
 
-        return MetabolicExprImpution
+        return MetabolicExprImputation
 
     @ProcGroup.add_proc
     def p_pathway_activity(self) -> Type[Proc]:

biopipen-0.27.8/biopipen/scripts/scrna/ExprImputation.R

@@ -0,0 +1,7 @@
+{% if envs.tool == "rmagic" %}
+{% include biopipen_dir + "/scripts/scrna/ExprImputation-rmagic.R" %}
+{% elif envs.tool == "scimpute" %}
+{% include biopipen_dir + "/scripts/scrna/ExprImputation-scimpute.R" %}
+{% elif envs.tool == "alra" %}
+{% include biopipen_dir + "/scripts/scrna/ExprImputation-alra.R" %}
+{% endif %}

{biopipen-0.27.6 → biopipen-0.27.8}/biopipen/scripts/scrna/SeuratClusterStats-stats.R

@@ -38,7 +38,7 @@ do_one_stats = function(name) {
         df_cells = df_cells %>% filter(!!rlang::parse_expr(case$subset))
     }
 
-    select_cols = c(case$ident, case$group.by, case$split.by)
+    select_cols = unique(c(case$ident, case$group.by, case$split.by))
     if (!is.null(case$split.by)) {
         plot_df = do_call(rbind, lapply(group_split(
             df_cells %>% select(all_of(select_cols)),

biopipen-0.27.8/biopipen/scripts/scrna/SeuratMap2Ref.R

@@ -0,0 +1,302 @@
+source("{{biopipen_dir}}/utils/misc.R")
+
+library(parallel)
+library(Seurat)
+library(SeuratDisk)
+library(rlang)
+library(dplyr)
+
+set.seed(8525)
+
+sobjfile = {{in.sobjfile | r}}
+outfile = {{out.outfile | r}}
+use = {{envs.use | r}}
+ident = {{envs.ident | r}}
+ref = {{envs.ref | r}}
+refnorm = {{envs.refnorm | r}}
+ncores = {{envs.ncores | r}}
+split_by = {{envs.split_by | r}}
+mutaters = {{envs.mutaters | r}}
+sctransform_args = {{envs.SCTransform | r: todot="-"}}
+normalizedata_args = {{envs.NormalizeData | r: todot="-"}}
+findtransferanchors_args = {{envs.FindTransferAnchors | r: todot="-"}}
+mappingscore_args = {{envs.MappingScore | r: todot="-"}}
+mapquery_args = {{envs.MapQuery | r: todot="-"}}
+
+# See if we have a reference
+if (is.null(ref)) {
+    stop("No reference provided (envs.ref)")
+}
+
+if (is.null(use)) {
+    stop("No use provided (envs.use), don't know which column to transfer as cluster")
+}
+
+if (is.null(mapquery_args$refdata) || length(mapquery_args$refdata) == 0) {
+    mapquery_args$refdata = list()
+}
+
+mapquery_args$refdata[[use]] = use
+
+outdir = dirname(outfile)
+if (is.null(split_by)) {
+    options(future.globals.maxSize = 80000 * 1024^2)
+    future::plan(strategy = "multicore", workers = 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
+}
+findtransferanchors_args = .expand_dims(findtransferanchors_args)
+
+# Load reference
+log_info("- Loading reference")
+if (endsWith(ref, ".rds") || endsWith(ref, ".RDS")) {
+    reference = readRDS(ref)
+} else if (endsWith(ref, ".h5ad") || endsWith(ref, ".H5AD")) {
+    reference = ReadH5AD(ref)
+} else {
+    reference = LoadH5Seurat(ref)
+}
+
+if (refnorm == "auto" && DefaultAssay(reference) == "SCT") {
+    refnorm = "SCTransform"
+}
+log_info("  Normalization method used: {refnorm}")
+if (refnorm == "SCTransform") {
+    findtransferanchors_args$normalization.method = "SCT"
+} else if (refnorm == "NormalizeData") {
+    findtransferanchors_args$normalization.method = "LogNormalize"
+} else {
+    stop("Unknown normalization method: {refnorm}")
+}
+
+# Load Seurat object
+log_info("- Loading Seurat object")
+sobj = readRDS(sobjfile)
+
+if (!is.null(mutaters) && length(mutaters) > 0) {
+    log_info("- Applying mutaters")
+    sobj@meta.data <- sobj@meta.data %>% mutate(!!!lapply(mutaters, parse_expr))
+}
+
+if (!is.null(split_by)) {
+    # check if each split has more than 100 cells
+    cellno = table(sobj@meta.data[[split_by]])
+    cellno = cellno[cellno < 100]
+    if (length(cellno) > 0) {
+        # stop and print the splits with # cells
+        stop(paste0(
+            "The following splits have less than 100 cells: \n",
+            paste0("- ", names(cellno), ": ", cellno, collapse = "\n"),
+            "\n\n",
+            "You can use `envs.mutaters` to merge these splits and use `newsplit` as `envs.split_by`: \n",
+            "> mutaters = {\n",
+            ">   newsplit = \"if_else(oldsplit %in% c('split1', 'split2'), 'mergedsplit', oldsplit)\"\n",
+            "> }\n"
+        ))
+    }
+    sobj = SplitObject(sobj, split.by = split_by)
+}
+
+# Normalize data
+log_info("- Normalizing data")
+if (refnorm == "SCTransform") {
+    log_info("  Using SCTransform normalization")
+    sctransform_args$residual.features = rownames(x = reference)
+    if (is.null(split_by)) {
+        sctransform_args$object = sobj
+        query = do_call(SCTransform, sctransform_args)
+    } else {
+        query = mclapply(
+            X = sobj,
+            FUN = function(x) {
+                sctransform_args$object = x
+                do_call(SCTransform, sctransform_args)
+            },
+            mc.cores = ncores
+        )
+        if (any(unlist(lapply(query, class)) == "try-error")) {
+            stop(paste0("\nmclapply (SCTransform) error:", query))
+        }
+    }
+} else {
+    log_info("  Using NormalizeData normalization")
+    if (is.null(split_by)) {
+        normalizedata_args$object = sobj
+        query = do_call(NormalizeData, normalizedata_args)
+    } else {
+        query = mclapply(
+            X = sobj,
+            FUN = function(x) {
+                normalizedata_args$object = x
+                do_call(NormalizeData, normalizedata_args)
+            },
+            mc.cores = ncores
+        )
+        if (any(unlist(lapply(query, class)) == "try-error")) {
+            stop(paste0("\nmclapply (NormalizeData) error:", query))
+        }
+    }
+}
+
+# Find anchors between query and reference
+log_info("- Finding anchors")
+findtransferanchors_args$reference = reference
+if (is.null(split_by)) {
+    findtransferanchors_args$query = query
+    anchors = do_call(FindTransferAnchors, findtransferanchors_args)
+} else {
+    anchors = mclapply(
+        X = query,
+        FUN = function(x) {
+            findtransferanchors_args$query = x
+            do_call(FindTransferAnchors, findtransferanchors_args)
+        },
+        mc.cores = ncores
+    )
+    if (any(unlist(lapply(anchors, class)) == "try-error")) {
+        stop(paste0("\nmclapply (FindTransferAnchors) error:", anchors))
+    }
+}
+
+# Map query to reference
+log_info("- Mapping query to reference")
+mapquery_args$reference = reference
+if (is.null(split_by)) {
+    mapquery_args$query = query
+    mapquery_args$anchorset = anchors
+    query = do_call(MapQuery, mapquery_args)
+} else {
+    query = mclapply(
+        X = seq_along(query),
+        FUN = function(i) {
+            mapquery_args$query = query[[i]]
+            mapquery_args$anchorset = anchors[[i]]
+            do_call(MapQuery, mapquery_args)
+        },
+        mc.cores = ncores
+    )
+    if (any(unlist(lapply(query, class)) == "try-error")) {
+        stop(paste0("\nmclapply (MapQuery) error:", query))
+    }
+}
+
+# Calculating mapping score
+log_info("- Calculating mapping score")
+mappingscore_sob_msg = paste0(
+    "While calculating mapping score, the following error was encountered: \n",
+    "subscript out of bounds.  \n\n",
+    "You may want to try a smaller `ndim` (default: 50) in `envs.MappingScore`."
+)
+if (is.null(split_by)) {
+    mappingscore_args$anchors = anchors
+    mappingscore = tryCatch({
+        do_call(MappingScore, mappingscore_args)
+    }, error = function(e) {
+        if (e$message == "subscript out of bounds") stop(mappingscore_sob_msg)
+        stop(e)
+    })
+} else {
+    mappingscore = mclapply(
+        X = seq_along(query),
+        FUN = function(i) {
+            mappingscore_args$anchors = anchors[[i]]
+            tryCatch({
+                do_call(MappingScore, mappingscore_args)
+            }, error = function(e) {
+                if (e$message == "subscript out of bounds") stop(mappingscore_sob_msg)
+                stop(e)
+            })
+        },
+        mc.cores = ncores
+    )
+    if (any(unlist(lapply(mappingscore, class)) == "try-error")) {
+        stop(paste0("\nmclapply (MappingScore) error:", mappingscore))
+    }
+}
+
+# Calculate mapping score and add to metadata
+log_info("- Adding mapping score to metadata")
+if (is.null(split_by)) {
+    query = AddMetaData(
+        object = query,
+        metadata = mappingscore,
+        col.name = "mapping.score"
+    )
+} else {
+    query = mclapply(
+        X = seq_along(query),
+        FUN = function(i) {
+            AddMetaData(
+                object = query[[i]],
+                metadata = mappingscore[[i]],
+                col.name = "mapping.score"
+            )
+        },
+        mc.cores = ncores
+    )
+    if (any(unlist(lapply(query, class)) == "try-error")) {
+        stop(paste0("\nmclapply (AddMetaData) error:", query))
+    }
+
+    # Combine the results
+    log_info("- Merging the results")
+    query = merge(query[[1]], query[2:length(query)], merge.dr = "ref.umap")
+}
+
+# Add the alias to the metadata for the clusters
+log_info("- Adding ident to metadata and set as ident")
+query@meta.data = query@meta.data %>% mutate(
+    !!sym(ident) := as.factor(!!parse_expr(paste0("predicted.", use)))
+)
+Idents(query) = ident
+
+# Save
+log_info("- Saving result ...")
+saveRDS(query, file = outfile)
+
+
+# ############################
+# Some plots
+# ############################
+
+# # Plot the UMAP
+log_info("- Plotting for transferred data ...")
+ref.reduction = mapquery_args$reduction.model %||% "wnn.umap"
+for (qname in names(mapquery_args$refdata)) {
+    rname <- mapquery_args$refdata[[qname]]
+
+    if (grepl("Array", class(reference[[rname]])) && grepl("Array", class(query[[qname]]))) {
+        log_warn("  Skipping transferred array: {qname} -> {rname}")
+        next
+    }
+
+    log_info("  Plotting transferred data: {qname} -> {rname}")
+
+    ref_p <- DimPlot(
+        object = reference,
+        reduction = ref.reduction,
+        group.by = rname,
+        label = TRUE,
+        label.size = 3,
+        repel = TRUE,
+    ) + NoLegend()
+
+    query_p <- DimPlot(
+        object = query,
+        reduction = "ref.umap",
+        group.by = paste0("predicted.", qname),
+        label = TRUE,
+        label.size = 3,
+        repel = TRUE,
+    ) + NoLegend()
+
+    png(file.path(outdir, paste0("UMAPs.png")), width = 1400, height = 700, res = 100)
+    print(ref_p | query_p)
+    dev.off()
+}

{biopipen-0.27.6 → biopipen-0.27.8}/biopipen/scripts/scrna_metabolic_landscape/MetabolicFeatures.R

@@ -50,8 +50,18 @@ do_one_group <- function(obj, features, group, outputdir, h1) {
     classes[classes != group] <- "_REST"
     classes[classes == group] <- groupname
     if (any(table(classes) < 5)) {
-        msg <- paste("Group", group, "has less than 5 cells, or only 5 cells left.")
+        msg <- paste("  Skipped. One of the groups has less than 5 cells.")
         log_warn(msg)
+        # write a warning.txt to odir with the message and table(classes)
+        write(paste0(msg, "\n\n"), file = file.path(odir, "warning.txt"))
+        write.table(
+            table(classes),
+            file = file.path(odir, "warning.txt"),
+            sep = "\t",
+            quote = FALSE,
+            row.names = FALSE,
+            append = TRUE
+        )
         return(
             list(
                 list(kind = "error", content = msg),

{biopipen-0.27.6 → biopipen-0.27.8}/biopipen/scripts/scrna_metabolic_landscape/MetabolicFeaturesIntraSubset.R

@@ -84,14 +84,18 @@ 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) {
-        log_warn("          Skip (not enough cells)")
-        add_report(
+    if (ncol(exprs_case) < 5 || ncol(exprs_control) < 5) {
+        log_warn("  Skipped (not enough cells).")
+        wfile <- file.path(odir, "warning.txt")
+        write("Skipped (not enough cells)\n\n", file = wfile)
+        write(paste0("n_cells (Case):", ncol(exprs_case)), file = wfile, append = TRUE)
+        write(paste0("n_cells (Control):", ncol(exprs_control)), file = wfile, append = TRUE)
+
+        return(list(
             list(kind = "error", content = "Not enough cells"),
             h1 = groupname,
             h2 = compname
-        )
-        return (NULL)
+        ))
     }
     if (fgsea) {
         ranks = prerank(

{biopipen-0.27.6 → biopipen-0.27.8}/biopipen/utils/gsea.R

@@ -2,11 +2,36 @@ library(ggplot2)
 library(dplyr)
 library(tibble)
 
-.slugify <- function(x, non_alphanum_replace="-", collapse_replace=TRUE, tolower=FALSE) {
-    x <- gsub("[^[:alnum:]_]", non_alphanum_replace, x)
-    if(collapse_replace) x <- gsub(paste0(non_alphanum_replace, "+"), non_alphanum_replace, x)
-    if(tolower) x <- tolower(x)
-    x
+if (!exists("slugify")) {
+    slugify <- function(x, non_alphanum_replace="-", collapse_replace=TRUE, tolower=FALSE) {
+        subs <- list(
+            "š"="s", "œ"="oe", "ž"="z", "ß"="ss", "þ"="y", "à"="a", "á"="a", "â"="a",
+            "ã"="a", "ä"="a", "å"="a", "æ"="ae", "ç"="c", "è"="e", "é"="e", "ê"="e",
+            "ë"="e", "ì"="i", "í"="i", "î"="i", "ï"="i", "ð"="d", "ñ"="n", "ò"="o",
+            "ó"="o", "ô"="o", "õ"="o", "ö"="o", "ø"="oe", "ù"="u", "ú"="u", "û"="u",
+            "ü"="u", "ý"="y", "ÿ"="y", "ğ"="g", "ı"="i", "ij"="ij", "ľ"="l", "ň"="n",
+            "ř"="r", "ş"="s", "ť"="t", "ų"="u", "ů"="u", "ý"="y", "ź"="z", "ż"="z",
+            "ſ"="s", "α"="a", "β"="b", "γ"="g", "δ"="d", "ε"="e", "ζ"="z", "η"="h",
+            "θ"="th", "ι"="i", "κ"="k", "λ"="l", "μ"="m", "ν"="n", "ξ"="x", "ο"="o",
+            "π"="p", "ρ"="r", "σ"="s", "τ"="t", "υ"="u", "φ"="ph", "χ"="ch", "ψ"="ps",
+            "ω"="o", "ά"="a", "έ"="e", "ή"="h", "ί"="i", "ό"="o", "ύ"="u", "ώ"="o",
+            "ϐ"="b", "ϑ"="th", "ϒ"="y", "ϕ"="ph", "ϖ"="p", "Ϛ"="st", "ϛ"="st", "Ϝ"="f",
+            "ϝ"="f", "Ϟ"="k", "ϟ"="k", "Ϡ"="k", "ϡ"="k", "ϰ"="k", "ϱ"="r", "ϲ"="s",
+            "ϳ"="j", "ϴ"="th", "ϵ"="e", "϶"="p"
+        )
+        # replace latin and greek characters to the closest english character
+        for (k in names(subs)) {
+            x <- gsub(k, subs[[k]], x)
+        }
+        x <- gsub("[^[:alnum:]_]", non_alphanum_replace, x)
+        if(collapse_replace) x <- gsub(
+            paste0(gsub("([][{}()+*^$|\\\\?.])", "\\\\\\1", non_alphanum_replace), "+"),
+            non_alphanum_replace,
+            x
+        )
+        if(tolower) x <- tolower(x)
+        x
+    }
 }
 
 localizeGmtfile <- function(gmturl, cachedir = tempdir()) {
@@ -25,7 +50,12 @@ localizeGmtfile <- function(gmturl, cachedir = tempdir()) {
         if (nrow(items) == 0) {
             stop(paste0("Empty GMT file: ", gmtfile, ", from ", gmturl))
         }
-        if (nchar(items$V2[1]) < nchar(items$V1[1]) && nchar(items$V2[1]) > 0) {
+        if (
+            is.character(items$V2[1]) &&
+            nchar(items$V2[1]) < nchar(items$V1[1]) &&
+            nchar(items$V2[1]) > 0 &&
+            is.na(suppressWarnings(as.numeric(items$V2[1])))
+        ) {
             warning(paste0(
                 "The second column is shorter, switching the first and second columns in GMT file ",
                 gmtfile,
@@ -153,7 +183,8 @@ runFGSEA = function(
 
     write.table(
         gsea_res %>%
-            mutate(leadingEdge = sapply(leadingEdge, function(x) paste(x, collapse=","))),
+            mutate(leadingEdge = sapply(leadingEdge, function(x) paste(x, collapse=",")),
+                   slug = sapply(pathway, slugify)),
         file = file.path(outdir, "fgsea.txt"),
         row.names = FALSE,
         col.names = TRUE,
@@ -172,16 +203,16 @@ runFGSEA = function(
 
     tablefig = file.path(outdir, "gsea_table.png")
     png(tablefig, res=100, width=1000, height=200 + 40 * length(topPathways))
-    plotGseaTable(
+    print(plotGseaTable(
         envs$pathways[topPathways],
         ranks,
         gsea_res,
         gseaParam = if (!is.null(envs$gseaParam)) envs$gseaParam else 1
-    )
+    ))
     dev.off()
 
     for (pathway in topPathways) {
-        enrfig = file.path(outdir, paste0("fgsea_", .slugify(pathway), ".png"))
+        enrfig = file.path(outdir, paste0("fgsea_", slugify(pathway), ".png"))
         png(enrfig, res=100, width=1000, height=800)
         print(plotEnrichment(
             envs$pathways[[pathway]],

{biopipen-0.27.6 → biopipen-0.27.8}/biopipen/utils/misc.R

@@ -33,6 +33,7 @@ bQuote <- function(x) {
 }
 
 #' Slugify a string
+#' Remember also update the one in gsea.R
 #' @param x A string
 #' @param non_alphanum_replace Replace non-alphanumeric characters
 #' @param collapse_replace Collapse consecutive non-alphanumeric character replacements

{biopipen-0.27.6 → biopipen-0.27.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "biopipen"
-version = "0.27.6"
+version = "0.27.8"
 description = "Bioinformatics processes/pipelines that can be run from `pipen run`"
 authors = ["pwwang <pwwang@pwwang.com>"]
 license = "MIT"

{biopipen-0.27.6 → biopipen-0.27.8}/setup.py

@@ -81,7 +81,7 @@ entry_points = \
 
 setup_kwargs = {
     'name': 'biopipen',
-    'version': '0.27.6',
+    'version': '0.27.8',
     'description': 'Bioinformatics processes/pipelines that can be run from `pipen run`',
     'long_description': 'None',
     'author': 'pwwang',

biopipen-0.27.6/biopipen/__init__.py

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

biopipen-0.27.6/biopipen/scripts/scrna/ExprImpution.R

@@ -1,7 +0,0 @@
-{% if envs.tool == "rmagic" %}
-{% include biopipen_dir + "/scripts/scrna/ExprImpution-rmagic.R" %}
-{% elif envs.tool == "scimpute" %}
-{% include biopipen_dir + "/scripts/scrna/ExprImpution-scimpute.R" %}
-{% elif envs.tool == "alra" %}
-{% include biopipen_dir + "/scripts/scrna/ExprImpution-alra.R" %}
-{% endif %}