File: progressr-91-appendix.html

package info (click to toggle)
r-cran-progressr 0.18.0-1
links: PTS, VCS
area: main
in suites: forky, sid
size: 2,184 kB
sloc: sh: 13; makefile: 7
file content (395 lines) | stat: -rw-r--r-- 32,865 bytes
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>progressr: Appendix</title>
<style>
body {
  font-family: sans-serif;
  line-height: 1.6;
  padding-left: 3ex;
  padding-right: 3ex;
  background-color: white;
  color: black;
}

a {
  color: #4183C4;
  text-decoration: none;
}

h1, h2, h3 {
  margin: 2ex 0 1ex;
  padding: 0;
  font-weight: bold;
  -webkit-font-smoothing: antialiased;
  cursor: text;
  position: relative;
}

h2 {
  border-bottom: 1px solid #cccccc;
}

code {
  margin: 0 2px;
  padding: 0 5px;
  white-space: nowrap;
  border: 1px solid #eaeaea;
  background-color: #f8f8f8;
  border-radius: 3px;
}

pre code {
  margin: 0;
  padding: 0;
  white-space: pre;
  border: none;
  background: transparent;
}

pre {
  background-color: #f8f8f8;
  border: 1px solid #cccccc;
  line-height: 2.5x;
  overflow: auto;
  padding: 0.6ex 1ex;
  border-radius: 3px;
}

pre code {
  background-color: transparent;
  border: none;
}
</style>
</head>
<body>
<h1>progressr: Appendix</h1>
<!--
%\VignetteIndexEntry{progressr: Appendix}
%\VignetteAuthor{Henrik Bengtsson}
%\VignetteKeyword{R}
%\VignetteKeyword{package}
%\VignetteKeyword{vignette}
%\VignetteKeyword{packages}
%\VignetteEngine{progressr::selfonly}
-->
<h2>How tos</h2>
<h3>Report on progress in non-interactive mode (&quot;batch mode&quot;)</h3>
<p>When running R from the command line, R runs in a non-interactive mode
(<code>interactive()</code> returns <code>FALSE</code>).  The default behavior of
<strong>progressr</strong> is to <em>not</em> report on progress in non-interactive mode.
To reported on progress also then, set R options <code>progressr.enable</code> or
environment variable <code>R_PROGRESSR_ENABLE</code> to <code>TRUE</code>.  For example,</p>
<pre><code class="language-sh">$ Rscript -e &quot;library(progressr)&quot; -e &quot;with_progress(y &lt;- slow_sum(1:10))&quot;
</code></pre>
<p>will <em>not</em> report on progress, whereas</p>
<pre><code class="language-sh">$ export R_PROGRESSR_ENABLE=TRUE
$ Rscript -e &quot;library(progressr)&quot; -e &quot;with_progress(y &lt;- slow_sum(1:10))&quot;
</code></pre>
<p>will.</p>
<h2>Notes of caution</h2>
<h3>Avoid sending progress updates too frequently</h3>
<p>Signaling progress updates comes with some overhead.  In situation
where we use progress updates, this overhead is typically much smaller
than the task we are processing in each step.  However, if the task we
iterate over is quick, then the extra time induced by the progress
updates might end up dominating the overall processing time.  If that
is the case, a simple solution is to only signal progress updates
every n:th step.  Here is a version of <code>slow_sum()</code> that signals
progress every 10:th iteration:</p>
<pre><code>slow_sum &lt;- function(x) {
  p &lt;- progressr::progressor(length(x) / 10)
  sum &lt;- 0
  for (kk in seq_along(x)) {
    Sys.sleep(0.1)
    sum &lt;- sum + x[kk]
    if (kk %% 10 == 0) p(message = sprintf(&quot;Adding %g&quot;, x[kk]))
  }
  sum
}
</code></pre>
<p>The overhead of progress signaling may depend on context.  For
example, in parallel processing with near-live progress updates via
'multisession' futures, each progress update is communicated via a
socket connections back to the main R session.  These connections
might become clogged up if progress updates are too frequent.</p>
<h2>Known Limitations</h2>
<h3>The global progress handler cannot be set during package load</h3>
<p>It is <em>not</em> possible to call <code>handlers(global = TRUE)</code> in all
circumstances.  For example, it cannot be called within <code>tryCatch()</code>
and <code>withCallingHandlers()</code>;</p>
<pre><code class="language-r">&gt; tryCatch(handlers(global = TRUE), error = identity)
Error in globalCallingHandlers(NULL) : 
  should not be called with handlers on the stack
