In rworkflow/ReUseData: Reusable and reproducible Data Management

knitr::opts_chunk$set(
  collapse = TRUE,
  comment = "#>"
)

Introduction

The growth in the volume and complexity of genomic data resources over the past few decades poses both opportunities and challenges for data reuse. Presently, reuse of data often involves similar preprocessing steps in different research projects. Lack of a standardized annotation strategy can lead to difficult-to-find and even duplicated datasets, resulting in substantial inefficiencies and wasted computing resources, especially for research collaborations and bioinformatics core facilities. Tools such as GoGetData and AnnotationHub have been developed to mitigate common problems in managing and accessing curated genomic datasets. However, their use can be limited due to software requirements (e.g., Conda https://conda.io), forms of data representation or scope of data resources.
To respond to the FAIR (findability, accessibility, interoperability, and reusability) data principles that are being widely adopted and organizational requirements for Data Management Plans (DMPs), here, we introduce ReUseData, an R/Bioconductor software tool to provide a systematic and versatile approach for standardized and reproducible data management. ReUseData facilitates transformation of shell or other ad hoc scripts for data preprocessing into workflow-based data recipes. Evaluation of data recipes generate curated data files in their generic formats (e.g., VCF, bed) with full annotations for subsequent reuse.

This package focuses on the management of genomic data resources and uses classes and functions from existing Bioconductor packages. So we think it should be a good fit for the Bioconductor.

Installation

1. Install the package from Bioconductor.

if (!requireNamespace("BiocManager", quietly = TRUE))
    install.packages("BiocManager")
BiocManager::install("ReUseData")

Use the development version:

BiocManager::install("ReUseData", version = "devel")

1. Load the package and other packages used in this vignette into the R session.

suppressPackageStartupMessages(library(Rcwl))
library(ReUseData)

Project resources

ReUseData recipe landing pages

The project website https://rcwl.org/dataRecipes/ contains all prebuilt data recipes for public data downloading and curation. They are available for direct use with convenient webpage searching. Each data recipe has a landing page including recipe description (inputs, outputs, etc.) and user instructions. Make sure to check the instructions of eligible input parameter values before recipe evaluation. These prebuilt data recipes demonstrate the use of software and can be taken as templates for users to create their own recipes for protected datasets.

There are many other R resources available on this main website https://rcwl.org/, including package vignettes for Rcwl andRcwlPipelines, Rcwl tutorial e-book, case studies of using RcwlPipelines in preprocessing single-cell RNA-seq data, etc.

ReUseData recipe scripts

The prebuilt data recipe scripts are included in the package, and are physically residing in a dedicated GitHub repository, which demonstrates the recipe construction for different situations. The most common case is that a data recipe can manage multiple data resources with different input parameters (species, versions, etc.). For example, the gencode_transcripts recipe download from GENCODE, unzip and index the transcript fasta file for human or mouse with different versions. A simple data downloading (using wget) for a specific file can be written as a data recipe without any input parameter. For example, the data recipe gcp_broad_gatk_hg38_1000G_omni2.5) downloads the 1000G_omni2.5.hg38.vcf.gz and the tbi index files from Google Cloud Platform bucket for Broad reference data GATK hg38.

If the data curation gets more complicated, say, multiple command-line tools are to be involved, and conda can be used to install required packages, or some secondary files are to be generated and collected, the raw way of building a ReUseData recipe using Rcwl functions is recommended, which gives more flexibility and power to accommodate different situations. An example recipe is the reference_genome which downloads, formats, and index reference genome data using tools of samtools, picard and bwa, and manages multiple secondary files besides the main fasta file for later reuse.

ReUseData core functions

Here we show the usage of 4 core functions recipeMake, recipeUpdate, recipeSearch, recipeLoad for constructing, updating, searching and loading ReUseData recipes in R.

Recipe construction and evaluation

One can construct a data recipe from scratch or convert existing shell scripts for data processing into data recipes, by specifying input parameters, and output globbing patterns using recipeMake function. Then the data recipe is represented in R as an S4 class cwlProcess. Upon assigning values to the input parameters, the recipe is ready to be evaluated to generate data of interest. Here are two examples:

script <- '
input=$1
outfile=$2
echo "Print the input: $input" > $outfile.txt
'

Equivalently, we can load the shell script directly:

script <- system.file("extdata", "echo_out.sh", package = "ReUseData")

rcp <- recipeMake(shscript = script,
                  paramID = c("input", "outfile"),
                  paramType = c("string", "string"),
                  outputID = "echoout",
                  outputGlob = "*.txt")
