L'exécution de sous-processus au sein des différentes virtualenv avec python

Disons que j'ai 2 versions différentes de mon app installé dans 2 différents virtualenvironments. myapp v1.0 et myapp v2.0.

Maintenant, je voudrais comparer ceux-ci. La comparaison est écrit en python lui-même. Quelle serait la meilleure façon de le faire? Supposons que je puisse exécuter séparément et écrire un fichier de sortie, donc je peux comparer plus tard.

Une façon de le faire serait d'écrire un script bash (c'est ce que j'ai actuellement). - Je activer un virtualenv, exécuter myapp v1.0, activez un autre virtualenv, exécuter myapp v2.0. Plus tard, un module de comparaison sur ces fichiers. Mais je voudrais ajouter un peu plus dynamique, il (prendre quelques arguments facultatifs etc) qui serait plus facile avec python.

Edit:

Actuellement, j'ai quelque chose comme ça (un script bash):

source virtualenv1/bin/activate
python my_script.py
deactivate

source virtualenv2/bin/activate
python my_other_script.py
deactivate

python my_comparison_script.py

au lieu de cela, je voudrais faire seulement:

python my_comparison_script.py

et mes scripts être exécuté à l'intérieur de ce.

InformationsquelleAutor Ago | 2011-11-08

python virtualenv

-2

quelle est exactement la question? comment utiliser les sous-processus pour exécuter des commandes shell? si c'est le cas, certains simpliste pseudo code pourrait ressembler à:
```
import subprocess

myProcess = subprocess.Popen(   ['these', 'are', 'for', 'the', 'shell'],
                                stdout=subprocess.PIPE,
                                stderr=subprocess.PIPE )

[outStream, errStream] = myProcess.communicate()
```
puis vous pouvez faire ce que vous voulez avec standard (outStream) et de faire des choses différentes si errStream existe (erreur standard). cela comprend la rédaction de la norme ou d'erreur standard vers un fichier. puis-je suppose que vous diff de ces fichiers?

un réel exemple de code (en supposant que vous avez la version 2.6 de python+ sur un système linux) pourrait ressembler à:
```
import subprocess

with open('dateHelp.log', 'w') as dateLog:
    with open('dateHelp.err', 'w') as errLog:
        dateHelp = subprocess.Popen([ 'date', '-h'], stdout=dateLog, 
                                                     stderr=errLog)
        dateHelp.communicate()
```
- Puis-je activer mon virtualenv de cette façon, aussi? Ma question est, comment puis-je exécuter des processus dans les différents virtualenvs. Mais je suppose que je peux activer virtualenv avec un processus, puis d'exécuter mon script qui dépend de la virtualenv? Merci pour l'exemple.
- eh bien, je ne suis pas sûr de savoir comment vous êtes l'activation de votre virtualenv normalement, mais j'imagine que vous pourriez le faire avec un processus secondaire. encore mieux, si vous avez déjà des scripts bash écrit, pourquoi ne pas utiliser python pour envelopper ces scripts? sous-processus peut appeler les scripts et les processus de leur sortie de la même manière. vous pouvez configurer le script python avec argparse ou optparse (selon votre version) si vous voulez qu'il ont des modes différents.
- Vous pouvez faire un . /venv1/bin/activate && python your_app.py et de l'exécuter à l'aide de shell = TRUE pour exécuter your_app.py à l'aide de venv1 dans un sous-processus.
- Grâce Noafal pour l'astuce, cela a bien fonctionné!
- suce plutôt (dangereux), vous devez utiliser le shell=True si.
- Oui. Je suis d'accord. Je ne voudrais pas le faire moi-même.
- Le lancement d'une commande par le shell est seulement dangereux si la commande est construit à partir d'douteuses en entrée.
InformationsquelleAutor aeroNotAuto
33

Accepté la réponse ne traite pas le problème de "l'activation" un virtualenv dans un sous-processus.

