Comment activer un serveur virtuel dans le terminal de PyCharm?
J'ai configuré PyCharm, créé mon virtualenv (via la commande virtual env ou 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 "Outils, Ouvrir un terminal", l'invite de shell fournie est not en utilisant l'env virtuel; Je dois encore utiliser source ~/envs/someenv/bin/activate dans ce 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 «faisable» mais assez moche, et cela signifie que j’ai de gros problèmes si je change d’environnement ou de projet de PyCharm: j’utilise maintenant un environnement totalement faux.
Existe-t-il un autre moyen beaucoup plus simple d’avoir «Outils, Ouvrir un terminal» pour activer automatiquement l’environnement virtuel?
Modifier:
Selon https://www.jetbrains.com/pycharm/whatsnew/#v2016-3-venv-in-terminal , PyCharm 2016.3 (publié en novembre 2016) offre un support vierge pour les terminaux
Auto virtualenv est pris en charge pour bash, zsh, fish et Windows cmd. Vous pouvez personnaliser vos préférences de shell dans les paramètres (Préférences) | Outils | Terminal.
ancienne méthode:
Créez un fichier .pycharmrc dans votre dossier personnel avec le contenu suivant
source ~/.bashrc
source ~/pycharmvenv/bin/activate
Utiliser votre chemin virtualenv comme dernier paramètre.
Puis définissez les préférences du shell-> Paramètres du projet-> Chemin du shell sur
/bin/bash --rcfile ~/.pycharmrc
Pour les utilisateurs Windows qui utilisent PyCharm et un environnement virtuel sous Windows, vous pouvez utiliser le paramètre/k avec 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, alors publiez cette version corrigée. Cela fait gagner beaucoup de temps.
Mettre à jour:
Remarque: Pycharm prend désormais directement en charge les environnements virtuels et cela semble bien fonctionner pour moi - mon solution de contournement n'est donc plus nécessaire.
Pour les utilisateurs de Windows: lors de l'utilisation de 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 ajouter /K <path-to-your-activate.bat>.
PyCharm 5: Settings, Tools, Terminal et ajoutez /K <path-to-your-activate.bat> à Shell path.
PyCharm 2016.1 ou 2016.2: Settings, Tools, Terminal et ajoutez ""/K <path-to-your-activate.bat>"" à Shell path et ajoutez (faites attention aux guillemets). Ajoutez également des guillemets autour de cmd.exe, ce qui donne:
"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 mis au point 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é cette situation. 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 rcf 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 du shell de PyCharm sur:
/bin/bash --rcfile ~/bin/pycharmactivate
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 serveur virtuel. Ils ont ajouté une "console Python" qui s'exécute dans l'interpréteur de projet configuré.
Merci Chris, ton 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
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 le chemin full 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 le souhaitez, puis suivez le premier paragraphe.
Je viens d'ajouter un script appelé pycharmactivate à mon répertoire personnel. Définissez la valeur de PyCharm (4.0.1) Fichier> Paramètres> Outils> Terminal> Chemin du shell vers/bin/bash --rcfile ~/pycharmactivate . Peut-être pas la meilleure solution si vous avez différents répertoires/noms de projet et virtu ça marche pour moi. Ce script contient les 3 lignes suivantes et suppose que virtualenv a le même nom que votre répertoire de projet.
source ~/.bashrc
projectdir=${PWD##*/}
source ~/.virtualenvs/$projectdir/bin/activate
Pour donner suite à 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 vu toutes les réponses ci-dessus, mais aucune n'est assez élégante pour moi. Dans Pycharm 2017.1.3 (sur mon ordinateur), le moyen le plus simple consiste à ouvrir Settings->Tools->Terminal et à cocher les options Shell integration et Activate virtualenv.
voici ce que je suis entrain de faire: Créer un fichier activate_env.bat (windows, peut-être .sh sous linux) dans le code source folde:
/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 virtualenv, vous resterez dans le chemin du code source, vous n'avez pas besoin de changer de chemin.
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>
J'ai une solution qui a fonctionné sur mon ordinateur Windows 7.
Je pense que le terminal de PyCharm est le résultat de l'exécution de cmd.exe, ce qui chargera la variable Windows PATH et utilisera la version de Python trouvée en premier dans ce PATH. Pour éditer cette variable, faites un clic droit Poste de travail -> Propriétés - -> Paramètres système avancés -> Options avancées -> Variables d'environnement ... . Dans la section Variables système , sélectionnez et modifiez la variable PATH.
Voici la partie pertinente de mon PATHbefore édition:
C:\Python27 \;
C:\Python27\Lib\site-packages\pip \;
C:\Python27\Scripts;
C:\Python27\Lib\site-packages\Django\bin;
... et après éditer 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 nouvea terminal Windows ( Démarrer -> tapez cmd et appuyez sur Enter) et voyez s’il utilise votre environnement virtuel. Si cela fonctionne, redémarrer PyCharm puis testez-le dans le terminal de PyCharm.
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
Sur Mac, il s'agit de PyCharm -> Préférences ... -> Outils -> Terminal -> Activer virtualenv , qui devrait être activé par défaut.
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 serveur virtuel virtuel linux.
Utilisez un fichier .pycharmrc comme décrit dans la réponse de Peter Gibson; Ajoutez le fichier .pycharmrc à votre répertoire de base avec le contenu suivant:
source ~/.bashrc
source ~/path_to_virtualenv/bin/activate
Dans Pycharm Fichier> Paramètres> Outils> Terminal, ajoutez le "chemin d'accès au shell" suivant:
"C:/Windows/system32/bash.exe" -c "bash --rcfile ~/.pycharmrc"
Virtualenv spécifique au projet
Le chemin d'accès à votre virtualenv dans .pycharmrc ne doit pas nécessairement être absolu. Vous pouvez définir un virtualenv spécifique à un projet en définissant un chemin relatif depuis 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 se présente comme suit:
source ~/.bashrcsource ~/pycharmvenv/bin/activate# chemin absolu source ./venv/bin/activate # chemin relatif
BONUS: ouvre automatiquement le tunnel ssh pour connecter virtualenv en tant qu'interprète de projet
Ajoutez les éléments suivants à votre fichier .pycharmrc:
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 l'ouvre sinon sinon . Dans Fichier -> Paramètres -> Projet -> Interprète de projet dans Pycharm, ajoutez un nouvel interpréteur distant avec la configuration suivante:
+ -------------------------- + ---------------------- ----------- + ------- + ---- + | Nom: | <Nom de l'interprète> | | | | Choisir | 'Titres de compétences 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 d'interprétation Python: | <Chemin Linux vers votre virtualenv> | | | | Chemin des assistants 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 le virtualenv en tant qu'interprète distant.
warning: la dernière mise à jour de Windows démarre automatiquement les services SshBroker et SshProxy au démarrage. Ceux-ci bloquent le tunnel ssh de Linux aux fenêtres. Vous pouvez arrêter ces services dans le Gestionnaire des tâches -> Services, après quoi tout fonctionnera à nouveau.
Une autre alternative consiste à utiliser virtualenvwrapper pour gérer vos environnements virtuels. Il semble qu’une fois le virtualenvwrapper script activé , pycharm puisse l’utiliser, puis 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$
Une option que vous avez lorsque vous entrez dans le terminal> Exécuter> Déboguer> Modifier les configurations 
sélectionnez le conda environnement approprié .. Également lorsque vous créez un nouveau projet - il vous est demandé de configurer cet emplacement.
PyCharm 4.5.4
Créez un fichier .pycharmrc dans votre dossier personnel avec le fichier .__ suivant. Contenu
source ~/.bashrc source ~/pycharmvenv/bin/activateUtiliser votre chemin virtualenv comme dernier paramètre.
Puis 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 ça ne marche pas pour moi. PyCharm imprime une erreur.
cmd.exe /K "<path-to-your-activate.bat>" Cela fonctionne, mais il crée le même virtualenv pour chaque projet, même si cela n'est pas nécessaire.
Ce reçu fonctionne! Mais la chaîne /env_yourenvlocate/scripts/activate.bat 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>
Cette méthode devrait fonctionner avec des environnements virtuels arbitraires par projet et elle ne fait pas de suppositions sur votre environnement car il utilise les points d'ancrage que vous créez.
Vous écrivez:
- Un script global qui appelle le hook
- Un script hook par projet PyCharm (non obligatoire)
Étant donné que la dernière version actuelle de PyCharm (Community 2016.1) n'autorise pas les paramètres du terminal par projet démarrer avec 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, appelez votre propre équivalent .bash_profile si vous le souhaitez.
Maintenant, configurez votre PyCharm "Outils -> Terminal -> Shell Path" pour appeler ce script, par exemple: /bin/bash --rcfile ~/.pycharmrc
Enfin, pour chaque projet PyCharm pour lequel un environnement virtuel spécifique doit être activé, créez un fichier dans la racine du projet PyCharm .pycharm/term-activate. C'est votre crochet et il va simplement définir 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 crochets avec tout ce que vous trouvez utile dans l’environnement terminal de votre projet PyCharm.
Je voulais un environnement virtuel distinct pour chaque projet et ne souhaitais pas beaucoup avoir des fichiers supplémentaires pour faciliter cela. Une solution que vous devez effectuer une seule fois et qui fonctionne pour tous les projets consiste à ajouter les éléments suivants à votre .bashrc ou .bash_profile:
if [ -d "./venv" ]; then
source ./venv/bin/activate
fi
Ceci vérifie s’il existe un environnement virtuel dans lequel le terminal est en cours d’ouverture et, le cas échéant, l’active (et bien sûr, d’autres chemins relatifs peuvent être utilisés). Les paramètres de terminal de PyCharm peuvent être laissés par défaut.
Pour les environnements virtuels conda sous Windows, assurez-vous que votre fichier de commandes n'est PAS nommé activate.bat car cela entraînerait un conflit avec la commande conda activate, ce qui entraînerait un appel récursif du fichier de commandes.
Ce qui fonctionne pour moi est le chemin de shell suivant:
"cmd.exe" /k ""C:\FullPathToYourProject\activate-env.bat""
Et dans le fichier activate-env.bat:
call activate myenvname