inputs(rcp)
outputs(rcp)

Evaluation of the data recipes are internally submitted as CWL workflow tasks, which requires the latest version of cwltool. Here we have used basilisk to initiate a conda environment and install the cwltool in that environment if it is not available (or only older versions are available) in the computer system.

We can install cwltool first to make sure a cwl-runner is available.

invisible(Rcwl::install_cwltool())

rcp$input <- "Hello World!"
rcp$outfile <- "outfile"
outdir <- file.path(tempdir(), "SharedData")
res <- getData(rcp,
               outdir = outdir,
               notes = c("echo", "hello", "world", "txt"))

Let's take a look at the output file, which is successfully generated in user-specified directory and grabbed through the outputGlob argument. For more details of the getData function for recipe evaluation, check the other vignette for reusable data management.

res$out
readLines(res$out)

Here we show a more complex example where the shell script has required command line tools. When specific tools are needed for the data processing, users just need to add their names in the requireTools argument in recipeMake function, and then add conda = TRUE when evaluating the recipe with getData function. Then these tools will be automatically installed by initiating a conda environment and the script can be successfully run in that environment.

This function promotes data reproducibility across different computing platforms, and removes barrier of using sophisticated bioinformatics tools by less experienced users.

The following code chunk is not evaluated for time-limit of package building but can be evaluated by users.

shfile <- system.file("extdata", "gencode_transcripts.sh",
                      package = "ReUseData")
readLines(shfile)
rcp <- recipeMake(shscript = shfile,
                  paramID = c("species", "version"),
                  paramType = c("string", "string"),
                  outputID = "transcripts", 
                  outputGlob = "*.transcripts.fa*",
                  requireTools = c("wget", "gzip", "samtools")
                  )
rcp$species <- "human"
rcp$version <- "42"
res <- getData(rcp,
        outdir = outdir,
        notes = c("gencode", "transcripts", "human", "42"),
        conda = TRUE)
res$output

Recipe caching and updating

recipeUpdate() creates a local cache for data recipes that are saved in specified GitHub repository (if first time use), syncs and updates data recipes from the GitHub repo to local caching system, so any newly added recipes can be readily accessed and loaded directly in R.

NOTE:

• The cachePath argument need to match between recipeUpdate, recipeLoad and recipeSearch functions.
• use force=TRUE when any old recipes that are previously cached are updated.
• use remote = TRUEto sync with remote GitHub repositories. By default, it syncs with ReUseDataRecipe GitHub repository](https://github.com/rworkflow/ReUseDataRecipe) for public, prebuilt data recipes. repo can also be a private GitHub repository.

## First time use
recipeUpdate(cachePath = "ReUseDataRecipe",
             force = TRUE)

To sync the local recipe cache with remote GitHub repository. Currently the remote data recipes on GitHub are the same as the recipes in package (so not evaluted here to avoid duplicate messages). We will do our best to keep current of the data recipes in package development version with the remote GitHub repository.

recipeUpdate(remote = TRUE,
             repos = "rworkflow/ReUseDataRecipe")  ## can be private repo

recipeUpdate returns a recipeHub object with a list of all available recipes. One can subset the list with [ and use getter functions recipeNames() to get the recipe names which can then be passed to the recipeSearch() or recipeLoad().

rh <- recipeUpdate()
is(rh)
rh[1]
recipeNames(rh)

Recipe searching and loading

Cached data recipes can be searched using multiple keywords to match the recipe name. It returns a recipeHub object with a list of recipes available.

recipeSearch()
recipeSearch("gencode")
recipeSearch(c("STAR", "index"))

Recipes can be directly loaded into R using recipeLoad function with user assigned name or the original recipe name. Once the recipe is successfully loaded, a message will be returned with recipe instructions.

rcp <- recipeLoad("STAR_index")

NOTE Use return=FALSE if you want to keep the original recipe name, or if multiple recipes are to be loaded.

recipeLoad("STAR_index", return = FALSE)

identical(rcp, STAR_index)

recipeLoad(c("ensembl_liftover", "gencode_annotation"), return=FALSE)

It's important to check the required inputs() of the recipe and the recipe landing page for eligible input parameter values before evaluating the recipe to generate data of interest.

inputs(STAR_index)
inputs(ensembl_liftover)
inputs(gencode_annotation)

SessionInfo

sessionInfo()

rworkflow/ReUseData documentation built on Dec. 7, 2023, 11 p.m.