Comment recharger des modules dans le shell django?

Je travaille avec Django et j'utilise le shell Django tout le temps. La partie ennuyeuse est que tandis que le serveur Django se recharge sur les changements de code, le shell ne le fait pas, donc chaque fois que je modifie une méthode que je teste, je dois quitter le shell et le redémarrer, réimporter tous les modules que je besoin, réinitialisez toutes les variables dont j'ai besoin, etc. Alors que l'historique d'iPython économise beaucoup de saisie à ce sujet, c'est toujours une douleur. Existe-t-il un moyen de recharger automatiquement le shell django, de la même manière que le serveur de développement django?

Je connais reload (), mais j'importe beaucoup de modèles et j'utilise généralement la from app.models import *syntaxe, donc reload () n'aide pas beaucoup.

Je recommande d'utiliser le projet django-extensions comme indiqué ci-dessus par dongweiming. Mais au lieu de simplement la commande de gestion 'shell_plus', utilisez:

manage.py shell_plus --notebook

Cela ouvrira un bloc-notes IPython sur votre navigateur Web. Écrivez votre code dans une cellule, vos importations etc. et exécutez-le.

Lorsque vous modifiez vos modules, cliquez simplement sur l'élément de menu du notebook 'Kernel-> Restart'

Voilà, votre code utilise maintenant vos modules modifiés.

Je suggère d'utiliser l' extension de chargement automatique IPython .

./manage.py shell

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

Et à partir de maintenant, tous les modules importés seront actualisés avant d'être évalués.

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'

Fonctionne également si quelque chose a été importé avant la %load_ext autoreloadcommande.

./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'

Il est également possible d'empêcher l'actualisation de certaines importations avec la %aimportcommande et 3 stratégies de chargement automatique:

% chargement automatique

• Rechargez tous les modules (sauf ceux exclus par% aimport) automatiquement maintenant.

% chargement automatique 0

• Désactivez le rechargement automatique.

% chargement automatique 1

• Rechargez tous les modules importés avec% aimport à chaque fois avant d'exécuter le code Python tapé.

% chargement automatique 2

• Rechargez tous les modules (sauf ceux exclus par% aimport) à chaque fois avant d'exécuter le code Python tapé.

% aimport

• Liste des modules qui doivent être importés automatiquement ou non.

% aimport foo

• Importez le module 'foo' et marquez-le comme étant chargé automatiquement pour% autoreload 1

% aimport -foo

• Marquer le module «foo» pour ne pas être chargé automatiquement.

Cela fonctionne généralement bien pour mon utilisation, mais il y a quelques cavetas:

• Le remplacement des objets de code ne réussit pas toujours: changer une propriété @ dans une classe en une méthode ordinaire ou une méthode en une variable membre peut poser des problèmes (mais dans les anciens objets uniquement).
• Les fonctions supprimées (par exemple via monkey-patching) d'un module avant qu'il ne soit rechargé ne sont pas mises à jour.
• Les modules d'extension C ne peuvent pas être rechargés et ne peuvent donc pas être rechargés automatiquement.

regardez la commande manage.py shell_plus fournie par le projet django-extensions . Il chargera tous vos fichiers de modèle au démarrage du shell. et rechargez automatiquement vos modifications mais n'avez pas besoin de quitter, vous pouvez y appeler directement

Ma solution est d'écrire le code et d'enregistrer dans un fichier, puis d'utiliser:

shell python manage.py <test.py

Je peux donc effectuer le changement, enregistrer et exécuter à nouveau cette commande jusqu'à ce que je répare tout ce que j'essaie de réparer.

Il semble que le consensus général sur ce sujet soit que python reload () est nul et qu'il n'y a pas de bon moyen de le faire.

Reload () ne fonctionne pas dans le shell Django sans quelques astuces. Vous pouvez vérifier ce fil de discussion et ma réponse en particulier:

Comment recharger un module de modèle Django à l'aide de l'interpréteur interactif via "manage.py shell"?

Ma solution à cet inconvénient suit. J'utilise 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)

Pour Python 3.x , 'reload' doit être importé en utilisant:

from importlib import reload

J'espère que cela aide. Bien sûr, c'est à des fins de débogage.

À votre santé.

Utilisez shell_plus avec une configuration ipython. Cela autoreloadactivera avant que shell_plus importe automatiquement quoi que ce soit.

pip install django-extensions
pip install ipython
ipython profile create

Modifiez votre profil ipython ( ~/.ipython/profile_default/ipython_config.py):

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

Ouvrez un shell - notez que vous n'avez pas besoin d'inclure --ipython:

python manage.py shell_plus

Désormais, tout ce qui est défini dans SHELL_PLUS_PRE_IMPORTSou SHELL_PLUS_POST_IMPORTS( docs ) se recharge automatiquement!

Notez que si votre shell est au niveau d'un débogueur (ex pdb.set_trace()) lorsque vous enregistrez un fichier, cela peut interférer avec le rechargement.

Au lieu d'exécuter des commandes depuis le shell Django, vous pouvez configurer une commande de gestion comme celle-ci et la réexécuter à chaque fois.

Pas exactement ce que vous voulez, mais j'ai maintenant tendance à me créer des commandes de gestion pour tester et manipuler les choses.

Dans la commande, vous pouvez configurer un groupe de locaux comme vous le souhaitez et ensuite les déposer dans un shell interactif.

import code

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

Pas de rechargement, mais un moyen simple et moins ennuyeux de tester interactivement les fonctionnalités de django.