From 5e096d9957a9353b829b67df17432129bf8d3ece Mon Sep 17 00:00:00 2001 From: wlandau Date: Fri, 15 Nov 2024 10:01:12 -0500 Subject: [PATCH] docs --- DESCRIPTION | 16 ++++++------ NEWS.md | 2 +- R/tar_quarto_files.R | 38 +++++++---------------------- man/tar_age.Rd | 46 ++++++++++++----------------------- man/tar_change.Rd | 46 ++++++++++++----------------------- man/tar_combine.Rd | 46 ++++++++++++----------------------- man/tar_download.Rd | 46 ++++++++++++----------------------- man/tar_file_read.Rd | 46 ++++++++++++----------------------- man/tar_files.Rd | 46 ++++++++++++----------------------- man/tar_force.Rd | 46 ++++++++++++----------------------- man/tar_formats.Rd | 46 ++++++++++++----------------------- man/tar_formats_superseded.Rd | 46 ++++++++++++----------------------- man/tar_group_by.Rd | 46 ++++++++++++----------------------- man/tar_group_count.Rd | 46 ++++++++++++----------------------- man/tar_group_select.Rd | 46 ++++++++++++----------------------- man/tar_group_size.Rd | 46 ++++++++++++----------------------- man/tar_knit.Rd | 16 ++++++------ man/tar_map2.Rd | 46 ++++++++++++----------------------- man/tar_map2_count.Rd | 46 ++++++++++++----------------------- man/tar_map2_size.Rd | 46 ++++++++++++----------------------- man/tar_map_rep.Rd | 46 ++++++++++++----------------------- man/tar_quarto.Rd | 16 ++++++------ man/tar_quarto_rep.Rd | 16 ++++++------ man/tar_render.Rd | 16 ++++++------ man/tar_render_rep.Rd | 16 ++++++------ man/tar_rep.Rd | 46 ++++++++++++----------------------- man/tar_rep2.Rd | 46 ++++++++++++----------------------- man/tar_rep_map.Rd | 46 ++++++++++++----------------------- man/tar_rep_map_raw.Rd | 46 ++++++++++++----------------------- man/tar_skip.Rd | 46 ++++++++++++----------------------- 30 files changed, 415 insertions(+), 733 deletions(-) diff --git a/DESCRIPTION b/DESCRIPTION index 3fcf07c..886405b 100644 --- a/DESCRIPTION +++ b/DESCRIPTION @@ -7,9 +7,9 @@ Description: Function-oriented Make-like declarative pipelines for By establishing reusable archetypes for common kinds of targets and pipelines, these functions help express complicated reproducible pipelines concisely and compactly. - The methods in this package were influenced by the 'drake' R package + The methods in this package were influenced by the 'targets' R package. by Will Landau (2018) . -Version: 0.10.0.9004 +Version: 0.11.0 License: MIT + file LICENSE URL: https://docs.ropensci.org/tarchetypes/, https://github.com/ropensci/tarchetypes BugReports: https://github.com/ropensci/tarchetypes/issues @@ -21,6 +21,12 @@ Authors@R: c( email = "will.landau.oss@gmail.com", comment = c(ORCID = "0000-0003-1878-3253") ), + person( + given = "Rudolf", + family = "Siegel", + role = "ctb", + comment = c(ORCID = "0000-0002-6021-804X") + ), person( given = "Samantha", family = "Oliver", @@ -36,12 +42,6 @@ Authors@R: c( person( family = "Eli Lilly and Company", role = c("cph", "fnd") - ), - person( - given = "Rudolf", - family = "Siegel", - role = "ctb", - comment = c(ORCID = "0000-0002-6021-804X") )) Depends: R (>= 3.5.0) diff --git a/NEWS.md b/NEWS.md index b1065ad..e112711 100644 --- a/NEWS.md +++ b/NEWS.md @@ -1,4 +1,4 @@ -# tarchetypes 0.10.0.9004 (development) +# tarchetypes 0.11.0 * Add an `output_file` argument to `tar_quarto()` and `tar_quarto_raw()` for single documents (#198, @mutlusun). * Detect child quarto documents (#199, @mutlusun). diff --git a/R/tar_quarto_files.R b/R/tar_quarto_files.R index ca9891b..e108f2d 100644 --- a/R/tar_quarto_files.R +++ b/R/tar_quarto_files.R @@ -61,10 +61,8 @@ tar_quarto_files <- function(path = ".", profile = NULL, quiet = TRUE) { tar_quarto_files_document <- function(path, quiet) { info <- quarto::quarto_inspect(input = path, quiet = quiet) out <- list() - # Collect data about source files. out$sources <- tar_quarto_files_get_source_files(info$fileInformation) - # Collect data about output files. for (format in info$formats) { out$output <- c( @@ -72,16 +70,10 @@ tar_quarto_files_document <- function(path, quiet) { file.path(dirname(path), format$pandoc$`output-file`) ) } - # Collect data about input files. As this is not a project, there doesn't # exist the `info$files` key. However, we can include resources if present. - if (length(info$resources) > 0) { - out$input <- info$resources - out$input <- out$input[file.exists(out$input)] - } else { - out$input <- character(0L) - } - + out$input <- as.character(info$resources) + out$input <- out$input[file.exists(out$input)] out } @@ -95,22 +87,13 @@ tar_quarto_files_project <- function(path, quiet) { "quarto.org to learn how to set output-dir in _quarto.yml." ) ) - out <- list(output = file.path(path, info$config$project$`output-dir`)) - # Collect data about source files. out$sources <- tar_quarto_files_get_source_files(info$fileInformation) - # Detect input files like the config file (`_quarto.yml`) and resources like # quarto extensions. Make sure in the end that these files exist. - out$input <- unlist( - c( - info$files$config, - info$files$resources - ) - ) + out$input <- unlist(c(info$files$config, info$files$resources)) out$input <- out$input[file.exists(out$input)] - out } @@ -126,8 +109,7 @@ tar_quarto_files_project <- function(path, quiet) { #' @param file_information The `fileInformation` element of the list #' returned by `quarto::quarto_inspect()`. tar_quarto_files_get_source_files <- function(file_information) { - ret <- character(0) - + out <- character(0) for (myfile in names(file_information)) { # Collect relevant source files. The files in `includeMap$target` are always # relative to the main entry point of the report. Thus, we need to add the @@ -135,8 +117,8 @@ tar_quarto_files_get_source_files <- function(file_information) { # # We don't need to include the `source` column as all files are also present # in `target` or are `myfile`. - ret <- c( - ret, + out <- c( + out, myfile, file.path( dirname(myfile), @@ -144,11 +126,9 @@ tar_quarto_files_get_source_files <- function(file_information) { ) ) } - # Check that these files actually exist. - ret <- ret[file.exists(ret)] - - # We don't need to call `unique` here on `ret` as this happens on the main + out <- out[file.exists(out)] + # We don't need to call `unique` here on `out` as this happens on the main # function. - ret + out } diff --git a/man/tar_age.Rd b/man/tar_age.Rd index 75e98c5..a367ef3 100644 --- a/man/tar_age.Rd +++ b/man/tar_age.Rd @@ -169,47 +169,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{A \code{targets::tar_cue()} object. (See the "Cue objects" diff --git a/man/tar_change.Rd b/man/tar_change.Rd index a6ac6b9..9edf8d3 100644 --- a/man/tar_change.Rd +++ b/man/tar_change.Rd @@ -204,47 +204,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} diff --git a/man/tar_combine.Rd b/man/tar_combine.Rd index a4d486c..3582f64 100644 --- a/man/tar_combine.Rd +++ b/man/tar_combine.Rd @@ -229,47 +229,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_download.Rd b/man/tar_download.Rd index 1efaeb5..ae85118 100644 --- a/man/tar_download.Rd +++ b/man/tar_download.Rd @@ -190,47 +190,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_file_read.Rd b/man/tar_file_read.Rd index 0794a6d..3e53dc3 100644 --- a/man/tar_file_read.Rd +++ b/man/tar_file_read.Rd @@ -188,47 +188,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_files.Rd b/man/tar_files.Rd index d1490b1..136976b 100644 --- a/man/tar_files.Rd +++ b/man/tar_files.Rd @@ -208,47 +208,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} diff --git a/man/tar_force.Rd b/man/tar_force.Rd index f932fe9..7ff8b13 100644 --- a/man/tar_force.Rd +++ b/man/tar_force.Rd @@ -205,47 +205,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} diff --git a/man/tar_formats.Rd b/man/tar_formats.Rd index bf4cb4e..7a66ad6 100644 --- a/man/tar_formats.Rd +++ b/man/tar_formats.Rd @@ -475,47 +475,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_formats_superseded.Rd b/man/tar_formats_superseded.Rd index 68d9c5b..b403b6b 100644 --- a/man/tar_formats_superseded.Rd +++ b/man/tar_formats_superseded.Rd @@ -429,47 +429,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_group_by.Rd b/man/tar_group_by.Rd index 0518e00..f5eb4d3 100644 --- a/man/tar_group_by.Rd +++ b/man/tar_group_by.Rd @@ -185,47 +185,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_group_count.Rd b/man/tar_group_count.Rd index 281f8cb..93ae3b5 100644 --- a/man/tar_group_count.Rd +++ b/man/tar_group_count.Rd @@ -185,47 +185,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_group_select.Rd b/man/tar_group_select.Rd index 440ec31..3b06e2a 100644 --- a/man/tar_group_select.Rd +++ b/man/tar_group_select.Rd @@ -186,47 +186,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_group_size.Rd b/man/tar_group_size.Rd index 67fae2a..bbc2962 100644 --- a/man/tar_group_size.Rd +++ b/man/tar_group_size.Rd @@ -186,47 +186,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_knit.Rd b/man/tar_knit.Rd index 243d8cc..2e0ad28 100644 --- a/man/tar_knit.Rd +++ b/man/tar_knit.Rd @@ -166,17 +166,19 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_map2.Rd b/man/tar_map2.Rd index f5dfbb1..23bd8d8 100644 --- a/man/tar_map2.Rd +++ b/man/tar_map2.Rd @@ -282,47 +282,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_map2_count.Rd b/man/tar_map2_count.Rd index 29e1167..fd3a4f0 100644 --- a/man/tar_map2_count.Rd +++ b/man/tar_map2_count.Rd @@ -289,47 +289,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_map2_size.Rd b/man/tar_map2_size.Rd index cb5ad82..1e1e8cc 100644 --- a/man/tar_map2_size.Rd +++ b/man/tar_map2_size.Rd @@ -289,47 +289,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_map_rep.Rd b/man/tar_map_rep.Rd index 539be1b..a67847a 100644 --- a/man/tar_map_rep.Rd +++ b/man/tar_map_rep.Rd @@ -255,47 +255,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_quarto.Rd b/man/tar_quarto.Rd index fc086f2..f874d4f 100644 --- a/man/tar_quarto.Rd +++ b/man/tar_quarto.Rd @@ -222,17 +222,19 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_quarto_rep.Rd b/man/tar_quarto_rep.Rd index 1bbcd22..32e906f 100644 --- a/man/tar_quarto_rep.Rd +++ b/man/tar_quarto_rep.Rd @@ -263,17 +263,19 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_render.Rd b/man/tar_render.Rd index e2b16ab..7170386 100644 --- a/man/tar_render.Rd +++ b/man/tar_render.Rd @@ -165,17 +165,19 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_render_rep.Rd b/man/tar_render_rep.Rd index 03f9a90..f21b7fe 100644 --- a/man/tar_render_rep.Rd +++ b/man/tar_render_rep.Rd @@ -208,17 +208,19 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_rep.Rd b/man/tar_rep.Rd index ad1b12d..74f75c0 100644 --- a/man/tar_rep.Rd +++ b/man/tar_rep.Rd @@ -232,47 +232,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_rep2.Rd b/man/tar_rep2.Rd index c16c714..d141f96 100644 --- a/man/tar_rep2.Rd +++ b/man/tar_rep2.Rd @@ -237,47 +237,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_rep_map.Rd b/man/tar_rep_map.Rd index 58fd089..cf0155a 100644 --- a/man/tar_rep_map.Rd +++ b/man/tar_rep_map.Rd @@ -210,47 +210,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_rep_map_raw.Rd b/man/tar_rep_map_raw.Rd index 97c8ab3..8b00cf7 100644 --- a/man/tar_rep_map_raw.Rd +++ b/man/tar_rep_map_raw.Rd @@ -211,47 +211,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the diff --git a/man/tar_skip.Rd b/man/tar_skip.Rd index 3736bbf..e8c3aa8 100644 --- a/man/tar_skip.Rd +++ b/man/tar_skip.Rd @@ -205,47 +205,33 @@ functionality, alternative data storage formats, and other optional capabilities of \code{targets}. See \code{tar_resources()} for details.} -\item{storage}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{storage}{Character string to control when the output of the target +is saved to storage. Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's return value is sent back to the host machine and saved/uploaded locally. \item \code{"worker"}: the worker saves/uploads the value. -\item \code{"none"}: almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. If you do use it, -then the return value of the target is totally ignored -when the target ends, but -each downstream target still attempts to load the data file -(except when \code{retrieval = "none"}). - -If you select \code{storage = "none"}, then -the return value of the target's command is ignored, -and the data is not saved automatically. -As with dynamic files (\code{format = "file"}) it is the -responsibility of the user to write to -the data store from inside the target. - -The distinguishing feature of \code{storage = "none"} -(as opposed to \code{format = "file"}) -is that in the general case, -downstream targets will automatically try to load the data -from the data store as a dependency. As a corollary, \code{storage = "none"} -is completely unnecessary if \code{format} is \code{"file"}. +\item \code{"none"}: \code{targets} makes no attempt to save the result +of the target to storage in the location where \code{targets} +expects it to be. Saving to storage is the responsibility +of the user. Use with caution. }} -\item{retrieval}{Character of length 1, only relevant to -\code{\link[targets:tar_make_clustermq]{tar_make_clustermq()}} and \code{\link[targets:tar_make_future]{tar_make_future()}}. +\item{retrieval}{Character string to control when the current target +loads its dependencies into memory before running. +(Here, a "dependency" is another target upstream that the current one +depends on.) Only relevant when using \code{targets} +with parallel workers (\url{https://books.ropensci.org/targets/crew.html}). Must be one of the following values: \itemize{ \item \code{"main"}: the target's dependencies are loaded on the host machine and sent to the worker before the target runs. -\item \code{"worker"}: the worker loads the targets dependencies. -\item \code{"none"}: the dependencies are not loaded at all. -This choice is almost never recommended. It is only for -niche situations, e.g. the data needs to be loaded -explicitly from another language. +\item \code{"worker"}: the worker loads the target's dependencies. +\item \code{"none"}: \code{targets} makes no attempt to load its +dependencies. With \code{retrieval = "none"}, loading dependencies +is the responsibility of the user. Use with caution. }} \item{cue}{An optional object from \code{tar_cue()} to customize the