Bug: Quarto render with intermediate print statements results in split code blocks for html and lost content for ipynb

[hguturu]

Bug description

A code block with intermediate print statements appears to be splitting the code block into two when rendering html (minor bug) and truncating the code block at the print when rendering ipynb (major bug).

Steps to reproduce

Considering the following qmd file, where the only difference in behavior is if the print("getting all analyses") is kept or commented out.

---
title: Test Notebook
format:
  html:
    embed-resources: true
  ipynb:
    default
---

```{r login}
# Stub to get analysis
get_analysis <- function() {
    print("getting all analyses") # this line is commented out for notebook_no_print results
    analysis <- list(
        list(analysis_name = "AvsB", id = 2),
        list(analysis_name = "CvsD", id = 3)
    )
    analysis
}

# Get analysis
analysis <- get_analysis()

# Filter Analysis
analysis <- purrr::keep(
    analysis,
    \(it) it$analysis_name == "AvsB"
)[[1]] |> as.list()

analysis
```

quarto render notebook_print.qmd and quarto notebook_no_print.qmd create the two bug states. Since I am unable to attach the html and ipynb, I will paste screenshots below.

notebook_no_print

html

ipynb

notebook_print

html

Code blocks are split

ipynb

Code block is truncated

Actual behavior

Code blocks with print in the middle split the code block in html (and truncate for ipynb). Other formats may also be impacted.

Expected behavior

I think in both cases the code blocks shouldn't be split (and certainly not truncated).

I think the correct behavior would be for the notebook_print case to behave like notebook_no_print case where all output being rendered after the code block. This also ensures the behavior similar to jupyter and also keeps code blocks together.

FWIW, this doesn't seem to be an issue when using {python}. The output looks as expected and the notebook is fine as well:

Your environment

• Shell: zsh 5.9 (arm64-apple-darwin24.0)
• OS: MacOS Sequoia 15.4

Quarto check output

Quarto 1.6.42
[✓] Checking environment information...
      Quarto cache location: /Users/hguturu/Library/Caches/quarto
[✓] Checking versions of quarto binary dependencies...
      Pandoc version 3.4.0: OK
      Dart Sass version 1.70.0: OK
      Deno version 1.46.3: OK
      Typst version 0.11.0: OK
[✓] Checking versions of quarto dependencies......OK
[✓] Checking Quarto installation......OK
      Version: 1.6.42
      Path: /Applications/quarto/bin

[✓] Checking tools....................OK
      TinyTeX: (not installed)
      Chromium: (not installed)

[✓] Checking LaTeX....................OK
      Tex:  (not detected)

[✓] Checking basic markdown render....OK

[✓] Checking Python 3 installation....OK
      Version: 3.11.11
      Path: /Users/hguturu/git/pas-ai-notebooks-internal/.venv/bin/python3
      Jupyter: 5.7.2
      Kernels: python3, ir

[✓] Checking Jupyter engine render....OK

[✓] Checking R installation...........OK
      Version: 4.4.3
      Path: /Library/Frameworks/R.framework/Resources
      LibPaths:
        - /Library/Frameworks/R.framework/Versions/4.4-arm64/Resources/library
      knitr: 1.50
      rmarkdown: 2.29

[✓] Checking Knitr engine render......OK

[mcanouil]

A Notebook is a JSON file so you can paste it as code block.

To be clear, here by notebook you mean the output format, correct?

[hguturu]

I am using the term notebook a bit casually to cover both qmd and ipynb. But, yes the truncation bug is with respect to the ipynb output format. The code block splitting is with the html output format. Pasting the json content if that is helpful.

notebook_no_print.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Test Notebook"
      ],
      "id": "c6cd2d8e-085a-47f5-9917-8215d8e40cc5"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "$analysis_name\n",
            "[1] \"AvsB\"\n",
            "\n",
            "$id\n",
            "[1] 2"
          ]
        }
      ],
      "source": [
        "# Stub to get analysis\n",
        "get_analysis <- function() {\n",
        "    # print(\"getting all analyses\")\n",
        "    analysis <- list(\n",
        "        list(analysis_name = \"AvsB\", id = 2),\n",
        "        list(analysis_name = \"CvsD\", id = 3)\n",
        "    )\n",
        "    analysis\n",
        "}\n",
        "\n",
        "# Get analysis\n",
        "analysis <- get_analysis()\n",
        "\n",
        "# Filter Analysis\n",
        "analysis <- purrr::keep(\n",
        "    analysis,\n",
        "    \\(it) it$analysis_name == \"AvsB\"\n",
        ")[[1]] |> as.list()\n",
        "\n",
        "analysis"
      ],
      "id": "7e3fbbf4-b290-49d2-9eeb-3e78190fb3fa"
    }
  ],
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  }
}

