J'ai besoin d'exécuter un script Python à partir du shell Django. J'ai essayé:
./manage.py shell << my_script.py
Mais ça n'a pas marché. Il n'attendait que moi pour écrire quelque chose.
J'ai besoin d'exécuter un script Python à partir du shell Django. J'ai essayé:
./manage.py shell << my_script.py
Mais ça n'a pas marché. Il n'attendait que moi pour écrire quelque chose.
Réponses:
La <<
pièce est fausse, utilisez <
plutôt:
$ ./manage.py shell < myscript.py
Vous pourriez également faire:
$ ./manage.py shell
...
>>> execfile('myscript.py')
Pour python3, vous devez utiliser
>>> exec(open('myscript.py').read())
./manage.py shell <<EOF\ execfile('myscript.py') \EOF
echo 'import myscript' | python manage.py shell
. J'ai trouvé que cela peut être utile pour les scripts rapides et sales que vous n'avez besoin d'exécuter qu'une seule fois, sans avoir à passer par le processus fastidieux de création d'une manage.py
commande.
Get-Content myscript.py | .\manage.py shell
Il n'est pas recommandé de le faire à partir du shell
- et cela est prévu car vous ne devriez pas vraiment exécuter des scripts aléatoires à partir de l'environnement django (mais il existe des moyens de contourner cela, voir les autres réponses).
S'il s'agit d'un script que vous exécuterez plusieurs fois, c'est une bonne idée de le configurer comme une commande personnalisée, c'est-à-dire
$ ./manage.py my_command
pour ce faire, créez un fichier dans un sous-répertoire de management
et commands
de votre app
, c'est-à-dire
my_app/
__init__.py
models.py
management/
__init__.py
commands/
__init__.py
my_command.py
tests.py
views.py
et dans ce fichier, définissez votre commande personnalisée (en vous assurant que le nom du fichier est le nom de la commande à partir de laquelle vous souhaitez exécuter ./manage.py
)
from django.core.management.base import BaseCommand
class Command(BaseCommand):
def handle(self, **options):
# now do the things that you want with your models here
NoArgsCommand
est obsolète. Cette page donne un exemple de travail: docs.djangoproject.com/en/1.9/howto/custom-management-commands/…
def handle_noargs(self, **options):
pour def handle(self, **options):
.
def handle(self, **options):
comme le commentaire de James.
Pour tous ceux qui utilisent Django 1.7+, il semble que simplement importer le module des paramètres ne suffit pas.
Après quelques recherches, j'ai trouvé cette réponse Stack Overflow: https://stackoverflow.com/a/23241093
Vous devez maintenant:
import os, django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myapp.settings")
django.setup()
# now your code can go here...
Sans faire ce qui précède, j'obtenais une django.core.exceptions.AppRegistryNoReady
erreur.
Mon fichier de script se trouve dans le même répertoire que mon projet django (c'est-à-dire dans le même dossier que manage.py)
DJANGO_SETTINGS_MODULE
variable d'environnement. Avec cela, il suffisait de: import django ; django.setup()
moins de 1,7.
django.setup()
ne permettra pas au script d'accéder aux modèles Django, pas même de les importer!
import django; django.setup()
.
Je suis en retard pour la fête mais j'espère que ma réponse aidera quelqu'un: vous pouvez le faire dans votre script Python:
import sys, os
sys.path.append('/path/to/your/django/app')
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
from django.conf import settings
le reste de vos affaires va ici ....
sys.path.append
contenu aussi longtemps que vous le souhaitez DJANGO_SETTINGS_MODULES
(par exemple, si vous avez un script juste au-dessus de la racine de votre site, vous pouvez le faire os.environ['DJANGO_SETTINGS_MODULE'] = 'mysite.settings'
).
sys.path.append(os.getcwd())
, cela fonctionne lorsque je suis dans mon répertoire de projet, mon DJANGO_SETTINGS_MODULE est correct et j'essaie d'exécuter un script qui importe des modèles, des vues, etc.
runscript
de django-extensions
python manage.py runscript scripty.py
Un échantillon script.py
pour le tester:
from django.contrib.auth.models import User
print(User.objects.values())
Mentionné sur: http://django-extensions.readthedocs.io/en/latest/command_extensions.html et documenté sur:
python manage.py runscript --help
Testé sur Django 1.9.6, django-extensions 1.6.7.
django-extensions
(vous devriez). Remarque: Il semble que runscript
le django standard soit utilisé shell
. Ce serait fantastique s'il était utilisé shell_plus
(également dans les extensions) afin que vous n'ayez pas à tout importer pour des scripts simples.
Si IPython est disponible ( pip install ipython
), il ./manage.py shell
utilisera automatiquement son shell et vous pourrez alors utiliser la commande magique %run
:
%run my_script.py
runscript
fait qu'il fonctionne avec des scripts en dehors du projet / package et ne se plaint pas comme çaTypeError: the 'package' argument is required to perform a relative import for
Vous pouvez simplement exécuter le script avec l' DJANGO_SETTINGS_MODULE
ensemble de variables d'environnement. C'est tout ce qu'il faut pour configurer l'environnement Django-shell.
Cela fonctionne dans Django> = 1.4
@AtulVarma a fourni un commentaire très utile sous la réponse acceptée non fonctionnelle :
echo 'import myscript' | python manage.py shell
si vous n'avez pas beaucoup de commandes dans votre script, utilisez-le:
manage.py shell --command="import django; print(django.__version__)"
Comme d'autres réponses l'indiquent mais ne le disent pas explicitement, ce dont vous pourriez avoir besoin n'est pas nécessairement d'exécuter votre script à partir du shell Django, mais d'accéder à vos applications sans utiliser le shell Django .
Cela diffère beaucoup de la version Django de la version Django. Si vous ne trouvez pas votre solution sur ce fil, les réponses ici - Script Django pour accéder aux objets du modèle sans utiliser le shell manage.py - ou des recherches similaires peuvent vous aider.
Je devais commencer my_command.py par
import os,sys
sys.path.append('/path/to/myproject')
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings.file")
import django
django.setup()
import project.app.models
#do things with my models, yay
puis a couru python3 my_command.py
(Django 2.0.2)
sys.path.append('/path/to/myproject')
par BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
et `sys.path.append (BASE_DIR)`. N'oubliez pas non plus d'activer votre env virtuel avant d'exécuter la commande!
import os, sys, django
os.environ["DJANGO_SETTINGS_MODULE"] = "settings"
sys.path.insert(0, os.getcwd())
django.setup()
Notez que cette méthode est déconseillée pour les versions plus récentes de django! (> 1.3)
Une autre réponse, vous pouvez l'ajouter en haut de my_script.py
from django.core.management import setup_environ
import settings
setup_environ(settings)
et exécutez my_script.py
juste avec python dans le répertoire où vous avez, settings.py
mais c'est un peu hacky.
$ python my_script.py
Quelque chose que je viens de trouver intéressant est Django Scripts, qui vous permet d'écrire des scripts à exécuter avec python manage.py runscript foobar. Des informations plus détaillées sur la mise en œuvre et la structure sont disponibles ici, http://django-extensions.readthedocs.org/en/latest/index.html
Essayez ceci si vous utilisez un environnement virtuel: -
shell python manage.py
pour utiliser ces commandes, vous devez être dans un environnement virtuel. pour cette utilisation: -
workon vir_env_name
par exemple :-
dc@dc-comp-4:~/mysite$ workon jango
(jango)dc@dc-comp-4:~/mysite$ python manage.py shell
Python 2.7.6 (default, Mar 22 2014, 22:59:56)
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>>
Remarque : - Ici, mysite est le nom de mon site Web et jango est le nom de mon environnement virtuel
Sinon, exécutez celui-ci:
echo 'execfile("/path_to/myscript.py")' | python manage.py shell --settings=config.base
Cela fonctionne sur Python2.7 et Django1.9
Le shell django est le bon moyen d'exécuter un module python avec l'environnement django, mais il n'est pas toujours facile et fastidieux d'importer des modules et d'exécuter des fonctions manuellement, surtout sans auto-complétion. Pour résoudre ce problème, j'ai créé un petit script shell "runscript.sh" qui vous permet de profiter pleinement de l'auto-complétion et de l'historique des journaux de la console Linux.
NB: Copiez runscript.sh dans le projet racine et définissez le droit d'exécution (chmod + x)
Par exemple: je veux exécuter la fonction python nommée show (a, b, c) dans le module do_somethings.py dans myapp / do_folder /
La manière standard de Django (shell manage.py):
python3 manage.py shell
> from myapp.do_folder import do_somethings
> do_somethings.show("p1", "p2" , 3.14159)
Avec script (runscript.sh):
./runscript.sh myapp/do_folder/do_somethings.py show p1 p2 3.14159
Le script n'est pas limité en nombre d'arguments. Cependant, seuls les arguments de types primitifs sont pris en charge (int, float, string)
runscript
du django-extensions
package faire la même chose, vérifiez-le django-extensions.readthedocs.io/en/latest/runscript.html
Tard à la fête. Mais cela pourrait être utile pour quelqu'un.
Tout ce dont vous avez besoin est votre script et django-extensions
installé.
Exécutez simplement le shell_plus
disponible dans django_extensions
et importez le script que vous avez écrit.
Si votre script se trouve scpt.py
et se trouve dans un dossier, fol
vous pouvez exécuter le script comme suit.
python manage.py shell_plus
et importez simplement votre script à l'intérieur du shell comme suit.
>>> from fol import scpt
django.setup () ne semble pas fonctionner.
ne semble pas non plus nécessaire.
cela seul a fonctionné.
import os, django, glob, sys, shelve
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myProject.settings")
django
fonctionne, que voulez-vous réellement faire?