biopipen 0.21.0__py3-none-any.whl → 0.34.26__py3-none-any.whl

biopipen/scripts/stats/DiffCoexpr.R

@@ -0,0 +1,152 @@
+library(dcanr)
+library(scuttle)
+library(doRNG)
+library(doParallel)
+library(snpStats)
+library(rlang)
+library(dplyr)
+library(biopipen.utils)
+
+infile <- {{in.infile | r}}
+groupfile <- {{in.groupfile | r}}
+outfile <- {{out.outfile | r}}
+method <- {{envs.method | r}}
+beta <- {{envs.beta | r}}
+padj <- {{envs.padj | r}}
+perm_batch <- {{envs.perm_batch | r}}
+seed <- {{envs.seed | r}}
+ncores <- {{envs.ncores | r}}
+transpose_input <- {{envs.transpose_input | r}}
+transpose_group <- {{envs.transpose_group | r}}
+
+log <- get_logger()
+
+log$info("Setting seed and parallel backend ...")
+set.seed(seed)
+registerDoParallel(cores = ncores)
+registerDoRNG(seed)
+
+log$info("Reading input files ...")
+indata <- read.table(infile, header = TRUE, row.names = 1, sep = "\t", check.names = FALSE)
+if (transpose_input) {
+    indata <- t(indata)
+}
+gdata <- read.table(groupfile, header = TRUE, row.names = 1, sep = "\t", check.names = FALSE)
+if (transpose_group) {
+    gdata <- t(gdata)
+}
+ngroups <- ncol(gdata)
+
+sign2 <- function(x) sign(x) * x^2
+mat2vec <- dcanr:::mat2vec
+
+diffcoex_score <- function(group) {
+
+    gvals <- unique(gdata[, group, drop = TRUE])
+    if (length(gvals) < 2) {
+        log$debug("  Less than 2 groups in the input. Skipping ...")
+        return(NULL)
+    }
+    rs <- lapply(gvals, function(gval) {
+        samples <- rownames(gdata[gdata[[group]] == gval, , drop = FALSE])
+        expr <- indata[samples, , drop = FALSE]
+        if (length(samples) < 3) {
+            log$debug("  Less than 3 samples in one of the groups. Skipping ...")
+            return(NULL)
+        }
+        cor.pairs(as.matrix(expr), cor.method = method)
+    })
+    rs[sapply(rs, is.null)] <- NULL
+    if (length(rs) < 2) {
+        log$debug("  Less than 2 groups with at least 3 samples. Skipping ...")
+        return(NULL)
+    }
+    N <- length(rs)
+    C0 <- lapply(rs, sign2)
+    C0 <- Reduce(`+`, C0) / N
+    D <- lapply(rs, function(r) abs(sign2(r) - C0))
+    D <- Reduce(`+`, D) / 2 / (N - 1)
+    D <- sqrt(D)
+    D <- D^beta
+    T_ovlap <- D %*% D + ncol(D) * D  #calc topological ovlap
+
+    mins = matrix(rep(rowSums(D), ncol(D)), nrow = ncol(D))
+    mins = pmin(mins, matrix(rep(colSums(D), each = ncol(D)), nrow = ncol(D)))
+    T_ovlap = 1 - (T_ovlap/(mins + 1 - D))
+
+    diag(T_ovlap) = 1
+
+    #add run parameters as attributes
+    attributes(T_ovlap) = c(
+        attributes(T_ovlap),
+        'method' = method,
+        'beta' = beta,
+        'call' = match.call()
+    )
+
+    return(1 - T_ovlap)
+}
+
+
+perm_test <- function(dcscores, group, B = perm_batch) {
+    obs = mat2vec(dcscores)
+
+    #package requirements
+    pckgs = c('dcanr')
+
+    #perform permutation
+    pvals = foreach(
+        b = seq_len(B),
+        .combine = function(...) {mapply(sum, ...)},
+        .multicombine = TRUE,
+        .inorder = FALSE,
+        .packages = pckgs
+    ) %dorng% {
+        #shuffle condition and recalculate scores
+        env = new.env()
+        assign('group', group, envir = env)
+        permsc = eval(attr(dcscores, 'call'), envir = env)
+        permsc = mat2vec(permsc)
+
+        #count elements greater than obs
+        permsc = abs(permsc)
+        permsc = permsc[!(is.na(permsc) || is.infinite(permsc))]
+        permcounts = vapply(abs(obs), function(x) sum(permsc > x), 0)
+        return(c(permcounts, length(permsc)))
+    }
+
+    #p-values
+    N <- pvals[length(pvals)]
+    pvals <- pvals[-(length(pvals))] / N
+    # attributes(pvals) = attributes(obs)
+    # pvals = dcanr:::vec2mat(pvals)
+    # attr(pvals, 'dc.test') = 'permutation'
+    # return(pvals)
+    # Format into Group,Feature1,Feature2,Pval
+    feature_pairs <- as.data.frame(t(combn(attr(obs, 'feature.names'), 2)))
+    colnames(feature_pairs) <- c('Feature1', 'Feature2')
+    feature_pairs$Group <- group
+    feature_pairs$Pval <- pvals
+    feature_pairs[, c('Group', 'Feature1', 'Feature2', 'Pval'), drop = FALSE]
+}
+
+do_one_group <- function(i) {
+    group <- colnames(gdata)[i]
+    log$info("- Processing group {i}/{ngroups}: {group} ...")
+    log$info("  Calculating differential co-expression scores ...")
+    dcscores <- diffcoex_score(group)
+
+    if (!is.null(dcscores)) {
+        log$info("  Calculating p-values ...")
+        perm_test(dcscores, group)
+    }
+}
+
+trios <- do_call(rbind, lapply(seq_len(ngroups), do_one_group))
+if (padj != "none") {
+    log$info("Correcting p-values ...")
+    trios$Padj <- p.adjust(trios$Pval, method = padj)
+}
+
+log$info("Writing output ...")
+write.table(trios, file = outfile, sep = "\t", quote = FALSE, row.names = FALSE)

