¿Cómo activo un virtualenv dentro de la terminal de PyCharm?

Configuré PyCharm, creé mi virtualenv (ya sea a través del comando env virtual o directamente en PyCharm) y activé ese entorno como mi intérprete. Todo está funcionando bien.

Sin embargo, si abro una terminal usando "Herramientas, Abrir terminal", el indicador de shell proporcionado no usa el entorno virtual; Todavía tengo que usar source ~/envs/someenv/bin/activatedentro de ese Terminal para activarlo.

Otro método es activar el entorno en un shell y ejecutar PyCharm desde ese entorno. Esto es "viable" pero bastante feo, y significa que tengo problemas importantes si cambio de entorno o proyecto desde PyCharm: ahora estoy usando el entorno totalmente incorrecto.

¿Existe alguna otra forma mucho más fácil de hacer que "Herramientas, Abrir Terminal" active automáticamente el entorno virtual?

Editar:

Según https://www.jetbrains.com/pycharm/whatsnew/#v2016-3-venv-in-terminal , PyCharm 2016.3 (lanzado en noviembre de 2016) tiene soporte virutalenv para terminales listos para usar

Auto virtualenv es compatible con bash, zsh, fish y cmd de Windows. Puede personalizar su preferencia de shell en Configuración (Preferencias) | Herramientas Terminal.

Cree un archivo .pycharmrcen su carpeta de inicio con el siguiente contenido

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

Usando su ruta virtualenv como último parámetro.

Luego configure las Preferencias de shell-> Configuración del proyecto-> Ruta de Shell

/bin/bash --rcfile ~/.pycharmrc

Actualizar:

Las preferencias en Configuración (Preferencias) | Herramientas Los terminales son globales.
Si usa un venv para cada proyecto, recuerde usar la variable de ruta actual y un nombre de venv predeterminado:

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

Para usuarios de Windows: cuando use PyCharm con un entorno virtual, puede usar el /Kparámetro paracmd.exe para configurar el entorno virtual automáticamente.

PyCharm 3 o 4: Settings, Terminal, Default shelly añadir/K <path-to-your-activate.bat> .

PyCharm 5: Settings, Tools, Terminal, y añadir /K <path-to-your-activate.bat>aShell path .

PyCharm 2016,1 2016,2 o: Settings, Tools, Terminal, y añadir ""/K <path-to-your-activate.bat>""a Shell pathy añadir (la mente las comillas). También agregue comillas alrededor de cmd.exe, lo que resultará en:

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

Para los usuarios de Windows que utilizan PyCharm y un entorno virtual en Windows, puede utilizar el parámetro / k en cmd.exe para configurar el entorno virtual automáticamente.

Vaya a Configuración, Terminal, Shell predeterminado y agregue /K <path-to-your-activate.bat>.

No tengo la reputación de comentar sobre la respuesta anterior, así que publico esta versión corregida. Esto realmente ahorra MUCHO tiempo.

Actualizar:

Nota: Pycharm ahora admite entornos virtuales directamente y parece funcionar bien para mí, por lo que mi solución ya no es necesaria.

Basándome en las respuestas de Peter y la experimentación, he encontrado una buena "solución general", que resuelve lo siguiente:

• Restaura el comportamiento de un shell de inicio de sesión. PyCharm normalmente ejecuta un shell de inicio de sesión, pero --rcfile detuvo que esto sucediera. El script todavía usa --rcfile, pero intenta emular el comportamiento de INVOCACIÓN de un shell de inicio de sesión.
• Elimina la necesidad de crear un archivo rc para cada entorno.
• Elimina la necesidad de actualizar la configuración del proyecto si cambia el entorno.

Suelta este script en un directorio bin en algún lugar. Por ejemplo, ~ / 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

Luego establezca la ruta de Shell de PyCharm en:

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

PyCharm 4 ahora tiene virtualenvs integrados en el IDE. Al seleccionar el intérprete de su proyecto, puede crear, agregar o seleccionar un virtualenv. Han agregado una "consola Python" que se ejecuta en el intérprete del proyecto configurado.

Más info aquí.

Gracias Chris, tu guión funcionó para algunos proyectos pero no todos en mi máquina. Aquí hay un guión que escribí y espero que alguien lo encuentre útil.

#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

He visto todas las respuestas anteriores, pero ninguna es lo suficientemente elegante para mí. En Pycharm 2017.1.3 (en mi computadora), la forma más fácil es abrir Settings->Tools->Terminaly verificar Shell integrationy Activate virtualenvopciones.

