biopipen 0.25.4__py3-none-any.whl → 0.26.1__py3-none-any.whl

biopipen/scripts/stats/LiquidAssoc.R

@@ -0,0 +1,136 @@
+source("{{biopipen_dir}}/utils/misc.R")
+
+library(rlang)
+library(dplyr)
+library(tidyr)
+library(fastLiquidAssociation)
+
+infile <- {{in.infile | r}}
+covfile <- {{in.covfile | r}}
+groupfile <- {{in.groupfile | r}}
+fmlfile <- {{in.fmlfile | r}}
+outfile <- {{out.outfile | r}}
+x <- {{envs.x | r}}
+nvec <- {{envs.nvec | r}}
+topn <- {{envs.topn | r}}
+rvalue <- {{envs.rvalue | r}}
+cut <- {{envs.cut | r}}
+ncores <- {{envs.ncores | r}}
+padj <- {{envs.padj | r}}
+transpose_input <- {{envs.transpose_input | r}}
+transpose_group <- {{envs.transpose_group | r}}
+transpose_cov <- {{envs.transpose_cov | r}}
+xyz_names <- {{envs.xyz_names | r}}
+if (!is.null(xyz_names) && length(xyz_names) == 1) {
+	xyz_names <- trimws(strsplit(xyz_names, ",")[[1]])
+}
+
+if (is.null(groupfile) && is.null(nvec)) {
+	stop("Must provide either in.groupfile or envs.nvec")
+}
+if (!is.null(groupfile) && !is.null(nvec)) {
+	stop("Must provide either in.groupfile or envs.nvec, not both")
+}
+
+log_info("Reading and preparing data ...")
+indata <- read.table(infile, header = TRUE, sep = "\t", row.names = 1, check.names = FALSE)
+if (transpose_input) {
+	indata <- t(indata)
+}
+if (!is.null(covfile)) {
+	covdata <- read.table(covfile, header = TRUE, sep = "\t", row.names = 1)
+	if (transpose_cov) {
+		covdata <- t(covdata)
+	}
+	if (!isTRUE(all.equal(rownames(indata), rownames(covdata)))) {
+		stop("Row names of indata and covdata must be identical")
+	}
+	indata <- indata %>% mutate(across(everything(), function(xx) {
+		lm(xx ~ as.matrix(covdata))$residuals
+	}))
+}
+
+expand_range <- function(range) {
+	items <- trimws(strsplit(range, ",|-")[[1]])
+	num_items <- as.numeric(items)
+	if (anyNA(num_items)) {
+		# it's sample names
+		return(match(items, colnames(indata)))
+	}
+	return(num_items)
+}
+
+cut <- cut %||% max(ceiling(nrow(indata)/22), 4)
+if (!is.null(x)) { x <- expand_range(x) }
+if (!is.null(groupfile)) {
+	groupdata <- read.table(groupfile, header = TRUE, sep = "\t", row.names = 1)
+	if (transpose_group) {
+		groupdata <- t(groupdata)
+	}
+	if (!isTRUE(all.equal(rownames(indata), rownames(groupdata)))) {
+		stop("Row names of indata and groupdata must be identical")
+	}
+	nvec <- (ncol(indata) + 1) : (ncol(indata) + ncol(groupdata))
+	indata <- cbind(indata, groupdata)
+} else {
+	nvec <- expand_range(nvec)
+}
+
+log_info("Running fastLiquidAssociation ...")
+indata <- as.matrix(indata)
+mla <- fastMLA(
+	data = indata,
+	topn = topn,
+	rvalue = rvalue,
+	cut = cut,
+	threads = ncores,
+	nvec = nvec
+)
+
+if (nrow(mla) == 0) {
+	log_warn("No significant associations found")
+	out <- data.frame(
+		X12 = character(),
+		X21 = character(),
+		X3 = character(),
+		rhodiff = numeric(),
+		`MLA.value` = numeric(),
+		estimates = numeric(),
+		`san.se` = numeric(),
+		wald = numeric(),
+		Pval = numeric(),
+		model = character()
+	)
+} else {
+	cnm <- mass.CNM(data = indata, GLA.mat = mla, nback = topn)
+	out <- cnm$`top p-values` %>%
+		dplyr::select(X12 = "X1 or X2", X21 = "X2 or X1", everything(), Pval = "p value")
+}
+
+if (!is.null(fmlfile)) {
+	fmldata <- read.table(fmlfile, header = FALSE, sep = "\t", row.names = NULL)
+	colnames(fmldata) <- c("Z", "X", "Y")
+	all_combns <- fmldata %>% unite("XYZ", X, Y, Z, sep = " // ") %>% pull(XYZ)
+	out <- out %>%
+		unite("XYZ", X12, X21, X3, sep = " // ", remove = FALSE) %>%
+		dplyr::filter(XYZ %in% all_combns) %>%
+		dplyr::select(-XYZ)
+}
+
+if (!is.null(xyz_names)) {
+	out <- out %>%
+		dplyr::select(
+			!!sym(xyz_names[1]) := "X12",
+			!!sym(xyz_names[2]) := "X21",
+			!!sym(xyz_names[3]) := "X3",
+			everything()
+		)
+}
+
+if (padj != "none") {
+	log_info("Calculating adjusted p-values ...")
+	out$Padj <- p.adjust(out$Pval, method = padj)
+}
+
+log_info("Writing output ...")
+write.table(out, file = outfile, sep = "\t", quote = FALSE, row.names = FALSE)

