Conditional Chunk Execution

[agerlach]

Is it possible to conditionally evaluate a chunk based on the output format? https://quarto.org/docs/authoring/conditional.html only seems to apply with the actual display of content. Any chunks are still executed. I expect that the div gets parsed after execution. If not possible, it would be nice to have something like #| eval-when-format: and #| eval-unless-format:

MWE:

::: {.content-hidden when-format="html"}
```{julia}
q = 4
```
:::

```{julia}
using Markdown
Markdown.parse(""" q = $(q)""")
```

shows q=4 even with html output.

The motivation for doing this is to use conditional CairoMakie themes based on the output, e.g. font and font size of labels and figure size.

[cscheid]

Your suspicion is correct, and unfortunately that's not currently possible. It's on our radar to support a language-agnostic way for quarto to communicate things like output format, but it doesn't currently exist.

[agerlach]

I figured, but wanted to double check.

Alternatively, I could have the conditional execution happen inside the chunk itself. Is if possible to set a parameter or document variable for the format that I could if/else on?

[TS-CUBED]

Any news on this? For me that's now a hard requirement for the next paper (i.e. right now) - want to move to Quarto from Org-Mode, where I can do everything, but need to get all colleagues to Emacs. Quarto is great, but not quite as complete for "write-once, publish anywhere" literate programming/reproducible publications.

If there isn't a code-block option, is there a trick to set a variable in the headers, so I can do a conditional execution within the code block? Basically, what @agerlach asked.

[cscheid]

Unfortunately, it's not there yet.

[TS-CUBED]

Any idea when it will be? I can try and hack around it (exporting both options as include files and use the .visible divs to only slow the ones that fit the output format, or write both image formats and have two different ![]() blocks), but wouldn't if a more elegant solution is available soon.

[cscheid]

I think, realistically it's something we'll get to on 1.4, which means 2-3 months out.

[dtoher]

I think, realistically it's something we'll get to on 1.4, which means 2-3 months out.

Is this likely to solve the issue when you want to use 2 different
\newcommand{\bfmu}{\boldsymbol{\upmu}}

but, then redefining (renewing the command) if the output is in pdf format?
\renewcommand{\bfmu}{\mbfsansmu}

All I want to do is have upright boldface Greek lowercase letters, who knew if could be so tricky?

I know that I could essentially wrap long parts of my text within

::: {.content-hidden unless-format="pdf"}

:::

etc, but this becomes unwieldy very quickly and makes documents much harder to ensure consistency in.

[cscheid]

@dtoher If I understand correctly, your issue is solvable in a simpler way, by defining commands depending on formats on the yaml front matter.

[andrewpbray]

This will definitely be a useful feature when it's available!

In the meantime, here is a hack that... might work? It relies up on the behavior that execution options specifically within a cell override global execution options specified in document YAML.

1. Set up a custom html format.

   title: eval-false
   author: J.J. Allaire
   version: 1.0.0
   quarto-required: ">=1.2.222"
   contributes:
     formats:
       html:
         execute:
           eval: false
   

2. In the YAML of your qmd, change it to format: html-eval-false

3. Adjust your second cell (which you always want to execute) to use eval: true.

Your MWE would look like:

---
format: html-eval-false
---
::: {.content-hidden when-format="html-eval-false"}
```{julia}
q = 4
```
:::