</code></pre>
<p>This is not a bug - neither in <strong>progressr</strong> nor in R itself. It's due
to a conservative design on how <em>global</em> calling handlers should work
in R. If it allowed, there's a risk we might end up getting weird and
unpredictable behaviors when messages, warnings, errors, and other
types of conditions are signaled.</p>
<p>Because <code>tryCatch()</code> and <code>withCallingHandlers()</code> is used in many
places throughout base R, this means that we also cannot call
<code>handlers(global = TRUE)</code> as part of a package's startup process,
e.g. <code>.onLoad()</code> or <code>.onAttach()</code>.</p>
<p>Another example of this error is if <code>handlers(global = TRUE)</code> is used
inside package vignettes and dynamic documents such as Rmarkdown.  In
such cases, the global progress handler has to be enabled <em>prior</em> to
processing the document, e.g.</p>
<pre><code class="language-r">&gt; progressr::handlers(global = TRUE)
&gt; rmarkdown::render(&quot;input.Rmd&quot;)
</code></pre>
<h3>A progressor cannot be created in the global environment</h3>
<p>It is not possible to create a progressor in the global environment,
e.g. in the the top-level of a script. It can only be created inside a
function, within <code>with_progress({ ... })</code>, <code>local({ ... })</code>, or a
similar construct.  For example, the following:</p>
<pre><code class="language-r">library(progressr)
handlers(global = TRUE)

xs &lt;- 1:5
p &lt;- progressor(along = xs)
y &lt;- lapply(xs, function(x) {
  Sys.sleep(0.1)
  p(sprintf(&quot;x=%g&quot;, x))
  sqrt(x)
})
</code></pre>
<p>results in an error if tried:</p>
<pre><code>Error in progressor(along = xs) : 
  A progressor must not be created in the global environment unless wrapped in a
  with_progress() or without_progress() call. Alternatively, create it inside a
  function or in a local() environment to make sure there is a finite life span
  of the progressor
</code></pre>
<p>The solution is to wrap it in a <code>local({ ... })</code> call, or more
explicitly, in a <code>with_progress({ ... })</code> call:</p>
<pre><code class="language-r">library(progressr)
handlers(global = TRUE)

