Comment activer une virtualenv dans le terminal de PyCharm?

J'ai configuré PyCharm, créé mon virtualenv (soit via la commande virtual env, soit directement dans PyCharm) et activé cet environnement en tant qu'interprète. Tout fonctionne très bien.

Cependant, si j'ouvre un terminal en utilisant "Tools, Open Terminal", l'invite shell fournie n'utilise pas l'environnement virtuel; Je dois encore utiliser source ~/envs/someenv/bin/activatece terminal pour l'activer.

Une autre méthode consiste à activer l'environnement dans un shell et à exécuter PyCharm à partir de cet environnement. C'est "réalisable" mais assez moche, et cela signifie que j'ai de gros problèmes si je change d'environnement ou de projet depuis PyCharm: j'utilise maintenant un environnement totalement incorrect.

Existe-t-il un autre moyen beaucoup plus simple pour que "Outils, Open Terminal" active automatiquement l'environnement virtuel?

Éditer:

Selon https://www.jetbrains.com/pycharm/whatsnew/#v2016-3-venv-in-terminal , PyCharm 2016.3 (publié en novembre 2016) prend en charge virutalenv pour les terminaux prêts à l'emploi

Auto virtualenv est pris en charge pour bash, zsh, fish et Windows cmd. Vous pouvez personnaliser vos préférences de shell dans Paramètres (Préférences) | Outils | Terminal.

Créez un fichier .pycharmrcdans votre dossier personnel avec le contenu suivant

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

Utilisation de votre chemin virtualenv comme dernier paramètre.

Ensuite, définissez les Préférences du shell-> Paramètres du projet-> Chemin du shell sur

/bin/bash --rcfile ~/.pycharmrc

Mettre à jour:

Les préférences dans Paramètres (Préférences) | Outils | Les terminaux sont mondiaux.
Si vous utilisez un venv pour chaque projet, n'oubliez pas d'utiliser la variable de chemin actuelle et un nom venv par défaut:

"cmd.exe" /k ""%CD%\venv\Scripts\activate"" 

Pour les utilisateurs Windows: lorsque vous utilisez PyCharm avec un environnement virtuel, vous pouvez utiliser le /Kparamètre à cmd.exepour définir automatiquement l'environnement virtuel.

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

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

