Freeze execution of individual code blocks

[skwde]

Description

While creating slides I would like to have code blocks executed until I am

1. Happy with the code
2. Happy with the output

It seems however that there is no fine-grained control on which ones to freeze and which ones to run.
It appears that the freeze: true can only applied globally via _quarto.yml or via _metadata.yml.

While this is fine at the beginning once there are many executable code blocks it quickly takes a lot of time when rerendering / previewing.

Here is a minimal working example:

Use the revealjs-slides/_metadata.yml

jupyter: python3
execute:
  echo: true
  output: true
  freeze: false
  # cache: true
  keep-ipynb: false
format:
  revealjs:
    # ## use aspectratio 1610
    width: 1280 # default: 970
    height: 800 # default: 700
    auto-stretch: false
    navigation-mode: vertical
    controls: true
    progress: true
    slide-number: h.v
    toc: true
    toc-depth: 1

and the revealjs-slides/slides.qmd

---
title: TEST
---

# ABC

```{python}
# | tags: [parameters]
bound = 1000000
```

starting at `0`

There are of course severals ways to do this.

Using a simple `for` loop

```{python}
# | freeze: true
%%timeit
s = []
for i in range(bound):
    s.append(i*i)
sum(s)
```

The _quarto.yml just has

date: last-modified
date-format: long

Running this via

quarto preview revealjs-slides/slides.qmd --no-browser  --port 8000

while modifying revealjs-slides/slides.qmd shows that the freeze: true in the executable code block is just ignored.

Note, also using {{< include sub.qmd >}} in slides.qmd with a frontmatter execute.freeze: true in sub.qmd seems to be ignored.

How do I prevent individual codeblocks from rendering and / or vice versa when setting freeze: true globally?

---

My setup:

# quarto --version
1.5.5

on debian bookworm in a devcontainer on MacOS.

[mcanouil]

Did you look at the documentation about caching? (https://quarto.org/docs/computations/caching.html#jupyter-cache)

[skwde]

Well yes, briefly but I haven't done any tests.

The second sentence from the docs you link to

If any of the cells in the notebook change then all of the cells will be re-executed

already reads like it is not providing a mechanism to stop individual cells from being executed.
It seems like all cells are executed if a single cell changes.

Am I wrong?

[cderv]

Quarto does not provide mechanism to cache / freeze a single cell only.

freeze: true in the executable code block is just ignored.

freeze is not an option you can set on a cell. AFAIK we don't document it, and it is not offer by autocompletion in cell option either. So not expected to be valid, or have the effect you expect.

As documented, freeze is a applying at a document level so that computation are not re-ran when the whole project is rendered with quarto render

Other options quarto offers is Caching, and this is by leveraging anything that the engine offers, JupyterCache or Knitr cache. What you can do with those are specific to the engine. With knitr engine, you can cache a single cell if needed. With Jupyter engine, I don't think you can cache a single cell execution, so this is why Quarto does not offer this.

It means you need to come up with you own caching mechanism if you need to save state of long computation code cells, by maybe using Python packages that allows to store result on disk or elsewhere easily, and invalidate when something change in the evaluation code.

Hope this helps understand

[mcanouil]

What do you think of freeze on individual code cells?
Would this be a valid future request?

That's unlikely to happen at least in a near future as this will lead to more headaches than anything else.
if you "freeze" or cache a cell without a mechanism to invalidate it if the things it depends on change, then you'll get bad results without even knowing it. That's possibly why Jupyter cache everything.
Having the users to check the validity of every cache/freeze manually is really a terrible design choice.

As suggested, you should look to such tools directly in the engine you are using. For example, there targets in R which does a better/more advanced caching than what knitr does.

For your other issue, please open a new discussion (if there is none already opened) with a fully reproducible example as it's unrelated to the current thread.

[skwde]

For your other issue, please open a new discussion (if there is none already opened) with a fully reproducible example as it's unrelated to the current thread.

Ok, done. I opened the issue #10447

---

As for the rest:

Hmm ok I do agree that this is kind of a bad design choice. (But this is just how jupyter notebooks work, you can run individual cells and it will not rerun all cells.)

In any case a possible solution would be to allow for groups that are rerun (and overwrites the freeze if set) when a certain cell runs.

Even if it is unlikely for the near future it would be nice to allow for it in future ;).

[mcanouil]

Hmm ok I do agree that this is kind of a bad design choice. (But this is just how jupyter notebooks work, you can run individual cells and it will not rerun all cells.)

Quarto can use Jupyter Notebook directly and you can choose to execute the cells or not.

[skwde]

I am aware of that but thanks for pointing it out.

I however don't know if I can create slides from that (other than rendering to revealjs which would make it difficult to stick to slide sizes).

[mcanouil]

I however don't know if I can create slides from that (other than rendering to revealjs which would make it difficult to stick to slide sizes).

I don't understand what you mean. You can make Reveal.js using Jupyter Notebook. It works the same way.