Si está utilizando la versión de Windows, es bastante fácil. Si ya tiene el entorno virtual, navegue hasta su carpeta, busque la carpeta activate.batinterior Scripts. copie su ruta completa y péguela en la terminal de pycharm y luego presioneEnter y listo.

Si necesita crear un nuevo entorno virtual:

Vaya a archivos> configuración, luego busque project interpreter, ábralo, haga clic en el botón de engranaje y cree el entorno donde desee y luego siga el primer párrafo.

En Mac es PyCharm => Preferencias ... => Herramientas => Terminal => Activar virtualenv , que debería estar habilitado por defecto.

Acabo de agregar un script llamado pycharmactivate a mi directorio de inicio. Establezca el valor de PyCharm (4.0.1) Archivo> Configuración> Herramientas> Terminal> Ruta del shell a / bin / bash --rcfile ~ / pycharmactivate. Tal vez no sea la mejor solución en caso de que tenga diferentes directorios / nombres de proyectos y virtualenv, pero a mí me funciona. Este script contiene las siguientes 3 líneas y asume que su virtualenv tiene el mismo nombre que el directorio de su proyecto.

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

Siguiendo con la respuesta de Peter, aquí la versión para Mac del .pycharmrcarchivo:

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

Gallina

Tengo una solución que funcionó en mi máquina con Windows 7.

Creo que la terminal de PyCharm es el resultado de su ejecución cmd.exe, que cargará la PATHvariable de Windows y usará la versión de Python que encuentre primero dentro de ella PATH. Para editar esta variable, haga clic con el botón derecho en Mi PC -> Propiedades -> Configuración avanzada del sistema -> pestaña Avanzado -> Botón Variables de entorno ... Dentro de la sección Variables del sistema , seleccione y edite elPATH variable.

Aquí está la parte relevante de mi PATH antes de editar:

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

... y después de editar PATH(solo 3 líneas ahora):

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

Para probar esto, abra una nueva terminal de Windows ( Inicio -> escriba cmdy presione Enter) y vea si está usando su entorno virtual. Si eso funciona, reinicie PyCharm y luego pruébelo en la terminal de PyCharm.

esto es lo que estoy haciendo: crear un archivo active_env.bat (windows, tal vez .sh en linux) en el código fuente folde:

/env_yourenvlocate/scripts/activate.bat

y otro archivo deactivate_env.bat:

/env_yourenvlocate/scripts/deactivate.bat

cada vez que abra la ventana de terminal, simplemente ejecute el archivo bat para activar / desactivar virtualenv, permanecerá en la ruta del código fuente, sin necesidad de cambiar la ruta hacia arriba y hacia atrás.

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 su Pycharm 2016.1.4v y superior debe usar "default path" /K "<path-to-your-activate.bat>" no olvide las comillas

Si ha movido su proyecto a otro directorio, puede establecer la nueva ruta a través del cuadro de diálogo Configuración. Y luego debe configurar este intérprete de proyecto en el cuadro de diálogo Editar configuración.

Otra alternativa es utilizar virtualenvwrapper para administrar sus entornos virtuales. Parece que una vez que se activa el script virtualenvwrapper , pycharm puede usarlo y luego el workoncomando simple estará disponible en la consola de pycharm y le presentará los entornos virtuales 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$ 

Este método debería funcionar con entornos virtuales arbitrarios por proyecto y no hace suposiciones sobre su entorno, ya que utiliza los ganchos que usted crea.

Usted escribe:

• Un script global que invoca el gancho
• Un script de gancho por proyecto de PyCharm (no obligatorio)

Dado que la última versión actual de PyCharm (Comunidad 2016.1) no permite que la configuración de Terminal por proyecto comience con el script que invoca el enlace específico del proyecto. Este es mi ~/.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 está utilizando algo que no sea Bash, invoque su propio .bash_profileequivalente si lo desea.

Ahora configure su PyCharm "Herramientas -> Terminal -> Ruta de Shell" para invocar este script, por ejemplo: /bin/bash --rcfile ~/.pycharmrc

Finalmente, para cada proyecto de PyCharm que necesite un entorno virtual específico activado, cree un archivo dentro de la raíz del proyecto de PyCharm .pycharm/term-activate. Este es su gancho y simplemente definirá el nombre del entorno virtual deseado para su proyecto PyCharm:

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

Por supuesto, puede ampliar sus ganchos con cualquier cosa que encuentre útil en el entorno de terminal de su proyecto PyCharm en particular.

