[Django]-How do I set up Jupyter/IPython Notebook for Django?

1. Install django-extensions from https://github.com/django-extensions/django-extensions/blob/master/docs/index.rst

    pip install django-extensions
   

2. Change your settings file to include ‘django-extensions’

    INSTALLED_APPS += ['django_extensions']
   

3. Run your Django server like this:

   python manage.py shell_plus --notebook
   

4. alter to suit, and run this in your first cell

   import os, sys
   PWD = os.getenv('PWD')
   os.chdir(PWD)
   sys.path.insert(0, os.getenv('PWD'))
   os.environ.setdefault("DJANGO_SETTINGS_MODULE", "local_settings.py")
   import django
   django.setup()
   

5. Now you should be able to import your django models etc. eg:

   from app.models import Foobar
   Foobar.objects.all()
   

Here’s what just worked for me

1. install Django Extensions (I used 1.9.6) as per other answers
2. install jupyter
   pip install jupyter
3. some stuff I did to setup jupyter inside my Docker container — see below if this applies to you †
4. from your base Django directory, create a directory for notebooks, e.g.
   mkdir notebooks
5. Go to that directory
   cd notebooks
6. start django extensions shell_plus from inside that directory:
   ../manage.py shell_plus --notebook
   
   The notebook server should now be running, and may launch a new browser. If it doesn’t launch a browser window, follow the instructions to paste a link or a token.
7. from the browser, open a new “Django Shell Plus” notebook, as per John Mee’s answer’s screenshot

AND, importantly, what didn’t work was changing directories from inside the notebook environment. If I tried to work with any notebook that was not in the directory that manage.py shell_plus --notebook was run in, then the kernal was not configured correctly. For me, having the notebook be configured for just a single directory at a time was good enough. If you need a more robust solution, you should be able set PYTHONPATH prior to starting jupyter. For example add export PYTHONPATH="$PYTHONPATH:/path/to/django/project" to a virtualenv activate script. But I haven’t tried this.

† Docker Setup (optional)

1. add a port mapping for your container for port 8888

For example, in your docker compose file;

ports:
      -  "8890:8888"

2. Configure your project settings file to use ip 0.0.0.0

This is what I did:

NOTEBOOK_ARGUMENTS = [
    '--ip', '0.0.0.0', 
    '--allow-root',
    '--no-browser', 
]

Note: I am using Python 3.7 and Django 2.1, it works for Django 2.2. I don’t have to run anything in my first cell, and this works like charm as long as you don’t mind having the notebooks in the root of your Django project.

It is assumed that you have a virtual environment for your project, and it is activated. I use pipenv to create virtual environments and track dependencies of my python projects, but it is up to you what tool you use.

It is also assumed that you have created a Django project and your current working directory is the root of this project.

Steps

1. Install jupyter

   Using pip

   pip install jupyter
   

   Using pipenv

   pipenv install jupyter
   

2. Install django-extentions

   Using pip

   pip install django-extensions
   

   Using pipenv

   pipenv install django-extensions
   

3. Set up django-extensions by adding it to the INSTALLED_APPS setting of your Django project settings.py file.:

   INSTALLED_APPS = (
       ...
       'django_extensions',
   )
   

4. Run the shell_plus management command that is part of django-extensions. Use the option --notebook to start a notebook:

   python manage.py shell_plus --notebook
   

   Jupyter Notebooks will open automatically in your browser.

5. Start a new Django Shell-Plus notebook

That’s it!

Again, you don’t have to run anything in the first cell, and you can corroborate by running dir() to see the names in the current local scope.

Edit:

If you want to put your notebooks in a directory called notebooks at the root directory, you can do the following:

$ mkdir notebooks && cd notebooks
$ python ../manage.py shell_plus --notebook

Thanks to Mark Chackerian whose answer provided the idea to make run the notebooks in a directory other than the project’s root.

These are the modules that are imported automatically thanks to shell_plus:

# Shell Plus Model Imports
from django.contrib.admin.models import LogEntry
from django.contrib.auth.models import Group, Permission, User
from django.contrib.contenttypes.models import ContentType
from django.contrib.sessions.models import Session
# Shell Plus Django Imports
from django.core.cache import cache
from django.conf import settings
from django.contrib.auth import get_user_model
from django.db import transaction
from django.db.models import Avg, Case, Count, F, Max, Min, Prefetch, Q, Sum, When, Exists, OuterRef, Subquery
from django.utils import timezone
from django.urls import reverse

Actually turns out you (might not) need to do all that crap. Just install django-extensions and run jupyter!

