¿Cómo configuro Jupyter / IPython Notebook para Django?

Este dilema se puede tratar de diferentes maneras, por lo tanto te mostramos la que en nuestra opinión es la solución más completa.

Solución:

1. Instalar en pc django-extensions de https://github.com/django-extensions/django-extensions/blob/master/docs/index.rst

    pip install django-extensions
   

2. Cambie su archivo de configuración para incluir ‘django-extensions’

    INSTALLED_APPS += ['django_extensions']
   

3. Ejecute su servidor Django así:

   python manage.py shell_plus --notebook
   

4. Altere para adaptarse, y ejecute esto en su primera celda

   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. Ahora debería poder importar sus modelos de django, etc., por ejemplo:

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

Solo para completar (pero es 2018, así que tal vez las cosas hayan cambiado desde que se publicó esta pregunta): en realidad, puede instalar un kernel Jupyter Python en su entorno Django que luego se conectará (se ejecutará bajo) un servidor / entorno Jupyter diferente (uno donde usted ‘ he instalado widgets, extensiones, cambiado el tema, etc.). django_extensions ahora mismo todavía hace solo una parte del trabajo requerido 🙂

Esto supone que tiene un entorno virtual de Jupyter que está separado del de Django y cuyos núcleos / extensiones están instalados con --user. Todas las extensiones de Jupyter (y sus dependencias) están instaladas en este venv en lugar de las de Django (aún necesitará pandas, matplotlib, etc. en el entorno de Django si necesita usarlas junto con el código de Django).

En su entorno virtual Django (que puede ejecutar una versión diferente de Python, incluido un intérprete de la versión 2) instale el kernel de ipython:

pip install -U ipykernel
ipython kernel install --user --name='environment_name' --display-name='Your Project'

Esto creará un directorio de configuración del kernel con el nombre -– especificado en el directorio del kernel de Jupyter de su usuario (en Linux es ~/.jupyter/ mientras que en OSX es ~/Library/Jupyter/) que contiene su archivo kernel.json e imágenes / íconos (por defecto, se usa el ícono predeterminado de Jupyter para el kernel que estamos instalando). Este kernel se ejecutará dentro del entorno virtual que estaba activo en el momento de la creación, por lo que utilizará exactamente la misma versión de python y todos los módulos instalados utilizados por nuestro proyecto Django.

Corriendo ./manage.py shell_plus --notebook hace algo muy similar, pero además de requerir todo (incluido el servidor Jupyter y todas las extensiones) instalado en el venv actual, tampoco puede ejecutar cuadernos en directorios diferentes de la raíz del proyecto (el que contiene ./manage.py). Además, ejecutará el kernel utilizando el primer ejecutable llamado python que encuentre en la ruta, no el del entorno virtual, por lo que se comportará mal cuando no se inicie desde la línea de comandos dentro de un entorno virtual Django activo.

Para solucionar estos problemas de modo que podamos crear un Cuaderno que se ejecute dentro de cualquier proyecto de Django que tengamos configurado y para poder ejecutar cuadernos almacenados en cualquier lugar del sistema de archivos, necesitamos:

1. asegúrese de que el primer parámetro ‘argv’ contenga la ruta completa al intérprete de Python contenido en el entorno virtual
2. agregue (si aún no está presente) una sección ‘env’ que contendrá variables de entorno de shell, luego úselas para decirle a Python dónde encontrar nuestro proyecto y qué configuración de Django debe usar. Hacemos esto agregando algo como lo siguiente:

   "env": 
      "DJANGO_SETTINGS_MODULE": "my_project.settings",
      "PYTHONPATH": "$PYTHONPATH:/home/projectuser/projectfolder/my_project"
   

3. opcional: cambie ‘display_name’ para que sea amigable para los humanos y reemplace los íconos.

editando este archivo de entorno kernel.json, verá algo similar:

 "display_name": "My Project", 
 "language": "python", 
 "env": 
  "DJANGO_SETTINGS_MODULE": "my_project.settings",
  "PYTHONPATH": "$PYTHONPATH:/home/projectuser/projectfolder/my_project"
 ,
 "argv": [
  "/home/projectuser/.pyenv/versions/2.7.15/envs/my_project_venv/bin/python", 
  "-m", 
  "ipykernel_launcher", 
  "-f", 
  "connection_file",
  "--ext",
  "django_extensions.management.notebook_extension"
 ]

Líneas notables:

• “DJANGO_SETTINGS_MODULE”: “my_project.settings”: su configuración, generalmente como se ve dentro del archivo manage.py de su proyecto

• “PYTHONPATH”: “$ PYTHONPATH: / home / projectuser / projectfolder / my_project”: PYTHONPATH se extiende para incluir el directorio principal de su proyecto (el que contiene manage.py) para que se puedan encontrar las configuraciones incluso si el kernel no se ejecuta en ese directorio exacto (aquí django_extensions usará un genérico python, ejecutando el entorno virtual incorrecto a menos que se inicie todo el servidor Jupyter desde su interior: agregar esto al kernel.json creado por django_extensions le permitirá ejecutar cuadernos en cualquier lugar del directorio del proyecto Django)

• “/home/projectuser/.pyenv/versions/2.7.15/envs/my_project_venv/bin/python”: el primer argumento (lista argv) de la ejecución del kernel, debe ser la ruta completa al intérprete de python del entorno virtual de su proyecto (esto es otra cosa que django_extensions se equivoca: arreglar esto permitirá que cualquier servidor portátil ejecute el kernel de ese entorno Django específico con todas sus módulos instalados)

• “django_extensions.management.notebook_extension”: esta es la extensión que cargará la funcionalidad ‘shell_plus’ en el cuaderno (opcional pero útil :-))

Esto es lo que me funcionó

1. instale las extensiones de Django (usé 1.9.6) según otras respuestas
2. instalar jupyter
   pip install jupyter
3. Algunas cosas que hice para configurar jupyter dentro de mi contenedor Docker; vea a continuación si esto se aplica a usted †
4. desde su directorio base de Django, cree un directorio para cuadernos, por ejemplo
   mkdir notebooks
5. Ir a ese directorio
   cd notebooks
6. inicie las extensiones de django shell_plus desde dentro de ese directorio:
   ../manage.py shell_plus --notebook
   El servidor de la computadora portátil debería estar ejecutándose y es posible que inicie un nuevo navegador. Si no abre una ventana del navegador, siga las instrucciones para pegar un enlace o un token.
7. desde el navegador, abra un nuevo cuaderno “Django Shell Plus”, según la captura de pantalla de la respuesta de John Mee

Y, lo que es más importante, ¿qué no lo hice el trabajo consistía en cambiar directorios desde el interior del entorno del portátil. Si intenté trabajar con cualquier portátil que no estuviera en el directorio que manage.py shell_plus --notebook se ejecutó, entonces el kernal no se configuró correctamente. Para mí, tener el portátil configurado para un solo directorio a la vez fue lo suficientemente bueno. Si necesita una solución más sólida, debería poder configurar PYTHONPATH antes de iniciar jupyter. Por ejemplo, agregue export PYTHONPATH="$PYTHONPATH:/path/to/django/project" a un script de activación virtualenv. Pero no lo he probado.

† Configuración de Docker (opcional)

1. agregue una asignación de puerto para su contenedor para el puerto 8888

Por ejemplo, en su docker compose file;

ports:
      -  "8890:8888"

2. Configure el archivo de configuración de su proyecto para usar ip 0.0.0.0

Esto es lo que hice:

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

Calificaciones y comentarios

Recuerda dar recomendación a este tutorial si te fue de ayuda.

---

---

Utiliza Nuestro Buscador