Déterminez si Python est en cours d'exécution à l'intérieur virtualenv

Question

Est-il possible de déterminer si le script en cours est en cours d'exécution dans un environnement virtualenv?

Answer 1

AFAIK la façon la plus fiable pour vérifier ce (et la façon dont est utilisé en interne dans virtualenv et pip) est de vérifier l'existence de sys.real_prefix:

import sys

if hasattr(sys, 'real_prefix'):
    #...

Dans un virtualenv, points de sys.prefix dans le répertoire virtualenv et points de sys.real_prefix au préfixe "réel" du Python système (souvent /usr ou /usr/local ou quelque).

En dehors d'un virtualenv, sys.real_prefix ne devrait pas exister.

En utilisant la variable d'environnement VIRTUAL_ENV n'est pas fiable. Il est défini par le script shell activate de virtualenv, mais un virtualenv peut être utilisé sans activation en exécutant directement un fichier exécutable à partir du répertoire de bin/ de virtualenv (ou Scripts), auquel cas $VIRTUAL_ENV ne sera pas réglée.

Answer 2

Essayez d'utiliser pip -V (avis du capital V)

Si vous utilisez env virtuel. il va montrer le chemin de l'emplacement de l'env..

Answer 3

Ceci est une amélioration de la réponse acceptée par Carl Meyer . Il fonctionne avec virtualenv pour Python 3 et 2, et aussi pour le venv Module dans le python 3:

import sys


def is_venv():
    return (hasattr(sys, 'real_prefix') or
            (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix))

Le chèque sys.real_prefix couvre virtualenv, l'égalité des sys.base_prefix non vide avec sys.prefix couvre venv.

Considérons un script qui utilise la fonction comme ceci:

if is_venv():
    print('inside virtualenv or venv')
else:
    print('outside virtualenv or venv')

Et l'invocation suivante:

$ python2 test.py 
outside virtualenv or venv

$ python3 test.py 
outside virtualenv or venv

$ python2 -m virtualenv virtualenv2
...
$ . virtualenv2/bin/activate
(virtualenv2) $ python test.py 
inside virtualenv or venv
(virtualenv2) $ deactivate

$ python3 -m virtualenv virtualenv3
...
$ . virtualenv3/bin/activate
(virtualenv3) $ python test.py 
inside virtualenv or venv
(virtualenv3) $ deactivate 

$ python3 -m venv venv3
$ . venv3/bin/activate
(venv3) $ python test.py 
inside virtualenv or venv
(venv3) $ deactivate 

Answer 4

Vérifiez la variable d'environnement $VIRTUAL_ENV.

La variable d'environnement $VIRTUAL_ENV contient le répertoire de l'environnement virtuel lorsque dans un environnement virtuel actif.

>>> import os
>>> os.environ['VIRTUAL_ENV']
'/some/path/project/venv'

Une fois que vous exécutez deactivate / quitter l'environnement virtuel, la variable $VIRTUAL_ENV sera effacée / vide. Python déclenche une KeyError parce que la variable d'environnement était hors service.

>>> import os
>>> os.environ['VIRTUAL_ENV']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/Cellar/python/3.7.3/Frameworks/Python.framework/Versions/3.7/lib/python3.7/os.py", line 678, in __getitem__
    raise KeyError(key) from None
KeyError: 'VIRTUAL_ENV'

Ces mêmes contrôles variables d'environnement peuvent bien sûr être aussi fait en dehors du script Python, dans la coquille.

Answer 5

Selon le pep virtualenv http://www.python.org/dev/peps/ spécification pep-0405 / # vous pouvez simplement utiliser sys.prefix à la place os.environ [ 'VIRTUAL_ENV'].

la sys.real_prefix n'existe pas dans mon virtualenv et même avec sys.base_prefix.

Answer 6

Vous pouvez faire which python et voir si son pointage à celui env virtuel.

Answer 7

Pour vérifier si votre intérieur virtualenv:

import os

if os.getenv('VIRTUAL_ENV'):
    print('Using Virtualenv')
else:
    print('Not using Virtualenv')

Vous pouvez également obtenir plus de données sur votre environnement:

import sys
import os

print(f'Python Executable: {sys.executable}')
print(f'Python Version: {sys.version}')
print(f'Virtualenv: {os.getenv("VIRTUAL_ENV")}')

Answer 8

J'utilise couramment plusieurs environnements virtuels Anaconda installés (venv). Cet extrait / exemples de code vous permet de déterminer si oui ou non vous êtes dans un venv (ou votre environnement système), et d'exiger aussi un venv spécifique pour votre script.

AJOUTER À PYTHON SCRIPT (extrait de code de):

# ----------------------------------------------------------------------------
# Want script to run in Python 3.5 (has required installed OpenCV, imutils, ... packages):
import os

# First, see if we are in a conda venv { py27: Python 2.7 | py35: Python 3.5 | tf: TensorFlow | thee : Theano }
try:
   os.environ["CONDA_DEFAULT_ENV"]
except KeyError:
   print("\tPlease set the py35 { p3 | Python 3.5 } environment!\n")
   exit()

# If we are in a conda venv, require the p3 venv:
if os.environ['CONDA_DEFAULT_ENV'] != "py35":
    print("\tPlease set the py35 { p3 | Python 3.5 } environment!\n")
    exit()

# See also:
# Python: Determine if running inside virtualenv
# http://stackoverflow.com/questions/1871549/python-determine-if-running-inside-virtualenv  
# [ ... SNIP! ... ]

