django - shell_plus - jupyter notebook tutorial español

¿Cómo configurar el portátil Jupyter/IPython para Django?

Question

He estado usando el método descrito en esta publicación para configurar el bloc de notas de IPython para que funcione bien con Django. La esencia del método es crear una extensión IPython que establezca DJANGO_SETTINGS_MODULE y ejecute django.setup () cuando se inicie IPython.

El código para la extensión es:

def load_ipython_extension(ipython):
    # The `ipython` argument is the currently active `InteractiveShell`
    # instance, which can be used in any way. This allows you to register
    # new magics or aliases, for example.
    try:
        import os
        os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings")
        import django
        django.setup()
    except ImportError:
        pass

Con una actualización reciente al portátil Jupyter, esta configuración ahora está rota para mí. Puedo ejecutar el código Django en el cuaderno Jupyter agregando un código similar a la primera celda del notebook. Sin embargo, no pude averiguar cómo hacer que Jupyter ejecute la extensión automáticamente, así no tendría que volver a hacer esto para todos y cada uno de los portátiles que estoy creando.

¿Qué debo hacer para que Django y Jupyter jueguen bien?

ACTUALIZACIÓN: para @DarkLight: estoy usando Django 1.8.5 con Jupyter 1.0.0. El código que ejecuto en el cuaderno es:

import os, sys
sys.path.insert(0, ''/path/to/project'')
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settingsfile")
import django
django.setup()

Answer 1

1. Instala django-extensions desde 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 de esta manera:

   python manage.py shell_plus --notebook

4. alter para adaptarse y ejecutar 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 django, etc. Por ejemplo:

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

Answer 2

En realidad resulta que ( puede que no ) necesite hacer toda esa mierda. ¡Simplemente instale django-extensions y ejecute jupyter!

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

En el navegador, inicie un nuevo "Django Shell-Plus":

Y deberías ser bueno para ir. p.ej:

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

Answer 3

Esto es lo que funcionó para mí

1. instalar Extensiones Django (utilicé 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 - ver más abajo si esto se aplica a ti †
4. desde su directorio base de Django, cree un directorio para cuadernos, por ej.
   mkdir notebooks
5. Ir a ese directorio
   cd notebooks
6. Inicie las extensiones django shell_plus desde dentro de ese directorio:
   manage.py shell_plus --notebook
   El servidor portátil ahora debería estar en ejecución, y puede lanzar 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 una nueva computadora portátil "Django Shell Plus", según la captura de pantalla de la respuesta de John Mee

Y , lo que es más importante, lo que no funcionó fue cambiar directorios desde el interior del entorno del portátil. Si traté de trabajar con cualquier computadora portátil que no estaba en el directorio en el que se manage.py shell_plus --notebook , entonces el kernal no se configuró correctamente. Para mí, tener el notebook configurado para un solo directorio a la vez era suficiente.

† Configuración de Docker (opcional)

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

Por ejemplo, en el archivo de redacción de la ventana acoplable;

ports:
      -  "8890:8888"

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

Esto es lo que hice:

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

Answer 4

Lo siguiente funciona para mí usando win10, Python 3.5, Django 1.10:

• Instale Python con la distribución de Anaconda para que Jupyter se instale también

• Instala Django e instala django-extensions :

  pip install Django
  
  pip install django-extensions

• Comience un nuevo proyecto de Django. Tienes que hacer eso en esa parte de tu árbol de directorios a la que puede acceder Jupyter más adelante.

  django-admin startproject _myDjangoProject_

• Comience Jypter

• navegue por Jupyter al directorio myDjangoProject e ingrese el primero / arriba myDjangoProject -directory
• Comience dentro del directorio de myDjangoProject primero / superior un nuevo noteboke de Jupyter: nuevo -> Django Shell-Plus

• ingrese y ejecute el siguiente fragmento de código:

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

• Tenga en cuenta que este fragmento de código es el mismo que en manage.py , y tenga en cuenta que "myDjangoProject.settings" apunta a myDjangoProject / settings.py

• Ahora puede comenzar con ejemplos, por ejemplo:

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

Answer 5

Solo por completitud (pero es 2018, tal vez las cosas cambiaron desde que se publicó esta pregunta): en realidad puedes instalar un kernel Jupyter Python en tu entorno Django que luego conectará (ejecutará) un servidor / entorno Jupyter diferente (uno donde '' he instalado widgets, extensiones, cambiado el tema, etc.). django_extensions ahora solo hace una parte del trabajo requerido :-)

Esto supone que tiene un entorno virtual Jupyter que está separado del de Django y cuyos kernels / 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 one / ones 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 Jupyter de tu usuario (en Linux es ~ / .jupyter / while en OSX es ~ / Library / Jupyter /) que contiene su archivo kernel.json e imágenes / iconos ( de forma predeterminada, se utiliza el icono Jupyter predeterminado para el kernel que estamos instalando). Este kernel ejecutará dentro del entorno virtual lo que estuvo activo en la creación, utilizando así la misma versión exacta de python y todos los módulos instalados utilizados por nuestro proyecto Django.

Ejecutando ./manage.py shell_plus --notebook hace algo muy similar, pero además de requerir todo (incluso el servidor Jupyter y todas las extensiones) instalados en el entorno actual, tampoco puede ejecutar portátiles en directorios diferentes a la raíz del proyecto. (el que contiene ./manage.py). Además, ejecutará el kernel utilizando el primer ejecutable llamado python que encuentra en la ruta, no el del entorno virtual, lo que hace que se comporte mal cuando no se inicia desde la línea de comando dentro de un entorno virtual de Django activo.

Para solucionar estos problemas y poder crear un portátil que se ejecute dentro de cualquier proyecto de Django, así lo hemos configurado y para poder ejecutar portátiles almacenados en cualquier parte del sistema de archivos, necesitamos:

1. asegúrese de que el primer parámetro ''argv'' contiene la ruta completa al kernel de ipython que se encuentra en el entorno virtual

2. agregue (si no está presente) una sección ''env'' que contendrá variables de entorno de shell, luego use estas para decirle a Python dónde encontrar nuestro proyecto y qué configuraciones de Django debería usar. Hacemos esto agregando algo como lo siguiente:

   "env": {"DJANGO_SETTINGS_MODULE": "your_project.settings", "PYTHONPATH": "$ PYTHONPATH: / home / projectuser / projectfolder / your_project"}

3. opcional: cambie ''display_name'' para que sea humano y reemplace los íconos.

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

{ "display_name": "My Project", "language": "python", "env": { "DJANGO_SETTINGS_MODULE": "my_project.settings", "PYTHONPATH": "$PYTHONPATH:/home/user/devel/my_project/my_project" }, "argv": [ "/home/user/.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, por lo general como se ve dentro de la gestión de su proyecto.

• "PYTHONPATH": "$ PYTHONPATH: / home / user / devel / my_project / my_project" : PYTHONPATH se amplía para incluir el directorio principal de su proyecto, de modo que se puedan encontrar configuraciones incluso si el kernel no se ejecuta en ese directorio exacto (aquí django_extensions usará una python genérica, ejecutando así el entorno virtual incorrecto a menos que se inicie todo el servidor Jupyter desde adentro: agregar esto al kernel.json creado por django_extensions le permitirá ejecutar notebooks en cualquier parte del directorio del proyecto Django)

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

• "django_extensions.management.notebook_extension" : esta es la extensión que cargará la funcionalidad ''shell_plus'' en el notebook (opcional pero útil :-))