```{julia}
#| eval: true
using Markdown
Markdown.parse(""" q = $(q)""")

This should lead to the following behavior.

• When format: html-eval-false:
  • Cell 1 does not execute and is not shown
  • Cell 2 does execute and is shown
• When format: anything-else:
  • Cell 1 does execute and is shown
  • Cell 2 does execute and is shown

I haven't tried this so I can't verify that it'd work. It counts on the fact that conditional formatting works for custom formats. Reading the docs, I can't tell if that's true or not.

[cscheid]

This is probably something that might work on 1.2 and probably won't work on 1.3, where we changed the resolution of when-format attributes to be more lenient (and, in the process, means that we lost the ability to target a "specific" format).

We have a separate open issue about that.

[dtoher]

My current trivial solution is to create two options of defining the same commands and commenting out the irrelevant one as needed. It would be nice to have these in separate files, only called as needed for more complex documents, but I have a functional solution that is likely to remain functional.

[cscheid]

Thanks for the context! Is that file publicly available, by any chance? The more we know about how this stuff is needed in the wild, the better we'll be able to design a proper fix for it.

[mcanouil]

It's a follow up from Twitter (thread: https://twitter.com/dtoher/status/1631292531349635072?s=20):

source: https://github.com/dtoher/QuartoIssues

A PR of mine with a suggestion to use knitr and R: dtoher/QuartoIssues#1.

[bennotkin]

I'm similarly trying to conditionally run chunks and have come to the following "solution" using ojs_define(), !expr and the frontmatter parameters. For R, this works well. For OJS, I'm not sure.

For R:

1. In the YAML front matter, define a parameter that determines if the chunk should run or not. (Here, I am simply using run: true or run: false but you could use a non-boolean parameter that you then handle in an R chunk later on.)
2. Set eval: !expr params$run (or whichever parameter name you're using) in the chunk options. The chunk won't run if params$run evaluates to false.

For OJS, same first step:

3. For OJS, we need to port our parameter over using ojs_define(): ojs_define(run = params$run)
4. As with R, we set the chunk options to eval: !expr run. This only partially prevents the chunk from running but it does prevent it from throwing an error!
5. If it's okay that the code runs but doesn't error with your use case, all you need to do now is hide the output with CSS (after giving a CSS class to the code chunk with some inline R.

    ---
    format: html
    params:
      run: false
    ---
    
    ```{r}
    #| eval: !expr params$run
    paste("This isn't supposed to run if `run` is false. `run`= ", params$run)
    ```
    
    And, because `!expr params$run` evaluates to `false`, that chunk doesn't run. Good!
    
    With ojs we first pass params$run with `ojs_define()`
    
    ```{r}
    ojs_define(run = params$run)
    ```
    
    and check that ojs does indeed have it
    
    ```{ojs}
    "OJS knows `run` = " + run
    ```
    
    and then test it out in the `eval` chunk option.
    
    ```{ojs}
    //| eval: !expr run
    
    "Will an undefined variable trigger an error?"
    run // Try a defined variable
    undefined_variable // Try an undefined variable
    ```
    
    And *voila!*-ish, the code runs (see `run` prints as `false`), but `undefined_variable` doesn't cause a runtime error. Meanwhile, we see that running the same chunk with `eval: true` *does* cause a runtime error:
    
    ```{ojs}
    //| eval: true
    
    "Will an undefined variable trigger an error?"
    run // Try a defined variable
    undefined_variable // Try an undefined variable
    ```

Now, to hide the output we need some CSS, and to assign a CSS class to the cell. First, assign the class by using div fences and some inline R:

    ::: `r paste0("eval-", params$run)`
    ```{ojs}
    //| eval: !expr run
    //| echo: false
    //| output: false
    
    "Will an undefined object trigger an error?"
    undefined_object
    ```
    :::

This means that the div will be class .eval-TRUE when it is supposed to be evaluated and .eval-FALSE when not. We want to set display: none for .eval-FALSE.

But the rendering also throws in some raw code (another div fence and some javascript? :::{.cell eval=“{”value”:“run”,“tag”:“!expr”}“} and ::: as paragraph tags). To hide these, we need to select the first <p> child and the first <p> sibling:

div.eval-FALSE,
div.eval-FALSE + p ,
.eval-TRUE p:first-child,
.eval-TRUE + p {
    display: none;
}

Again, this only partially stops evaluation (not really sure how much is being stopped, so beware!

[trizniak]

I have a qmd doc rendered in both html and docx, and I wanted to include a DT datatable in the html output
I tried various simple solutions, including some of those mentioned here, to have knitr ignore that part of the code for the docx output, but I always got the same

Error: Functions that produce HTML output found in document targeting docx output.

what worked was to include the problematic part of the code in an if statement, the condition being knitr::is_html_output()
{if (knitr::is_html_output()) DT::datatable(...)}
this is based on @dtoher's post on greek vectors

tried also to have the whole chunk evaluated or not based on the same condition (#| eval: !expr "knitr::is_html_output()" or #| eval: !expr 'knitr::is_html_output()') but it didn't work; not sure whether it was due to incorrect syntax

[mcanouil]

Please provide a small reproducible example when asking for help.

---

You can share a self-contained "working" (reproducible) Quarto document using the following syntax, i.e., using more backticks than you have in your document (usually four ````).
See https://quarto.org/bug-reports.html#small-is-beautiful-aim-for-a-single-document-with-10-lines.

If you have multiple files (and if it is absolutely required to have multiple files), please share as a Git repository.

R	Python
````qmd --- title: "Reproducible Quarto Document" format: html engine: knitr --- This is a reproducible Quarto document. {{< lipsum 1 >}} ```{r} x <- c(1, 2, 3, 4, 5) y <- c(1, 4, 9, 16, 25) plot(x, y) ``` {#fig-placeholder} {{< lipsum 1 >}} The end after @fig-placeholder. ````	````qmd --- title: "Reproducible Quarto Document" format: html engine: jupyter --- This is a reproducible Quarto document. {{< lipsum 1 >}} ```{python} import matplotlib.pyplot as plt x = [1, 2, 3, 4, 5] y = [1, 4, 9, 16, 25] plt.plot(x, y) plt.show() ``` {#fig-placeholder} {{< lipsum 1 >}} The end after @fig-placeholder. ````

Additionally and if not already given, please share the output of quarto check within a code blocks (i.e., using three backticks ```txt), see https://quarto.org/bug-reports.html#check.

[cderv]

what worked was to include the problematic part of the code in an if statement, the condition being knitr::is_html_output()
{if (knitr::is_html_output()) DT::datatable(...)}

This is the recommended way to avoid some R code to be ran in a specific format. We documented it in the R Markdown Cookbook at the time: https://bookdown.org/yihui/rmarkdown-cookbook/latex-html.html
which is still valid for Quarto as it is knitr engine related.

tried also to have the whole chunk evaluated or not based on the same condition (#| eval: !expr "knitr::is_html_output()" or #| eval: !expr 'knitr::is_html_output()') but it didn't work; not sure whether it was due to incorrect syntax

Using !expr feature from R yaml package works in knitr context, but you need to understand it. After expr should be a R expression. So it would be

#| eval: !expr knitr::is_html_output() 

without any quotes, otherwise this is a R string.

Hope it helps