Setup Jupyter Lab with Kernels and Widgets

Written on Dec 4, 2020

Computer Setup
Software Engineering

Jupyter Lab is a very useful tool to write Python code. I use it all the time when I'm starting a new project. It's also a good way to present something you're working on and add notes next to your code. This post will help you setup Jupyter Lab with various kernels and widgets, so that your productivity increases.

We are going to see how to make it from Jupyter Lab most basic interface to a more sophisticated one, with kernels, widgets and everything to make you love Jupyter Lab even more. You will start from the picture on the left, and hopefully end up with the picture on the right.

Setup

Install Jupyter Lab:

pip3 instal jupyterlab

Launch it with:

jupyter-lab

Note: I prefer to launch it in the background with tmux:

tmux new -d -s jupyter "jupyter-lab --no-browser"

It’s even cooler to use aliases, in your .zshrc (or .bashrc ), append:

alias jupyter-tmux='tmux new -d -s jupyter "jupyter-lab --no-browser"';
alias tas='tmux attach-session -t'

Then launch jupyter with:

jupyter-tmux

Attach to the session with:

tas jupyter

Install Kernels

Jupyter comes with a default Python kernel, the one installed on your computer. This is a good start but you might want to use different python environments (if you’re used to working with virtualenv for instance) with different python versions or librairies. You might also want to use Jupyter Lab with other programming languages, like R or Julia. If that sounds appealing to you, look no further, we are going to install kernels !

The installed kernels will be located under $HOME/Library/Jupyter/kernels.

Python kernel from a virtual environment

Let’s first add Python kernels to Jupyter Lab. I am going to assume you are familiar with virtual environments, if not you should refer to this tutorial: Pipenv & Virtual Environments.

Make sure you have virtualenv installed on your computer:

pip3 install virtualenv

Step 1: A Python 3 Kernel

We are going to create a first kernel based on Python 3, and we are going to name it “Python (data-science)”. It’s fairly easy:

Create the virtual environment based on python3
```
virtualenv data-science -p python3
```
Activate the environment
```
source data-science/bin/activate
```
Install ipykernel within it
```
pip install ipykernel
```

python -m ipykernel install --user --name data-science --display-name "Python (data-science)"

Step 2: A Python 2 Kernel

By following the same steps, here’s how to add a Python 2 kernel, for your legacy projects:

virtualenv python2 -p python2
source data-science/bin/activate
pip install ipykernel
python -m ipykernel install --user --name python2 --display-name "Python 2"

Now if you install libraries within one of these virtual environments, they will be available though the corresponding Jupyter Lab kernel. If you reload your Jupyter Lab interface, you should see something like this:

Here are some useful commands:

List your kernels:
```
jupyter kernelspec list
```

Uninstall a kernel:

jupyter kernelspec uninstall data-science

Kernels with other programming languages

The nice thing about Jupyter Lab is that you’re not limited to Python. Let’s see how to use other languages like R and Julia within notebooks.

R Kernel

Assuming you have R installed, run these lines in a terminal:

Rscript -e 'install.packages(c("repr", "IRdisplay", "IRkernel"), type = "source", repos="https://cran.rstudio.com");'
Rscript -e 'IRkernel::installspec()'

Reload Jupyter Lab and you should see this:

Nice, R kernel just appeared. Here’s another trick, you can actually write R code within a Python notebook. For this, you need to install the library rpy2:

pip3 install rpy2

Then, from a Python notebook cell, load the rpy2 extension:

%load_ext rpy2.ipython

You can now write R code within that cell! For instance:

Julia kernel

I have been recently introduced to the Julia programming language, and it seems very fun and powerful. Let’s create a Julia kernel, because why not ?

Assuming you have Julia installed, launch Julia from a terminal (just run Julia) and then type:

Pkg.add("IJulia")

Reload Jupyter Lab as usual, and you should now see the new Julia kernel:

That’s pretty neat, we now have 5 kernels:

Python 3: the default python on your computer
Python (data-science): python 3 from a virtual environment
Python 2: python 2 from a virtual environment
R: to run R code
Julia: to run Julia code

Widgets

Let’s now tweak our beloved Jupyter Lab by adding some widgets. Namely:

Table of contents: automatically generate a table of contents for your notebook, based on the markdown sections you wrote
Git: If working within a git repository, directly add & commit from the Jupyter Lab interface
Latex: Write and compile Latex files from Jupyter Lab
Templates: Lets you start a notebook from a template

Note: you can either install extensions from the command line, or by using the “Extension Manager” tab within the Jupyter Lab user interface. I prefer the command line though, it’s easier to store my extensions and make a script to automatically install them.

As mentioned earlier, this widget generates a table of content from your notebook.

Install it with:

jupyter-labextension install @jupyterlab/toc

You’ll see a new tab appear, when you click on it, it’ll show the table of content. The sections are automatically created based on the markdown sections. Note that you can either enable automatic numbering or not. I did enable it on the following screenshot, and it looks like this:

Git

If you’re tired of running back and forth between your terminal and Jupyter Lab to commit your code, consider this extension that brings a Git interface to Jupyter Lab. Install it with:

pip3 install jupyterlab-git
jupyter-labextension install @jupyterlab/git

As usual, a new tab appears:

Latex

I mostly use overleaf for Latex, but if you’re not and if you wish to use Jupyter Lab for compiling Latex documents, this plugin will do the job. Install it with:

pip3 install jupyterlab_latex
jupyter-labextension install @jupyterlab/latex

Now when you are editing a Latex file, a right click on the document will show an option that lets you render the file to pdf:

Templates

Sometimes you might feel like you always copy paste the same lines of code at the beginning of a new notebook. If you are, consider using notebook templates with this plugin. Install it with:

pip3 install jupyterlab_templates
jupyter labextension install jupyterlab_templates
jupyter serverextension enable --py jupyterlab_templates

Then you will see a new “Template” icon next to your kernels. If you click on it, you will be asked which template you want to use, and it will create a notebook based on this template. You can create your own templates by saving notebooks in the template directory. You also get to choose which directory the plugin will pick the templates from.

Wrapping up

You know now how to setup Jupyter Lab and enhance it with kernels and widgets. There’s a lot more to it and I’d love to hear about what kernels and widgets you love. Feel free to reach out in the comments. I hope this tutorial was somehow helpful.

How I record my guitar videos on YouTube

Written on May 16, 2020

I have been playing guitar since 2004 and I started recording music videos on YouTube in 2009. In this post, I am going to explain how I record guitar tracks in my home studio. ...

Music

Deploy Metabase with Docker and Nginx over HTTPS