biopipen/scripts/stats/LiquidAssoc.R

@@ -0,0 +1,135 @@
+library(rlang)
+library(dplyr)
+library(tidyr)
+library(fastLiquidAssociation)
+library(biopipen.utils)
+
+infile <- {{in.infile | r}}
+covfile <- {{in.covfile | r: quote_none=False | 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/Mediation.R

@@ -0,0 +1,108 @@
+library(rlang)
+library(parallel)
+library(mediation)
+library(biopipen.utils)
+
+infile <- {{in.infile | r}}
+fmlfile <- {{in.fmlfile | r}}
+outfile <- {{out.outfile | r}}
+
+ncores <- {{envs.ncores | r}}
+sims <- {{envs.sims | r}}
+args <- {{envs.args | r}}
+padj <- {{envs.padj | r}}
+cases <- {{envs.cases | r}}
+transpose_input <- {{envs.transpose_input | r}}
+
+set.seed(123)
+log <- get_logger()
+
+log$info("Reading input file ...")
+indata <- read.table(infile, header = TRUE, sep = "\t", row.names = NULL, check.names = FALSE)
+if (transpose_input) { indata <- t(indata) }
+
+log$info("Reading formula file/cases ...")
+if (!is.null(fmlfile)) {
+    if (!is.null(cases) && length(cases) > 0) {
+        log$warn("envs.cases ignored as in.fmlfile is provided")
+    }
+    fmldata <- read.table(fmlfile, header = TRUE, sep = "\t", row.names = NULL)
+    # Case   M   Y   X   Cov     Model_M    Model_Y
+    cases <- split(fmldata, fmldata$Case)
+} else if (is.null(cases) || length(cases) == 0) {
+    stop("Either envs.cases or in.fmlfile must be provided")
+}
+
+args <- args %||% list()
+
+medanalysis <- function(i, total) {
+    casename <- names(cases)[i]
+    case <- cases[[casename]]
+    if (total < 50) {
+        log$info("- Case: ", casename)
+    } else if (total < 500) {
+        if (i %% 10 == 0) {
+            log$info("- Processing case {i}/{total} ...")
+        }
+    } else {
+        if (i %% 100 == 0) {
+            log$info("- Processing case {i}/{total} ...")
+        }
+    }
+    M <- case$M
+    Y <- case$Y
+    X <- case$X
+    covs <- case$Cov
+    modelm <- match.fun(case$Model_M)
+    modely <- match.fun(case$Model_Y)
+    fmlm <- as.formula(sprintf("%s ~ %s", bQuote(M), bQuote(X)))
+    fmly <- as.formula(sprintf("%s ~ %s + %s", bQuote(Y), bQuote(M), bQuote(X)))
+    if (!is.null(covs) && length(covs) == 1) {
+        covs <- trimws(strsplit(covs, ",")[[1]])
+    }
+    if (!is.null(covs)) {
+        cov_fml <- as.formula(sprintf("~ . + %s", paste(bQuote(covs), collapse = " + ")))
+        fmlm <- update.formula(fmlm, cov_fml)
+        fmly <- update.formula(fmly, cov_fml)
+    }
+
+    data <- indata[, c(M, X, Y, covs), drop = FALSE]
+    data <- data[complete.cases(data), , drop = FALSE]
+    margs <- args
+    margs$sims <- sims
+    margs$model.m <- modelm(fmlm, data = data)
+    margs$model.y <- modely(fmly, data = data)
+    margs$treat <- X
+    margs$mediator <- M
+    margs$outcome <- Y
+    if (!is.null(covs)) {
+        margs$covariates <- data[, covs, drop = FALSE]
+    }
+    med <- do_call(mediate, margs)
+    if (is.na(med$d1.p) || is.na(med$n1)) {
+        NULL
+    } else {
+        data.frame(
+            Case         = casename,
+            M            = M,
+            X            = X,
+            Y            = Y,
+            ACME         = med$d1,
+            ACME95CI1    = med$d1.ci[1],
+            ACME95CI2    = med$d1.ci[2],
+            TotalEffect  = med$tau.coef,
+            ADE          = med$z1,
+            PropMediated = med$n1,
+            Pval         = med$d1.p
+        )
+    }
+}
+
+total <- length(cases)
+out <- do_call(rbind, mclapply(1:total, medanalysis, total = total, mc.cores = ncores))
+
+if (padj != "none") {
+    out$Padj <- p.adjust(out$Pval, method = padj)
+}
+
+write.table(out, file = outfile, sep = "\t", quote = FALSE, row.names = FALSE)

biopipen/scripts/stats/MetaPvalue.R

@@ -0,0 +1,130 @@
+library(metap)
+library(rlang)
+library(dplyr)
+library(biopipen.utils)
+
+infiles <- {{in.infiles | each: str | 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}}
+keep_single <- {{envs.keep_single | r}}
+padj <- {{envs.padj | r}}
+
+if (method == "fisher") { method = "sumlog" }
+
+log <- get_logger()
+
+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 && keep_single) {
+            metaps <- c(metaps, ps)
+            ns <- c(ns, 1)
+        } else if (any(ps == 0)) {
+            metaps <- c(metaps, 0)
+            ns <- c(ns, length(ps))
+        } 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/stats/MetaPvalue1.R

@@ -0,0 +1,74 @@
+library(metap)
+library(rlang)
+library(dplyr)
+library(biopipen.utils)
+
+infile <- {{in.infile | r}}
+outfile <- {{out.outfile | r}}
+id_cols <- {{envs.id_cols | r}}
+pval_col <- {{envs.pval_col | r}}
+method <- {{envs.method | r}}
+na <- {{envs.na | r}}
+keep_single <- {{envs.keep_single | r}}
+padj <- {{envs.padj | r}}
+
+log <- get_logger()
+
+if (method == "fisher") { method = "sumlog" }
+
+# Check pval_cols
+if (is.null(pval_col)) { stop("Must provide envs.pval_col") }
+
+# 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]])
+}
+
+log$info("Reading input and performing meta-analysis ...")
+outdata <- read.table(
+        infile, header = TRUE, sep = "\t", row.names = NULL, check.names = FALSE
+    ) %>%
+    group_by(!!!syms(id_cols)) %>%
+    summarise(
+        N = n(),
+        .pvals = list(!!sym(pval_col)),
+        .groups = "drop"
+    )
+
+metaps <- c()
+ns <- c()
+for (ps in outdata$.pvals) {
+    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 && keep_single) {
+        metaps <- c(metaps, ps)
+        ns <- c(ns, 1)
+    } else if (any(ps == 0)) {
+        metaps <- c(metaps, 0)
+        ns <- c(ns, length(ps))
+    } else {
+        metaps <- c(metaps, do.call(method, list(ps))$p)
+        ns <- c(ns, length(ps))
+    }
+}
+outdata$MetaPval <- metaps
+outdata$N <- ns
+outdata$.pvals <- NULL
+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/tcgamaf/Maf2Vcf.py