Para entornos virtuales conda en Windows, asegúrese de que su archivo por lotes NO tenga un nombre, activate.batya que esto causará un conflicto con el activatecomando conda , lo que resultará en una llamada recursiva del archivo por lotes.

Lo que me funciona es la siguiente ruta de Shell:

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

Y en el archivo active-env.bat:

call activate myenvname

Quería un entorno virtual separado para cada proyecto y no me importaba mucho tener archivos adicionales para facilitar esto. Una solución que solo necesita hacer una vez y que funciona para todos los proyectos es agregar lo siguiente a su .bashrco .bash_profile:

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

Esto verifica si hay un entorno virtual donde se está abriendo el terminal y, si es así, lo activa (y por supuesto se podrían usar otras rutas relativas). La configuración del terminal de PyCharm se puede dejar como predeterminada.

PyCharm 4.5.4

Cree un archivo .pycharmrc en su carpeta de inicio con el siguiente contenido

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

Usando su ruta virtualenv como último parámetro.

Luego configure las Preferencias de shell-> Configuración del proyecto-> Ruta de Shell

/bin/bash --rcfile ~/.pycharmrc

No sé por qué, pero no me funciona. PyCharm imprime un error.

cmd.exe /K "<path-to-your-activate.bat>" Funciona, pero crea el mismo virtualenv para cada proyecto, e incluso si esto no es necesario.

¡Este recibo está funcionando! Pero la cadena /env_yourenvlocate/scripts/activate.batdebe contener comillas, como esta"Full_path_to_your_env_locate\scripts\activate.bat" !

Desactivar virtualenv es muy fácil: escriba en la terminal 'desactivar'

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

Solución para WSL (Ubuntu en Windows)

Si está usando WSL (Ubuntu en Windows), también puede abrir bash como terminal en pycharm y activar un linux virtualenv.

Utilice un .pycharmrcarchivo como se describe en la respuesta de Peter Gibson; Agregue el .pycharmrcarchivo a su directorio de inicio con el siguiente contenido:

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

En Archivo Pycharm > Configuración> Herramientas> Terminal, agregue la siguiente ' Ruta de Shell':

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

Virtualenv específico del proyecto

El camino hacia su virtualenv en .pycharmrcno tiene que ser absoluto. Puede configurar un virtualenv específico del proyecto estableciendo una ruta relativa desde el directorio de su proyecto. Mi virtualenv siempre se encuentra en una carpeta 'venv' en el directorio de mi proyecto, por lo que mi.pycharmrc archivo se ve así:

fuente ~ / .bashrc
 fuente ~ / pycharmvenv / bin / activar # ruta absoluta
source ./venv/bin/activate # ruta relativa

BONUS: abre automáticamente el túnel ssh para conectar virtualenv como intérprete del proyecto

Agregue lo siguiente a su .pycharmrcarchivo:

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

Esto verifica si un túnel ssh ya está abierto y, de lo contrario, abre uno. En Archivo -> Configuración -> Proyecto -> Intérprete de proyecto en Pycharm, agregue un nuevo intérprete remoto con la siguiente configuración:

+ -------------------------- + ---------------------- ----------- + ------- + ---- +
| Nombre: | <Nombre del intérprete> | | |
| Seleccione | 'Credenciales SSH' | | |
| Anfitrión: | 127.0.0.1 | Puerto: | 22 |
| Usuario: | <Nombre de usuario de Linux> | | |
| Tipo de autorización: | 'Contraseña' | | |
| Contraseña: | <Contraseña de Linux> | | |
| Ruta del intérprete de Python: | <Ruta de Linux a su virtualenv> | | |
| Ruta de ayuda de Python: | <Establecer automáticamente> | | |
+ -------------------------- + ---------------------- ----------- + ------- + ---- +

Ahora, cuando abre su proyecto, su bash se inicia automáticamente en su virtualenv, abre un túnel ssh y pycharm conecta virtualenv como intérprete remoto.

advertencia: la última actualización en Windows inicia automáticamente un servicio SshBroker y SshProxy al inicio. Estos bloquean el túnel ssh desde Linux a Windows. Puede detener estos servicios en el Administrador de tareas -> Servicios, después de lo cual todo volverá a funcionar.

Una opción que tiene cuando ingresa al terminal> Ejecutar> Depurar> Editar configuraciones

seleccione el entorno de conda apropiado. También cuando crea un nuevo proyecto, le pide que configure esta ubicación.