RUN SCRIPT VOTRE (exemples):

$ python  webcam_cv3_v2_fps_v2c.py  -n50
    Please set the py35 { p3 | Python 3.5 } environment!

$ thee
  [Theano in Anaconda Python 2.7 venv (source activate theano-env)]

(theano-env) $ python  webcam_cv3_v2_fps_v2c.py  -n50
    Please set the py35 { p3 | Python 3.5 } environment!

(theano-env) $ tf
  [TensorFlow in Anaconda Python 2.7 venv (source activate tf-env]

(tf-env) $ python  webcam_cv3_v2_fps_v2c.py  -n50
    Please set the py35 { p3 | Python 3.5 } environment!

(tf-env) $ p2
  [Anaconda Python 2.7 venv (source activate py27)]

(py27) $ python  webcam_cv3_v2_fps_v2c.py  -n50
    Please set the py35 { p3 | Python 3.5 } environment!

(py27) $ p3
  [Anaconda Python 3.5 venv (source activate py35)]

(py35) $ python  webcam_cv3_v2_fps_v2c.py  -n50

    current env: py35
    processing (live): found 2 faces and 4 eyes in this frame

    threaded OpenCV implementation
    num_frames: 50
    webcam -- approx. FPS: 18.59
    Found 2 faces and 4 eyes!

(py35) $ sd
  [Anaconda venv deactivate (source deactivate)]

$ python  webcam_cv3_v2_fps_v2c.py  -n50
    Please set the py35 { p3 | Python 3.5 } environment!

$ ## Q.E.D.  ;-)

Mise à jour: utiliser dans les scripts bash:

Vous pouvez également utiliser cette approche dans les scripts bash (par exemple, ceux qui doivent fonctionner dans un environnement virtuel spécifique). Exemple (ajouté au scénario bash):

# ----------------------------------------------------------------------------
# Excerpt from: /mnt/Vancouver/Programming/scripts/tf_tb_del.sh      ## tf_tb_del: tf_tensorboard_delete
# [bash script run on command-line: calls TensorFlow-related commands, therefore must be run in tf-env venv]

if [ $CONDA_DEFAULT_ENV ]        ## << note the spaces (important in bash)!
then
    printf  '\n\tvenv: tf-env\n'
else
    printf '\n\n\t*******************************************************************\n'
    printf '\t***  NOTE! Must run this script in tf-env virtual environment!  ***\n'
    printf '\t*******************************************************************'
    exit
fi
## [ ... snip ... ]

Answer 9

plus simple est de simplement exécuter: which python, si vous êtes dans un virtualenv il pointera vers son python au lieu de celui global

Answer 10

(sous la direction) Je trouve cette façon, que pensez-vous de celui-ci? (Elle retourne aussi le chemin de base venv et fonctionne même pour readthedocs où la vérification de la variable env ne fonctionne pas):

import os
import sys
from distutils.sysconfig import get_config_vars


def get_venv_basedir():
    """Returns the base directory of the virtualenv, useful to read configuration and plugins"""

    exec_prefix = get_config_vars()['exec_prefix']

    if hasattr(sys, 'real_prefix') is False or exec_prefix.startswith(sys.real_prefix):
        raise EnvironmentError('You must be in a virtual environment')

    return os.path.abspath(get_config_vars()['exec_prefix'] + '/../')

Answer 11

Ce n'est pas l'épreuve des balles, mais pour les environnements UNIX test simple comme

if run("which python3").find("venv") == -1:
    # something when not executed from venv

fonctionne très bien pour moi. Il est plus simple alors tester existant d'un attribut et, de toute façon, vous devez appeler votre répertoire venv venv.

Answer 12

Dans Windows OS vous voyez quelque chose comme ceci:

C:\Users\yourusername\virtualEnvName\Scripts>activate
(virtualEnvName) C:\Users\yourusername\virtualEnvName\Scripts>

Parenthèses signifie que vous êtes réellement dans l'environnement virtuel appelé « virtualEnvName ».

Answer 13

potentiel solution est :

os.access(sys.executable, os.W_OK)

Dans mon cas, je voulais vraiment juste pour détecter si je pouvais installer des éléments avec pip comme il est. Bien qu'il pourrait ne pas être la bonne solution pour tous les cas, pensez à vérifier simplement si vous disposez des autorisations d'écriture pour l'emplacement de l'exécutable Python.

Remarque: cela fonctionne dans toutes les versions de Python, mais renvoie également True si vous exécutez le Python système avec sudo. Voici une utilisation potentielle cas:

import os, sys
can_install_pip_packages = os.access(sys.executable, os.W_OK)

if can_install_pip_packages:
    import pip
    pip.main(['install', 'mypackage'])

Answer 14

Ceci est une question ancienne, mais trop d'exemples ci-dessus sont trop compliquées.

Keep It Simple: (en Jupyter Notebook ou Python 3.7.1 terminaux sous Windows 10)

import sys
print(sys.executable)```

# example output: >> `C:\Anaconda3\envs\quantecon\python.exe`

OR 
```sys.base_prefix```

# Example output: >> 'C:\\Anaconda3\\envs\\quantecon'

Answer 15

Il y a beaucoup de grandes méthodes affichées ici déjà, mais simplement l'ajout d'un plus:

import site
site.getsitepackages()

vous indique où pip installé les paquets.