Si vous démarrez votre application avec un appel à l'exécutable python, comme dans votre exemple, il est en fait très simple: il vous suffit de spécifier le fichier exécutable dans le virtualenv.
```
import subprocess

subprocess.Popen(["virtualenv1/bin/python", "my_script.py"])
subprocess.Popen(["virtualenv2/bin/python", "my_other_script.py"])
```
va commencer le processus dans les virtualenvs.

Important

Pour répondre aux préoccupations exprimées dans les commentaires:

Si vous souhaitez exécuter un sous-processus et assurez-vous d'utiliser l'interprète que le processus actuel est en cours d'exécution en vous devez utiliser sys.exécutable. Aussi disponible: sys.exec_prefix pour accéder au répertoire spécifique au site préfixe où la plate-forme dépendant de fichiers Python sont installés.

Si vous voulez un beaucoup plus en profondeur de la discussion de ce sujet, jetez un oeil à ce pull request.
- En fait, ce n'est pas suffisant. L'activation d'un virtualenv modifie également certaines variables d'environnement, appelant spécifiques virutalenv de python ne fait pas ça. En conséquence, mal bibliothèques seront chargés.
- Je suis en désaccord - cette approche fonctionne et je l'utilise dans mon propre code de production. Je suis ce n'est pas le seul à le recommander, que ce soit. Je voudrais être utile si vous concrétiser les variables d'environnement que vous faites référence à un cas de test qui montre, en vertu de laquelle les circonstances mal bibliothèques d'être chargé.
- Oui j'ai vu que la recommandation sur virtualenv du site aussi. Il y a au moins deux cas où la course avec virtualenv lié interpréteur python directement est différente de l'utilisation d'activer: quand PYTHONHOME est définie et quand la cible programme utilise command ou Popen pour exécuter un autre programme en Python. Ce dernier s'sans doute glauque.
- J'ai juste essayé le deuxième scénario et c'est vrai: l'appel de sous-processus de l'intérieur my_script.py seraient exécutés avec le système de Python de nouveau. Maladroite.
- Sur windows. J'ai besoin de "se mettre PYTHONPATH= & quelques-virtualenv1" avant d'appeler le python ou le script. Sinon, l'interpréteur python PYTHONPATH pointe toujours vers le système de bibliothèques.
- Désolé pour le détournement de cette mais comment fait-tox gérer cela?
InformationsquelleAutor Oliver Bestwalter
2

D'une option simple serait d'exécuter une série de commandes avec sous-processus comme suit.
```
import subprocess

subprocess.call('source activate my_virtualenv; python my_script.py', shell=True)
```
Et répéter au besoin.

InformationsquelleAutor fiskhe
1

Je pense que virtualenv documentation explique bien.

TL;DR

Running python venv binaire directement est PAS le même que l'activation de venv.
Vous devez également modifier CHEMIN et VIRTUAL_ENV variables en conséquence (voir os.environ)

Source

$ source /chemin/vers/ENV/bin/activate

Cela va changer votre $PATH de sorte que sa première entrée est le virtualenv est
le répertoire bin/. (Vous devez utiliser la source parce qu'il change votre shell
l'environnement en place.) C'est tout ce qu'il fait, c'est purement une commodité.

Si vous exécutez un script ou l'interpréteur python à partir de la
virtualenv bin/répertoire (par exemple en chemin/vers/ENV/bin/pip ou
/path/to/ENV/bin/python-script.py) puis sys.chemin d'accès sera automatiquement
configuré pour utiliser les bibliothèques Python associé avec le virtualenv. Mais,
contrairement à l'activation des scripts, les variables d'environnement PATH et
VIRTUAL_ENV ne sera pas modifié. Cela signifie que si votre Python
script utilise par exemple sous-processus à exécuter un autre script Python (par exemple via un
!/usr/bin/env python ligne shebang) le second script ne peut pas être exécutée avec les mêmes Python binaire comme le premier ni le même
les bibliothèques offrent à elle. Pour éviter ce qui se passe votre premier script
besoin de modifier les variables d'environnement de la même manière que
l'activation des scripts, avant le second script est exécuté.

InformationsquelleAutor eleksis

Vous devez vous connecter pour publier un commentaire.