Come ricaricare i moduli nella shell di django?

Sto lavorando con Django e uso sempre la shell Django. La parte fastidiosa è che mentre il server Django si ricarica alle modifiche al codice, la shell no, quindi ogni volta che apporto una modifica a un metodo che sto testando, devo uscire dalla shell e riavviarla, reimportare tutti i moduli che ho bisogno, reinizializza tutte le variabili di cui ho bisogno, ecc. Anche se la cronologia di iPython consente di risparmiare molto sulla digitazione, questo è ancora un problema. C'è un modo per ricaricare automaticamente la shell di django, allo stesso modo del server di sviluppo di django?

Conosco reload (), ma importa molti modelli e generalmente uso la from app.models import *sintassi, quindi reload () non è di grande aiuto.

Consiglio di utilizzare il progetto django-extensions come indicato sopra da dongweiming. Ma invece del solo comando di gestione 'shell_plus', usa:

manage.py shell_plus --notebook

Questo aprirà un notebook IPython sul tuo browser web. Scrivi il tuo codice lì in una cella, le tue importazioni ecc. Ed eseguilo.

Quando modifichi i moduli, fai clic sulla voce di menu del notebook "Kernel-> Restart"

Ecco fatto, il tuo codice ora utilizza i tuoi moduli modificati.

Suggerirei di utilizzare l' estensione di caricamento automatico IPython .

./manage.py shell

In [1]: %load_ext autoreload
In [2]: %autoreload 2

E da ora tutti i moduli importati verranno aggiornati prima di valutare.

In [3]: from x import print_something
In [4]: print_something()
Out[4]: 'Something'

 # Do changes in print_something method in x.py file.

In [5]: print_something()
Out[5]: 'Something else'

Funziona anche se qualcosa è stato importato prima del %load_ext autoreloadcomando.

./manage.py shell
In [1]: from x import print_something
In [2]: print_something()
Out[2]: 'Something'

 # Do changes in print_something method in x.py file.

In [3]: %load_ext autoreload
In [4]: %autoreload 2
In [5]: print_something()
Out[5]: 'Something else'

È anche possibile impedire l'aggiornamento di alcune importazioni con il %aimportcomando e 3 strategie di caricamento automatico:

% autoreload

• Ricarica automaticamente tutti i moduli (eccetto quelli esclusi da% aimport) ora.

% autoreload 0

• Disabilita il ricaricamento automatico.

% autoreload 1

• Ricarica tutti i moduli importati con% aimport ogni volta prima di eseguire il codice Python digitato.

% autoreload 2

• Ricarica tutti i moduli (eccetto quelli esclusi da% aimport) ogni volta prima di eseguire il codice Python digitato.

% aimport

• Elenca i moduli che devono essere importati automaticamente o che non devono essere importati.

% aimport foo

• Importa il modulo 'pippo' e contrassegnalo per essere caricato automaticamente per% autoreload 1

% aimport -foo

• Contrassegna il modulo 'pippo' per non essere caricato automaticamente.

Questo generalmente funziona bene per il mio uso, ma ci sono alcuni cavetas:

• La sostituzione degli oggetti di codice non sempre riesce: cambiare una proprietà @ in una classe in un metodo ordinario o un metodo in una variabile membro può causare problemi (ma solo nei vecchi oggetti).
• Le funzioni che vengono rimosse (ad es. Tramite monkey-patch) da un modulo prima che venga ricaricato non vengono aggiornate.
• I moduli di estensione C non possono essere ricaricati e quindi non possono essere caricati automaticamente.

guarda il comando manage.py shell_plus fornito dal progetto django-extensions . Caricherà tutti i file del modello all'avvio della shell. e carica automaticamente qualsiasi modifica ma non è necessario uscire, puoi chiamare direttamente lì

La mia soluzione è che scrivo il codice e lo salvo in un file, quindi utilizzo:

python manage.py shell <test.py

Quindi posso apportare la modifica, salvare ed eseguire di nuovo quel comando finché non aggiusto tutto ciò che sto cercando di riparare.

Sembra che il consenso generale su questo argomento sia che python reload () fa schifo e non c'è un buon modo per farlo.

Reload () non funziona nella shell Django senza alcuni trucchi. Puoi controllare questo thread na e la mia risposta in particolare:

Come si ricarica un modulo del modello Django utilizzando l'interprete interattivo tramite "manage.py shell"?

Segue la mia soluzione per questo inconveniente. Sto usando IPython.

$ ./manage.py shell
> import myapp.models as mdls   # 'mdls' or whatever you want, but short...
> mdls.SomeModel.objects.get(pk=100)
> # At this point save some changes in the model
> reload(mdls)
> mdls.SomeModel.objects.get(pk=100)

Per Python 3.x , 'reload' deve essere importato utilizzando:

from importlib import reload

Spero che sia d'aiuto. Ovviamente è a scopo di debug.

Saluti.

Usa shell_plus con una configurazione ipython. Questo si abiliterà autoreloadprima che shell_plus importi automaticamente qualcosa.

pip install django-extensions
pip install ipython
ipython profile create

Modifica il tuo profilo ipython ( ~/.ipython/profile_default/ipython_config.py):

c.InteractiveShellApp.exec_lines = ['%autoreload 2']
c.InteractiveShellApp.extensions = ['autoreload']

Apri una shell: tieni presente che non è necessario includere --ipython:

python manage.py shell_plus

Ora qualsiasi cosa definita in SHELL_PLUS_PRE_IMPORTSo SHELL_PLUS_POST_IMPORTS( docs ) verrà caricata automaticamente!

Nota che se la tua shell è in un debugger (ex pdb.set_trace()) quando salvi un file, può interferire con il ricaricamento.

Invece di eseguire comandi dalla shell Django, puoi impostare un comando di gestione in questo modo e rieseguirlo ogni volta.

Non esattamente quello che vuoi, ma ora tendo a costruirmi comandi di gestione per testare e giocherellare con le cose.

Nel comando puoi impostare un gruppo di locali nel modo che preferisci e poi cadere in una shell interattiva.

import code

class Command(BaseCommand):
  def handle(self, *args, **kwargs):
     foo = 'bar'
     code.interact(local=locals())

Nessuna ricarica, ma un modo semplice e meno fastidioso per testare interattivamente le funzionalità di django.