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

biopipen/scripts/cnvkit/guess_baits.py

@@ -25,10 +25,10 @@ import sys
 import numpy as np
 import pandas as pd
 
-import cnvlib
-from cnvlib import parallel
-from cnvlib.descriptives import modal_location
-from skgenome import tabio, GenomicArray as GA
+import cnvlib  # type: ignore
+from cnvlib import parallel  # type: ignore
+from cnvlib.descriptives import modal_location  # type: ignore
+from skgenome import tabio, GenomicArray as GA  # type: ignore
 
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 
@@ -36,11 +36,12 @@ logging.basicConfig(level=logging.INFO, format="%(message)s")
 # ___________________________________________
 # Guided method: guess from potential targets
 
+
 def filter_targets(target_bed, sample_bams, procs, fasta):
     """Check if each potential target has significant coverage."""
     try:
-        baits = tabio.read(target_bed, 'bed4')
-    except:
+        baits = tabio.read(target_bed, "bed4")
+    except:  # noqa
         raise RuntimeError("Targets must be in BED format; try skg_convert.py")
     logging.info("Loaded %d candidate regions from %s", len(baits), target_bed)
     # Loop over BAMs to calculate weighted averages of bin coverage depths
@@ -48,47 +49,46 @@ def filter_targets(target_bed, sample_bams, procs, fasta):
     for bam_fname in sample_bams:
         logging.info("Evaluating targets in %s", bam_fname)
         sample = cnvlib.do_coverage(target_bed, bam_fname, processes=procs, fasta=fasta)
-        assert len(sample) == len(baits), \
-                "%d != %d" % (len(sample), len(baits))
-        total_depths += sample['depth'].values
-    baits['depth'] = total_depths / len(sample_bams)
-    logging.info("Average candidate-target depth:\n%s",
-                 baits['depth'].describe())
+        assert len(sample) == len(baits), "%d != %d" % (len(sample), len(baits))
+        total_depths += sample["depth"].values
+    baits["depth"] = total_depths / len(sample_bams)
+    logging.info("Average candidate-target depth:\n%s", baits["depth"].describe())
     return baits
 
 
 # _________________________________________
 # Unguided method: guess from raw depths
 
-def scan_targets(access_bed, sample_bams, min_depth, min_gap, min_length,
-                 procs):
+
+def scan_targets(access_bed, sample_bams, min_depth, min_gap, min_length, procs):
     """Estimate baited regions from a genome-wide, per-base depth profile."""
     bait_chunks = []
     # ENH: context manager to call rm on bed chunks? with to_chunks as pool, ck?
-    logging.info("Scanning for enriched regions in:\n  %s",
-                 '\n  '.join(sample_bams))
+    logging.info("Scanning for enriched regions in:\n  %s", "\n  ".join(sample_bams))
     #  with futures.ProcessPoolExecutor(procs) as pool:
     with parallel.pick_pool(procs) as pool:
-        args_iter = ((bed_chunk, sample_bams,
-                    min_depth, min_gap, min_length)
-                    for bed_chunk in parallel.to_chunks(access_bed))
+        args_iter = (
+            (bed_chunk, sample_bams, min_depth, min_gap, min_length)
+            for bed_chunk in parallel.to_chunks(access_bed)
+        )
         for bed_chunk_fname, bait_chunk in pool.map(_scan_depth, args_iter):
             bait_chunks.append(bait_chunk)
             parallel.rm(bed_chunk_fname)
     baits = GA(pd.concat(bait_chunks))
-    baits['depth'] /= len(sample_bams)
+    baits["depth"] /= len(sample_bams)
     return baits
 
 
 def _scan_depth(args):
     """Wrapper for parallel map"""
     bed_fname, bam_fnames, min_depth, min_gap, min_length = args
-    regions = list(drop_small(merge_gaps(scan_depth(bed_fname, bam_fnames,
-                                                    min_depth),
-                                         min_gap),
-                              min_length))
-    result = pd.DataFrame.from_records(list(regions),
-                                       columns=regions[0]._fields)
+    regions = list(
+        drop_small(
+            merge_gaps(scan_depth(bed_fname, bam_fnames, min_depth), min_gap),
+            min_length,
+        )
+    )
+    result = pd.DataFrame.from_records(list(regions), columns=regions[0]._fields)
     return bed_fname, result
 
 
