Is the Jupyter kernel needed for publish github action when freeze: auto is set?

[dmbates]

I have been looking at the way that I currently have a Quarto book with Julia code chunks being rendered to gh-pages. (Book is at https://JuliaMixedModels.github.io/EmbraceUncertainty).

If I understand the documents at https://quarto.org/docs/publishing/github-pages.html#freezing-computations correctly then setting freeze: auto in _quarto.yml and rendering the book will save the output of the code chunks in the _freeze directory (which I do have committed in the repository).

I was hoping that I could then render the book in a github action without the need to configure Jupyter and a Julia kernel. However, the render and publish step fails because it can't access the kernel. (I am actually experimenting on another, private repository but can pull back the curtains if my description is too vague.)

Should this be happening or have I misconfigured the github action? In other words, is there a way I can configure the github action so that Quarto recognizes that it will use the results in the _freeze directory and can ignore the jupyter specification in the files?

An alternative approach, although perhaps less efficient, would be to get a recipe for configuring a Julia kernel in Jupyter for the github action.

[andrewpbray]

I went through a similar conundrum with a course website: how to handle the rendering and publishing via CI. I didn't want to have to fully reproduce the compute environment on the GHA machine, so I opted for freeze: auto, commit that repo, then just have the GHA quarto render the non-compute stuff. Here's the action:

https://github.com/stat20/course-materials/blob/main/.github/workflows/publish-full.yml

This is all in R, not Julia, but my understanding of the render and freeze functionality is that it'd be the same regardless of if it's knitr or jupyter handling the compute.

Happy to take a look at your GHA, though I'm no pro at those.

[mcanouil]

In some cases, the kernel to be used might not be properly detected, I'd recommend you to set it explicitly, see #4218.

Also note that Quarto Actions do not setup R/Python/Julia/etc., thus you need to add the appropriate step into your GitHub Actions Workflow.
R/Python/Julia have all actions to install them.

EDIT: if you really want no computations at all, use freeze: auto.
Note also that "freeze" is not "cache" as discussed in several other GitHub Issues/Discussions and described in Quarto documentation.

[cderv]

@dmbates Using freeze should indeed not require Julia in your CI when re rendering. The approach of freezing for CI rendering is mentionned in https://quarto.org/docs/publishing/ci.html#rendering-for-ci

But this means you need to commit in your github repository the _freeze directory. Currently it is not https://github.com/JuliaMixedModels/EmbraceUncertainty/blob/main/.gitignore#L10

This is explained for example in the Github Pages and Github Action part: https://quarto.org/docs/publishing/github-pages.html#github-action

Once you’ve done this, check all of the newly created files (including the _freeze directory) into your repository and then push to GitHub.

So rendering everything locally with freeze and adding the folder to your git repo will allow you to rendering only the output on your CI workflow without need to set up a computation environment.

You can find that @andrewpbray example has correctly the _freeze folder checked on Github in https://github.com/stat20/course-materials

Hope it helps

[mcanouil]

@cscheid I did not know this was available ... 🤯
I was going to basically write it again here 🤦‍♂️
In the future, I will simply share that link 😎

[dmbates]

@cscheid I think I have the Python, Jupyter, Julia and IJulia installation working now. I still haven't got the deployment quite right but I can work on that later.

It appears that publish action re-executes the code chunks. In other words, it doesn't seem to abide by the freeze: true in _quarto.yml. Should I expect it to do so? This is not a big deal for this simple example but for a book it would be a heavy load to re-execute all the code for tables, figures, etc. at every commit. It seems that the _freeze directory would not be of any use in that case and the advantages like evaluating code chunks in a specialized environment would be lost.

[cscheid]

It appears that publish action re-executes the code chunks. In other words, it doesn't seem to abide by the freeze: true in _quarto.yml. Should I expect it to do so?

You should expect it to do so, yes. If that's not happening, it's a bug on our side. I'm actually in the middle of tracking that other Julia bug, so it'll take me a bit to get to the bottom of this one. But (from a cursory look) your repo looks good, and I'm inclined to think this is a bug.

[cderv]

Thanks @cscheid for chiming in !

Test I did here:

• Clone plotdemo repo
• Render locally quarto render -> Julia is not needed. The freezing works
• Try to publish quarto publish quarto-pub => Rendering using Julia is happening

So we have an issue here I believe in our publish workflow

[cderv]

I have opened #4252 to track this