@@ -1,12 +1,12 @@
 from biopipen.utils.misc import run_command, dict_to_cli_args
 
-infile = {{in.infile | quote}}  # pyright: ignore
+infile: str = {{in.infile | quote}}  # pyright: ignore  # noqa
 outfile = {{out.outfile | quote}}  # pyright: ignore
 outdir = {{out.outdir | quote}}  # pyright: ignore
 perl = {{envs.perl | quote}}  # pyright: ignore
 ref = {{envs.ref | repr}}  # pyright: ignore
 samtools = {{envs.samtools | quote}}  # pyright: ignore
-args = {{envs.args | repr}}  # pyright: ignore
+args: dict = {{envs.args | dict}}  # pyright: ignore
 maf2vcf = {{biopipen_dir | append: "/scripts/tcgamaf/maf2vcf.pl" | repr}}  # pyright: ignore
 
 args['input-maf']  = infile

biopipen/scripts/tcgamaf/MafAddChr.py

@@ -1,6 +1,6 @@
 
-infile = {{in.infile | quote}}  # pyright: ignore
-outfile = {{out.outfile | quote}}  # pyright: ignore
+infile: str = {{in.infile | quote}}  # pyright: ignore  # noqa
+outfile: str = {{out.outfile | quote}}  # pyright: ignore
 
 with open(infile) as fin, open(outfile, "w") as fout:
     for line in fin:

biopipen/scripts/tcr/Attach2Seurat.R

@@ -1,4 +1,4 @@
-source("{{biopipen_dir}}/utils/misc.R")
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
 
 library(Seurat)
 library(immunarch)
@@ -11,6 +11,7 @@ immfile = {{in.immfile | r}}
 sobjfile = {{in.sobjfile | r}}
 outfile = {{out.outfile | r}}
 metacols = {{envs.metacols | r}}
+prefix = {{envs.prefix | r}}
 
 immdata = readRDS(immfile)
 sobj = readRDS(sobjfile)
@@ -31,7 +32,7 @@ metadf = do_call(rbind, lapply(seq_len(nrow(immdata$meta)), function(i) {
 
     cldata %>%
         separate_rows(Barcode, sep=";") %>%
-        mutate(Barcode = glue("{{envs.prefix}}{Barcode}"))
+        mutate(Barcode = glue(paste0(prefix, "{Barcode}")))
 
 }))