(myprojectvenv)$ cd myproject    
(myprojectvenv)$ pip install jupyter
(myprojectvenv)$ pip install django-extensions
(myprojectvenv)$ jupyter notebook

In the browser, start a new “Django Shell-Plus”:

And you should be good to go. eg:

from myproject.models import Foobar
Foobar.objects.all()

While the accepted answer from RobM works, it was less clear than it could be and has a few unnecessary steps. Simply put, to run notebooks through Django from a notebook environment outside of the project directory:

Install:

 pip install django-extensions

Add 'django-extensions' to your INSTALLED_APPS list in settings.py

 INSTALLED_APPS += ['django_extensions']

Run a notebook from within Django, then close it:

python manage.py shell_plus --notebook

This will create your kernel, which we will now edit to point to an absolute path of Python rather than a relative path.

On OSX, the kernel file is at: ~/Library/Jupyter/kernels/django_extensions/kernel.json

On Linux: ~/.jupyter/kernels/django_extensions/kernel.json

We only need to make two changes:

The first is to edit the first value in the "argv" list from "python" to the full address of the python version in your Django virtual environment. E.g.: "/Users/$USERNAME/Documents/PROJECT_FOLDER/venv/bin/python"

Secondly, to the "env" dictionary, add "DJANGO_SETTINGS_MODULE": "mysite.settings", where mysite is the folder that contains your Django settings.

Optionally, change the value of "display_name".

Now when you run a notebook from any directory, choosing the "Django Shell-Plus" kernel will allow your notebooks to interact with Django. Any packages such as pandas will need to be installed in the Django venv.

The following does work for me using win10, Python 3.5, Django 1.10:

• Install Python with the Anaconda distribution so Jupyter will be installed as well

• Install Django and install django-extensions:

  pip install Django
  
  pip install django-extensions
  

• Start a new Django project. You have to do that in that part of your tree of directories which can be accessed by Jupyter later.

  django-admin startproject _myDjangoProject_
  

• Start Jypter

• navigate Jupyter to the directory myDjangoProject and enter the first/top myDjangoProject-directory
• Start within the first/top myDjangoProject-directory a new Jupyter noteboke: new –> Django Shell-Plus

• enter and run the following piece of code :

  import os
  os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myDjangoProject.settings")
  import django
  django.setup()
  

• Note that this piece of code is the same as in manage.py, and note that “myDjangoProject.settings” points to myDjangoProject/settings.py

• Now you can start with examples, e.g.:

  from django.template import Template, Context
  
  template = Template('The name of this project is {{ projectName }}')
  context = Context({'projectName': 'MyJypyterDjangoSite'})
  template.render(context)
  

Run this command.

PYTHONPATH=/path/to/project/root DJANGO_SETTINGS_MODULE=settings python manage.py shell_plus --notebook

I will add some information to the very complete answer of RobM, for the benefit of the very rare developers that use buildout along with djangorecipe djangorecipe as I do… I refer to jupyter lab as I use that but I think all info can be applied to old jupyter notebooks.

When using buildout you end up with a ‘bin/django’ handler you’ll use instead of ‘manage.py’. That’s the script that defines the whole path. I added one more part in my buildout.cfg:

[ipython]
recipe = zc.recipe.egg
eggs =  ${buildout:eggs}
extra-paths = ${buildout:directory}/apps
initialization =  import os
   os.environ['DJANGO_SETTINGS_MODULE'] = 'web.settings'

so that another script named ipython will be created in ./bin directory. I point kernelspec to that interpreter. Moreover I use kernel argument rather than "-m", "ipykernel_launcher" so that the kernel definition I use is:

{
    "argv": [
        "/misc/src/hg/siti/trepalchi/bin/ipython",
        "kernel",
        "-f",
        "{connection_file}",
        "--ext",
        "django_extensions.management.notebook_extension"
    ],
    "display_name": "Trepalchi",
    "language": "python"
}

Due to how the ipython script is created by buildout there’s no need to add environmental variables in my case.

As Rob already mentioned, jupiterlab is only installed in one environment where I start it with the command:

jupyter lab

not in the environment of Django project whare I only install ipykernel (that has already a bunch of 20 dependencies).

Since I tend to have quite a lot of projects I find it usefull to have a single point where I start jupyter lab with many links to the projects so that I can reach them easily. Thanks to the extension provided by django_extension I don’t need any extra cell to initialize the notebook.

Any single kernel added in this way can be found with the command:

jupyter kernelspec list

And clearly listed in the launcher of jupyter lab