How do I correctly convert from .qmd to .ipynb?

[juliasilge]

Description

If I start with a Quarto file, say named test.qmd, like this:

---
title: "Here is my great title"
format: html
---

This is a reproducible Quarto document using `format: html`.
It is written in Markdown and contains embedded R code.
When you run the code, it will produce a plot.

```{r}
plot(cars)
```

Wow, nice!

Then I can convert it via quarto convert test.qmd. However, the .ipynb file that I get is pretty mangled:

{
  "cells": [
    {
      "cell_type": "raw",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Here is my great title\"\n",
        "format: html\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This is a reproducible Quarto document using `format: html`.\n",
        "It is written in Markdown and contains embedded R code.\n",
        "When you run the code, it will produce a plot.\n",
        "\n",
        "```{r}\n",
        "library(ggplot2)\n",
        "```\n",
        "\n",
        "Wow, nice!"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}

What is the correct way to convert from .qmd to .ipynb? I could understand not having the right kernelspec since that's not really encoded in the Quarto file, but the cells are not at all correct.

I'm using Quarto 1.5.21 on macOS.

[juliasilge]

cc @blairj09

[mcanouil]

Python does not know how to treat R code.
So in this context, it's expected that the R code cell is "markdown".

Try out with a Python code cell, you should see a Python cell in the notebook.

Setting the engine and kernel to one that knows R, could help Quarto (nbconvert) do the translation.

[juliasilge]

Setting the engine and kernel to one that knows R

Can you say more about this? Are there docs I can look at on this?

[jthomasmock]

I think you'd need to specify an R jupyter kernel: https://quarto.org/docs/computations/python.html#kernel-selection

IRkernel for example: https://github.com/IRkernel/IRkernel

[jthomasmock]

However, interestingly quarto convert doesn't roundtrip the kernel information:

---
title: "Test R Quarto"
format: html
jupyter:
    kernelspec:
        name: "ir43"
        language: "R"
        display_name: "R 4.3.2"
---

```{r}
library(ggplot2)
```

Becomes

[cscheid]

@jthomasmock This is definitely a bug on Quarto!

[maptv]

@juliasilge, I had the same problem (code blocks turning into markdown when converting from qmd to ipynb), so I tried the inverse (ipynb to qmd) and found the answer in the resulting qmd.

@mcanouil and @jthomasmock are correct; providing Jupyter info in the YAML header is the key (unintentional YAML pun). I got your example to work by adding jupyter: ir to the test.qmd YAML header:

---
title: "Here is my great title"
format: html
jupyter: ir
---

I tested this solution with the ir, python3, xlua, julia-1.10, and deno kernels using Quarto 1.5.56 on macOS.

Before trying this solution, I suggest that you check the name of your R kernel by running jupyter kernelspec list or quarto check jupyter. You will get an error if the kernel name in your YAML header is not an exact match:

ERROR: Jupyter kernel 'TEST' not found. Known kernels: python3, xlua, deno, julia-1.10, ir.

@jthomasmock, I tested your example. In my hands, the entire YAML header survived roundtrip conversion, even if all of the kernelspec parameters are wrong.

Also, your example solves the issue, but only if the language YAML parameter in kernelspec is provided correctly. If the language is wrong, the issue persists and everything except for the YAML header is lost after roundtrip conversion🙀. Clearly, setting the correct language is critical. Luckily, the language is easy to guess and can be obtained from the kernel.json file located at the kernel path provided by jupyter kernelspec list.

Interestingly, providing the wrong kernel name in kernelspec does not result in an error. Instead, when I use JupyterLab to open an ipynb that was created with an incorrect kernelspec name, I get a prompt to select a kernel. I can imagine situations in which this behavior is helpful, e.g. I don't have the kernel installed but I want to set it for someone else.

[david-cortes]

I'm still seeing the issue of the YAML header showing up as the first cell in the resulting .ipynb, even after specifying jupyter: ir in the header.

This is with quarto 1.6.39 on linux.

[maptv]

I believe you are observing the expected behavior: after running quarto convert <name>.qmd, the yaml header should show up as a raw cell in the resulting <name>.ipynb file. The Quarto JupyterLab extension can make this raw cell look nicer.

In my tests, the yaml header survived round-trip quarto-to-ipynb-to-quarto conversion but only if the language parameter in the yaml header was provided correctly. If you want to remove the yaml header, I think you want to use quarto render instead of quarto convert.