rlang PR 1255.batchtools template file can be brewed
(#1359, @pat-s).targets.NOTICE and inst/NOTICE to more
explicitly credit code included from other open source projects.
(Previously drake just had comments in the source with
links to the various projects.)dsl_sym() instead of as.symbol() when
constructing commands for combine() (#1340, @vkehayas).level_separation argument to
vis_drake_graph() and render_drake_graph() to
control the aspect ratio of visNetwork graphs (#1303, @matthewstrasiotto, @matthiasgomolka,
@robitalec).caching = "master" in favor of
caching = "main"..data in DSL (#1323,
@shirdekel).identical() to compare file hashes (#1324, @shirdekel).seed = TRUE in future::future().parallelism = "clustermq"
and caching = "worker" (@richardbayes).NROW() throws an error (#1300,
julian-tagell on Stack Overflow).lifecycle that does not require
badges to be in man/figures.log_worker argument of
clustermq::workers() to make() and
drake_config() (#1305, @billdenney, @mschubert).as.is to TRUE in
utils::type.convert() (#1309, @bbolker).cached_planned() and cached_unplanned()
now work with non-standard cache locations (#1268, @Plebejer).use_cache to FALSE more often (#1257,
@Plebejer).iris dataset with the
airquality dataset in all documentation, examples, and
tests (#1271).code_to_function() to the
proper environment (#1275, @robitalec).tidyselect (#1274, @dernst).txtq lockfiles (#1232, #1239, #1280, @danwwilson, @pydupont, @mattwarkentin).drake_script() function to write
_drake.R files for r_make() (#1282).expose_imports() in favor of
make(envir = getNamespace("yourPackage") (#1286, @mvarewyck).r_make() if
getOption("drake_r_make_message") is FALSE
(#1238, @januz).visNetwork graph by using
the hierarchical layout with
visEdges(smooth = list(type = "cubicBezier", forceDirection = TRUE))
(#1289, @mstr3336).splice_inner() from dropping formal arguments
shared by c() (#1262, @bart1).subtarget_hashes.cross() for crosses on a single
grouping variable.group() used with specialized formats
(#1236, @adamaltmejd).tidyselect >= 1.0.0..names argument (#1240, @maciejmotyka, @januz).drake_plan()
(#1237, @januz).cross()
sub-targets (#1204, @psadil). Expansion order is the same, but
names are correctly matched now.file_out() files in
clean(), even when garbage_collection is
TRUE (#521, @the-Hull).keep_going = TRUE for formatted targets
(#1206).progress_bar instead of progress) so that
drake works without the progress package
(#1208, @mbaccou).config$settings (#965).drake_done() and
drake_cancelled() (#1205).drake_graph_info() (#1207).verbose is 2 (#1203, @kendonB).jobs argument of
clean().drake_build() or drake_debug() (#1214, @kendonB).hasty_build (#1222).config$settings
(#965).file_in()/file_out()/knitr_in()
files are not literal strings (#1229).file_out() and knitr_in() in
imported functions (#1229).knitr_in() in dynamic branching (#1229).target().progress() => drake_progress(),
running() => drake_running(),
failed() => drake_failed()) (#1205).digest version to require 0.6.21 (#1166, @boshek)depend trigger to toggle invalidation from
dynamic-only dependencies, including the max_expand
argument of make().session_info argument parsing (and reduce calls
to utils::sessionInfo() in tests).tibble 3.0.0.target(format = "file")
(#1168, #1127).max_expand on a target-by-target
basis via target() (#1175, @kendonB).make(), not in drake_config() (#1156).make(verbose = 2), remove the spinner and use a
progress bar to track how many targets are done so far.cli
(optional package).console_log_file in favor of
log_make as an argument to make() and
drake_config()."loop" and
"future" parallel backends (#400).loadd() RStudio addin
through the new rstudio_drake_cache global option (#1169,
@joelnitta).recoverable(), e.g. dynamic
branching + dynamic files.drake_plan() if
a grouping variable is undefined or invalid (#1182, @kendonB).drake_deps and drake_deps_ht (#1183).rlang::trace_back() to make
diagnose()$error$calls nicer (#1198).These changes invalidate some targets in some workflows, but they are necessary bug fixes.
$<-()
and @<-() (#1144).bind_plans() (#1136,
@jennysjaarda).analyze_assign() (#1119, @jennysjaarda)."running" progress of dynamic targets."fst_tbl" format for large
tibble targets (#1154, @kendonB).format argument to make(), an
optional custom storage format for targets without an explicit
target(format = ...) in the plan (#1124).lock_cache argument to make() to
optionally suppress cache locking (#1129). (It can be annoying to
interrupt make() repeatedly and unlock the cache manually
every time.)cancel() and cancel_if()
function to cancel targets mid-build (#1131).subtarget_list argument to
loadd() and readd() to optionally load a
dynamic target as a list of sub-targets (#1139, @MilesMcBain).file_out() (#1141).drake_config() level (#1156, @MilesMcBain).config argument in all user-side
functions (#1118, @vkehayas). Users can now supply the plan
and other make() arguments directly, without bothering with
drake_config(). Now, you only need to call
drake_config() in the _drake.R file for
r_make() and friends. Old code with config
objects should still work. Affected functions:
make()outdated()drake_build()drake_debug()recoverable()missed()deps_target()deps_profile()drake_graph_info()vis_drake_graph()sankey_drake_graph()drake_graph()text_drake_graph()predict_runtime(). Needed to rename the
targets argument to targets_predict and
jobs to jobs_predict.predict_workers(). Same argument name changes as
predict_runtime().drake_config() is to serve functions r_make()
and friends.@ operator. For example, in the static code
analysis of x@y, do not register y as a
dependency (#1130, @famuvie).deps_profile() (#1134, @kendonB).deps_target() output (#1134, @kendonB).drake_meta_()
objects objects.drake_envir() and id_chr() (#1132).drake_envir() to select the environment with
imports (#882).vctrs paradigm and its type stability for
dynamic branching (#1105, #1106).target as a symbol by default in
read_trace(). Required for the trace to make sense in
#1107."future" backend (#1083, @jennysjaarda).log_build_times argument to
make() and drake_config(). Allows users to
disable the recording of build times. Produces a speedup of up to 20% on
Macs (#1078).make(), outdated(make_imports = TRUE),
recoverable(make_imports = TRUE),
vis_drake_graph(make_imports = TRUE), clean(),
etc. on the same cache.format trigger to invalidate targets when the
specialized data format changes (#1104, @kendonB).cache_planned() and
cache_unplanned() to help selectively clean workflows with
dynamic targets (#1110, @kendonB).drake_config() objects and analyze_code()
objects."qs" format (#1121, @kendonB).%||% (%|||% is
faster). (#1089, @billdenney)%||NA due to slowness (#1089, @billdenney).is_dynamic() and
is_subtarget() (#1089, @billdenney).getVDigest() instead of digest()
(#1089, #1092,
https://github.com/eddelbuettel/digest/issues/139#issuecomment-561870289,
@eddelbuettel,
@billdenney).backtick and .deparseOpts() to
speed up deparse() (#1086,
https://stackoverflow.com/users/516548/g-grothendieck,
@adamkski).build_times() (#1098).mget_hash() in progress()
(#1098).drake_graph_info() (#1098).outdated()
(#1098).make(), avoid checking for nonexistent metadata for
missing targets.drake_config().use_drake()
(#1097, @lorenzwalthert, @tjmahr).drake’s
interpretation of the plan. In the plan, all the dependency
relationships among targets and files are implicit. In the
spec, they are all explicit. We get from the plan to the spec
using static code analysis, e.g. analyze_code().drake::drake_plan(x = target(...)) from
throwing an error if drake is not loaded (#1039, @mstr3336).transformations lifecycle badge to the proper
location in the docstring (#1040, @jeroen).readd() / loadd() from turning an
imported function into a target (#1067).disk.frame targets with their stored
values (#1077, @brendanf).subtargets() function to get the cached names
of the sub-targets of a dynamic target.subtargets arguments to loadd()
and readd() to retrieve specific sub-targets from a parent
dynamic target.get_trace() and read_trace()
functions to help track which values of grouping variables go into the
making of dynamic sub-targets.id_chr() function to get the name of the
target while make() is running.plot(plan) (#1036).vis_drake_graph(), drake_graph_info(), and
render_drake_graph() now take arguments that allow behavior
to be defined upon selection of nodes. (#1031,@mstr3336).max_expand argument to make()
and drake_config() to scale down dynamic branching (#1050,
@hansvancalster).drake_config()
objects.prework is a language object, list of
language objects, or character vector (#1 at pat-s/multicore-debugging
on GitHub, @pat-s).config$layout.
Supports internal modifications by reference. Required for #685.dynamic a formal argument of
target().storrs and decorated
storrs (#1071).setdiff() and avoiding
names(config$envir_targets).dir_size(). Incurs
rehashing for some workflows, but should not invalidate any
targets.which_clean() function to preview which
targets will be invalidated by clean() (#1014, @pat-s).storr (#1015, @billdenney, @noamross)."diskframe" format for larger-than-memory
data (#1004, @xiaodaigh).drake_tempfile() function to help with
"diskframe" format. It makes sure we are not copying large
datasets across different physical storage media (#1004, @xiaodaigh).code_to_function() to allow for
parsing script based workflows into functions so
drake_plan() can begin to manage the workflow and track
dependencies. (#994, @thebioengineer)seed_trigger() (#1013,
@CreRecombinase).txtq API inside decorated
storr API (#1020).max_expand in
drake_plan(). max_expand is now the maximum
number of targets produced by map(), split(),
and cross(). For cross(), this reduces the
number of targets (less cumbersome) and makes the subsample of targets
more representative of the complete grid. It also. ensures consistent
target naming when .id is FALSE (#1002). Note:
max_expand is not for production workflows anyway, so this
change does not break anything important. Unfortunately, we do lose the
speed boost in drake_plan() originally due to
max_expand, but drake_plan() is still fast, so
that is not so bad.NULL targets (#998).cross() (#1009). The same fix should apply to
map() and split() too.map() (#1010).fst-powered saving of
data.table objects.transform a formal argument of
target() so that users do not have to type “transform =”
all the time in drake_plan() (#993).ropensci.github.io/drake to
docs.ropensci.org/drake.target(format = "keras") (#989).verbose argument in various caching
functions. The location of the cache is now only printed in
make(). This made the previous feature easier to
implement.combine()
(#1008).storr (#968).drake_plan(transform = slice()) understand
.id and grouping variables (#963).clean(garbage_collection = TRUE, destroy = TRUE).
Previously it destroyed the cache before trying to collect garbage.r_make() passes informative error messages
back to the calling process (#969).map() and
cross() on topologically side-by-side targets (#983).dsl_left_outer_join() so cross() selects the
right combinations of existing targets (#986). This bug was probably
introduced in the solution to #983.progress() more consistent, less
dependent on whether tidyselect is installed.format argument of target() (#971). This
allows users to leverage faster ways to save and load targets, such as
write_fst() for data frames and
save_model_hdf5() for Keras models. It also improves memory
because it prevents storr from making a serialized
in-memory copy of large data objects.tidyselect functionality for ... in
progress(), analogous to loadd(),
build_times(), and clean().do_stuff() and the method stuff.your_class()
are defined in envir, and if do_stuff() has a
call to UseMethod("stuff"), then drake’s code
analysis will detect stuff.your_class() as a dependency of
do_stuff().file_in() URLs. Requires
the new curl_handles argument of make() and
drake_config() (#981).target(), map(), split(),
cross(), and combine() (#979).file_out() files in clean() unless
garbage_collection is TRUE. That way,
make(recover = TRUE) is a true “undo button” for
clean(). clean(garbage_collection = TRUE)
still removes data in the cache, as well as any file_out()
files from targets currently being cleaned.clean() only appears if
garbage_collection is TRUE. Also, this menu is
added to rescue_cache(garbage_collection = TRUE)..drake/. The
old .drake_history/ folder was awkward. Old histories are
migrated during drake_config(), and
drake_history()..drake_history in
plan_to_code(), plan_to_notebook(), and the
examples in the help files.make(recover = TRUE).recoverable() and
r_recoverable() to show targets that are outdated but
recoverable via make(recover = TRUE).drake_history(). Powered by txtq (#918,
#920).no_deps() function, similar to
ignore(). no_deps() suppresses dependency
detection but still tracks changes to the literal code (#910).transform_plan().seed column of drake plans
to set custom seeds (#947).seed trigger to optionally ignore changes to
the target seed (#947).drake_plan(), interpret custom columns as
non-language objects (#942).clustermq >= 0.8.8.ensure_workers in drake_config()
and make().make() after config is already supplied.make() from inside the cache
(#927).CITATION file with JOSS paper.deps_profile(), include the seed and change the
names.make(). All
this does is invalidate old targets.set_hash() and get_hash() in
storr to double the speed of progress tracking.$ (#938).xxhash64 as the default hash algorithm
for non-storr hashing if the driver does not have a hash
algorithm.These changes are technically breaking changes, but they should only affect advanced users.
rescue_cache() no longer returns a value.clustermq (#898). Suggest
version >= 0.8.8 but allow 0.8.7 as well.drake recomputes config$layout when
knitr reports change (#887).make()
(#878).r_drake_build().r_make() (#889).expose_imports(): do not do the
environment<- trick unless the object is a non-primitive
function.assign() vs
delayedAssign().file_in() files and other strings (#896).ignore() work inside loadd(),
readd(), file_in(), file_out(),
and knitr_in().file_in() and
file_out(). drake now treats
file_in()/file_out() files as URLS if they
begin with “http://”, “https://”, or “ftp://”. The fingerprint is a
concatenation of the ETag and last-modified timestamp. If neither can be
found or if there is no internet connection, drake throws
an error."unload" and
"none", which do not attempt to load a target’s
dependencies from memory (#897).drake_slice() to help split data across multiple
targets. Related: #77, #685, #833.drake_cache() function, which is now
recommended instead of get_cache() (#883).r_deps_target() function.r_make(),
r_vis_drake_graph(), and r_outdated()
(#892).get_cache() in favor of
drake_cache().clean() menu
prompt.drake_config().config argument.use_cache to FALSE
in storr function calls for saving and loading targets.
Also, at the end of make(), call flush_cache()
(and then gc() if garbage collection is enabled).callr::r() within commands as a safe
alternative to lock_envir = FALSE in the self-invalidation
section of the make() help file.file_in()/file_out()/knitr_in()
files. We now rehash files if the file is less than 100 KB or the time
stamp changed or the file size changed.rlang’s new interpolation operator
{{, which was causing make() to fail when
drake_plan() commands are enclosed in curly braces
(#864).config$lock_envir <- FALSE” from
loop_build() to backend_loop(). This makes
sure config$envir is correctly locked in
make(parallelism = "clustermq")..data
argument of map() and cross() in the DSL.drake_plan(), repair
cross(.data = !!args), where args is an
optional data frame of grouping variables.file_in()/file_out() directories for Windows
(#855)..id_chr work with combine() in the
DSL (#867).make_spinner() unless the version of
cli is at least 1.1.0.text_drake_graph() (and
r_text_drake_graph() and
render_text_drake_graph()). Uses text art to print a
dependency graph to the terminal window. Handy for when users SSH into
remote machines without X Window support.max_expand argument to
drake_plan(), an optional upper bound on the lengths of
grouping variables for map() and cross() in
the DSL. Comes in handy when you have a massive number of targets and
you want to test on a miniature version of your workflow before you
scale up to production.clustermq workers for as
long as possible. Before launching them, build/check targets locally
until we reach an outdated target with hpc equal to
FALSE. In other words, if no targets actually require
clustermq workers, no workers get created.make(parallelism = "future"), reset the
config$sleep() backoff interval whenever a new target gets
checked.CodeDepends with a base R solution in
code_to_plan(). Fixes a CRAN note.drake_plan()) is no longer
experimental.callr API (r_make() and friends) is no
longer experimental.evaluate_plan(), expand_plan(),
map_plan(), gather_plan(),
gather_by(), reduce_plan(),
reduce_by().deps(),
max_useful_jobs(), and
migrate_drake_project().drake_plan(x = target(..., transform = map(...)))
avoid inserting extra dots in target names when the grouping variables
are character vectors (#847). Target names come out much nicer this way,
but those name changes will invalidate some targets (i.e. they need to
be rebuilt with make()).config$jobs_preprocess (local jobs) in several
places where drake was incorrectly using
config$jobs (meant for targets).loadd(x, deps = TRUE, config = your_config) to
work even if x is not cached (#830). Required disabling
tidyselect functionality when deps
TRUE. There is a new note in the help file about this, and
an informative console message prints out on
loadd(deps = TRUE, tidyselect = TRUE). The default value of
tidyselect is now !deps.testthat >=
2.0.1.9000.drake_plan() transformations, allow the user to
refer to a target’s own name using a special .id_chr
symbol, which is treated like a character string.transparency argument to
drake_ggraph() and render_drake_ggraph() to
disable transparency in the rendered graph. Useful for R installations
without transparency support.vis_drake_graph() and drake_ggraph() displays.
Only activated in vis_drake_graph() when there are at least
10 nodes distributed in both the vertical and horizontal
directions.vis_drake_graph() and
render_drake_graph().drake_plan()
(#847).drake plans (drake_plan())
inside drake_config() objects. When other bottlenecks are
removed, this will reduce the burden on memory (re #800).targets argument inside
drake_config() objects. This is to reduce memory
consumption.layout and direction
arguments of vis_drake_graph() and
render_drake_graph(). Direction is now always left to right
and the layout is always Sugiyama.drake_cache.csv by default) to avoid issues with spaces
(e.g. entry names with spaces in them, such as “file report.Rmd”)`.drake 7.0.0, if you run make() in
interactive mode and respond to the menu prompt with an option other
than 1 or 2, targets will still build.drake_graph(). The
bug came from append_output_file_nodes(), a utility
function of drake_graph_info().r_make(r_fn = callr::r_bg()) re #799.drake_ggraph() and
sankey_drake_graph() to work when the graph has no
edges.use_drake() function to write the
make.R and _drake.R files from the “main
example”. Does not write other supporting scripts.hpc column in your
drake_plan(), you can now select which targets to deploy to
HPC and which to run locally.list argument to build_times(), just
like loadd().file_in() and file_out() can now handle
entire directories,
e.g. file_in("your_folder_of_input_data_files") and
file_out("directory_with_a_bunch_of_output_files").config to HPC workers.drake_ggraph()
drake plan to the config argument of a
function.map() and cross() transformations
in the DSL, prevent the accidental sorting of targets by name (#786).
Needed merge(sort = FALSE) in
dsl_left_outer_join().verbose argument of
make() now takes values 0, 1, and 2, and maximum verbosity
in the console prints targets, retries, failures, and a spinner. The
console log file, on the other hand, dumps maximally verbose runtime
info regardless of the verbose argument.f <- Rcpp::cppFunction(...) did not stay up to date from
session to session because the addresses corresponding to anonymous
pointers were showing up in deparse(f). Now,
drake ignores those pointers, and Rcpp
functions compiled inline appear to stay up to date. This problem was
more of an edge case than a bug.drake_plan(), deprecate the
tidy_evaluation argument in favor of the new and more
concise tidy_eval. To preserve back compatibility for now,
if you supply a non-NULL value to
tidy_evaluation, it overwrites tidy_eval.drake_config() objects by
assigning closure of config$sleep to
baseenv().drake plans, the command and
trigger columns are now lists of language objects instead
of character vectors. make() and friends still work if you
have character columns, but the default output of
drake_plan() has changed to this new format.parallelism argument of
make()) except “clustermq” and “future” are removed. A new
“loop” backend covers local serial execution.built(), find_project(),
imported(), and parallel_stages(); full list
at #564) and the single-quoted file API.lock_envir to
TRUE in make() and
drake_config(). So make() will automatically
quit in error if the act of building a target tries to change upstream
dependencies.make() no longer returns a value. Users will need to
call drake_config() separately to get the old return value
of make().jobs argument to be of length 1
(make() and drake_config()). To parallelize
the imports and other preprocessing steps, use
jobs_preprocess, also of length 1.storr namespace. As a result,
drake is faster, but users will no longer be able to load
imported functions using loadd() or
readd().target(), users must now explicitly name all the
arguments except command,
e.g. target(f(x), trigger = trigger(condition = TRUE))
instead of target(f(x), trigger(condition = TRUE)).bind_plans() when the result has
duplicated target names. This makes drake’s API more
predictable and helps users catch malformed workflows earlier.loadd() only loads targets listed in the plan. It no
longer loads imports or file hashes.progress(),
deps_code(), deps_target(), and
predict_workers() are now data frames.hover to FALSE
in visualization functions. Improves speed.bind_plans() to work with lists of plans
(bind_plans(list(plan1, plan2)) was returning
NULL in drake 6.2.0 and 6.2.1).get_cache(path = "non/default/path", search = FALSE) looks
for the cache in "non/default/path" instead of
getwd().tibble.ensure_loaded() in
meta.R and triggers.R when ensuring the
dependencies of the condition and change
triggers are loaded.config argument to drake_build()
and loadd(deps = TRUE).lock_envir argument to safeguard
reproducibility. More discussion: #619, #620.from_plan() function allows the users to
reference custom plan columns from within commands. Changes to values in
these columns columns do not invalidate targets.make()
pitfalls in interactive mode (#761). Appears once per session. Disable
with options(drake_make_menu = FALSE).r_make(),
r_outdated(), etc. to run drake functions more
reproducibly in a clean session. See the help file of
r_make() for details.progress() gains a progress argument for
filtering results. For example,
progress(progress = "failed") will report targets that
failed.storr’s key mangling in favor of drake’s own
encoding of file paths and namespaced functions for storr
keys.., .., and
.gitignore from being target names (consequence of the
above).drake cache, which the
user can set with the hash_algorithm argument of
new_cache(), storr::storr_rds(), and various
other cache functions. Thus, the concepts of a “short hash algorithm”
and “long hash algorithm” are deprecated, and the functions
long_hash(), short_hash(),
default_long_hash_algo(),
default_short_hash_algo(), and
available_hash_algos() are deprecated. Caches are still
back-compatible with drake > 5.4.0 and <= 6.2.1.magrittr dot symbol to appear in some
commands sometimes.fetch_cache argument in all
functions.DBI and RSQLite from
“Suggests”.config$eval <- new.env(parent = config$envir) for
storing built targets and evaluating commands in the plan. Now,
make() no longer modifies the user’s environment. This move
is a long-overdue step toward purity.codetools package.session argument of
make() and drake_config(). Details: in
#623.graph and layout arguments
to make() and drake_config(). The change
simplifies the internals, and memoization allows us to do this.make() in a subdirectory of
the drake project root (determined by the location of the
.drake folder in relation to the working directory).verbose argument, including
the option to print execution and total build times.mclapply() or parLapply(), depending on the
operating system).build_times(), predict_runtime(), etc. focus
on only the targets.plan_analyses(), plan_summaries(),
analysis_wildcard(), cache_namespaces(),
cache_path(), check_plan(),
dataset_wildcard(), drake_meta(),
drake_palette(), drake_tip(),
recover_cache(), cleaned_namespaces(),
target_namespaces(), read_drake_config(),
read_drake_graph(), and
read_drake_plan().target() as a user-side function. From now
on, it should only be called from within drake_plan().drake_envir() now throws an error, not a warning, if
called in the incorrect context. Should be called only inside commands
in the user’s drake plan.*expr*() rlang functions with
their *quo*() counterparts. We still keep
rlang::expr() in the few places where we know the
expressions need to be evaluated in config$eval.prework argument to make() and
drake_config() can now be an expression (language object)
or list of expressions. Character vectors are still acceptable.make(), print messages about triggers
etc. only if verbose >= 2L.in_progress() to
running().knitr_deps() to
deps_knitr().dependency_profile() to
deps_profile().predict_load_balancing() to
predict_workers().this_cache() and defer to
get_cache() and storr::storr_rds() for
simplicity.hover to FALSE
in visualization functions. Improves speed. Also a breaking change.drake_cache_log_file(). We recommend using
make() with the cache_log_file argument to
create the cache log. This way ensures that the log is always up to date
with make() results.Version 6.2.1 is a hotfix to address the failing automated CRAN
checks for 6.2.0. Chiefly, in CRAN’s Debian R-devel (2018-12-10) check
platform, errors of the form “length > 1 in coercion to logical”
occurred when either argument to && or
|| was not of length 1
(e.g. nzchar(letters) && length(letters)). In
addition to fixing these errors, version 6.2.1 also removes a
problematic link from the vignette.
sep argument to gather_by(),
reduce_by(), reduce_plan(),
evaluate_plan(), expand_plan(),
plan_analyses(), and plan_summaries(). Allows
the user to set the delimiter for generating new target names.hasty_build argument to make()
and drake_config(). Here, the user can set the function
that builds targets in “hasty mode”
(make(parallelism = "hasty")).drake_envir() function that returns the
environment where drake builds targets. Can only be
accessed from inside the commands in the workflow plan data frame. The
primary use case is to allow users to remove individual targets from
memory at predetermined build steps.tibble 2.0.0.0s from
predict_runtime(targets_only = TRUE) when some targets are
outdated and others are not.sort(NULL) warnings from
create_drake_layout(). (Affects R-3.3.x.)evaluate,
formatR, fs, future,
parallel, R.utils, stats, and
stringi.parse() in code_dependencies().memory_strategy (previously pruning_strategy)
to "speed" (previously "lookahead").drake_config()
(config$layout) just to store the code analysis results.
This is an intermediate structure between the workflow plan data frame
and the graph. It will help clean up the internals in future
development.label argument to future() inside
make(parallelism = "future"). That way , job names are
target names by default if job.name is used correctly in
the batchtools template file.dplyr,
evaluate, fs, future,
magrittr, parallel, R.utils,
stats, stringi, tidyselect, and
withr.rprojroot from “Suggests”.force argument in all functions except
make() and drake_config().prune_envir() to
manage_memory().pruning_strategy argument to
memory_strategy (make() and
drake_config()).console_log_file in
real time (#588).vis_drake_graph() hover text to
display commands in the drake plan more elegantly.predict_load_balancing() and remove its
reliance on internals that will go away in 2019 via #561.worker column of
config$plan in predict_runtime() and
predict_load_balancing(). This functionality will go away
in 2019 via #561.predict_load_balancing() to time and
workers.predict_runtime() and
predict_load_balancing() up to date.drake_session() and rename to
drake_get_session_info().timeout argument in the API of
make() and drake_config(). A value of
timeout can be still passed to these functions without
error, but only the elapsed and cpu arguments
impose actual timeouts now.map_plan() function to easily create
a workflow plan data frame to execute a function call over a grid of
arguments.plan_to_code() function to turn
drake plans into generic R scripts. New users can use this
function to better understand the relationship between plans and code,
and unsatisfied customers can use it to disentangle their projects from
drake altogether. Similarly,
plan_to_notebook() generates an R notebook from a
drake plan.drake_debug() function to run a target’s
command in debug mode. Analogous to drake_build().mode argument to trigger() to
control how the condition trigger factors into the decision
to build or skip a target. See the ?trigger for
details.sleep argument to make() and
drake_config() to help the main process consume fewer
resources during parallel processing.caching argument for the
"clustermq" and "clustermq_staged" parallel
backends. Now,
make(parallelism = "clustermq", caching = "main") will do
all the caching with the main process, and
make(parallelism = "clustermq", caching = "worker") will do
all the caching with the workers. The same is true for
parallelism = "clustermq_staged".append argument to
gather_plan(), gather_by(),
reduce_plan(), and reduce_by(). The
append argument control whether the output includes the
original plan in addition to the newly generated rows.load_main_example(),
clean_main_example(), and
clean_mtcars_example().filter argument to gather_by() and
reduce_by() in order to restrict what we gather even when
append is TRUE.make(parallelism = "hasty") skips all
of drake’s expensive caching and checking. All targets run
every single time and you are responsible for saving results to custom
output files, but almost all the by-target overhead is gone.path.expand() on the file argument to
render_drake_graph() and
render_sankey_drake_graph(). That way, tildes in file paths
no longer interfere with the rendering of static image files.evaluate_plan(trace = TRUE) followed by
expand_plan(), gather_plan(),
reduce_plan(), gather_by(), or
reduce_by(). The more relaxed behavior also gives users
more options about how to construct and maintain their workflow plan
data frames."future" parallelism to make sure
files travel over network file systems before proceeding to downstream
targets.visNetwork
package is not installed.make_targets() if all the targets are
already up to date.seed argument in
make() and drake_config().caching argument of make()
and drake_config() to "main" rather than
"worker". The default option should be the lower-overhead
option for small workflows. Users have the option to make a different
set of tradeoffs for larger workflows.condition trigger to evaluate to non-logical
values as long as those values can be coerced to logicals.condition trigger evaluate to a vector
of length 1.drake_plan_source().make(verbose = 4) now prints to the console when a
target is stored.gather_by() and reduce_by() now
gather/reduce everything if no columns are specified.make(jobs = 4) was equivalent to
make(jobs = c(imports = 4, targets = 4)). Now,
make(jobs = 4) is equivalent to
make(jobs = c(imports = 1, targets = 4)). See issue #553
for details.verbose is at least 2.load_mtcars_example().hook argument of make() and
drake_config().gather_by() and reduce_by(), do not
exclude targets with all NA gathering variables.digest() wherever possible. This
puts old drake projects out of date, but it improves
speed.stringi package no longer compiles on 3.2.0.code_dependencies(), restrict the possible global variables
to the ones mentioned in the new globals argument (turned
off when NULL. In practical workflows, global dependencies
are restricted to items in envir and proper targets in the
plan. In deps_code(), the globals slot of the
output list is now a list of candidate globals, not necessarily
actual globals (some may not be targets or variables in
envir).unlink() in clean(), set
recursive and force to FALSE.
This should prevent the accidental deletion of whole directories.clean() deleted input-only files if no
targets from the plan were cached. A patch and a unit test are included
in this release.loadd(not_a_target) no longer loads every target in the
cache.igraph vertex attribute (fixes #503).knitr_in() file code
chunks.sort(NULL) that caused warnings in
R 3.3.3.analyze_loadd() was
sometimes quitting with “Error: attempt to set an attribute on
NULL”.digest::digest(file = TRUE) on directories.
Instead, set hashes of directories to NA. Users should
still not directories as file dependencies.vis_drake_graph(). Previously, these files were missing
from the visualization, but actual workflows worked just fine.codetools failures in R 3.3 (add
a tryCatch() statement in
find_globals()).clustermq-based parallel backend:
make(parallelism = "clustermq").evaluate_plan(trace = TRUE) now adds a
*_from column to show the origins of the evaluated targets.
Try
evaluate_plan(drake_plan(x = rnorm(n__), y = rexp(n__)), wildcard = "n__", values = 1:2, trace = TRUE).gather_by() and reduce_by(),
which gather on custom columns in the plan (or columns generated by
evaluate_plan(trace = TRUE)) and append the new targets to
the previous plan.template argument of clustermq
functions (e.g. Q() and workers()) as an
argument of make() and drake_config().code_to_plan() function to turn R scripts and
R Markdown reports into workflow plan data frames.drake_plan_source() function, which generates
lines of code for a drake_plan() call. This
drake_plan() call produces the plan passed to
drake_plan_source(). The main purpose is visual inspection
(we even have syntax highlighting via prettycode) but users
may also save the output to a script file for the sake of
reproducibility or simple reference.deps_targets() in favor of a new
deps_target() function (singular) that behaves more like
deps_code().vis_drake_graph() and
render_drake_graph().vis_drake_graph() and
render_drake_graph().vis_drake_graph() using
the “title” node column.vis_drake_graph(collapse = TRUE).dependency_profile() show major trigger hashes
side-by-side to tell the user if the command, a dependency, an input
file, or an output file changed since the last make().txtq
package is installed.loadd() and
readd(), giving specific usage guidance in prose.build_drake_graph() and print
to the console the ones that execute.txtq is not installed.drake’s code examples to the
drake-examples GitHub repository and make make
drake_example() and drake_examples() download
examples from there.show_output_files argument to
vis_drake_graph() and friends."clustermq_staged" and "future_lapply".igraph attributes of the
dependency graph to allow for smarter dependency/memory management
during make().vis_drake_graph() and
sankey_drake_graph() to save static image files via
webshot.static_drake_graph() and
render_static_drake_graph() in favor of
drake_ggraph() and render_drake_ggraph().columns argument to evaluate_plan()
so users can evaluate wildcards in columns other than the
command column of plan.target() so users do not have to
(explicitly).sankey_drake_graph() and
render_sankey_drake_graph().static_drake_graph() and
render_static_drake_graph() for
ggplot2/ggraph static graph
visualizations.group and clusters arguments to
vis_drake_graph(), static_drake_graph(), and
drake_graph_info() to optionally condense nodes into
clusters.trace argument to
evaluate_plan() to optionally add indicator columns to show
which targets got expanded/evaluated with which wildcard values.always_rename argument to
rename in evaluate_plan().rename argument to
expand_plan().make(parallelism = "clustermq_staged"), a
clustermq-based staged parallelism backend (see #452).make(parallelism = "future_lapply_staged"), a
future-based staged parallelism backend (see #450).codetools rather than
CodeDepends for finding global variables.loadd() and readd() dependencies in
knitr reports referenced with knitr_in()
inside imported functions. Previously, this feature was only available
in explicit knitr_in() calls in commands.drake_plan()s.inst/hpc_template_files.drake_batchtools_tmpl_file() in favor of
drake_hpc_template_file() and
drake_hpc_template_files().garbage_collection argument to
make(). If TRUE, gc() is called
after every new build of a target.sanitize_plan() in
make().tracked() to accept only a
drake_config() object as an argument. Yes, it is
technically a breaking change, but it is only a small break, and it is
the correct API choice.DESCRIPTION file.knitr reports without
warnings.lapply-like backends,
drake uses persistent workers and a main process. In the
case of "future_lapply" parallelism, the main process is a
separate background process called by Rscript.make()’s. (Previously, there were “check” messages and a
call to staged_parallelism().)make(parallelism = c(imports = "mclapply_staged", targets = "mclapply").make(jobs = 1). Now, they are kept in memory until no
downstream target needs them (for make(jobs = 1)).predict_runtime(). It is a more sensible way to
go about predicting runtimes with multiple jobs. Likely to be more
accurate.make() no longer leave targets in the user’s
environment.imports_only argument to
make() and drake_config() in favor of
skip_targets.migrate_drake_project().max_useful_jobs().upstream_only argument to failed()
so users can list failed targets that do not have any failed
dependencies. Naturally accompanies
make(keep_going = TRUE).plyr as a dependency.drake_plan() and
bind_plans().target() to help create drake plans
with custom columns.drake_gc(), clean out disruptive files in
storrs with mangled keys (re: #198).load_basic_example() in favor of
load_mtcars_example().README.md file on the main example rather
than the mtcars example.README.Rmd file to generate
README.md.deps_targets().deps() in favor of
deps_code()pruning_strategy argument to make()
and drake_config() so the user can decide how
drake keeps non-import dependencies in memory when it
builds a target.drake plans to help users customize
scheduling.makefile_path argument to make() and
drake_config() to avoid potential conflicts between
user-side custom Makefiles and the one written by
make(parallelism = "Makefile").console argument to make() and
drake_config() so users can redirect console output to a
file.show_source(),
readd(show_source = TRUE),
loadd(show_source = TRUE).!! operator from tidyeval and
rlang is parsed differently than in R <= 3.4.4. This
change broke one of the tests in tests/testthat/tidy-eval.R
The main purpose of drake’s 5.1.2 release is to fix the
broken test.R CMD check error from building the pdf
manual with LaTeX.drake_plan(), allow users to customize target-level
columns using target() inside the commands.bind_plans() function to concatenate the rows
of drake plans and then sanitize the aggregate plan.session argument to tell
make() to build targets in a separate, isolated main R
session. For example,
make(session = callr::r_vanilla).reduce_plan() function to do pairwise reductions
on collections of targets..) from being a dependency of
any target or import. This enforces more consistent behavior in the face
of the current static code analysis functionality, which sometimes
detects . and sometimes does not.ignore() to optionally ignore pieces of workflow
plan commands and/or imported functions. Use
ignore(some_code) to
drake to not track dependencies in
some_code, andsome_code when it comes to
deciding which target are out of date.drake to only look for imports in environments
inheriting from envir in make() (plus
explicitly namespaced functions).loadd() to ignore foreign imports (imports not
explicitly found in envir when make() last
imported them).loadd() so that only targets (not imports) are
loaded if the ... and list arguments are
empty..gitignore file containing "*" to
the default .drake/ cache folder every time
new_cache() is called. This means the cache will not be
automatically committed to git. Users need to remove
.gitignore file to allow unforced commits, and then
subsequent make()s on the same cache will respect the
user’s wishes and not add another .gitignore. this only
works for the default cache. Not supported for manual
storrs."future" backend with a manual
scheduler.dplyr-style tidyselect
functionality in loadd(), clean(), and
build_times(). For build_times(), there is an
API change: for tidyselect to work, we needed to insert a
new ... argument as the first argument of
build_times().file_in() for file inputs to commands or imported
functions (for imported functions, the input file needs to be an
imported file, not a target).file_out() for output file targets (ignored if used in
imported functions).knitr_in() for
knitr/rmarkdown reports. This tells
drake to look inside the source file for target
dependencies in code chunks (explicitly referenced with
loadd() and readd()). Treated as a
file_in() if used in imported functions.drake_plan() so that it automatically fills in
any target names that the user does not supply. Also, any
file_out()s become the target names automatically
(double-quoted internally).read_drake_plan() (rather than an empty
drake_plan()) the default plan argument in all
functions that accept a plan.loadd(..., lazy = "bind"). That way, when you have a target
loaded in one R session and hit make() in another R
session, the target in your first session will automatically
update.dataframes_graph().diagnose() will take on
the role of returning this metadata.read_drake_meta() function in favor of
diagnose().expose_imports() function to optionally force
drake detect deeply nested functions inside specific
packages.drake_build() to be an exclusively user-side
function.replace argument to loadd() so that
objects already in the user’s environment need not be replaced.seed argument to make(),
drake_config(), and load_basic_example(). Also
hard-code a default seed of 0. That way, the
pseudo-randomness in projects should be reproducible across R
sessions.drake_read_seed() function to read the seed
from the cache. Its examples illustrate what drake is doing
to try to ensure reproducible random numbers.!! for the
... argument to drake_plan(). Suppress this
behavior using tidy_evaluation = FALSE or by passing in
commands passed through the list argument.rlang::expr()
before evaluating them. That means you can use the quasiquotation
operator !! in your commands, and make() will
evaluate them according to the tidy evaluation paradigm.drake_example("basic"),
drake_example("gsp"), and
drake_example("packages") to demonstrate how to set up the
files for serious drake projects. More guidance was needed
in light of #193.drake_plan() in the help file
(?drake_plan).drake to rOpenSci GitHub URL.config
argument, which you can get from drake_config() or
make(). Examples:
cache$exists() instead.make() decides to build targets.storr cache in a way
that is not back-compatible with projects from versions 4.4.0 and
earlier. The main change is to make more intelligent use of
storr namespaces, improving efficiency (both time and
storage) and opening up possibilities for new features. If you attempt
to run drake >= 5.0.0 on a project from drake <= 4.0.0, drake will
stop you before any damage to the cache is done, and you will be
instructed how to migrate your project to the new drake.formatR::tidy_source() instead of
parse() in tidy_command() (originally
tidy() in R/dependencies.R). Previously,
drake was having problems with an edge case: as a command,
the literal string "A" was interpreted as the symbol
A after tidying. With tidy_source(), literal
quoted strings stay literal quoted strings in commands. This may put
some targets out of date in old projects, yet another loss of back
compatibility in version 5.0.0.rescue_cache(), exposed to the user and used
in clean(). This function removes dangling orphaned files
in the cache so that a broken cache can be cleaned and used in the usual
ways once more.cpu and elapsed
arguments of make() to NULL. This solves an
elusive bug in how drake imposes timeouts.graph argument to functions
make(), outdated(), and
missed().prune_graph() function for igraph
objects.prune() and
status().analyses() => plan_analyses()as_file() => as_drake_filename()backend() => future::plan()build_graph() =>
build_drake_graph()check() => check_plan()config() => drake_config()evaluate() => evaluate_plan()example_drake() => drake_example()examples_drake() =>
drake_examples()expand() => expand_plan()gather() => gather_plan()plan(), workflow(),
workplan() => drake_plan()plot_graph() => vis_drake_graph()read_config() =>
read_drake_config()read_graph() => read_drake_graph()read_plan() => read_drake_plan()render_graph() =>
render_drake_graph()session() => drake_session()summaries() => plan_summaries()output and code as names in the
workflow plan data frame. Use target and
command instead. This naming switch has been formally
deprecated for several months prior.drake_quotes(),
drake_unquote(), and drake_strings() to remove
the silly dependence on the eply package.skip_safety_checks flag to make()
and drake_config(). Increases speed.sanitize_plan(), remove rows with blank targets
““.purge argument to clean() to
optionally remove all target-level information.namespace argument to cached() so
users can inspect individual storr namespaces.verbose to numeric: 0 = print nothing, 1 = print
progress on imports only, 2 = print everything.next_stage() function to report the targets
to be made in the next parallelizable stage.session_info argument to make().
Apparently, sessionInfo() is a bottleneck for small
make()s, so there is now an option to suppress it. This is
mostly for the sake of speeding up unit tests.log_progress argument to make()
to suppress progress logging. This increases storage efficiency and
speeds some projects up a tiny bit.namespace argument to
loadd() and readd(). You can now load and read
from non-default storr namespaces.drake_cache_log(),
drake_cache_log_file(), and
make(..., cache_log_file = TRUE) as options to track
changes to targets/imports in the drake cache.rmarkdown::render(), not just knit().drake properly.plot_graph() to display subcomponents. Check out
arguments from, mode, order, and
subset. The graph visualization vignette has
demonstrations."future_lapply" parallelism: parallel backends
supported by the future and future.batchtools
packages. See ?backend for examples and the parallelism
vignette for an introductory tutorial. More advanced instruction can be
found in the future and future.batchtools
packages themselves.diagnose().hook argument to make() to
wrap around build(). That way, users can more easily
control the side effects of distributed jobs. For example, to redirect
error messages to a file in
make(..., parallelism = "Makefile", jobs = 2, hook = my_hook),
my_hook should be something like
function(code){withr::with_message_sink("messages.txt", code)}.drake was previously using the outfile
argument for PSOCK clusters to generate output that could not be caught
by capture.output(). It was a hack that should have been
removed before.drake was previously using the outfile
argument for PSOCK clusters to generate output that could not be caught
by capture.output(). It was a hack that should have been
removed before.make() and outdated()
print “All targets are already up to date” to the console."future_lapply" backends.plot_graph() and progress(). Also
see the new failed() function, which is similar to
in_progress().parLapply parallelism. The
downside to this fix is that drake has to be properly
installed. It should not be loaded with
devtools::load_all(). The speedup comes from lightening the
first clusterExport() call in run_parLapply().
Previously, we exported every single individual drake
function to all the workers, which created a bottleneck. Now, we just
load drake itself in each of the workers, which works
because build() and do_prework() are
exported.overwrite to FALSE
in load_basic_example().report.Rmd in
load_basic_example().get_cache(..., verbose = TRUE).lightly_parallelize() and
lightly_parallelize_atomic(). Now, processing happens
faster, and only over the unique values of a vector.make_with_config() function to do the work of
make() on an existing internal configuration list from
drake_config().drake_batchtools_tmpl_file() to
write a batchtools template file from one of the examples
(drake_example()), if one exists.Version 4.3.0 has: - Reproducible random numbers (#56) - Automatic detection of knitr dependencies (#9) - More vignettes - Bug fixes
Version 4.2.0 will be released today. There are several improvements to code style and performance. In addition, there are new features such as cache/hash externalization and runtime prediction. See the new storage and timing vignettes for details. This release has automated checks for back-compatibility with existing projects, and I also did manual back compatibility checks on serious projects.
Version 3.0.0 is coming out. It manages environments more
intelligently so that the behavior of make() is more
consistent with evaluating your code in an interactive session.
Version 1.0.1 is on CRAN! I’m already working on a massive update, though. 2.0.0 is cleaner and more powerful.