PyCharm 2016,1 2016,2 ou: Settings, Tools, Terminalet ajouter ""/K <path-to-your-activate.bat>""à Shell pathet ajouter ( l' esprit les guillemets). Ajoutez également des guillemets autour de cmd.exe, ce qui entraîne:

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

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

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, donc poster cette version corrigée. Cela fait vraiment gagner beaucoup de temps.

Mettre à jour:

Remarque: Pycharm prend désormais en charge directement les environnements virtuels et cela semble bien fonctionner pour moi - donc ma solution de contournement n'est plus nécessaire.

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 les problèmes suivants:

• 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 INVOCATION 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 l'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 Shell de PyCharm sur:

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

PyCharm 4 intègre désormais des virtualenvs dans l'EDI. Lors de la sélection de 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.

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

J'ai vu toutes les réponses ci-dessus mais aucune d'entre elles n'est assez élégante pour moi. Dans PyCharm 03/01/2017 (dans mon ordinateur), la meilleure façon est d'ouvrir Settings->Tools->Terminalet de vérifier Shell integrationet d' Activate virtualenvoptions.

Si vous utilisez la version Windows, c'est assez simple. Si vous disposez déjà de l'environnement virtuel, accédez simplement à son dossier, recherchez le dossier à l' activate.batintérieur Scripts. copiez son chemin complet et collez-le dans le terminal de pycharm puis appuyez sur Enteret 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 le premier paragraphe.

Sur Mac, c'est PyCharm => Préférences ... => Outils => Terminal => Activer virtualenv , qui devrait être activé par défaut.

Je viens d'ajouter un script nommé pycharmactivate à mon répertoire personnel. Définissez la valeur de PyCharm (4.0.1) File> Settings> Tools> Terminal> Shell path to / 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

Suite à la réponse de Peter, voici la version Mac du .pycharmrcfichier:

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 pense que le terminal de PyCharm est le résultat de son exécution cmd.exe, qui chargera la PATHvariable Windows et utilisera la version de Python qu'il trouve en premier dans ce dernier PATH. Pour modifier cette variable, cliquez avec le bouton droit sur Poste de travail -> Propriétés -> Paramètres système avancés -> onglet Avancé -> bouton Variables d'environnement ... Dans la section Variables système , sélectionnez et modifiez la PATHvariable.

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

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

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

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

Pour tester cela, ouvrez un nouveau terminal Windows ( Démarrer -> tapez cmdet 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.

voici ce que je fais: créer un fichier activate_env.bat (windows, peut-être .sh sous linux) dans le fichier de code source:

/env_yourenvlocate/scripts/activate.bat

et un autre fichier deactivate_env.bat:

/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 le chemin vers et inversement.

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.4v et supérieur, vous devez utiliser "default path" /K "<path-to-your-activate.bat>" n'oubliez pas les guillemets

Si vous avez déplacé votre projet vers un autre répertoire, vous pouvez définir le nouveau chemin via la boîte de dialogue Paramètres. Et puis vous devez définir cet interpréteur de projet dans la boîte de dialogue Modifier la configuration.

Une autre alternative consiste à utiliser virtualenvwrapper pour gérer vos environnements virtuels. Il semble qu'une fois le script virtualenvwrapper activé , pycharm peut l'utiliser, puis la workoncommande simple 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 doit fonctionner avec des environnements virtuels arbitraires par projet et elle ne fait pas d'hypothèses sur votre environnement car elle utilise les hooks que vous créez.

Vous écrivez:

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

Étant donné que le dernier PyCharm (Community 2016.1) n'autorise pas les paramètres de terminal par projet, commencez par le script qui appelle le hook spécifique au projet. 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, invoquez votre propre .bash_profileéquivalent si vous le souhaitez.

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

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

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 de commandes n'est PAS nommé activate.batcar cela entraînera un conflit avec la activatecommande conda , entraînant un appel récursif du fichier de commandes.

Ce qui fonctionne pour moi, c'est le chemin Shell suivant:

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

Et dans le fichier activate-env.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 consiste ensuite à ajouter les éléments suivants à votre .bashrcou .bash_profile:

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

Cela vérifie s'il existe un environnement virtuel dans lequel 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éez un fichier .pycharmrc dans votre dossier personnel avec le contenu suivant

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

Utilisation de votre chemin virtualenv comme dernier paramètre.

Ensuite, définissez les Préférences du shell-> Paramètres du projet-> Chemin du shell sur

/bin/bash --rcfile ~/.pycharmrc

Je ne sais pas pourquoi, mais cela ne fonctionne pas pour moi. PyCharm imprime une erreur.

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

Ce reçu fonctionne! Mais la chaîne /env_yourenvlocate/scripts/activate.batdoit contenir des guillemets, comme ceci "Full_path_to_your_env_locate\scripts\activate.bat"!

Désactiver le virtualenv est très simple - 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 Linux virtualenv.

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

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

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

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

Virtualenv spécifique au projet

Le chemin vers votre virtualenv dans .pycharmrcn'a pas à être absolu. Vous pouvez définir un virtualenv spécifique à un projet en définissant un chemin relatif à partir du répertoire de votre projet. Mon virtualenv est toujours situé dans un dossier 'venv' sous mon répertoire de projet, donc mon .pycharmrcfichier ressemble à ceci:

source ~ / .bashrc
 source ~ / pycharmvenv / bin / activate # chemin absolu
source ./venv/bin/activate # chemin relatif

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

Ajoutez ce qui suit à votre .pycharmrcfichier:

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

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

+ -------------------------- + ---------------------- ----------- + ------- + ---- +
| Nom: | <Nom de l'interprète> | | |
| Sélectionnez | «Informations d'identification SSH» | | |
| Hôte: | 127.0.0.1 | Port: | 22 |
| Utilisateur: | <Nom d'utilisateur Linux> | | |
| Type d'authentification: | «Mot de passe» | | |
| Mot de passe: | <Mot de passe Linux> | | |
| Chemin de l'interpréteur Python: | <Chemin Linux vers votre virtualenv> | | |
| Chemin des aides Python: | <Définir automatiquement> | | |
+ -------------------------- + ---------------------- ----------- + ------- + ---- +

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

avertissement: la dernière mise à jour de Windows démarre automatiquement un service SshBroker et SshProxy au démarrage. Ceux-ci bloquent le tunnel ssh de Linux vers 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 vous demande de configurer cet emplacement.