biopipen/scripts/stats/MetaPvalue.R

@@ -0,0 +1,128 @@
+source("{{biopipen_dir}}/utils/misc.R")
+
+library(metap)
+library(rlang)
+library(dplyr)
+
+infiles <- {{in.infiles | r}}
+outfile <- {{out.outfile | r}}
+id_cols <- {{envs.id_cols | r}}
+id_exprs <- {{envs.id_exprs | r}}
+pval_cols <- {{envs.pval_cols | r}}
+method <- {{envs.method | r}}
+na <- {{envs.na | r}}
+padj <- {{envs.padj | r}}
+
+if (method == "fisher") { method = "sumlog" }
+
+if (length(infiles) == 1 && padj == "none") {
+    log_info("Only one input file, copying to output ...")
+    file.copy(infiles, outfile)
+} else if (length(infiles) == 1) {
+    log_info("Only one input file, performing p-value adjustment ...")
+    if (is.null(pval_cols)) {
+        stop("Must provide envs.pval_cols")
+    }
+    indata <- read.table(infiles, header = TRUE, sep = "\t", row.names = NULL, check.names = FALSE)
+    if (!pval_cols %in% colnames(indata)) {
+        stop("envs.pval_cols does not exist in input file")
+    }
+    indata$Padj <- p.adjust(indata[, pval_cols], method = padj)
+
+    log_info("Writing output ...")
+    write.table(indata, outfile, quote = FALSE, sep = "\t", row.names = FALSE)
+} else {
+    # Check pval_cols
+    if (is.null(pval_cols)) {
+        stop("Must provide envs.pval_cols")
+    }
+    if (length(pval_cols) == 1) {
+        pval_cols <- trimws(strsplit(pval_cols, ",")[[1]])
+    }
+    if (length(pval_cols) == 1) {
+        pval_cols <- rep(pval_cols, length(infiles))
+    }
+    if (length(pval_cols) != length(infiles)) {
+        stop("envs.pval_cols must be a single name or have the same length as in.infiles")
+    }
+
+    # Check id_cols
+    if (is.null(id_cols)) {
+        stop("Must provide envs.id_cols")
+    }
+    if (length(id_cols) == 1) {
+        id_cols <- trimws(strsplit(id_cols, ",")[[1]])
+    }
+
+    # Check id_exprs
+    if (!is.null(id_exprs)) {
+        if (length(id_exprs) == 1) {
+            id_exprs <- rep(id_exprs, length(infiles))
+        }
+        if (length(id_exprs) != length(infiles)) {
+            stop("envs.id_exprs must be a single expression or have the same length as in.infiles")
+        }
+        if (length(id_cols) != 1) {
+            stop("envs.id_cols must be a single name if envs.id_exprs is provided")
+        }
+    }
+
+    log_info("Reading and preparing data ...")
+    outdata <- NULL
+    for (i in seq_along(infiles)) {
+        infile <- infiles[i]
+        name <- tools::file_path_sans_ext(basename(infile))
+        pval_col <- paste0("Pval_", name)
+        dat <- read.table(
+            infile, header = TRUE, sep = "\t", row.names = NULL, check.names = FALSE
+        )
+        if (!is.null(id_exprs)) {
+            dat <- dat %>% mutate(!!sym(id_cols) := !!parse_expr(id_exprs[i]))
+        }
+        dat <- dat %>% dplyr::select(all_of(id_cols), !!sym(pval_col) := !!sym(pval_cols[i]))
+
+        if (is.null(outdata)) {
+            outdata <- dat
+        } else {
+            outdata <- full_join(outdata, dat, by = id_cols)
+        }
+    }
+
+    log_info("Running metap on each row ...")
+    metaps <- c()
+    ns <- c()
+    pval_columns <- setdiff(colnames(outdata), id_cols)
+    for (i in seq_len(nrow(outdata))) {
+        ps <- unlist(outdata[i, pval_columns, drop = TRUE])
+        if (na == -1) {
+            ps <- ps[!is.na(ps)]
+        } else {
+            ps[is.na(ps)] <- na
+        }
+        if (length(ps) == 0) {
+            metaps <- c(metaps, NA)
+            ns <- c(ns, NA)
+        } else if (length(ps) == 1) {
+            metaps <- c(metaps, ps)
+            ns <- c(ns, 1)
+        } else {
+            metaps <- c(metaps, do.call(method, list(ps))$p)
+            ns <- c(ns, length(ps))
+        }
+    }
+    outdata$MetaPval <- metaps
+    outdata$N <- ns
+    outdata <- outdata %>% arrange(MetaPval)
+
+    if (padj != "none") {
+        log_info("Calculating adjusted p-values ...")
+        outdata$MetaPadj <- p.adjust(outdata$MetaPval, method = padj)
+
+    }
+
+    log_info("Writing output ...")
+    write.table(outdata, outfile, quote = FALSE, sep = "\t", row.names = FALSE)
+}
+
+
+