@@ -100,32 +100,42 @@ def scan_depth(bed_fname, bam_fnames, min_depth):
     tuple
         Region coordinates (0-indexed, half-open): chromosome name, start, end
     """
-    Region = collections.namedtuple('Region', 'chromosome start end depth')
+    Region = collections.namedtuple("Region", "chromosome start end depth")
 
     nsamples = len(bam_fnames)
     if nsamples == 1:
+
         def get_depth(depths):
             return int(depths[0])
+
     else:
         min_depth *= nsamples
+
         # NB: samtools emits additional BAMs' depths as trailing columns
         def get_depth(depths):
             return sum(map(int, depths))
 
-    proc = subprocess.Popen([SAMTOOLS, 'depth',
-                             '-Q',  '1',  # Skip pseudogenes
-                             '-b', bed_fname,
-                            ] + bam_fnames,
-                            stdout=subprocess.PIPE,
-                            encoding='utf-8',
-                            shell=False)
+    proc = subprocess.Popen(
+        [
+            SAMTOOLS,
+            "depth",
+            "-Q",
+            "1",  # Skip pseudogenes
+            "-b",
+            bed_fname,
+        ]
+        + bam_fnames,
+        stdout=subprocess.PIPE,
+        encoding="utf-8",
+        shell=False,
+    )
 
     # Detect runs of >= min_depth; emit their coordinates
     chrom = start = depths = None
-    for line in proc.stdout:
-        fields = line.split('\t')
+    for line in proc.stdout:  # type: ignore
+        fields = line.split("\t")
         depth = get_depth(fields[2:])
-        is_enriched = (depth >= min_depth)
+        is_enriched = depth >= min_depth
         if start is None:
             if is_enriched:
                 # Entering a new captured region
@@ -137,7 +147,7 @@ def scan_depth(bed_fname, bam_fnames, min_depth):
                 continue
         elif is_enriched and fields[0] == chrom:
             # Still in a captured region -- extend it
-            depths.append(depth)
+            depths.append(depth)   # type: ignore
         else:
             # Exiting a captured region
             # Update target region boundaries
@@ -146,10 +156,12 @@ def scan_depth(bed_fname, bam_fnames, min_depth):
             ok_dp_idx = np.nonzero(darr >= half_depth)[0]
             start_idx = ok_dp_idx[0]
             end_idx = ok_dp_idx[-1] + 1
-            yield Region(chrom,
-                            start + start_idx,
-                            start + end_idx,
-                            darr[start_idx:end_idx].mean())
+            yield Region(
+                chrom,
+                start + start_idx,
+                start + end_idx,
+                darr[start_idx:end_idx].mean(),
+            )
             chrom = start = depths = None
 
 
@@ -170,75 +182,129 @@ def merge_gaps(regions, min_gap):
 
 def drop_small(regions, min_length):
     """Merge small gaps and filter by minimum length."""
-    return (reg for reg in regions
-            if reg.end - reg.start >= min_length)
+    return (reg for reg in regions if reg.end - reg.start >= min_length)
 
 
 # ___________________________________________
 # Shared
 
+
 def normalize_depth_log2_filter(baits, min_depth, enrich_ratio=0.1):
     """Calculate normalized depth, add log2 column, filter by enrich_ratio."""
     # Normalize depths to a neutral value of 1.0
-    dp_mode = modal_location(baits.data.loc[baits['depth'] > min_depth,
-                                            'depth'].values)
-    norm_depth = baits['depth'] / dp_mode
+    dp_mode = modal_location(baits.data.loc[baits["depth"] > min_depth, "depth"].values)
+    norm_depth = baits["depth"] / dp_mode
     # Drop low-coverage targets
-    keep_idx = (norm_depth >= enrich_ratio)
-    logging.info("Keeping %d/%d bins with coverage depth >= %f, modal depth %f",
-                 keep_idx.sum(), len(keep_idx), dp_mode * enrich_ratio, dp_mode)
+    keep_idx = norm_depth >= enrich_ratio
+    logging.info(
+        "Keeping %d/%d bins with coverage depth >= %f, modal depth %f",
+        keep_idx.sum(),
+        len(keep_idx),
+        dp_mode * enrich_ratio,
+        dp_mode,
+    )
     return baits[keep_idx]
 
 
-SAMTOOLS = 'samtools'
+SAMTOOLS = "samtools"
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     AP = argparse.ArgumentParser(description=__doc__)
-    AP.add_argument('sample_bams', nargs='+',
-                    help="""Sample BAM file(s) to test for target coverage.""")
-    AP.add_argument('-o', '--output', metavar='FILENAME',
-                    help="""The inferred targets, in BED format.""")
-    AP.add_argument('-c', '--coverage', metavar='FILENAME',
-                    help="""Filename to output average coverage depths in .cnn
-                    format.""")
-    AP.add_argument('-p', '--processes', metavar='CPU',
-                    nargs='?', type=int, const=0, default=1,
-                    help="""Number of subprocesses to segment in parallel.
+    AP.add_argument(
+        "sample_bams",
+        nargs="+",
+        help="""Sample BAM file(s) to test for target coverage.""",
+    )
+    AP.add_argument(
+        "-o",
+        "--output",
+        metavar="FILENAME",
+        help="""The inferred targets, in BED format.""",
+    )
+    AP.add_argument(
+        "-c",
+        "--coverage",
+        metavar="FILENAME",
+        help="""Filename to output average coverage depths in .cnn
+                    format.""",
+    )
+    AP.add_argument(
+        "-p",
+        "--processes",
+        metavar="CPU",
+        nargs="?",
+        type=int,
+        const=0,
+        default=1,
+        help="""Number of subprocesses to segment in parallel.
                     If given without an argument, use the maximum number
-                    of available CPUs. [Default: use 1 process]""")
-    AP.add_argument('-f', '--fasta', metavar="FILENAME",
-            help="Reference genome, FASTA format (e.g. UCSC hg19.fa)")
-    AP.add_argument('-s', '--samtools', metavar="SAMTOOLS",
-            help="Path to samtools", default="samtools")
+                    of available CPUs. [Default: use 1 process]""",
+    )
+    AP.add_argument(
+        "-f",
+        "--fasta",
+        metavar="FILENAME",
+        help="Reference genome, FASTA format (e.g. UCSC hg19.fa)",
+    )
+    AP.add_argument(
+        "-s",
+        "--samtools",
+        metavar="SAMTOOLS",
+        help="Path to samtools",
+        default="samtools",
+    )
 
     AP_x = AP.add_mutually_exclusive_group(required=True)
-    AP_x.add_argument('-t', '--targets', metavar='TARGET_BED',
-                    help="""Potentially targeted genomic regions, e.g. all known
+    AP_x.add_argument(
+        "-t",
+        "--targets",
+        metavar="TARGET_BED",
+        help="""Potentially targeted genomic regions, e.g. all known
                     exons in the reference genome, in BED format. Each of these
                     regions will be tested as a whole for enrichment. (Faster
-                    method)""")
-    AP_x.add_argument('-a', '--access', metavar='ACCESS_BED',
-                    # default="../data/access-5k-mappable.grch37.bed",
-                    help="""Sequencing-accessible genomic regions (e.g. from
+                    method)""",
+    )
+    AP_x.add_argument(
+        "-a",
+        "--access",
+        metavar="ACCESS_BED",
+        # default="../data/access-5k-mappable.grch37.bed",
+        help="""Sequencing-accessible genomic regions (e.g. from
                     'cnvkit.py access'), or known genic regions in the reference
                     genome, in BED format. All bases will be tested for
-                    enrichment. (Slower method)""")
+                    enrichment. (Slower method)""",
+    )
 
     AP_target = AP.add_argument_group("With --targets only")
-    AP_target.add_argument('-d', '--min-depth', metavar='DEPTH',
-                    type=int, default=5,
-                    help="""Minimum sequencing read depth to accept as captured.
-                    [Default: %(default)s]""")
+    AP_target.add_argument(
+        "-d",
+        "--min-depth",
+        metavar="DEPTH",
+        type=int,
+        default=5,
+        help="""Minimum sequencing read depth to accept as captured.
+                    [Default: %(default)s]""",
+    )
 
     AP_access = AP.add_argument_group("With --access only")
-    AP_access.add_argument('-g', '--min-gap', metavar='GAP_SIZE',
-                    type=int, default=25,
-                    help="""Merge regions separated by gaps smaller than this.
-                    [Default: %(default)s]""")
-    AP_access.add_argument('-l', '--min-length', metavar='TARGET_SIZE',
-                    type=int, default=50,
-                    help="""Minimum region length to accept as captured.
-                    [Default: %(default)s]""")
+    AP_access.add_argument(
+        "-g",
+        "--min-gap",
+        metavar="GAP_SIZE",
+        type=int,
+        default=25,
+        help="""Merge regions separated by gaps smaller than this.
+                    [Default: %(default)s]""",
+    )
+    AP_access.add_argument(
+        "-l",
+        "--min-length",
+        metavar="TARGET_SIZE",
+        type=int,
+        default=50,
+        help="""Minimum region length to accept as captured.
+                    [Default: %(default)s]""",
+    )
 
     args = AP.parse_args()
     SAMTOOLS = args.samtools
@@ -247,13 +313,20 @@ if __name__ == '__main__':
         args.processes = None
 
     if args.targets:
-        baits = filter_targets(args.targets, args.sample_bams, args.processes, args.fasta)
+        baits = filter_targets(
+            args.targets, args.sample_bams, args.processes, args.fasta
+        )
     else:
-        baits = scan_targets(args.access, args.sample_bams,
-                             0.5 * args.min_depth,  # More sensitive 1st pass
-                             args.min_gap, args.min_length, args.processes)
+        baits = scan_targets(
+            args.access,
+            args.sample_bams,
+            0.5 * args.min_depth,  # More sensitive 1st pass
+            args.min_gap,
+            args.min_length,
+            args.processes,
+        )
     baits = normalize_depth_log2_filter(baits, args.min_depth)
-    tabio.write(baits, args.output or sys.stdout, 'bed')
+    tabio.write(baits, args.output or sys.stdout, "bed")
     if args.coverage:
-        baits['log2'] = np.log2(baits['depth'] / baits['depth'].median())
-        tabio.write(baits, args.coverage, 'tab')
+        baits["log2"] = np.log2(baits["depth"] / baits["depth"].median())
+        tabio.write(baits, args.coverage, "tab")

biopipen/scripts/delim/RowsBinder.R

@@ -1,4 +1,4 @@
-source("{{biopipen_dir}}/utils/misc.R")
+library(biopipen.utils)
 
 infiles <- {{in.infiles | r}}
 outfile <- {{out.outfile | r}}

biopipen/scripts/delim/SampleInfo.R

@@ -1,19 +1,27 @@
-source("{{biopipen_dir}}/utils/misc.R")
-source("{{biopipen_dir}}/utils/mutate_helpers.R")
 library(rlang)
 library(dplyr)
-library(ggplot2)
-library(ggprism)
-library(ggsci)
-library(ggrepel)
+library(gglogger)
+library(biopipen.utils)
+library(plotthis)
 
 infile <- {{in.infile | r}}
 outfile <- {{out.outfile | r}}
+joboutdir <- {{job.outdir | r}}
 sep <- {{envs.sep | r}}
 mutaters <- {{envs.mutaters | r}}
 save_mutated <- {{envs.save_mutated | r}}
 defaults <- {{envs.defaults | r}}
 stats <- {{envs.stats | r}}
+exclude_cols <- {{envs.exclude_cols | r}}
+
+log <- get_logger()
+reporter <- get_reporter()
+
+if (is.null(exclude_cols)) {
+    exclude_cols <- c()
+} else {
+    exclude_cols <- trimws(unlist(strsplit(exclude_cols, ",")))
+}
 
 outdir <- dirname(outfile)
 indata <- read.delim(infile, sep = sep, header = TRUE, row.names = NULL)
@@ -22,6 +30,59 @@ if (colnames(indata)[1] == "row.names") {
     stop("Wrong number of column names. Do you have the right `sep`?")
 }
 
+#' Get plotthis function from plot_type
+#'
+#' @param plot_type The plot type
+#' @param gglogger_register Register the plotthis function to gglogger
+#' @param return_name Return the name of the function instead of the function
+#' @return The plotthis function
+#' @export
+get_plotthis_fn <- function(plot_type, gglogger_register = TRUE, return_name = FALSE) {
+    fn_name <- switch(plot_type,
+        hist = "Histogram",
+        histo = "Histogram",
+        histogram = "Histogram",
+        featuredim = "FeatureDimPlot",
+        splitbar = "SplitBarPlot",
+        enrichmap = "EnrichMap",
+        enrichnet = "EnrichNetwork",
+        enrichnetwork = "EnrichNetwork",
+        gsea = "GSEAPlot",
+        gseasummary = "GSEASummaryPlot",
+        gseasum = "GSEASummaryPlot",
+        heatmap = "Heatmap",
+        network = "Network",
+        pie = "PieChart",
+        wordcloud = "WordCloudPlot",
+        venn = "VennDiagram",
+        {
+            title_case_plot_type <- tools::toTitleCase(plot_type)
+            if (endsWith(title_case_plot_type, "Plot")) {
+                title_case_plot_type
+            } else if (endsWith(title_case_plot_type, "plot")) {
+                paste0(substr(title_case_plot_type, 1, nchar(title_case_plot_type) - 4), "Plot")
+            } else {
+                paste0(title_case_plot_type, "Plot")
+            }
+        }
+    )
+    if (return_name) {
+        return(fn_name)
+    }
+    fn <- tryCatch({
+        utils::getFromNamespace(fn_name, "plotthis")
+    }, error = function(e) {
+        stop("Unknown plot type: ", plot_type)
+    })
+
+    if (gglogger_register) {
+        gglogger::register(fn, fn_name)
+    } else {
+        fn
+    }
+}
+
+log$info("Applying mutaters to the data if any ...")
 if (!is.null(mutaters) && length(mutaters) > 0) {
     mutdata <- indata %>%
         mutate(!!!lapply(mutaters, parse_expr))
@@ -38,125 +99,62 @@ write.table(
     quote = FALSE
 )
 
-theme_set(theme_prism())
-for (name in names(stats)) {
-    stat <- list_update(defaults, stats[[name]])
-    plotfile <- file.path(outdir, paste0(name, ".png"))
-
-    is_continuous <- FALSE
-    if (!is.null(stat$distinct)) {
-        data <- mutdata %>% distinct(!!sym(stat$distinct), .keep_all = TRUE)
-    } else {
-        data <- mutdata
-    }
-    if (!is.null(stat$group) && !stat$na_group) {
-        data <- data %>% filter(!is.na(!!sym(stat$group)))
-    }
-    if (!is.null(stat$each) && !stat$na_each) {
-        data <- data %>% filter(!is.na(!!sym(stat$each)))
-    }
 
-    if (is.numeric(data[[stat$on]])) {
-        is_continuous <- TRUE
-    }
+reporter$add(
+    list(
+        kind = "descr",
+        content = "The samples used in the analysis. Each row is a sample, and columns are the meta information about the sample. This is literally the input sample information file, but the paths to the scRNA-seq and scTCR-seq data are hidden.",
+        once = TRUE
+    ),
+    list(
+        kind = "table",
+        pageSize = 50,
+        data = list(file = outfile, sep = sep, excluded = exclude_cols),
+        src = FALSE
+    ),
+    h1 = "Sample Information"
+)
 
-    if (is.null(stat$plot)) {
-        stat$plot <- if (is_continuous) "boxplot" else "pie"
-    }
+if (length(stats) > 0) {
+    cases <- expand_cases(stats, defaults)
+    for (name in names(cases)) {
+        log$info("- Statistic: {name}")
 
-    data$..group <- "All"
-    group <- if (is.null(stat$group)) sym("..group") else sym(stat$group)
-    count_on <- paste0("..count.", stat$on)
-    if (!is_continuous) {
-        data <- data %>% add_count(!!group, name = count_on)
-    }
+        case <- cases[[name]]
+        info <- case_info(name, outdir, is_dir = FALSE, create = TRUE)
+        case <- extract_vars(case, "plot_type", "more_formats", "save_code", "section", "subset", "devpars", "descr")
 
-    if (is.null(stat$devpars)) {
-        stat$devpars <- list()
-    }
-    if (is.null(stat$devpars$width)) {
-        stat$devpars$width <- 800
-    }
-    if (is.null(stat$devpars$height)) {
-        stat$devpars$height <- 600
-    }
-    if (is.null(stat$devpars$res)) {
-        stat$devpars$res <- 100
-    }
+        plot_fn <- get_plotthis_fn(plot_type)
+        more_formats <- unique(c("png", more_formats))
 
-    png(
-        plotfile,
-        width = stat$devpars$width,
-        height = stat$devpars$height,
-        res = stat$devpars$res
-    )
-    if (stat$plot == "boxplot" || stat$plot == "box") {
-        p <- ggplot(data, aes(x=!!group, y=!!sym(stat$on), fill=!!group)) +
-            geom_boxplot(position = "dodge") +
-            scale_fill_ucscgb(alpha = .8) +
-            xlab("")
-    } else if (stat$plot == "violin" ||
-               stat$plot == "violinplot" ||
-               stat$plot == "vlnplot") {
-        p <- ggplot(data, aes(x = !!group, y = !!sym(stat$on), fill=!!group)) +
-            geom_violin(position = "dodge") +
-            scale_fill_ucscgb(alpha = .8) +
-            xlab("")
-    } else if (
-        (grepl("violin", stat$plot) || grepl("vln", stat$plot)) &&
-        grepl("box", stat$plot)
-    ) {
-        p <- ggplot(data, aes(x = !!group, y = !!sym(stat$on), fill = !!group)) +
-            geom_violin(position = "dodge") +
-            geom_boxplot(width = 0.1, position = position_dodge(0.9), fill="white") +
-            scale_fill_ucscgb(alpha = .8) +
-            xlab("")
-    } else if (stat$plot == "histogram" || stat$plot == "hist") {
-        p <- ggplot(data, aes(x = !!sym(stat$on), fill = !!group)) +
-            geom_histogram(bins = 10, position = "dodge", alpha = 0.8, color = "white") +
-            scale_fill_ucscgb(alpha = .8)
-    } else if (stat$plot == "pie" || stat$plot == "piechart") {
-        if (is.null(stat$each)) {
-            data <- data %>% distinct(!!group, .keep_all = TRUE)
+        if (!is.null(subset)) {
+            case$data <- mutdata %>% dplyr::filter(!!parse_expr(subset))
         } else {
-            data <- data %>%
-                distinct(!!group, !!sym(stat$each), .keep_all = TRUE) %>%
-                group_by(!!sym(stat$each))
+            case$data <- mutdata
         }
-        p <- ggplot(
-            data %>% arrange(!!group),
-            aes(x = "", y = !!sym(count_on), fill = !!group, label = !!sym(count_on))
-        ) +
-            geom_bar(stat="identity", width=1, color="white", position = position_stack(reverse = TRUE)) +
-            coord_polar("y", start = 0) +
-            theme_void() +
-            theme(plot.title = element_text(hjust = 0.5)) +
-            geom_label_repel(
-                position = position_stack(vjust = 0.5),
-                color="#333333",
-                fill="#EEEEEE",
-                size=4
-            ) +
-            scale_fill_ucscgb(alpha = .7, name = group) +
-            ggtitle(paste0("# ", stat$on))
-    } else if (stat$plot == "bar" || stat$plot == "barplot") {
-        if (is.null(stat$each)) {
-            data <- data %>% distinct(!!group, .keep_all = TRUE)
-        } else {
-            data <- data %>% distinct(!!group, !!sym(stat$each), .keep_all = TRUE)
+
+        p <- do_call(plot_fn, case)
+        save_plot(p, info$prefix, devpars, formats = more_formats)
+        if (save_code) {
+            save_plotcode(
+                p,
+                setup = c('library(plotthis)', '', 'load("data.RData")', 'list2env(case, envir = .GlobalEnv)'),
+                prefix = info$caseprefix,
+                "case",
+                auto_data_setup = FALSE
+            )
         }
-        p <- ggplot(
-            data,
-            aes(x = !!group, y = !!sym(count_on), fill = !!group)) +
-            geom_bar(stat = "identity") +
-            scale_fill_ucscgb(alpha = .8) +
-            ylab(paste0("# ", stat$on))
-    } else {
-        stop("Unknown plot type: ", stat$plot)
-    }
-    if (!is.null(stat$each)) {
-        p <- p + facet_wrap(vars(!!sym(stat$each)), ncol = stat$ncol)
+
+        reporter$add(
+            reporter$image(
+                info$prefix,
+                c("png", more_formats),
+                save_code,
+                kind = "table_image"
+            ),
+            h1 = "Statistics", ui = "table_of_images:2"
+        )
     }
-    print(p)
-    dev.off()
 }
+
+reporter$save(joboutdir)