Comment activer un virtualenv dans le terminal de PyCharm?

Pour les utilisateurs Windows lorsque vous utilisez PyCharm et un environnement virtuel sous Windows, vous pouvez utiliser le paramètre / k pour cmd.exe pour définir l'environnement virtuel automatiquement.

Allez dans Paramètres, Terminal, shell par défaut et ajoutez /K <path-to-your-activate.bat>.

Je n'ai pas la réputation de commenter la réponse précédente afin de poster cette version corrigée. Cela économise vraiment beaucoup de temps.

Mise à Jour:

Remarque: Pycharm supporte maintenant directement les environnements virtuels et cela semble fonctionner Eh bien pour moi-donc ma solution de contournement n'est plus nécessaire.

Pour les utilisateurs Windows: lorsque vous utilisez PyCharm avec un environnement virtuel, vous pouvez utiliser le paramètre /K sur cmd.exe pour définir automatiquement l'environnement virtuel.

PyCharm 3 ou 4: Settings, Terminal, Default shell et d'ajouter /K <path-to-your-activate.bat>.

PyCharm 5: Settings, Tools, Terminal, et d'ajouter /K <path-to-your-activate.bat> à Shell path.

PyCharm 2016.1 ou 2016.2: Settings, Tools, Terminal, et d'ajouter ""/K <path-to-your-activate.bat>"" à Shell path et ajouter (n'oubliez pas les guillemets). Ajoutez également des citations autour de cmd.exe, résultant en:

"cmd.exe" /k ""C:\mypath\my-venv\Scripts\activate.bat""

Sur la base des réponses de Peter et de l'expérimentation, j'ai trouvé une bonne "solution générale", qui résout ce qui suit:

• Restaure le comportement d'un shell de connexion. PyCharm exécute normalement un shell de connexion, mais --rcfile a arrêté cela. Le Script utilise toujours --rcfile, mais tente d'émuler le comportement D'appel d'un shell de connexion.
• supprime la nécessité de créer un fichier rc pour chaque environnement
• Supprime la nécessité de mettre à jour les paramètres du projet si vous modifiez environnement.

Déposez ce script dans un répertoire bin quelque part. Par exemple ~ / bin / pycharmactivate

if [ -r "/etc/profile" ] ; then . /etc/profile ; fi
if [ -r "~/.bash_profile" ] ; then
    . ~/.bash_profile
elif [ -r "~/.bash_login" ] ; then
    . ~/.bash_login
elif [ -r "~/.profile" ] ; then
    . ~/.profile
fi
ACTIVATERC=`cat .idea/workspace.xml | perl -n -e 'print "\$1/bin/activate" if m:option name="SDK_HOME" value="\\\$USER_HOME\\\$(.*)/bin/python":'`
if [ -n "$ACTIVATERC" ] ; then . "$HOME/$ACTIVATERC" ; else echo "Could not find virtualenv from PyCharm" ; fi

Ensuite, définissez le chemin du Shell de PyCharm sur:

/bin/bash --rcfile ~/bin/pycharmactivate

Merci Chris, votre script a fonctionné pour certains projets mais pas tous sur ma machine. Voici un script que j'ai écrit et j'espère que tout le monde le trouvera utile.

#Stored in ~/.pycharmrc 

