Trying to figure out where a markdown file gets converted and executed into a notebook

[fm75]

I am looking at some sort of problem where I have two different interpreters set up - each is a 2.7 based. I have jupyter-book installed using 3.8. I have kernel.json files set up for each of the 2.7 interpreters. One is just a native 2.7 interpreter, the other is embedded in an application.

jupyter book build works for one (the embedded one!) and generates the expected notebook.

For the other, it fails to execute with an import error. But if I set it up to not fail on the error, when I publish, the notebook that failed works just fine, running the desired interpreter. Changing the kernel name from python2 to the embedded one works, but could not always be expected to work since the embedded one has some modules that the normal 2.7 version does not have.

Where should I look to find the start of the execution in the build step?

[choldgraf]

The MyST-NB package handles MD->IPYNB parsing and execution. Here's where that happens:

• parsing class: https://github.com/executablebooks/MyST-NB/blob/master/myst_nb/parser.py#L37
• execution: https://github.com/executablebooks/MyST-NB/blob/master/myst_nb/parser.py#L75
• the execution uses jupyter cache: https://github.com/executablebooks/jupyter-cache

hope that helps!

[fm75]

@choldgraf Thank you for your pointers.

I found parsing kernelspec for:

• language in myst_nb.parser
• name in myst_nb.converter
• display_name in myst_nb.converter

kernelspec.name seems to be what it used when the generated notebook is launched in "binder". But the output that it starts with seems like it was not properly used.

I still don't completely understand the flow of this yet, but I am getting closer.

[chrisjsewell]

could you attach your kernel.json here, out of interest. If you are working with mutiple interpreters, and thus multiple environments, I assume these all have to be installed in the Docker container binder generates?

[fm75]

python2/kernel.json

{
 "display_name": "Python 2", 
 "language": "python", 
 "argv": [
  "/opt/bb/bin/python2.7", 
  "-m", 
  "ipykernel_launcher", 
  "-f", 
  "{connection_file}"
 ]
}

custom2.7/kernel.json

{
 "argv": [
  "/opt/bb/bin/custom2.7",
  "-m",
  "ipykernel_launcher",
  "-f",
  "{connection_file}"
 ],
 "display_name": "custom2.7",
 "language": "python"
}

What is strange about this, is that the custom2.7 generates a working notebook and executes ok.
The python2 version does not. Yes, the kernelspec.name is python2 in the markdown when it fails. But the notebook generated, when launched, works! So I have been trying to figure out where I could "log" what happens during the conversion/execution in the jupyter-notebook build step, to identify what I might have done wrong, if this is not a bug.

I