Jupyter front end systems

5.1 Configuring

The location of theming infrastructure, widgets, CSS, etc. has moved of late; check your version number. The current location is ~/.jupyter/custom/custom.css, not the former location ~/.ipython/profile_default/static/custom/custom.css

Julius Schulz’s ultimate setup guide is also the ultimate pro tip compilation.

5.2 Auto-closing parentheses

If I must use jupyter notebook then I kill parenthesis molestation (referred to in the docs as bracket autoclose) with fire. I do not like having to fight with the notebook’s misplaced faith in its ability to read my mind. The setting is tricky to find, because it is not called “put syntax errors in my code without me asking Y/N”, but instead cm_config.autoCloseBrackets and is not in the preference menus. According to a support ticket, the following should work.

# Run this in Python once, it should take effect permanently

from notebook.services.config import ConfigManager
c = ConfigManager()
c.update('notebook', {"CodeCell": {
  "cm_config": {"autoCloseBrackets": False}}})

or add the following to custom.js:

define([
    'base/js/namespace',
], function(Jupyter) {
    Jupyter.CodeCell.options_default.cm_config.autoCloseBrackets = false;
})

or maybe create ~/.jupyter/nbconfig/notebook.json with the content

{
  "CodeCell": {
    "cm_config": {
      "autoCloseBrackets": false
    }
  }
}

That doesn’t work with jupyterlab, which is even more righteously sure that it knows better than you about what you truly wish to do with parentheses. Perhaps the following does work? Go to Settings --> Advanced Settings Editor and add the following to the User Overrides section:

{
  "codeCellConfig": {
    "autoClosingBrackets": false
  }
}

or in the file ~/.jupyter/lab/user-settings/@jupyterlab/notebook-extension/tracker.jupyterlab-settings.

Ahhhhhhhh. Update: it is easier now.

5.3 Notebook extensions

Jupyter classic is more usable if you install the notebook extensions, which includes, e.g. drag-and-drop image support.

$ pip install --upgrade jupyter_contrib_nbextensions
$ jupyter contrib nbextension install --user

For example, if you run nbconvert to generate an HTML file, this image will remain outside of the HTML file. You can embed all images by using the calling nbconvert with the EmbedPostProcessor.

$ jupyter nbconvert --post=embed.EmbedPostProcessor

Update — broken in Jupyter 5.0

Wait, that was still pretty confusing; I need the notebook configurator whatsit.

$ pip install --upgrade jupyter_nbextensions_configurator
$ jupyter nbextensions_configurator enable --user

6.1 Jupyterlab UI

The UI, though… The mysterious curse of JavaScript development is that once you have tasted it, you are unable to resist an uncontrollable urge to reimplement something that already works, but as a jankier JavaScript version. The jupyter lab have tasted that forbidden fruit, have the spidermonkey on their backs, and they hunger to reinvent things using JavaScript. So far they have reimplemented copy, paste, search/replace, browser tabs and the command line.

Yo dawg I heard you like notebook tabs so I put notebook tabs in your browser notebook tab.

The replacement jupyter tab system clashes with the browser tab system, keyboard shortcuts and generally confuses the eye. Why do we get some a search function which AFAICT non-deterministically sometimes does regexp matching but then doesn’t search the whole page? Possibly the intention is that it should not be run through a normal browser, but in a custom single-tab embedded browser? Or maybe for true believers, once you load up a jupyter notebook you like it so hard that you never need to browse to a website on the internet again and you close all the other tabs forever. Whatever the rationale, the learning curve for these weird UI choices is bumpy, and the lessons are not transferable.

Is the learning process worth it? I am not using jupyter for its artisanal, quirky alternate take on tabs, cut-and-paste etc, but because I want a quick interface to run some shareable code with embedded code and graphics. Does it get me that?

Maybe. If I get in and out fast, do most of my development in a real code editor and leave the jupyter nonsense for results sharing, I neither need the weird UI, nor am I bothered by it. The other features are like that button on the microwave labelled “fish”, which no one has ever need or intentionally used, but which does not stop the microwave from defrosting things if you use the normal controls.

At the same time, some jupyterlab enthusiasts want to re-implement text editors, which is an indicator that there might be a contagion of NIH fever going around in the community, and it makes me nervous.

Whether I like the overwrought jupyter lab UX or not, we should allow it a moderate nonsense-baggage allowance, if the developer API is truly cleaner and easier to work with. That would be a solid win in terms of delivering the features I would actually regard as improvements including, maybe, ultimately, a better UI.

6.2 Collaborative options

Simultaneous users are supported natively in jupyterlab with an OK UI for identifying running notebooks. IMO this could be a killer feature of jupyter lab. As currently implemented, it is usable but sometimes calculation output gets lost in the system somewhere.

There is an under-documented project to introduce real-time collaboration to jupyterlab coordinating on notebook content code, output and backend state, which apparently works, but is barely mentioned in the docs. Maybe the JupyterLab RTC Design Documentation would help there.

If you have a snakepit of different jupyter sessions running on some machine you have just logged in to and want to open up the browser to get a UI for them, then you want to work out which are running on a given machine so that you can attach them. The command is (for either jupyter notebook notebooks or jupyter lab sessions):

jupyter notebook list

6.3 Lab extensions

Related to, inspired by and maybe conflicting or intersecting with the nbextensions are the labextensions, which add bits of extra functionality to the lab interface rather than the notebook interface (where the lab interface is built upon the notebook interface and runs notebooks just like it but with different moving parts under the hood.)

I try to keep the use of these to a minimum as I have a possibly irrational foreboding that some complicated death spiral of version clashes is beginning between all the different jupyter kernel and lab and notebook installations I have cluttering up my hard disk and it can’t improve things to put various versions of lab extensions in the mix, can it? And I really don’t want to have to understand how it works to work out whether that is true or not, so please don’t explain it to me. I moreover do not wish to obsessively update lab extensions everywhere.

Anyway, there are some useful ones, so I live with it by running install and update commands obsessively in every combination of kernel/lab/whatever environment in the hope that something sticks.

Life is easier with jupyterlab-toc which allows you to navigate your lab notebook by markdown section headings.

jupyter labextension install @jupyterlab/toc

The upgrade command is

jupyter labextension update @jupyterlab/toc

Integrated diagram editor? Someone integrated drawio as jupyterlab-drawio to prove a point about the developer API thing.

jupyter labextension install jupyterlab-drawio

LaTeX editor? As flagged, I think this is a terrible idea. Even worse than the diagram editor. There are better editors than jupyter, better means of scientific communication than latex, and better specific latex tooling, but I will concede there is some kind of situation where this sweet spot of mediocrity might be useful, e.g. as a plot point in a contrived techno-thriller script written by cloistered nerds. If you find yourself in such dramaturgical straits:

jupyter labextension install @jupyterlab/latex

One nerdy extension is jupyter-matplotlib, a.k.a., confusingly, ipympl, which integrates interactive plotting into the notebook better.

pip install ipympl
# If using JupyterLab

# Install nodejs: https://nodejs.org/en/download/
jupyter labextension install @jupyter-widgets/jupyterlab-manager
jupyter labextension install jupyter-matplotlib

jupyterlab/jupyterlab-hdf5 claims to provide a UI for HDF5 files.

9.1 Multiple clients connecting to a single kernel

jupyter qtconsole can connect two frontends to the same kernel. This will be loopy since they update the same variables (presumably) but AFAICT not the same notebook content, so some care would be required to make sure you are doing what you intend.

%qtconsole