xs &lt;- 1:5
with_progress({
  p &lt;- progressor(along = xs)
  y &lt;- lapply(xs, function(x) {
    Sys.sleep(0.1)
    p(sprintf(&quot;x=%g&quot;, x))
    sqrt(x)
  })
})
#  |====================                               |  40%
</code></pre>
<p>The main reason for this is to limit the life span of each progressor.
If we created it in the global environment, there is a significant
risk it would never finish and block all of the following progressors.</p>
<h3>No coloring by the 'cli' and 'crayon' packages</h3>
<p>The <strong><a href="https://cran.r-project.org/package=cli">cli</a></strong> package can be used to output colored text and messages
in the terminal, e.g. <code>message(cli::col_blue(&quot;hey&quot;))</code>. However,
<strong>cli</strong> disables such coloring by default when there is an active
progressor. The workaround is to set <strong>cli</strong> option <code>cli.num_colors</code> to:</p>
<pre><code class="language-r">options(cli.num_colors = cli::num_ansi_colors())
</code></pre>
<p>This will force <strong>cli</strong> to use the same number of colors with and
without an active progressor.</p>
<p>The same happens when using the superseeded <strong><a href="https://cran.r-project.org/package=crayon">crayon</a></strong> package for
colorization. To re-enable coloring for <strong>crayon</strong>, set the same
(sic!)  above R options.</p>
<p>The technical reason for <strong>cli</strong> and <strong>crayon</strong> disabling coloring, is
that the <strong>progressr</strong> package buffers standard output using a sink,
which these packages consider to be mono-color only.</p>
<h2>Known Issues</h2>
<h3>RStudio bug #16331: Setting global progressr handlers during startup does not work</h3>
<p>Setting the global progressr handler in <code>~/.Rprofile</code> does <em>not</em> work
in RStudio 2025.09:</p>
<pre><code class="language-r">if (requireNamespace(&quot;progressr&quot;, quietly = TRUE)) {
  progressr::handlers(global = TRUE)
}
</code></pre>
<p>This is due to a <a href="https://github.com/rstudio/rstudio/issues/16331">bug introduced in RStudio
2025.09</a>, which has
been fixed for the next release RStudio 2025.11. If you are using
RStudio 2025.09, the workaround is to instead use:</p>
<pre><code class="language-r">if (requireNamespace(&quot;progressr&quot;, quietly = TRUE)) {
  progressr::handlers(global = TRUE)

  ## Workaround for RStudio 2025.09 console bug #16331
  if (nzchar(Sys.getenv(&quot;RSTUDIO&quot;)) &amp;&amp; !nzchar(Sys.getenv(&quot;RSTUDIO_TERM&quot;))) {
    invisible(addTaskCallback(function(...) {
      ver &lt;- RStudio.Version()$version
      if (ver &gt;= &quot;2025.09&quot; &amp;&amp; ver &lt; &quot;2025.11&quot;) {
        message(&quot;Workaround for RStudio 2025.09 bug #16331: Added progressr global handler&quot;)
        progressr::handlers(global = TRUE)
      } else {
        warning(&quot;Workaround for RStudio 2025.09 bug #16331: Not needed in RStudio v&quot;, ver, &quot;. Please remove task callback 'rstudio::progressr::once' in your Rprofile startup file&quot;, call. = FALSE, immediate. = TRUE)
      }
      removeTaskCallback(&quot;rstudio::progressr::once&quot;)
    }, name = &quot;rstudio::progressr::once&quot;))
  }
}
</code></pre>
<h3>Positron bug #6892: Setting global progressr handlers during startup does not work</h3>
<p>Positron does not support setting global calling handlers during R's
startup process, e.g. in <code>~/.Rprofile</code>. Even if such handlers are
registered, they have no effect. This is a <a href="https://github.com/posit-dev/positron/issues/6892">bug in
Positron</a>
(2025-03-20), which was most recently confirmed with Position
2025.09.0 on Linux. Because of this, having something like in your
<code>~/.Rprofile</code>:</p>
<pre><code class="language-r">if (requireNamespace(&quot;progressr&quot;, quietly = TRUE)) {
  progressr::handlers(global = TRUE)
}
</code></pre>
<p>will have no effect. If used, the workaround is to manually
re-registering all calling handlers, which can be done as:</p>
<pre><code class="language-r">if (requireNamespace(&quot;progressr&quot;, quietly = TRUE)) {
  progressr::handlers(global = TRUE)

  ## Workaround for Positron (&gt;= 2025.09) bug #16331
  if (nzchar(Sys.getenv(&quot;POSITRON&quot;))) local({
    ver &lt;- numeric_version(Sys.getenv(&quot;POSITRON_VERSION&quot;))
    if (ver &gt;= &quot;2025.09&quot;) {
      message(&quot;Workaround for Positron (&gt;= 2025.09) bug #6892: progressr global handler will be installed *after* the next call has been completed&quot;)
      invisible(addTaskCallback(function(...) {
        message(&quot;Workaround for Positron (&gt;= 2025.09) bug #6892: re-installed progressr global handler&quot;)
        globalCallingHandlers(globalCallingHandlers(NULL))
        removeTaskCallback(&quot;positron::progressr::once&quot;)
      }, name = &quot;positron::progressr::once&quot;))
    }
  })
}
</code></pre>
<p>Alternatively, call:</p>
<pre><code class="language-r">globalCallingHandlers(globalCallingHandlers(NULL))
</code></pre>
<p>or</p>
<pre><code class="language-r">progressr::handlers(global = FALSE)  ## important
progressr::handlers(global = TRUE)
</code></pre>
<p>at the prompt.</p>
<h3>Positron: Messages add extra newline before the final progress step</h3>
<p>One of the features of <strong>progressr</strong> is that messages are buffered
during progress reporting and relayed as soon as possible, which
typically happens just before handlers re-render the progress
output. This way you can use <code>message()</code> as usual, regardless whether
progress is reported or not.</p>
<p>Currently, when using Positron (e.g. Positron 2025.09.0), any
<code>message()</code> output adds an extra newline before the <em>final</em> progress
step is reported, e.g.</p>
<pre><code class="language-r">&gt; progressr::handlers(global = TRUE)
&gt; progressr::handlers(&quot;cli&quot;)
&gt; y &lt;- progressr::slow_sum(1:5, message = TRUE)
M: Added value 1
M: Added value 2
M: Added value 3
M: Added value 4

M: Added value 5
&gt; 
</code></pre>
<p>I do not fully understand the reason for this, but I hope we can get
to the bottom of it and fix it, either in <strong>progressr</strong> or in
Positron, e.g. <a href="https://github.com/posit-dev/positron/issues/9486">Bug #9486</a>
(2025-09-18).</p>
<h3>Jupyter: Reporting progress to stderr (default) does not work</h3>
<p>The default for most terminal progress renders, including the ones for
<strong>progressr</strong>, display the progress on standard error (stderr). Due to
limitation in Jupyter, this default does not work there. The reason is
that <a href="https://github.com/futureverse/progressr/issues/170">Jupyter silently
drops</a> any output
send to stderr, e.g.</p>
<pre><code class="language-r">&gt; cat(&quot;hello stderr\n&quot;, file = stderr())
&gt; cat(&quot;hello stdout\n&quot;, file = stdout())
hello stdout
&gt;
</code></pre>
<p>If we try the following</p>
<pre><code class="language-r">library(progressr)
handlers(globals = TRUE)
handlers(&quot;txtprogressbar&quot;)
y &lt;- slow_sum(1:20)
</code></pre>
<p>there will be no progress being reported. This is not specific to
<strong>progressr</strong>, we have the same problem with for instance <strong>cli</strong>. Try
for instance,</p>
<pre><code class="language-r">void &lt;- cli::cli_progress_demo(delay = 1.0)
</code></pre>
<p>The workaround is to direct all progress output to the standard output
(stdout) when working in Jupyter. For this to work, we also need to
disable the buffering (&quot;delaying&quot;) of any other output to stdout.</p>
<pre><code class="language-r">library(progressr)
handlers(globals = TRUE)

## Workaround for Jupyter
options(progressr.enable = TRUE, progressr.delay_stdout = FALSE)

## Jupyter requires that progress is rendered to standard output;
## it does not work with the default standard error
handlers(handler_txtprogressbar(file = stdout()))

y &lt;- slow_sum(1:20)
</code></pre>
<h3>Jupyter bug #732 - handlers(&quot;progress&quot;) output is messy</h3>
<p>Jupyter has other outputting issues. Specifically, Jupyter <a href="https://github.com/IRkernel/IRkernel/issues/732">injects an
<em>extra</em> newline at the end of every
message</a>, e.g.</p>
<pre><code class="language-r">&gt; message(&quot;abc&quot;, appendLF = FALSE); message(&quot;def&quot;, appendLF = FALSE)
abc
def
&gt; message(&quot;abc&quot;); message(&quot;def&quot;)
abc

def

&gt; 
</code></pre>
<p>This causes any progress framework (e.g. the <strong>progress</strong> package)
that reports via messages to render progress output very poorly or not
at all.</p>
<h2>Design and Implementation</h2>
<h3>Under the hood</h3>
<p>When using the <strong>progressr</strong> package, progression updates are
communicated via R's condition framework, which provides methods for
creating, signaling, capturing, muffling, and relaying conditions.
Progression updates are of classes <code>progression</code> and
<code>immediateCondition</code>(*).  The below figure gives an example how
progression conditions are created, signaled, and rendered.</p>
<p>(*) The <code>immediateCondition</code> class of conditions are relayed as soon
as possible by the <strong><a href="https://future.futureverse.org">future</a></strong> framework, which means that
progression updates produced in parallel workers are reported to the
end user as soon as the main R session have received them.</p>
<p><img src="data:image/svg+xml;base64,<svg class="bob" font-family="monospace" font-size="14" height="608" width="656" xmlns="http://www.w3.org/2000/svg">
<defs>
<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
</marker>
<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
</marker>
<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
<circle cx="10" cy="10" fill="black" r="8"/>
</marker>
<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
<rect fill="black" height="20" width="20" x="0" y="0"/>
</marker>
<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
</marker>
<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
</marker>
</defs>
<style type="text/css">

    line,path {
      stroke: black;
      stroke-width: 2;
      stroke-opacity: 1;
      fill-opacity: 1;
      stroke-linecap: round;
      stroke-linejoin: miter;
    }
    line.dashed {
        stroke-dasharray: 5;
    }
    circle.solid {
      fill:black;
      stroke: black;
      stroke-width: 2;
      stroke-opacity: 1;
      fill-opacity: 1;
      stroke-linecap: round;
      stroke-linejoin: miter;
    }
    circle.open {
      fill:none;
      stroke: black;
      stroke-width: 2;
      stroke-opacity: 1;
      fill-opacity: 1;
      stroke-linecap: round;
      stroke-linejoin: miter;
    }
    tspan.head{
        fill: none;
        stroke: none;
    }
    
</style>
<rect fill="white" height="608" width="656" x="0" y="0"/>
<g>
<line x1="12" x2="12" y1="12" y2="52"/>
<path d="M 12 52 A 4 4 0 0 0 16 56" fill="none"/>
<path d="M 16 8 A 4 4 0 0 0 12 12" fill="none"/>
</g>
<g>
<line x1="16" x2="120" y1="8" y2="8"/>
<path d="M 124 12 A 4 4 0 0 0 120 8" fill="none"/>
</g>
<g>
<line x1="16" x2="120" y1="56" y2="56"/>
<path d="M 120 56 A 4 4 0 0 0 124 52" fill="none"/>
</g>
<g>
<line x1="88" x2="208" y1="550" y2="550"/>
</g>
<g>
<line marker-end="url(#triangle)" x1="88" x2="84" y1="552" y2="552"/>
</g>
<g>
<line x1="88" x2="208" y1="554" y2="554"/>
</g>
<g>
<line x1="124" x2="124" y1="12" y2="52"/>
</g>
<g>
<line x1="204" x2="204" y1="156" y2="196"/>
<path d="M 204 196 A 4 4 0 0 0 208 200" fill="none"/>
</g>
<g>
<line marker-end="url(#circle)" x1="204" x2="204" y1="492" y2="520"/>
<path d="M 208 488 A 4 4 0 0 0 204 492" fill="none"/>
</g>
<g>
<line x1="208" x2="256" y1="200" y2="200"/>
<path d="M 260 204 A 4 4 0 0 0 256 200" fill="none"/>
<line marker-end="url(#open_circle)" x1="260" x2="260" y1="204" y2="248"/>
<line marker-end="url(#open_circle)" marker-start="url(#open_circle)" x1="260" x2="260" y1="248" y2="312"/>
<line marker-start="url(#open_circle)" x1="260" x2="264" y1="248" y2="248"/>
<line marker-end="url(#open_circle)" marker-start="url(#open_circle)" x1="260" x2="260" y1="312" y2="360"/>
<line marker-start="url(#open_circle)" x1="260" x2="264" y1="312" y2="312"/>
<line marker-start="url(#open_circle)" x1="260" x2="260" y1="360" y2="384"/>
<line marker-start="url(#open_circle)" x1="260" x2="264" y1="360" y2="360"/>
</g>
<g>
<line x1="208" x2="256" y1="488" y2="488"/>
<path d="M 256 488 A 4 4 0 0 0 260 484" fill="none"/>
<line marker-start="url(#open_circle)" x1="260" x2="260" y1="440" y2="484"/>
<line marker-start="url(#open_circle)" x1="260" x2="264" y1="440" y2="440"/>
</g>
<g>
<line marker-end="url(#triangle)" x1="208" x2="212" y1="552" y2="552"/>
</g>
<g>
<line x1="276" x2="268" y1="240" y2="248"/>
<line x1="276" x2="284" y1="240" y2="248"/>
<line x1="292" x2="284" y1="240" y2="248"/>
<line x1="292" x2="300" y1="240" y2="248"/>
<line x1="308" x2="300" y1="240" y2="248"/>
<line x1="308" x2="316" y1="240" y2="248"/>
<line x1="324" x2="316" y1="240" y2="248"/>
<line x1="324" x2="332" y1="240" y2="248"/>
<line x1="340" x2="332" y1="240" y2="248"/>
<line x1="340" x2="348" y1="240" y2="248"/>
<line x1="356" x2="348" y1="240" y2="248"/>
<line x1="356" x2="364" y1="240" y2="248"/>
<line x1="372" x2="364" y1="240" y2="248"/>
<line x1="372" x2="380" y1="240" y2="248"/>
</g>
<g>
<line x1="276" x2="268" y1="304" y2="312"/>
<line x1="276" x2="284" y1="304" y2="312"/>
<line x1="292" x2="284" y1="304" y2="312"/>
<line x1="292" x2="300" y1="304" y2="312"/>
<line x1="308" x2="300" y1="304" y2="312"/>
<line x1="308" x2="316" y1="304" y2="312"/>
<line x1="324" x2="316" y1="304" y2="312"/>
<line x1="324" x2="332" y1="304" y2="312"/>
<line x1="340" x2="332" y1="304" y2="312"/>
<line x1="340" x2="348" y1="304" y2="312"/>
<line x1="356" x2="348" y1="304" y2="312"/>
<line x1="356" x2="364" y1="304" y2="312"/>
<line x1="372" x2="364" y1="304" y2="312"/>
<line x1="372" x2="380" y1="304" y2="312"/>
</g>
<g>
<line x1="276" x2="268" y1="352" y2="360"/>
<line x1="276" x2="284" y1="352" y2="360"/>
<line x1="292" x2="284" y1="352" y2="360"/>
<line x1="292" x2="300" y1="352" y2="360"/>
<line x1="308" x2="300" y1="352" y2="360"/>
<line x1="308" x2="316" y1="352" y2="360"/>
<line x1="324" x2="316" y1="352" y2="360"/>
<line x1="324" x2="332" y1="352" y2="360"/>
<line x1="340" x2="332" y1="352" y2="360"/>
<line x1="340" x2="348" y1="352" y2="360"/>
<line x1="356" x2="348" y1="352" y2="360"/>
<line x1="356" x2="364" y1="352" y2="360"/>
<line x1="372" x2="364" y1="352" y2="360"/>
<line x1="372" x2="380" y1="352" y2="360"/>
</g>
<g>
<line x1="276" x2="268" y1="432" y2="440"/>
<line x1="276" x2="284" y1="432" y2="440"/>
<line x1="292" x2="284" y1="432" y2="440"/>
<line x1="292" x2="300" y1="432" y2="440"/>
<line x1="308" x2="300" y1="432" y2="440"/>
<line x1="308" x2="316" y1="432" y2="440"/>
<line x1="324" x2="316" y1="432" y2="440"/>
<line x1="324" x2="332" y1="432" y2="440"/>
<line x1="340" x2="332" y1="432" y2="440"/>
<line x1="340" x2="348" y1="432" y2="440"/>
<line x1="356" x2="348" y1="432" y2="440"/>
<line x1="356" x2="364" y1="432" y2="440"/>
<line x1="372" x2="364" y1="432" y2="440"/>
<line x1="372" x2="380" y1="432" y2="440"/>
</g>
<g>
<line x1="284" x2="284" y1="12" y2="52"/>
<path d="M 284 52 A 4 4 0 0 0 288 56" fill="none"/>
<path d="M 288 8 A 4 4 0 0 0 284 12" fill="none"/>
</g>
<g>
<line x1="288" x2="384" y1="8" y2="8"/>
<path d="M 388 12 A 4 4 0 0 0 384 8" fill="none"/>
</g>
<g>
<line x1="288" x2="384" y1="56" y2="56"/>
<path d="M 384 56 A 4 4 0 0 0 388 52" fill="none"/>
</g>
<g>
<line marker-end="url(#triangle)" x1="384" x2="388" y1="248" y2="248"/>
</g>
<g>
<line marker-end="url(#triangle)" x1="384" x2="388" y1="312" y2="312"/>
</g>
<g>
<line marker-end="url(#triangle)" x1="384" x2="388" y1="360" y2="360"/>
</g>
<g>
<line marker-end="url(#triangle)" x1="384" x2="388" y1="440" y2="440"/>
</g>
<g>
<line x1="388" x2="388" y1="12" y2="52"/>
</g>
<g>
<line marker-start="url(#circle)" x1="396" x2="392" y1="248" y2="248"/>
<line marker-end="url(#open_circle)" marker-start="url(#circle)" x1="396" x2="428" y1="248" y2="248"/>
</g>
<g>
<line x1="396" x2="396" y1="264" y2="256"/>
<line marker-end="url(#open_circle)" x1="396" x2="428" y1="264" y2="264"/>
</g>
<g>
<line marker-start="url(#circle)" x1="396" x2="392" y1="312" y2="312"/>
<line marker-end="url(#open_circle)" marker-start="url(#circle)" x1="396" x2="428" y1="312" y2="312"/>
</g>
<g>
<line x1="396" x2="396" y1="328" y2="320"/>
<line marker-end="url(#open_circle)" x1="396" x2="428" y1="328" y2="328"/>
</g>
<g>
<line marker-start="url(#circle)" x1="396" x2="392" y1="360" y2="360"/>
<line marker-end="url(#open_circle)" marker-start="url(#circle)" x1="396" x2="428" y1="360" y2="360"/>
</g>
<g>
<line x1="396" x2="396" y1="376" y2="368"/>
<line marker-end="url(#open_circle)" x1="396" x2="428" y1="376" y2="376"/>
</g>
<g>
<line marker-start="url(#circle)" x1="396" x2="392" y1="440" y2="440"/>
<line marker-end="url(#open_circle)" marker-start="url(#circle)" x1="396" x2="428" y1="440" y2="440"/>
</g>
<g>
<line x1="396" x2="396" y1="456" y2="448"/>
<line marker-end="url(#open_circle)" x1="396" x2="428" y1="456" y2="456"/>
</g>
<g>
<line x1="444" x2="444" y1="12" y2="52"/>
<path d="M 444 52 A 4 4 0 0 0 448 56" fill="none"/>
<path d="M 448 8 A 4 4 0 0 0 444 12" fill="none"/>
</g>
<g>
<line x1="448" x2="552" y1="8" y2="8"/>
<path d="M 556 12 A 4 4 0 0 0 552 8" fill="none"/>
</g>
<g>
<line x1="448" x2="552" y1="56" y2="56"/>
<path d="M 552 56 A 4 4 0 0 0 556 52" fill="none"/>
</g>
<g>
<line x1="456" x2="576" y1="550" y2="550"/>
</g>
<g>
<line marker-end="url(#triangle)" x1="456" x2="452" y1="552" y2="552"/>
</g>
<g>
<line x1="456" x2="576" y1="554" y2="554"/>
</g>
<g>
<line x1="556" x2="556" y1="12" y2="52"/>
</g>
<g>
<line marker-end="url(#triangle)" x1="576" x2="580" y1="552" y2="552"/>
</g>
<g>
<line class="dashed" fill="none" x1="68" x2="68" y1="240" y2="480"/>
</g>
<g>
<line class="dashed" fill="none" x1="164" x2="164" y1="384" y2="400"/>
</g>
<g>
<line class="dashed" fill="none" x1="260" x2="260" y1="384" y2="400"/>
<line marker-end="url(#open_circle)" x1="260" x2="260" y1="400" y2="440"/>
</g>
<g>
<line class="dashed" fill="none" x1="316" x2="316" y1="384" y2="400"/>
</g>
<g>
<line class="dashed" fill="none" x1="484" x2="484" y1="384" y2="400"/>
</g>
<g>
<text x="17" y="124">
library(progressr)
</text>
</g>
<g>
<text x="17" y="140">
handlers(&#39;progress&#39;, &#39;beepr&#39;)
</text>
</g>
<g>
<text x="17" y="172">
y &lt;- with_progress({
</text>
</g>
<g>
<text x="17" y="204">
})
</text>
</g>
<g>
<text x="25" y="28">
R
</text>
</g>
<g>
<text x="33" y="188">
slow_sum(1:10)
</text>
</g>
<g>
<text x="41" y="28">
code
</text>
</g>
<g>
<text x="81" y="252">
p &lt;- progressor(10)
</text>
</g>
<g>
<text x="81" y="268">
sum &lt;- 0
</text>
</g>
<g>
<text x="81" y="300">
sum &lt;- sum + x[1]
</text>
</g>
<g>
<text x="81" y="316">
p(&#39;Added 1&#39;)
</text>
</g>
<g>
<text x="81" y="348">
sum &lt;- sum + x[2]
</text>
</g>
<g>
<text x="81" y="364">
p(&#39;Added 2&#39;)
</text>
</g>
<g>
<text x="81" y="428">
sum &lt;- sum + x[10]
</text>
</g>
<g>
<text x="81" y="444">
p(&#39;Added 10&#39;)
</text>
</g>
<g>
<text x="81" y="476">
return(sum)
</text>
</g>
<g>
<text x="97" y="572">
controlled
</text>
</g>
<g>
<text x="97" y="588">
the
</text>
</g>
<g>
<text x="129" y="588">
DEVELOPER
</text>
</g>
<g>
<text x="185" y="572">
by
</text>
</g>
<g>
<text x="273" y="236">
progression
</text>
</g>
<g>
<text x="273" y="300">
progression
</text>
</g>
<g>
<text x="273" y="348">
progression
</text>
</g>
<g>
<text x="273" y="428">
progression
</text>
</g>
<g>
<text x="297" y="28">
signaled
</text>
</g>
<g>
<text x="297" y="44">
conditions
</text>
</g>
<g>
<text x="441" y="252">
[---------]
</text>
</g>
<g>
<text x="441" y="268">
♫
</text>
</g>
<g>
<text x="441" y="316">
[&gt;--------]
</text>
</g>
<g>
<text x="441" y="332">
𝅘𝅥𝅯
</text>
</g>
<g>
<text x="441" y="364">
[=&gt;-------]
</text>
</g>
<g>
<text x="441" y="380">
𝅘𝅥𝅯
</text>
</g>
<g>
<text x="441" y="444">
[========&gt;] 100% Added 10
</text>
</g>
<g>
<text x="441" y="460">
♫
</text>
</g>
<g>
<text x="457" y="28">
progression
</text>
</g>
<g>
<text x="457" y="44">
handler
</text>
</g>
<g>
<text x="465" y="572">
controlled
</text>
</g>
<g>
<text x="465" y="588">
the
</text>
</g>
<g>
<text x="497" y="588">
END
</text>
</g>
<g>
<text x="529" y="588">
USER
</text>
</g>
<g>
<text x="545" y="316">
10% Added 1
</text>
</g>
<g>
<text x="545" y="364">
20% Added 2
</text>
</g>
<g>
<text x="553" y="252">
0%
</text>
</g>
<g>
<text x="553" y="572">
by
</text>
</g>
<g>
<line marker-start="url(#open_circle)" x1="204" x2="204" y1="88" y2="116"/>
</g>
</svg>" alt="" /></p>
<p><em>Figure: Sequence diagram illustrating how signaled progression
conditions are captured by <code>with_progress()</code>, or the global
progression handler, and relayed to the two progression handlers
'progress' (a progress bar in the terminal) and 'beepr' (auditory)
that the end user has chosen.</em></p>
<h3>Roadmap</h3>
<p>Because this project is under active development, the progressr API is
currently kept at a very minimum.  This will allow for the framework
and the API to evolve while minimizing the risk for breaking code that
depends on it.  The roadmap for developing the API is roughly:</p>
<ul>
<li>
<p>[x] Provide minimal API for producing progress updates,
i.e. <code>progressor()</code>, <code>with_progress()</code>, <code>handlers()</code></p>
</li>
<li>
<p>[x] Add support for global progress handlers removing the need for
the user having to specify <code>with_progress()</code>,
i.e. <code>handlers(global = TRUE)</code> and <code>handlers(global = FALSE)</code></p>
</li>
<li>
<p>[ ] Make it possible to create a progressor also in the global
environment (see 'Known Issues' above)</p>
</li>
<li>
<p>[ ] Add support for nested progress updates</p>
</li>
<li>
<p>[ ] Add API to allow users and package developers to design
additional progression handlers</p>
</li>
</ul>
<p>For a more up-to-date view on what features might be added, see
<a href="https://github.com/futureverse/progressr/issues">https://github.com/futureverse/progressr/issues</a>.</p>
</body>
</html>