ACTIVATERC=$(python -c 'import re
import os
from glob import glob

try:
  #sets Current Working Directory to _the_projects .idea folder
  os.chdir(os.getcwd()+"/.idea") 

  #gets every file in the cwd and sets _the_projects iml file
  for file in glob("*"): 
    if re.match("(.*).iml", file):
      project_iml_file = file

  #gets _the_virtual_env for _the_project
  for line in open(project_iml_file):
    env_name = re.findall("~/(.*)\" jdkType", line.strip())
    # created or changed a virtual_env after project creation? this will be true
    if env_name:
      print env_name[0] + "/bin/activate"
      break

    inherited = re.findall("type=\"inheritedJdk\"", line.strip())
    # set a virtual_env during project creation? this will be true
    if inherited:
      break

  # find _the_virtual_env in misc.xml
  if inherited:
    for line in open("misc.xml").readlines():
      env_at_project_creation = re.findall("\~/(.*)\" project-jdk", line.strip())
      if env_at_project_creation:
        print env_at_project_creation[0] + "/bin/activate"
        break
finally:
  pass
')

if [ "$ACTIVATERC" ] ; then . "$HOME/$ACTIVATERC" ; fi

PyCharm 4 a maintenant virtualenvs intégré dans L'IDE. Lorsque vous sélectionnez votre interpréteur de projet, vous pouvez créer, ajouter ou sélectionner un virtualenv. Ils ont ajouté une "Console Python" qui s'exécute dans l'interpréteur de projet configuré.

Plus d'infos ici.

Si Vous utilisez la version windows, il est assez facile. Si vous avez déjà l'environnement virtuel, accédez simplement à son dossier, recherchez activate.bat dans le dossier Scripts. copiez c'est full path et collez-le dans le terminal de pycharm puis appuyez sur Enter et vous avez terminé!

Si vous devez créer un nouvel environnement virtuel:

Allez dans Fichiers > Paramètres puis recherchez project interpreter, Ouvrez-le, Cliquez sur le bouton d'engrenage et créez l'environnement où vous voulez, puis suivez d'abord paragraphe.

Je viens d'ajouter un script nommé pycharmactivate à mon répertoire personnel. Définissez la valeur de PyCharm (4.0.1) Fichier > Paramètres > Outils > Terminal > chemin Shell vers / bin /bash -- rcfile ~ / pycharmactivate. Peut-être pas la meilleure solution dans le cas où vous avez différents répertoires / noms de projets et de virtualenv, mais cela fonctionne pour moi. Ce script contient les 3 lignes suivantes et suppose que votre virtualenv a le même nom que votre répertoire de projet.

source ~/.bashrc
projectdir=${PWD##*/}
source ~/.virtualenvs/$projectdir/bin/activate

Suivi de la réponse de Peter, voici la version Mac du fichier .pycharmrc:

source /etc/profile
source ~/.bash_profile
source  <venv_dir>/bin/activate

Poule

J'ai une solution qui a fonctionné sur ma machine Windows 7.

Je crois que le terminal de PyCharm est le résultat de l'exécution de cmd.exe, qui chargera la variable Windows PATH, et utilisera la version de Python qu'il trouve en premier dans cette PATH. Pour modifier cette variable, à droite, cliquez sur Mon Ordinateur --> Propriétés --> Paramètres Système Avancés --> Avancé onglet --> Variables d'Environnement...Bouton . Dans les variables système sélectionnez et modifiez la variable PATH.

Voici la partie pertinente de mon PATH avant de édition:

C:\Python27\;
C:\Python27\Lib\site-packages\pip\;
C:\Python27\Scripts;
C:\Python27\Lib\site-packages\django\bin;

...et après édition de PATH (seulement 3 lignes):

C: [project_path] \ virtualenv-Py2. 7_Dj1. 7\Lib \ site-packages\pip;
C: [project_path] \ virtualenvs\virtualenv-Py2. 7_Dj1.7 \ Scripts;
C: [project_path] \ virtualenvs\virtualenv-Py2. 7_Dj1. 7 \ Lib \ site-packages \ django\bin;

Pour tester cela, ouvrez unNouveau terminal windows ( Start -- > tapez cmd et appuyez sur Enter ) et voyez s'il utilise votre environnement virtuel. Si cela fonctionne, redémarrez PyCharm , puis testez-le dans le terminal de PyCharm.

C'est ce que je fais: créer un activate_env.bat (windows,peut-être .sh sous linux) Fichier dans le code source folde:

/env_yourenvlocate/scripts/activate.bat

Et un autre fichier deactivate_env.MTD:

/env_yourenvlocate/scripts/deactivate.bat

Chaque fois que vous ouvrez la fenêtre du terminal, exécutez simplement le fichier bat pour activer / désactiver le virtualenv, vous resterez dans le chemin du code source, pas besoin de changer de chemin d'accès et de retour.

E:\Projects\django_study\src>active_env.bat

E:\Projects\django_study\src>../env_django_study/scripts/activate.bat
(env_django_study) E:\Projects\django_study\src>



(env_django_study) E:\Projects\django_study\src>deactive_env.bat

(env_django_study)E:\Projects\django_study\src>../env_django_study/scripts/deactivate.bat
E:\Projects\django_study\src>

Si votre Pycharm 2016.1.4 v et supérieur, vous devez utiliser "default path" /K "<path-to-your-activate.bat>" ne pas oublier les citations

J'ai vu toutes les réponses ci-dessus, mais aucune d'entre elles n'est assez élégante pour moi. Dans Pycharm 2017.1.3(dans mon ordinateur), le plus simple est d'ouvrir Settings->Tools->Terminal et vérifier Shell integration et Activate virtualenv options.

. une Autre alternative est d'utiliser virtualenvwrapper pour gérer vos environnements virtuels. Il semble qu'une fois que le script virtualenvwrapper est activé , pycharm peut l'utiliser et la simple commande workon sera disponible à partir de la console pycharm et vous présentera les environnements virtuels disponibles:

kevin@debian:~/Development/django-tutorial$ workon
django-tutorial
FlaskHF
SQLAlchemy
themarkdownapp
kevin@debian:~/Development/django-tutorial$ workon django-tutorial
(django-tutorial)kevin@debian:~/Development/django-tutorial$ 

Cette méthode devrait fonctionner avec des environnements virtuels arbitraires par projet et elle ne fait pas d'hypothèses sur votre environnement car elle utilise des hooks que vous créez.

Vous écrivez:

• Un script global qui appelle le crochet
• un script hook par projet PyCharm (non obligatoire)

Étant donné que le dernier PyCharm actuel (Community 2016.1) n'autorise pas les paramètres de Terminal par projet commencez par le script qui appelle le projet spécifique crochet. C'est mon ~/.pycharmrc:

if [ -r ".pycharm/term-activate" ]; then
   echo "Terminal activation hook detected."
   echo "Loading Bash profile..."
   source ~/.bash_profile
   echo "Activating terminal hook..."
   source ".pycharm/term-activate"
   source activate $PYCHARM_VENV
fi

Si vous utilisez autre chose que Bash, appelez votre propre équivalent .bash_profile Si vous le souhaitez.

Définissez maintenant votre PyCharm "Tools -> Terminal -> Shell Path" pour appeler ce script, par exemple: /bin/bash --rcfile ~/.pycharmrc

Enfin, pour chaque projet PyCharm, vous devez activer un environnement virtuel spécifique, créez un fichier dans la racine du projet PyCharm .pycharm/term-activate. Ceci est votre crochet et il va simplement définir le nom de l'environnement virtuel souhaité pour votre PyCharm projet:

export PYCHARM_VENV=<your-virtual-env-name>

Vous pouvez bien sûr étendre vos hooks avec tout ce que vous trouvez utile dans l'environnement terminal de votre projet PyCharm particulier.

Pour les environnements virtuels conda sous Windows, assurez-vous que votre fichier batch n'est pas nommé activate.bat car cela provoquera un conflit avec la commande conda activate, entraînant un appel récursif du fichier batch.

Ce qui fonctionne pour moi est le chemin de Shell suivant:

"cmd.exe" /k ""C:\FullPathToYourProject\activate-env.bat""

Et dans activate-env.fichier bat:

call activate myenvname

Je voulais un environnement virtuel séparé pour chaque projet, et je ne me souciais pas beaucoup d'avoir des fichiers supplémentaires pour faciliter cela. Une solution que vous n'avez besoin de faire qu'une seule fois et qui fonctionne pour tous les projets est ensuite d'ajouter ce qui suit à votre .bashrc ou .bash_profile:

if [ -d "./venv" ]; then
    source ./venv/bin/activate
fi

Cela vérifie s'il existe un environnement virtuel où le terminal est ouvert, et si c'est le cas, il l'active (et bien sûr d'autres chemins relatifs pourraient être utilisés). Les paramètres du terminal de PyCharm peuvent être laissés par défaut.

PyCharm 4.5.4

Créer un fichier .pycharmrc dans votre dossier personnel avec les éléments suivants table des matières

source ~/.bashrc
source ~/pycharmvenv/bin/activate

En utilisant votre chemin virtualenv comme dernier paramètre.

Définissez ensuite les préférences du shell - > paramètres du projet- > chemin du Shell sur

/bin/bash --rcfile ~/.pycharmrc

Je ne sais pas pourquoi, mais ça ne marche pas pour moi. PyCharm imprime une erreur.

cmd.exe /K "<path-to-your-activate.bat>" Il fonctionne, mais il crée le même virtualenv pour chaque projet, et même si cela n'est pas nécessaire.

Ce la réception Fonctionne! Mais la chaîne {[4] } doit contenir des guillemets, comme ceci "Full_path_to_your_env_locate\scripts\activate.bat"!

Désactiver le virtualenv est très facile-tapez dans le terminal 'désactiver'

(virt_env) D:\Projects\src>deactivate
D:\Projects\src>

Solution pour WSL (Ubuntu sous Windows)

Si vous utilisez WSL (Ubuntu sous Windows), vous pouvez également ouvrir bash en tant que terminal dans PyCharm et activer un virtualenv linux.

Utilisez un fichier .pycharmrc comme décrit dans la réponse de Peter Gibson; ajoutez le fichier .pycharmrc à votre répertoire personnel avec le contenu suivant:

source ~/.bashrc
source ~/path_to_virtualenv/bin/activate

Dans Pycharm Fichier > Paramètres > Outils > Terminal ajoutez le 'chemin du Shell' suivant:

"C:/Windows/system32/bash.exe" -c "bash --rcfile ~/.pycharmrc"

Projet spécifique virtualenv

Le chemin vers votre virtualenv dans .pycharmrc ne doit pas nécessairement être absolu. Vous pouvez définir un virtualenv spécifique au projet en définissant un chemin relatif à partir de votre répertoire de projet. Mon virtualenv est toujours situé dans un dossier' venv ' sous le répertoire de mon projet, donc mon fichier .pycharmrc ressemble à ceci:

source ~/.bashrc
source ~/pycharmvenv/bin/activate #absolute path
source ./venv/bin/activate #relative path

BONUS: ouvrez automatiquement le tunnel ssh pour connecter virtualenv en tant qu'interpréteur de projet

Ajoutez ce qui suit à votre .pycharmrc fichier:

if [ $(ps -aux | grep -c 'ssh') -lt 2 ]; then
    sudo service ssh start 
fi

Ceci vérifie si un tunnel ssh est déjà ouvert, et en ouvre un autrement. Dans Fichier - > Paramètres - > projet - > interpréteur de projet dans Pycharm, ajoutez un nouvel interpréteur distant avec la configuration suivante:

+--------------------------+---------------------------------+-------+----+
| Name:                    | <Interpreter name>              |       |    |
| Select                   | 'SSH Credentials'               |       |    |
| Host:                    | 127.0.0.1                       | Port: | 22 |
| User:                    | <Linux username>                |       |    |
| Auth type:               | 'Password'                      |       |    |
| Password:                | <Linux password>                |       |    |
| Python interpreter path: | <Linux path to your virtualenv> |       |    |
| Python helpers path:     | <Set automatically>             |       |    |
+--------------------------+---------------------------------+-------+----+

Maintenant, lorsque vous ouvrez votre projet, votre bash démarre automatiquement dans votre virtualenv, ouvre un tunnel ssh et pycharm connecte le virtualenv en tant qu'interpréteur distant.

avertissement: la dernière mise à jour dans Windows démarre automatiquement un Sshbroker et sshproxy service au démarrage. Ceux-ci bloquent le tunnel ssh de linux à windows. Vous pouvez arrêter ces services dans le Gestionnaire des tâches - > Services, après quoi tout fonctionnera à nouveau.

Une option que vous avez lorsque vous entrez dans le terminal > Exécuter > Déboguer > Modifier Les Configurations

Sélectionnez l'environnement conda approprié.. Aussi lorsque vous créez un nouveau projet, il demande à configurer cet emplacement.