| Title: | A Framework for Planning and Executing Analyses |
|---|---|
| Description: | A comprehensive framework for planning and executing analyses in R. It provides a structured approach to running the same function multiple times with different arguments, executing multiple functions on the same datasets, and creating systematic analyses across multiple strata or variables. The framework is particularly useful for applying the same analysis across multiple strata (e.g., locations, age groups), running statistical methods on multiple variables (e.g., exposures, outcomes), generating multiple tables or graphs for reports, and creating systematic surveillance analyses. Key features include efficient data management, structured analysis planning, flexible execution options, built-in debugging tools, and hash-based caching. |
| Authors: | Richard Aubrey White [aut, cre] (ORCID: <https://orcid.org/0000-0002-6747-1726>) |
| Maintainer: | Richard Aubrey White <[email protected]> |
| License: | MIT + file LICENSE |
| Version: | 2025.11.22 |
| Built: | 2026-06-09 06:04:05 UTC |
| Source: | https://github.com/raubreywhite/plnr |
This function creates a complete example project structure for an R Markdown analysis
using the plnr framework. It sets up a standardized directory structure and creates
example files demonstrating how to use plnr for data analysis and report generation.
create_rmarkdown(home)create_rmarkdown(home)
home |
Character string, the path where the project should be created |
The created project includes:
A main run.R script that initializes the project and demonstrates plnr usage
Example analysis functions in the R directory
A template R Markdown document
Standard project directories (results, paper, raw)
NULL, creates files and directories in the specified location
## Not run: # Create a temporary directory for the example temp_dir <- tempfile("plnr_example_") create_rmarkdown(temp_dir) # View the created structure list.files(temp_dir, recursive = TRUE) ## End(Not run)## Not run: # Create a temporary directory for the example temp_dir <- tempfile("plnr_example_") create_rmarkdown(temp_dir) # View the created structure list.files(temp_dir, recursive = TRUE) ## End(Not run)
This function serves as an example of how to structure an action function
for use with the Plan class. It simply prints the names of the data
and argset components it receives.
example_action_fn(data, argset)example_action_fn(data, argset)
data |
A named list containing the datasets for the analysis |
argset |
A named list containing the arguments for the analysis |
NULL, prints information about the input data and argset
# Create a new plan p <- plnr::Plan$new() # Add example data p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Create batch of argsets batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) # Add analyses to plan p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) # View argsets and run example p$get_argsets_as_dt() p$run_one("analysis_1")# Create a new plan p <- plnr::Plan$new() # Add example data p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Create batch of argsets batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) # Add analyses to plan p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) # View argsets and run example p$get_argsets_as_dt() p$run_one("analysis_1")
An example data_fn that returns a data set
example_data_fn_nor_covid19_cases_by_time_location()example_data_fn_nor_covid19_cases_by_time_location()
This function creates a cross product of multiple lists, similar to tidyr::expand_grid()
but with a more convenient interface that doesn't require wrapping arguments in an
extra list(). It's useful for generating combinations of parameters for analysis.
expand_list(...)expand_list(...)
... |
Named arguments, each containing a vector or list of values to combine |
A list of lists, where each inner list contains one combination of values from the input arguments
# Create combinations of parameters combinations <- plnr::expand_list( a = 1:2, b = c("a", "b") ) # View the combinations str(combinations) # Compare with tidyr::expand_grid tidyr::expand_grid(list( a = 1:2, b = c("a", "b") ))# Create combinations of parameters combinations <- plnr::expand_list( a = 1:2, b = c("a", "b") ) # View the combinations str(combinations) # Compare with tidyr::expand_grid tidyr::expand_grid(list( a = 1:2, b = c("a", "b") ))
This function extends base::get() to support package namespace scoping (e.g., "pkg::var").
It's particularly useful when working with package exports and namespace-qualified objects.
get_anything(x)get_anything(x)
x |
Character string specifying the object to retrieve. Can be either a simple object name or a namespace-qualified name (e.g., "pkg::var") |
The requested object
# Get a namespace-qualified object plnr::get_anything("plnr::nor_covid19_cases_by_time_location") # Get a simple object (same as base::get) x <- 1 get_anything("x")# Get a namespace-qualified object plnr::get_anything("plnr::nor_covid19_cases_by_time_location") # Get a simple object (same as base::get) x <- 1 get_anything("x")
This function determines whether code is being executed directly in the global environment or from within a function call. It's particularly useful for development and debugging purposes, allowing functions to behave differently when run directly versus when called as part of a larger analysis plan.
is_run_directly()is_run_directly()
A logical value: TRUE if the code is being run directly (i.e., from the global
environment), FALSE if it's being run from within a function call
# When run directly is_run_directly() # TRUE # When run from within a function test_fn <- function() { is_run_directly() # FALSE } test_fn()# When run directly is_run_directly() # TRUE # When run from within a function test_fn <- function() { is_run_directly() # FALSE } test_fn()
This data comes from the Norwegian Surveillance System for Communicable Diseases (MSIS). The date corresponds to when the PCR-test was taken.
nor_covid19_cases_by_time_locationnor_covid19_cases_by_time_location
A csfmt_rts_data_v1 with 11028 rows and 18 variables:
day/isoweek
nation, county
nor
norge, 11 counties
2020
total
Isoyear of event
Isoweek of event
Isoyearweek of event
Season of event
Seasonweek of event
Calyear of event
Calmonth of event
Calyearmonth of event
Date of event
Number of confirmed covid19 cases
Number of confirmed covid19 cases per 100.000 population
The raw number of cases and cases per 100.000 population are recorded.
This data was extracted on 2022-05-04.
The Plan class provides a framework for organizing and executing multiple analyses
on one or more datasets. It enforces a structured approach to analysis by:
Data Management:
Loading data once and reusing across analyses
Separating data cleaning from analysis
Providing hash-based tracking of data changes
Analysis Structure:
Requiring all analyses to use the same data sources
Standardizing analysis functions to accept only data and argset parameters
Organizing analyses into clear, maintainable plans
Execution Control:
Supporting both single-function and multi-function analysis plans
Providing flexible execution options (sequential or parallel)
Including built-in debugging tools
The framework uses three main concepts:
Argset: A named list containing a set of arguments for an analysis
Analysis: A combination of one argset and one action function
Plan: A container that holds one data pull and a list of analyses
analysesList of analyses, each containing an argset and action function
new()
Create a new Plan instance
Plan$new(verbose = interactive() | config$force_verbose, use_foreach = FALSE)
verboseLogical, whether to show verbose output. Defaults to TRUE in interactive mode or when config$force_verbose is TRUE
use_foreachLogical, whether to use foreach for parallel processing. NULL = program decides, FALSE = use loop, TRUE = use foreach
A new Plan instance
add_data()
Add a new dataset to the plan
Plan$add_data(name, fn = NULL, fn_name = NULL, direct = NULL)
nameCharacter string, name of the dataset
fnFunction that returns the dataset (optional)
fn_nameCharacter string, name of a function that returns the dataset (optional)
directDirect dataset object (optional)
NULL, modifies the plan in place
p <- plnr::Plan$new()
# Add data using a function
data_fn <- function() { return(plnr::nor_covid19_cases_by_time_location) }
p$add_data("data_1", fn = data_fn)
# Add data using a function name
p$add_data("data_2", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
# Add data directly
p$add_data("data_3", direct = plnr::nor_covid19_cases_by_time_location)
# View added data
p$get_data()
add_argset()
Add a new argset to the plan
Plan$add_argset(name = uuid::UUIDgenerate(), ...)
nameCharacter string, name of the argset (defaults to a UUID)
...Named arguments that will comprise the argset
NULL, modifies the plan in place
p <- plnr::Plan$new()
# Add argsets with different arguments
p$add_argset("argset_1", var_1 = 3, var_b = "hello")
p$add_argset("argset_2", var_1 = 8, var_c = "hello2")
# View added argsets
p$get_argsets_as_dt()
add_argset_from_df()
Add multiple argsets from a data frame
Plan$add_argset_from_df(df)
dfData frame where each row represents a new argset
NULL, modifies the plan in place
p <- plnr::Plan$new()
# Create data frame of argsets
batch_argset_df <- data.frame(
name = c("a", "b", "c"),
var_1 = c(1, 2, 3),
var_2 = c("i", "j", "k")
)
# Add argsets from data frame
p$add_argset_from_df(batch_argset_df)
# View added argsets
p$get_argsets_as_dt()
add_argset_from_list()
Add multiple argsets from a list
Plan$add_argset_from_list(l)
lList of lists, where each inner list represents a new argset
NULL, modifies the plan in place
p <- plnr::Plan$new() # Create list of argsets batch_argset_list <- list( list(name = "a", var_1 = 1, var_2 = "i"), list(name = "b", var_1 = 2, var_2 = "j"), list(name = "c", var_1 = 3, var_2 = "k") ) # Add argsets from list p$add_argset_from_list(batch_argset_list) # View added argsets p$get_argsets_as_dt()
add_analysis()
Add a new analysis to the plan
Plan$add_analysis(name = uuid::UUIDgenerate(), fn = NULL, fn_name = NULL, ...)
nameCharacter string, name of the analysis (defaults to a UUID)
fnFunction to use for the analysis (optional)
fn_nameCharacter string, name of the function to use (optional)
...Additional arguments to be added to the argset
NULL, modifies the plan in place
p <- plnr::Plan$new()
# Add example data
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
# Add analysis
p$add_analysis(
name = "analysis_1",
fn_name = "plnr::example_action_fn"
)
# View argsets and run analysis
p$get_argsets_as_dt()
p$run_one("analysis_1")
add_analysis_from_df()
Add multiple analyses from a data frame
Plan$add_analysis_from_df(fn = NULL, fn_name = NULL, df)
fnFunction to use for all analyses (optional)
fn_nameCharacter string, name of the function to use (optional)
dfData frame where each row represents a new analysis
NULL, modifies the plan in place
p <- plnr::Plan$new()
# Add example data
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
# Create data frame of analyses
batch_argset_df <- data.frame(
name = c("a", "b", "c"),
var_1 = c(1, 2, 3),
var_2 = c("i", "j", "k")
)
# Add analyses from data frame
p$add_analysis_from_df(
fn_name = "plnr::example_action_fn",
df = batch_argset_df
)
# View argsets and run example
p$get_argsets_as_dt()
p$run_one(1)
add_analysis_from_list()
Add multiple analyses from a list
Plan$add_analysis_from_list(fn = NULL, fn_name = NULL, l)
fnFunction to use for all analyses (optional)
fn_nameCharacter string, name of the function to use (optional)
lList of lists, where each inner list represents a new analysis
NULL, modifies the plan in place
p <- plnr::Plan$new()
# Add example data
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
# Create list of analyses
batch_argset_list <- list(
list(name = "analysis_1", var_1 = 1, var_2 = "i"),
list(name = "analysis_2", var_1 = 2, var_2 = "j"),
list(name = "analysis_3", var_1 = 3, var_2 = "k")
)
# Add analyses from list
p$add_analysis_from_list(
fn_name = "plnr::example_action_fn",
l = batch_argset_list
)
# View argsets and run example
p$get_argsets_as_dt()
p$run_one("analysis_1")
apply_action_fn_to_all_argsets()
Applies an action function to all the argsets
Plan$apply_action_fn_to_all_argsets(fn = NULL, fn_name = NULL)
fnAction function.
fn_nameAction function name. p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_argset_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$get_argsets_as_dt() p$apply_action_fn_to_all_argsets(fn_name = "plnr::example_action_fn") p$run_one("analysis_1")
apply_analysis_fn_to_all()
Deprecated. Use apply_action_fn_to_all_argsets.
Plan$apply_analysis_fn_to_all(fn = NULL, fn_name = NULL)
fnAction function.
fn_nameAction function name.
x_length()
Number of analyses in the plan.
Plan$x_length()
x_seq_along()
Generate a regular sequence from 1 to the length of the analyses in the plan.
Plan$x_seq_along()
set_progress()
Set an internal progress bar
Plan$set_progress(pb)
pbProgress bar.
set_progressor()
Set an internal progressor progress bar
Plan$set_progressor(pb)
pbprogressor progress bar.
set_verbose()
Set verbose flag
Plan$set_verbose(x)
xBoolean.
set_use_foreach()
Set use_foreach flag
Plan$set_use_foreach(x)
xBoolean.
get_data()
Extracts the data provided via 'add_data' and returns it as a named list.
Plan$get_data()
Named list, where most elements have been added via add_data.
One extra named element is called 'hash'. 'hash' contains the data hashes of particular datasets/variables, as calculated using the 'spookyhash' algorithm via digest::digest. 'hash' contains two named elements:
current (the hash of the entire named list)
current_elements (the hash of the named elements within the named list)
p <- plnr::Plan$new()
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
p$get_data()
get_analysis()
Extracts an analysis from the plan.
Plan$get_analysis(index_analysis)
index_analysisEither an integer (1:length(analyses)) or a character string representing the name of the analysis.
An analysis.
p <- plnr::Plan$new()
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
batch_argset_list <- list(
list(name = "analysis_1", var_1 = 1, var_2 = "i"),
list(name = "analysis_2", var_1 = 2, var_2 = "j"),
list(name = "analysis_3", var_1 = 3, var_2 = "k")
)
p$add_analysis_from_list(
fn_name = "plnr::example_action_fn",
l = batch_argset_list
)
p$get_analysis("analysis_1")
get_argset()
Extracts an argset from the plan.
Plan$get_argset(index_analysis)
index_analysisEither an integer (1:length(analyses)) or a character string representing the name of the analysis.
An argset
p <- plnr::Plan$new()
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
batch_argset_list <- list(
list(name = "analysis_1", var_1 = 1, var_2 = "i"),
list(name = "analysis_2", var_1 = 2, var_2 = "j"),
list(name = "analysis_3", var_1 = 3, var_2 = "k")
)
p$add_analysis_from_list(
fn_name = "plnr::example_action_fn",
l = batch_argset_list
)
p$get_argset("analysis_1")
get_argsets_as_dt()
Gets all argsets and presents them as a data.table.
Plan$get_argsets_as_dt()
Data.table that contains all the argsets within a plan.
p <- plnr::Plan$new()
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
batch_argset_list <- list(
list(name = "analysis_1", var_1 = 1, var_2 = "i"),
list(name = "analysis_2", var_1 = 2, var_2 = "j"),
list(name = "analysis_3", var_1 = 3, var_2 = "k")
)
p$add_analysis_from_list(
fn_name = "plnr::example_action_fn",
l = batch_argset_list
)
p$get_argsets_as_dt()
run_one_with_data()
Run one analysis (data is provided by user).
Plan$run_one_with_data(index_analysis, data, ...)
index_analysisEither an integer (1:length(analyses)) or a character string representing the name of the analysis.
dataNamed list (generally obtained from p$get_data()).
...Not used.
Returned value from the action function.
p <- plnr::Plan$new()
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
batch_argset_list <- list(
list(name = "analysis_1", var_1 = 1, var_2 = "i"),
list(name = "analysis_2", var_1 = 2, var_2 = "j"),
list(name = "analysis_3", var_1 = 3, var_2 = "k")
)
p$add_analysis_from_list(
fn_name = "plnr::example_action_fn",
l = batch_argset_list
)
data <- p$get_data()
p$run_one_with_data("analysis_1", data)
run_one()
Run one analysis (data is obtained automatically from self$get_data()).
Plan$run_one(index_analysis, ...)
index_analysisEither an integer (1:length(analyses)) or a character string representing the name of the analysis.
...Not used.
Returned value from the action function.
p <- plnr::Plan$new()
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
batch_argset_list <- list(
list(name = "analysis_1", var_1 = 1, var_2 = "i"),
list(name = "analysis_2", var_1 = 2, var_2 = "j"),
list(name = "analysis_3", var_1 = 3, var_2 = "k")
)
p$add_analysis_from_list(
fn_name = "plnr::example_action_fn",
l = batch_argset_list
)
p$run_one("analysis_1")
run_all_with_data()
Run all analyses (data is provided by user).
Plan$run_all_with_data(data, ...)
dataNamed list (generally obtained from p$get_data()).
...Not used.
List where each element contains the returned value from the action function.
p <- plnr::Plan$new()
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
batch_argset_list <- list(
list(name = "analysis_1", var_1 = 1, var_2 = "i"),
list(name = "analysis_2", var_1 = 2, var_2 = "j"),
list(name = "analysis_3", var_1 = 3, var_2 = "k")
)
p$add_analysis_from_list(
fn_name = "plnr::example_action_fn",
l = batch_argset_list
)
data <- p$get_data()
p$run_all_with_data(data)
run_all()
Run all analyses (data is obtained automatically from self$get_data()).
Plan$run_all(...)
...Not used.
List where each element contains the returned value from the action function.
p <- plnr::Plan$new()
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
batch_argset_list <- list(
list(name = "analysis_1", var_1 = 1, var_2 = "i"),
list(name = "analysis_2", var_1 = 2, var_2 = "j"),
list(name = "analysis_3", var_1 = 3, var_2 = "k")
)
p$add_analysis_from_list(
fn_name = "plnr::example_action_fn",
l = batch_argset_list
)
p$run_all()
run_all_progress()
Run all analyses with a progress bar (data is obtained automatically from self$get_data()).
Plan$run_all_progress(...)
...Not used.
List where each element contains the returned value from the action function.
p <- plnr::Plan$new()
p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location")
batch_argset_list <- list(
list(name = "analysis_1", var_1 = 1, var_2 = "i"),
list(name = "analysis_2", var_1 = 2, var_2 = "j"),
list(name = "analysis_3", var_1 = 3, var_2 = "k")
)
p$add_analysis_from_list(
fn_name = "plnr::example_action_fn",
l = batch_argset_list
)
p$run_all_progress()
run_all_parallel()
Run all analyses in parallel (data is obtained automatically from self$get_data()).
This function only works on linux computers and uses pbmcapply as the parallel backend.
Plan$run_all_parallel(mc.cores = getOption("mc.cores", 2L), ...)mc.coresNumber of cores to be used.
...Not used.
List where each element contains the returned value from the action function.
clone()
The objects of this class are cloneable with this method.
Plan$clone(deep = FALSE)
deepWhether to make a deep clone.
## ------------------------------------------------ ## Method `Plan$add_data` ## ------------------------------------------------ p <- plnr::Plan$new() # Add data using a function data_fn <- function() { return(plnr::nor_covid19_cases_by_time_location) } p$add_data("data_1", fn = data_fn) # Add data using a function name p$add_data("data_2", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Add data directly p$add_data("data_3", direct = plnr::nor_covid19_cases_by_time_location) # View added data p$get_data() ## ------------------------------------------------ ## Method `Plan$add_argset` ## ------------------------------------------------ p <- plnr::Plan$new() # Add argsets with different arguments p$add_argset("argset_1", var_1 = 3, var_b = "hello") p$add_argset("argset_2", var_1 = 8, var_c = "hello2") # View added argsets p$get_argsets_as_dt() ## ------------------------------------------------ ## Method `Plan$add_argset_from_df` ## ------------------------------------------------ p <- plnr::Plan$new() # Create data frame of argsets batch_argset_df <- data.frame( name = c("a", "b", "c"), var_1 = c(1, 2, 3), var_2 = c("i", "j", "k") ) # Add argsets from data frame p$add_argset_from_df(batch_argset_df) # View added argsets p$get_argsets_as_dt() ## ------------------------------------------------ ## Method `Plan$add_argset_from_list` ## ------------------------------------------------ p <- plnr::Plan$new() # Create list of argsets batch_argset_list <- list( list(name = "a", var_1 = 1, var_2 = "i"), list(name = "b", var_1 = 2, var_2 = "j"), list(name = "c", var_1 = 3, var_2 = "k") ) # Add argsets from list p$add_argset_from_list(batch_argset_list) # View added argsets p$get_argsets_as_dt() ## ------------------------------------------------ ## Method `Plan$add_analysis` ## ------------------------------------------------ p <- plnr::Plan$new() # Add example data p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Add analysis p$add_analysis( name = "analysis_1", fn_name = "plnr::example_action_fn" ) # View argsets and run analysis p$get_argsets_as_dt() p$run_one("analysis_1") ## ------------------------------------------------ ## Method `Plan$add_analysis_from_df` ## ------------------------------------------------ p <- plnr::Plan$new() # Add example data p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Create data frame of analyses batch_argset_df <- data.frame( name = c("a", "b", "c"), var_1 = c(1, 2, 3), var_2 = c("i", "j", "k") ) # Add analyses from data frame p$add_analysis_from_df( fn_name = "plnr::example_action_fn", df = batch_argset_df ) # View argsets and run example p$get_argsets_as_dt() p$run_one(1) ## ------------------------------------------------ ## Method `Plan$add_analysis_from_list` ## ------------------------------------------------ p <- plnr::Plan$new() # Add example data p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Create list of analyses batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) # Add analyses from list p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) # View argsets and run example p$get_argsets_as_dt() p$run_one("analysis_1") ## ------------------------------------------------ ## Method `Plan$get_data` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") p$get_data() ## ------------------------------------------------ ## Method `Plan$get_analysis` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$get_analysis("analysis_1") ## ------------------------------------------------ ## Method `Plan$get_argset` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$get_argset("analysis_1") ## ------------------------------------------------ ## Method `Plan$get_argsets_as_dt` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$get_argsets_as_dt() ## ------------------------------------------------ ## Method `Plan$run_one_with_data` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) data <- p$get_data() p$run_one_with_data("analysis_1", data) ## ------------------------------------------------ ## Method `Plan$run_one` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$run_one("analysis_1") ## ------------------------------------------------ ## Method `Plan$run_all_with_data` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) data <- p$get_data() p$run_all_with_data(data) ## ------------------------------------------------ ## Method `Plan$run_all` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$run_all() ## ------------------------------------------------ ## Method `Plan$run_all_progress` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$run_all_progress()## ------------------------------------------------ ## Method `Plan$add_data` ## ------------------------------------------------ p <- plnr::Plan$new() # Add data using a function data_fn <- function() { return(plnr::nor_covid19_cases_by_time_location) } p$add_data("data_1", fn = data_fn) # Add data using a function name p$add_data("data_2", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Add data directly p$add_data("data_3", direct = plnr::nor_covid19_cases_by_time_location) # View added data p$get_data() ## ------------------------------------------------ ## Method `Plan$add_argset` ## ------------------------------------------------ p <- plnr::Plan$new() # Add argsets with different arguments p$add_argset("argset_1", var_1 = 3, var_b = "hello") p$add_argset("argset_2", var_1 = 8, var_c = "hello2") # View added argsets p$get_argsets_as_dt() ## ------------------------------------------------ ## Method `Plan$add_argset_from_df` ## ------------------------------------------------ p <- plnr::Plan$new() # Create data frame of argsets batch_argset_df <- data.frame( name = c("a", "b", "c"), var_1 = c(1, 2, 3), var_2 = c("i", "j", "k") ) # Add argsets from data frame p$add_argset_from_df(batch_argset_df) # View added argsets p$get_argsets_as_dt() ## ------------------------------------------------ ## Method `Plan$add_argset_from_list` ## ------------------------------------------------ p <- plnr::Plan$new() # Create list of argsets batch_argset_list <- list( list(name = "a", var_1 = 1, var_2 = "i"), list(name = "b", var_1 = 2, var_2 = "j"), list(name = "c", var_1 = 3, var_2 = "k") ) # Add argsets from list p$add_argset_from_list(batch_argset_list) # View added argsets p$get_argsets_as_dt() ## ------------------------------------------------ ## Method `Plan$add_analysis` ## ------------------------------------------------ p <- plnr::Plan$new() # Add example data p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Add analysis p$add_analysis( name = "analysis_1", fn_name = "plnr::example_action_fn" ) # View argsets and run analysis p$get_argsets_as_dt() p$run_one("analysis_1") ## ------------------------------------------------ ## Method `Plan$add_analysis_from_df` ## ------------------------------------------------ p <- plnr::Plan$new() # Add example data p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Create data frame of analyses batch_argset_df <- data.frame( name = c("a", "b", "c"), var_1 = c(1, 2, 3), var_2 = c("i", "j", "k") ) # Add analyses from data frame p$add_analysis_from_df( fn_name = "plnr::example_action_fn", df = batch_argset_df ) # View argsets and run example p$get_argsets_as_dt() p$run_one(1) ## ------------------------------------------------ ## Method `Plan$add_analysis_from_list` ## ------------------------------------------------ p <- plnr::Plan$new() # Add example data p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") # Create list of analyses batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) # Add analyses from list p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) # View argsets and run example p$get_argsets_as_dt() p$run_one("analysis_1") ## ------------------------------------------------ ## Method `Plan$get_data` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") p$get_data() ## ------------------------------------------------ ## Method `Plan$get_analysis` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$get_analysis("analysis_1") ## ------------------------------------------------ ## Method `Plan$get_argset` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$get_argset("analysis_1") ## ------------------------------------------------ ## Method `Plan$get_argsets_as_dt` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$get_argsets_as_dt() ## ------------------------------------------------ ## Method `Plan$run_one_with_data` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) data <- p$get_data() p$run_one_with_data("analysis_1", data) ## ------------------------------------------------ ## Method `Plan$run_one` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$run_one("analysis_1") ## ------------------------------------------------ ## Method `Plan$run_all_with_data` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) data <- p$get_data() p$run_all_with_data(data) ## ------------------------------------------------ ## Method `Plan$run_all` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$run_all() ## ------------------------------------------------ ## Method `Plan$run_all_progress` ## ------------------------------------------------ p <- plnr::Plan$new() p$add_data("covid_data", fn_name = "plnr::example_data_fn_nor_covid19_cases_by_time_location") batch_argset_list <- list( list(name = "analysis_1", var_1 = 1, var_2 = "i"), list(name = "analysis_2", var_1 = 2, var_2 = "j"), list(name = "analysis_3", var_1 = 3, var_2 = "k") ) p$add_analysis_from_list( fn_name = "plnr::example_action_fn", l = batch_argset_list ) p$run_all_progress()
This function allows users to configure package-wide options, such as verbosity of output messages. It modifies the package's internal configuration state.
set_opts(force_verbose = FALSE)set_opts(force_verbose = FALSE)
force_verbose |
Logical, whether to force verbose output messages regardless
of the interactive state. Defaults to |
NULL, modifies the package's internal configuration
# Enable verbose output set_opts(force_verbose = TRUE) # Disable verbose output set_opts(force_verbose = FALSE)# Enable verbose output set_opts(force_verbose = TRUE) # Disable verbose output set_opts(force_verbose = FALSE)
A simple test function that always returns 1, useful for testing the Plan framework's functionality.
test_action_fn(data, argset)test_action_fn(data, argset)
data |
A named list containing the datasets (unused in this example) |
argset |
A named list containing the arguments (unused in this example) |
The integer 1
This function attempts to execute code multiple times with random delays between attempts. It's particularly useful for handling transient failures in operations that may succeed on subsequent attempts, such as network requests or file operations.
try_again( x, times = 2, delay_seconds_min = 5, delay_seconds_max = 10, verbose = FALSE )try_again( x, times = 2, delay_seconds_min = 5, delay_seconds_max = 10, verbose = FALSE )
x |
The code to execute (as an expression) |
times |
Integer, the maximum number of attempts to make. Defaults to 2 |
delay_seconds_min |
Numeric, the minimum delay in seconds between attempts. Defaults to 5 |
delay_seconds_max |
Numeric, the maximum delay in seconds between attempts. Defaults to 10 |
verbose |
Logical, whether to show progress information. Defaults to |
The function is adapted from the try_again function in the testthat package,
but with additional features for controlling retry behavior and verbosity.
TRUE invisibly if successful, otherwise throws an error with the last
error message
## Not run: # Try a simple operation try_again({ # Your code here stop("Simulated error") }, times = 3, verbose = TRUE) # Try with custom delays try_again({ # Your code here stop("Simulated error") }, delay_seconds_min = 1, delay_seconds_max = 3) ## End(Not run)## Not run: # Try a simple operation try_again({ # Your code here stop("Simulated error") }, times = 3, verbose = TRUE) # Try with custom delays try_again({ # Your code here stop("Simulated error") }, delay_seconds_min = 1, delay_seconds_max = 3) ## End(Not run)