biopipen/scripts/tcr/CloneResidency.R

@@ -116,13 +116,13 @@ get_groups <- function(order) {
 }
 
 perpare_case <- function(casename, case) {
-    log_info("Preparing case: {casename} ...")
+    log_info("- Processing case: {casename} ...")
     # Check if required keys are provided
     if (is.null(case$subject) || length(case$subject) == 0) {
-        stop(paste("`subject` is required for case:", casename))
+        stop(paste("  `subject` is required for case:", casename))
     }
     if (is.null(case$group) || length(case$group) == 0) {
-        stop(paste("`group` is required for case:", casename))
+        stop(paste("  `group` is required for case:", casename))
     }
     if (!is.null(case$order) && length(case$order) > 0) {
         has_comma <- grepl(",", case$order)
@@ -134,13 +134,8 @@ perpare_case <- function(casename, case) {
             ))
         } else if (!any(has_comma)) {
             if (length(case$order) > 2) {
-                log_warn(
-                    paste0(
-                        "- Order of groups in case:", casename,
-                        " is not recommended, please use comma to separate groups. \n",
-                        "Instead of `['A', 'B', 'C']`, use `['A,B', 'A,C', 'B,C']`."
-                    )
-                )
+                log_warn("  Order of groups is not recommended, please use comma to separate groups.")
+                log_warn("  Instead of `['A', 'B', 'C']`, use `['A,B', 'A,C', 'B,C']`.")
                 case$order <- sapply(
                     combn(case$order, 2, simplify = FALSE),
                     function(x) paste(x, collapse = ",")
@@ -151,8 +146,8 @@ perpare_case <- function(casename, case) {
         } else {
             stop(
                 paste0(
-                    "- Order of groups in case:", casename,
-                    " is not consistent, please use comma to separate groups. \n",
+                    "  Order of groups in case:", casename,
+                    " is not consistent, please use comma to separate groups. ",
                     "Instead of `['A', 'B', 'C']`, use `['A,B', 'A,C', 'B,C']`, ",
                     "however, this is inconsistent: `['A,B', 'C']`"
                 )
@@ -255,14 +250,16 @@ plot_scatter <- function(counts, subject, suf1, suf2) {
     }
     ggplot(plotdata) +
         geom_point(
-            aes_string(
-                x = bQuote(suf1), y = bQuote(suf2), color = "Type", size = "Size", fill = "Type"
+            aes(
+                x = !!sym(suf1),
+                y = !!sym(suf2),
+                color = Type,
+                size = Size,
+                fill = Type
             ),
             alpha = .6,
             shape = 21
         ) +
-        # geom_point(aes_string(x=x, y=y, color='color'), shape=1) +
-        # scale_color_manual(values=color) +
         scale_x_continuous(
             trans = "log2",
             limits = c(minx, maxx),
@@ -277,7 +274,6 @@ plot_scatter <- function(counts, subject, suf1, suf2) {
         ) +
         theme_prism(base_size = 16) +
         scale_size(guide = "none") +
-        # theme(legend.position = "none") +
         labs(
             title = bquote(.(subject) ~ (italic(n) == .(n_formatted))),
             subtitle = subtitle
@@ -302,61 +298,38 @@ plot_venndg <- function(counts, groups, singletons) {
     venn <- Venn(venn_data)
     vdata <- process_data(venn)
     vregion <- venn_region(vdata)
-    sregion <- head(vregion, length(groups))
-    sregion$count = singletons[sregion$name, "count"]
-    sregion <- sregion %>% mutate(name = paste0(name, " singletons"))
+    vregion$singleton_count = singletons[vregion$name, "count"]
     vregion <- vregion %>% mutate(
         count_perc = round(count / sum(count) * 100, 1),
-        count_str = paste0(count, " (", count_perc, "%)")
+        count_str = paste0(count, " (", count_perc, "%)"),
+        count_str = if_else(is.na(singleton_count), count_str, paste0(count_str, "\nsingletons = ", singleton_count))
     )
 
-    # Align the catagory labels
-    cat_nudge_y <- 0
-    if (length(groups) == 3) { cat_nudge_y <- c(-400, 0, -400) }
-    # Shift Count labels
-    count_nudge_y <- -10
-    if (length(groups) == 3) { count_nudge_y <- c(20, -20, 20, rep(0, nrow(vregion) - 3))  }
-    # Shift the singletons stat labels
-    label_nudge_y <- 60
-    if (length(groups) == 3) { label_nudge_y <- c(60, -60, -60) }
-
     venn_p <- ggplot() +
         # 1. region count layer
         geom_sf(aes(fill = count), data = venn_region(vdata)) +
         # 2. set edge layer
         # geom_sf(aes(color = factor(id)), data = venn_setedge(data), show.legend = FALSE) +
         # 3. set label layer
-        geom_sf_text(aes(label = name), data = venn_setlabel(vdata), nudge_y = cat_nudge_y) +
+        geom_sf_text(aes(label = name), data = venn_setlabel(vdata)) +
         # 4. region label layer
         geom_sf_label(
             aes(label = count_str),
             alpha = .8,
             label.padding = unit(.2, "lines"),
-            data = vregion,
-            nudge_y = count_nudge_y
+            data = vregion
         ) +
         # 5. singletons label layer
         scale_fill_distiller(palette = "Oranges", direction = 1) +
-        new_scale_fill() +
-        geom_sf_label(
-            aes(label = count, fill = name),
-            alpha = .6,
-            data = sregion,
-            nudge_y = label_nudge_y,
-            label.padding = unit(1, "lines"),
-            label.r = unit(1.2, "lines"),
-            label.size = 0.05,
-            show.legend = TRUE
-        ) +
         theme_void() +
-        theme(plot.margin = margin(1,1,1,1, "cm")) +
-        scale_fill_brewer(palette = "Reds", name = "Singletons")
+        theme(plot.margin = margin(1,1,1,1, "cm"))
 
     venn_p
 }
 
 plot_upset <- function(counts, singletons) {
     query_singleton <- function(row) { row["Singletons"] == "true" }
+    query_multiplet <- function(row) { rep(TRUE, length(row)) }
 
     cnts <- column_to_rownames(counts, "CDR3.aa") %>%
         mutate(across(everything(), ~ as.integer(as.logical(.x))))
@@ -365,7 +338,19 @@ plot_upset <- function(counts, singletons) {
     cnts[sgltns, "Singletons"] <- "true"
     sets <- setdiff(colnames(cnts), "Singletons")
 
+    # Fix: Error in fix.by(by.x, x) : 'by' must specify uniquely valid columns
+    colnames(cnts) <- make.names(colnames(cnts))
+    sets <- make.names(sets)
+
     upset(cnts, sets = sets, query.legend = "top", sets.x.label = "# clones", queries = list(
+        list(
+            # in order to add legend
+            # actually mark all, but singleton will override
+            query = query_multiplet,
+            color = "#3b3b3b",
+            active = TRUE,
+            query.name = "Multiplets"
+        ),
         list(
             query = query_singleton,
             color = "orange",
@@ -407,7 +392,7 @@ handle_subject <- function(i, subjects, casename, case) {
         mutate(across(everything(), as.character)) %>%
         paste(collapse = "-")
 
-    log_info("Handling {i} {case$subject} ...")
+    log_info("  Handling {subject} ({i}/{nrow(subjects)}) ...")
 
     if (!is.null(case$subset)) {
         counts <- cldata %>% filter(!!parse_expr(case$subset))
@@ -432,7 +417,7 @@ handle_subject <- function(i, subjects, casename, case) {
         case$order <- sapply(combn(groups, 2, simplify = FALSE), function(x) paste(x, collapse = ","))
     }
     if (length(unique(counts[[case$group]])) < 2) {
-        log_warn("{casename}, Subject doesn't have enough groups: {subject}")
+        log_warn("  - Subject doesn't have enough groups: {subject}")
         return()
     }
     singletons = counts %>%
@@ -452,20 +437,6 @@ handle_subject <- function(i, subjects, casename, case) {
         select(CDR3.aa, !!!syms(groups))
     counts[is.na(counts)] <- 0
 
-    # # Save samples to group_by so they can be aligned accordingly in the report
-    # if (!is.null(section)) {
-    #     group_dir <- file.path(casedir, "section")
-    #     dir.create(group_dir, showWarnings = FALSE)
-
-    #     sgroups <- subject_row %>%
-    #         left_join(cldata) %>%
-    #         pull(section) %>%
-    #         unique() %>%
-    #         paste(collapse = "-")
-    #     group_file <- file.path(group_dir, paste0(slugify(sgroups), ".txt"))
-    #     cat(subject, file = group_file, sep = "\n", append = TRUE)
-    # }
-
     # Save counts
     counts_dir <- file.path(casedir, "counts")
     countfile <- file.path(counts_dir, paste0(slugify(subject), ".txt"))
@@ -495,13 +466,7 @@ handle_subject <- function(i, subjects, casename, case) {
     for (j in seq_along(case$order)) {
         pair <- strsplit(case$order[j], ",")[[1]]
         if (length(setdiff(pair, groups)) > 0) {
-            log_warn(
-                paste0(
-                    "- One of the comparisons doesn't exist in case (", casename,
-                    ") for subject (", subject, "): ",
-                    case$order[j]
-                )
-            )
+            log_warn("  - Comparison {case$order[j]} doesn't exist.")
             next
         }
         scatter_p <- plot_scatter(counts, subject, pair[1], pair[2])
@@ -534,7 +499,7 @@ handle_subject <- function(i, subjects, casename, case) {
 
     h <- headings(case$section, casename, "Overlapping Clones (Venn Diagram)")
     add_report(
-        list(src = venn_png),
+        list(src = venn_png, name = subject),
         h1 = h$h1,
         h2 = h$h2,
         h3 = h$h3,
@@ -549,7 +514,7 @@ handle_subject <- function(i, subjects, casename, case) {
 
     h <- headings(case$section, casename, "Overlapping Clones (UpSet Plots)")
     add_report(
-        list(src = upset_png),
+        list(src = upset_png, name = subject),
         h1 = h$h1,
         h2 = h$h2,
         h3 = h$h3,

biopipen/utils/misc.R

@@ -29,6 +29,25 @@ bQuote <- function(x) {
 #' @param tolower Convert to lowercase
 #' @return A slugified string
 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(non_alphanum_replace, "+"), non_alphanum_replace, x)
     if(tolower) x <- tolower(x)

biopipen/utils/misc.py

@@ -2,9 +2,24 @@ from __future__ import annotations
 from pathlib import Path
 
 import sys
+import logging
 from typing import List
 from biopipen.core.filters import dict_to_cli_args  # noqa: F401
 
+logger = logging.getLogger("biopipen_job")
+logger.setLevel(logging.INFO)
+_handler = logging.StreamHandler(sys.stdout)
+# Use same log format as in R
+# {sprintf("%-7s", level)} [{format(time, "%Y-%m-%d %H:%M:%S")}] {msg}
+# so the logs can be populated by pipen-poplog
+_handler.setFormatter(
+    logging.Formatter(
+        "%(levelname)-7s [%(asctime)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+)
+logger.addHandler(_handler)
+
 
 def exec_code(code, global_vars=None, local_vars=None, return_var=None):
     global_vars = global_vars or {}

{biopipen-0.25.4.dist-info → biopipen-0.26.1.dist-info}/METADATA

@@ -1,23 +1,22 @@
 Metadata-Version: 2.1
 Name: biopipen
-Version: 0.25.4
+Version: 0.26.1
 Summary: Bioinformatics processes/pipelines that can be run from `pipen run`
 License: MIT
 Author: pwwang
 Author-email: pwwang@pwwang.com
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 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.4,<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)
+Requires-Dist: datar[pandas] (>=0.15.5,<0.16.0)
+Requires-Dist: pipen-board[report] (>=0.15,<0.16)
+Requires-Dist: pipen-cli-run (>=0.13,<0.14)
+Requires-Dist: pipen-filters (>=0.12,<0.13)
+Requires-Dist: pipen-poplog (>=0.1,<0.2)
+Requires-Dist: pipen-runinfo (>=0.6,<0.7) ; extra == "runinfo"
+Requires-Dist: pipen-verbose (>=0.11,<0.12)