xeus-python RuntimeError: This frontend does not support input requests

[laguill]

Bug description

Create a new env with uv

uv init
uv venv --python 3.12

uv init -p 3.12
uv venv

```bash
uv add quarto-cli xeus-python

quarto preview

Steps to reproduce

---
title: "Reproducible Quarto Document"
format: html
jupyter: xpython
---

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

```{python}
print("Hello, world!")
```
The end.

Actual behavior

Got error in shell
RuntimeError: This frontend does not support input requests

Expected behavior

Preview document

Your environment

No response

Quarto check output

 quarto check
Quarto 1.6.42
[✓] Checking environment information...
      Quarto cache location: /home/laguill/.cache/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: /home/laguill/Documents/01-Etudes/OpenClassrooms/Test/.venv/lib/python3.12/site-packages/quarto_cli/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
(/) Checking Python 3 installation....      Version: 3.12.7
      Path: /home/laguill/Documents/01-Etudes/OpenClassrooms/Test/.venv/bin/python3
      Jupyter: 5.7.2
      Kernels: xpython, xpython-raw, python3

(|) Checking Jupyter engine render....registering handler for SIGSEGV
WARNING: this instance of xeus-python has been installed from a PyPI wheel.
We recommend using a general-purpose package manager instead, such as Conda / Mamba.

(/) Checking Jupyter engine render....Starting xeus-python kernel...

If you want to connect to this kernel from an other client, you can use the /tmp/tmppkhe9tqg.json file.
Run with XEUS 3.0.3
(\) Checking Jupyter engine render....

An error occurred while executing the following cell:
------------------

# imports
import os
import sys
import types
import json
import base64

# figure size/format
fig_width = 7
fig_height = 5
fig_format = 'retina'
fig_dpi = 96
interactivity = ''
is_shiny = False
is_dashboard = False
plotly_connected = True

# matplotlib defaults / format
try:
  import matplotlib.pyplot as plt
  plt.rcParams['figure.figsize'] = (fig_width, fig_height)
  plt.rcParams['figure.dpi'] = fig_dpi
  plt.rcParams['savefig.dpi'] = "figure"
  from IPython.display import set_matplotlib_formats
  set_matplotlib_formats(fig_format)
except Exception:
  pass

# plotly use connected mode
try:
  import plotly.io as pio
  if plotly_connected:
    pio.renderers.default = "notebook_connected"
  else:
    pio.renderers.default = "notebook"
  for template in pio.templates.keys():
    pio.templates[template].layout.margin = dict(t=30,r=0,b=0,l=0)
except Exception:
  pass

# disable itables paging for dashboards
if is_dashboard:
  try:
    from itables import options
    options.dom = 'fiBrtlp'
    options.maxBytes = 1024 * 1024
    options.language = dict(info = "Showing _TOTAL_ entries")
    options.classes = "display nowrap compact"
    options.paging = False
    options.searching = True
    options.ordering = True
    options.info = True
    options.lengthChange = False
    options.autoWidth = False
    options.responsive = True
    options.keys = True
    options.buttons = []
  except Exception:
    pass
  
  try:
    import altair as alt
    # By default, dashboards will have container sized
    # vega visualizations which allows them to flow reasonably
    theme_sentinel = '_quarto-dashboard-internal'
    def make_theme(name):
        nonTheme = alt.themes._plugins[name]    
        def patch_theme(*args, **kwargs):
            existingTheme = nonTheme()
            if 'height' not in existingTheme:
              existingTheme['height'] = 'container'
            if 'width' not in existingTheme:
              existingTheme['width'] = 'container'

            if 'config' not in existingTheme:
              existingTheme['config'] = dict()
            
            # Configure the default font sizes
            title_font_size = 15
            header_font_size = 13
            axis_font_size = 12
            legend_font_size = 12
            mark_font_size = 12
            tooltip = False

            config = existingTheme['config']

            # The Axis
            if 'axis' not in config:
              config['axis'] = dict()
            axis = config['axis']
            if 'labelFontSize' not in axis:
              axis['labelFontSize'] = axis_font_size
            if 'titleFontSize' not in axis:
              axis['titleFontSize'] = axis_font_size  

            # The legend
            if 'legend' not in config:
              config['legend'] = dict()
            legend = config['legend']
            if 'labelFontSize' not in legend:
              legend['labelFontSize'] = legend_font_size
            if 'titleFontSize' not in legend:
              legend['titleFontSize'] = legend_font_size  

            # The header
            if 'header' not in config:
              config['header'] = dict()
            header = config['header']
            if 'labelFontSize' not in header:
              header['labelFontSize'] = header_font_size
            if 'titleFontSize' not in header:
              header['titleFontSize'] = header_font_size    

            # Title
            if 'title' not in config:
              config['title'] = dict()
            title = config['title']
            if 'fontSize' not in title:
              title['fontSize'] = title_font_size

            # Marks
            if 'mark' not in config:
              config['mark'] = dict()
            mark = config['mark']
            if 'fontSize' not in mark:
              mark['fontSize'] = mark_font_size

            # Mark tooltips
            if tooltip and 'tooltip' not in mark:
              mark['tooltip'] = dict(content="encoding")

            return existingTheme
            
        return patch_theme

    # We can only do this once per session
    if theme_sentinel not in alt.themes.names():
      for name in alt.themes.names():
        alt.themes.register(name, make_theme(name))
      
      # register a sentinel theme so we only do this once
      alt.themes.register(theme_sentinel, make_theme('default'))
      alt.themes.enable('default')

  except Exception:
    pass

# enable pandas latex repr when targeting pdfs
try:
  import pandas as pd
  if fig_format == 'pdf':
    pd.set_option('display.latex.repr', True)
except Exception:
  pass

# interactivity
if interactivity:
  from IPython.core.interactiveshell import InteractiveShell
  InteractiveShell.ast_node_interactivity = interactivity

# NOTE: the kernel_deps code is repeated in the cleanup.py file
# (we can't easily share this code b/c of the way it is run).
# If you edit this code also edit the same code in cleanup.py!

# output kernel dependencies
kernel_deps = dict()
for module in list(sys.modules.values()):
  # Some modules play games with sys.modules (e.g. email/__init__.py
  # in the standard library), and occasionally this can cause strange
  # failures in getattr.  Just ignore anything that's not an ordinary
  # module.
  if not isinstance(module, types.ModuleType):
    continue
  path = getattr(module, "__file__", None)
  if not path:
    continue
  if path.endswith(".pyc") or path.endswith(".pyo"):
    path = path[:-1]
  if not os.path.exists(path):
    continue
  kernel_deps[path] = os.stat(path).st_mtime
print(json.dumps(kernel_deps))

# set run_path if requested
run_path = 'L3RtcC9xdWFydG8tc2Vzc2lvbjk2MTVkZDM0YTIyZWRlMDcvNmRjYTY3YTA1NmZlZmE0ZA=='
if run_path:
  # hex-decode the path
  run_path = base64.b64decode(run_path.encode("utf-8")).decode("utf-8")
  os.chdir(run_path)

# reset state
%reset

# shiny
# Checking for shiny by using False directly because we're after the %reset. We don't want
# to set a variable that stays in global scope.
if False:
  try:
    import htmltools as _htmltools
    import ast as _ast

    _htmltools.html_dependency_render_mode = "json"

    # This decorator will be added to all function definitions
    def _display_if_has_repr_html(x):
      try:
        # IPython 7.14 preferred import
        from IPython.display import display, HTML
      except:
        from IPython.core.display import display, HTML

      if hasattr(x, '_repr_html_'):
        display(HTML(x._repr_html_()))
      return x

    # ideally we would undo the call to ast_transformers.append
    # at the end of this block whenver an error occurs, we do 
    # this for now as it will only be a problem if the user 
    # switches from shiny to not-shiny mode (and even then likely
    # won't matter)
    import builtins
    builtins._display_if_has_repr_html = _display_if_has_repr_html

    class _FunctionDefReprHtml(_ast.NodeTransformer):
      def visit_FunctionDef(self, node):
        node.decorator_list.insert(
          0,
          _ast.Name(id="_display_if_has_repr_html", ctx=_ast.Load())
        )
        return node

      def visit_AsyncFunctionDef(self, node):
        node.decorator_list.insert(
          0,
          _ast.Name(id="_display_if_has_repr_html", ctx=_ast.Load())
        )
        return node

    ip = get_ipython()
    ip.ast_transformers.append(_FunctionDefReprHtml())

  except:
    pass

def ojs_define(**kwargs):
  import json
  try:
    # IPython 7.14 preferred import
    from IPython.display import display, HTML
  except:
    from IPython.core.display import display, HTML

  # do some minor magic for convenience when handling pandas
  # dataframes
  def convert(v):
    try:
      import pandas as pd
    except ModuleNotFoundError: # don't do the magic when pandas is not available
      return v
    if type(v) == pd.Series:
      v = pd.DataFrame(v)
    if type(v) == pd.DataFrame:
      j = json.loads(v.T.to_json(orient='split'))
      return dict((k,v) for (k,v) in zip(j["index"], j["data"]))
    else:
      return v

  v = dict(contents=list(dict(name=key, value=convert(value)) for (key, value) in kwargs.items()))
  display(HTML('<script type="ojs-define">' + json.dumps(v) + '</script>'), metadata=dict(ojs_define = True))
globals()["ojs_define"] = ojs_define
globals()["__spec__"] = None

[cscheid]

Why do you consider this a bug? Quarto needs that feature from the kernel in order to work. I'm going to go ahead and close this. I'm not sure what we can do if the jupyter kernel lacks the functionality required, but I'm all ears for a discussion.

[laguill]

I thought xeus-python kernel was supported because of the documentation

xeus-python

I don't know if it is an error from my setup, quarto or xeus-python.

[cscheid]

I'm trying to reproduce this and getting the following uv error:

$ uv init
Initialized project `issue-12423`
$ uv venv --python 3.12
Using CPython 3.12.6 interpreter at: /opt/homebrew/opt/python@3.12/bin/python3.12
warning: The requested interpreter resolved to Python 3.12.6, which is incompatible with the project's Python requirement: `>=3.13`
Creating virtual environment at: .venv
Activate with: source .venv/bin/activate
$ uv add quarto-cli xeus-python
Using CPython 3.13.1
Removed virtual environment at: .venv
Creating virtual environment at: .venv
  × No solution found when resolving dependencies:
  ╰─▶ Because all versions of xeus-python have no wheels with a matching Python version tag and your project depends on xeus-python, we can conclude that
      your project's requirements are unsatisfiable.
  help: If you want to add the package regardless of the failed resolution, provide the `--frozen` flag to skip locking and syncing.

I'm not a user of uv, so I can't go much further than this, sorry.

[laguill]

Sorry I forgot to specify the python version when initializing uv. (I edited my previous post)
You should delete the project folder and restart with a new one.

Here is the working commands:

uv init -p 3.12
uv add quarto-cli xeus-python
. .venv/bin/activate

Create the qmd document test.qmd

quarto preview test.qmd

[mcanouil]

@laguill Could you instead provide a Git repository with a uv.lock, pyproject.toml, a Quarto document, etc.?

[laguill]

Here it is:
xpython-quarto

[cderv]

FWIW I can reproduce (with some adjustment to your project - uv remove quarto-cli to use global quarto and adding uv add jupyter)

THis is the full error trace I can find

RuntimeError                              Traceback (most recent call last)
Cell In[1], line 193
    190   os.chdir(run_path)
    192 # reset state
--> 193 get_ipython().run_line_magic('reset', '')
    195 # shiny
    196 # Checking for shiny by using False directly because we're after the %reset. We don't want
    197 # to set a variable that stays in global scope.
    198 if False:

File ~\AppData\Local\Temp\quarto\xpython-quarto\.Venv\Lib\site-packages\IPython\core\interactiveshell.py:2482, in InteractiveShell.run_line_magic(self, magic_name, line, _stack_depth)
   2480     kwargs['local_ns�
[39m'] = self.get_local_scope(stack_depth)
   2481 with self.builtin_trap:
-> 2482     result = fn(*args, **kwargs)
   2484 # The code below prevents the output from being displayed
   2485 # when using magics with decorator @output_can_be_silenced
   2486 # when the last Python token in the expression is a ';'.
   2487 if getattr(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, False):

File ~\AppData\Local\Temp\quarto\xpython-quarto\.Venv\Lib\site-packages\IPython\core\magics\namespace.py:545, in NamespaceMagics.reset(self, parameter_s)
    543 else:
    544     try:
--> 545         ans = self.shell.ask_yes_no(
    546         "Once deleted, variables cannot be recovered. Proceed (y/[n])?",
    547         default='n')
    548     except StdinNotImplementedError:
    549         ans = True

File ~\AppData\Local\Temp\quarto\xpython-quarto\.Venv\Lib\site-packages\IPython\core\interactiveshell.py:3798, in InteractiveShell.ask_yes_no(self, prompt, default, interrupt)
   3796 if self.quiet:
   3797     return True
-> 3798 return ask_yes_no(prompt,default,interrupt)

File ~\AppData\Local\Temp\quarto\xpython-quarto\.Venv\Lib\site-packages\IPython\utils\io.py:98, in ask_yes_no(prompt, default, interrupt)
     96 while ans not in answers.keys():
     97     try:
---> 98         ans = input(prompt+' ').lower()
     99         if not ans:  # response was an empty string
    100             ans = default

RuntimeError: This frontend does not support input requests

So it seems the xeus-python is not a kernel working with Quarto 🤔