notebook_print.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Test Notebook"
      ],
      "id": "5c8a8181-9d92-4679-a429-121e912014ca"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1] \"getting all analyses\""
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "$analysis_name\n",
            "[1] \"AvsB\"\n",
            "\n",
            "$id\n",
            "[1] 2"
          ]
        }
      ],
      "source": [
        "# Stub to get analysis\n",
        "get_analysis <- function() {\n",
        "    print(\"getting all analyses\")\n",
        "    analysis <- list(\n",
        "        list(analysis_name = \"AvsB\", id = 2),\n",
        "        list(analysis_name = \"CvsD\", id = 3)\n",
        "    )\n",
        "    analysis\n",
        "}\n",
        "\n",
        "# Get analysis\n",
        "analysis <- get_analysis()"
      ],
      "id": "0a518236-c386-4c72-8a08-bdac45b86f66"
    }
  ],
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  }
}

[mcanouil]

Note that what you call "split" is a knitr feature not a bug.
If you want to have all outputs being generated only at the end of the code cell, use results: hold.

This option is likely to solve both issues.

[mcanouil]

I can reproduce the fact that if multiple outputs are generated, the Jupyter Notebook will only have the first code/output unless results: hold is used.

---
title: Test Notebook
format:
  html: default
  ipynb: default
---

```{r}
print("Hello, world!")
x <- 1:10
y <- x^2
print("Bye, world!")
```

```{r}
#| results: hold
print("Hello, world!")
x <- 1:10
y <- x^2
print("Bye, world!")
```

Note that if you want to output Jupyter Notebook, you should explicitly set a kernel that supports R as it will produce a Jupyter Notebook that uses Python as the kernel.

[hguturu]

I can reproduce the fact that if multiple outputs are generated, the Jupyter Notebook will only have the first code/output unless results: hold is used.

Is there a way to configure this globally for all qmd files? We are building a website that allows ipynb downloads, I want to make sure malformed ipynb aren't generated since the author forgot results: hold

Note that if you want to output Jupyter Notebook, you should explicitly set a kernel that supports R as it will produce a Jupyter Notebook that uses Python as the kernel.

What is the way to handle this if we have mixed code repositories? Our qmd files use a combination of R, Python and Julia.

{r login}

I noticed this when reviewing some R qmd files, is the annotation for a code block documented somewhere? Is it also available for other languages such as python?

I want to make sure my PR for nbqa covers the full set of possibilities? https://github.com/nbQA-dev/nbQA/pull/881/files#diff-d72c6dc865400b582f957459d2f13e4030da8a9f8afdec522def74313d29a25fR137. Perhaps I need to change it to token.info.startswith("{python") instead of token.info.startswith("{python}"). Unless this is something only for kintr and not quarto. Relevant to #12364.

[mcanouil]

Is there a way to configure this globally for all qmd files? We are building a website that allows ipynb downloads, I want to make sure malformed ipynb aren't generated since the author forgot results: hold

Note that this is a knitr specific option.
It's available at a code cell level but for global effect, you need to use knitr: https://quarto.org/docs/computations/r.html#knitr-options

What is the way to handle this if we have mixed code repositories? Our qmd files use a combination of R, Python and Julia.

Set engine explicitly per document: knitr, jupyter, or julia.
If you export to Jupyter Notebook you really should set the kernel that is to be used as the default Jupyter kernel otherwise it will be Python and Python kernel cannot handle R code or Julia code, so your user will download "broken" notebooks.

I noticed this when reviewing some R qmd files, is the annotation for a code block documented somewhere? Is it also available for other languages such as python?

In Quarto, code cells options are set as YAML (nothing but the language in the brackets), they are all documented in the computations reference guides. https://quarto.org/docs/reference/

Only knitr allows R inline options but that's knitr specific. Quarto handles YAML options mostly, so you should avoid R inline options, especially mixing syntaxes (that's already not recommended in knitr/rmarkdown).
Now, the users mixing syntaxes are knitr/rmarkdown users. If you want to support this, it's going to be a bit tricky for you as you will have to handle conflicts such as:

```{r my-label1}
#| label: my-label2
```

[hguturu]

Only knitr allows R inline options but that's knitr specific. Quarto handles YAML options mostly, so you should avoid R inline options, especially mixing syntaxes (that's already not recommended in knitr/rmarkdown).

Thanks for clarifying this. I won't support it since its not quarto, but rather knitr and R specific, while nbqa is python specific.