Como faço para ativar um virtualenv dentro do terminal da PyCharm?

Eu configurei o PyCharm, criei meu virtualenv (por meio do comando virtual env ou diretamente no PyCharm) e ativei esse ambiente como meu intérprete. Tudo está funcionando bem.

No entanto, se eu abrir um terminal usando "Ferramentas, Abrir Terminal", o prompt do shell fornecido não está usando o env virtual; Eu ainda tenho que usar source ~/envs/someenv/bin/activatedentro desse Terminal para ativá-lo.

Outro método é ativar o ambiente em um shell e executar o PyCharm a partir desse ambiente. Isso é "viável", mas muito feio, e significa que tenho grandes problemas se mudar de ambiente ou projeto do PyCharm: agora estou usando o ambiente totalmente errado.

Existe alguma outra maneira muito mais fácil de "Ferramentas, Abrir Terminal" ativar automaticamente o ambiente virtual?

Editar:

De acordo com https://www.jetbrains.com/pycharm/whatsnew/#v2016-3-venv-in-terminal , PyCharm 2016.3 (lançado em novembro de 2016) tem suporte virutalenv para terminais prontos para uso

O virtualenv automático é compatível com bash, zsh, fish e Windows cmd. Você pode personalizar suas preferências de shell em Configurações (Preferências) | Ferramentas | Terminal.

Crie um arquivo .pycharmrcem sua pasta pessoal com o seguinte conteúdo

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

Usando seu caminho virtualenv como último parâmetro.

Em seguida, defina as Preferências do shell-> Configurações do projeto-> Caminho do shell para

/bin/bash --rcfile ~/.pycharmrc

Atualizar:

As preferências em Configurações (Preferências) | Ferramentas | Terminal são globais.
Se você usar um venv para cada projeto, lembre-se de usar a variável de caminho atual e um nome venv padrão:

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

Para usuários do Windows: ao usar PyCharm com um ambiente virtual, você pode usar o /Kparâmetro cmd.exepara definir o ambiente virtual automaticamente.

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

PyCharm 5: Settings, Tools, Terminal, e adicione /K <path-to-your-activate.bat>a Shell path.

PyCharm 2016,1 ou 2016,2: Settings, Tools, Terminal, e adicione ""/K <path-to-your-activate.bat>""a Shell pathe adicione (mente as aspas). Além disso, adicione aspas ao redor de cmd.exe, resultando em:

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

Para usuários do Windows ao usar PyCharm e um ambiente virtual no Windows, você pode usar o parâmetro / k para cmd.exe para definir o ambiente virtual automaticamente.

Vá para Configurações, Terminal, Shell padrão e adicione /K <path-to-your-activate.bat>.

Não tenho reputação de comentar sobre a resposta anterior, portanto, estou postando esta versão corrigida. Isso realmente economiza muito tempo.

Atualizar:

Nota: Pycharm agora oferece suporte a ambientes virtuais diretamente e parece funcionar bem para mim - portanto, minha solução alternativa não é mais necessária.

Com base nas respostas de Peter e na experimentação, descobri uma boa "solução geral", que resolve o seguinte:

• Restaura o comportamento de um shell de login. O PyCharm normalmente executa um shell de login, mas --rcfile impediu que isso acontecesse. O script ainda usa --rcfile, mas tenta emular o comportamento INVOCATION de um shell de login.
• Remove a necessidade de criar um rcfile para cada ambiente
• Remove a necessidade de atualizar as configurações do projeto se você alterar o ambiente.

Solte este script em um diretório bin em algum lugar. Por exemplo, ~ / 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

Em seguida, defina o caminho do Shell do PyCharm para:

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

PyCharm 4 agora tem virtualenvs integrado no IDE. Ao selecionar seu intérprete de projeto, você pode criar, adicionar ou selecionar um virtualenv. Eles adicionaram um "Console Python" que é executado no interpretador de projeto configurado.

Mais informações aqui.

Obrigado Chris, seu script funcionou para alguns projetos, mas não todos na minha máquina. Aqui está um script que escrevi e espero que alguém o considere ú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

Eu vi todas as respostas acima, mas nenhuma delas é elegante o suficiente para mim. Em PyCharm 2017/01/03 (no meu computador), a maneira mais fácil é abrir Settings->Tools->Terminale verificar Shell integratione Activate virtualenvopções.

Se você estiver usando a versão windows é bastante fácil. Se você já possui o ambiente virtual basta navegar até a pasta, localize activate.batdentro da Scriptspasta. copie o caminho completo e cole no terminal do pycharm e pressione Entere pronto!

Se você precisa criar um novo ambiente virtual:

Vá para arquivos> configurações, procure project interpreter, abra-o, clique no botão de engrenagem e crie o ambiente onde quiser e siga o primeiro parágrafo.

No Mac é PyCharm => Preferências ... => Ferramentas => Terminal => Ativar virtualenv , que deve estar habilitado por padrão.

Acabei de adicionar um script chamado pycharmactivate ao meu diretório inicial. Defina o valor de PyCharm (4.0.1) Arquivo> Configurações> Ferramentas> Terminal> Caminho do shell para / bin / bash --rcfile ~ / pycharmactivate. Talvez não seja a melhor solução no caso de você ter diferentes projetos e diretórios / nomes de virtualenv, mas funciona para mim. Este script contém as 3 linhas a seguir e assume que seu virtualenv tem o mesmo nome que seu diretório de projeto.

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

Seguindo a resposta de Peter, aqui está a versão para Mac do .pycharmrcarquivo:

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

Galinha

Tenho uma solução que funcionou na minha máquina com Windows 7.

Acredito que o terminal do PyCharm é o resultado de sua execução cmd.exe, que carregará a PATHvariável do Windows e usará a versão do Python que encontrar primeiro dentro dela PATH. Para editar esta variável, clique com o botão direito em Meu Computador -> Propriedades -> Configurações Avançadas do Sistema -> guia Avançado -> botão Variáveis ​​de Ambiente .... Na seção Variáveis do sistema , selecione e edite a PATHvariável.

Aqui está a parte relevante do meu PATH antes de editar:

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

... e após a edição PATH(apenas 3 linhas agora):

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

Para testar isso, abra um novo terminal do Windows ( Iniciar -> digite cmde pressione Enter) e veja se ele está usando seu ambiente virtual. Se funcionar, reinicie o PyCharm e teste-o no terminal do PyCharm.

isto é o que estou fazendo: criar um arquivo activate_env.bat (windows, talvez .sh no linux) no seguinte código-fonte:

/env_yourenvlocate/scripts/activate.bat

e outro arquivo deactivate_env.bat:

/env_yourenvlocate/scripts/deactivate.bat

toda vez que abrir a janela do terminal, basta executar o arquivo bat para ativar / desativar o virtualenv, você ficará no caminho do código-fonte, não há necessidade de alterar o caminho de ida e volta.

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>

Se o seu Pycharm 2016.1.4v e superior você deve usar "default path" /K "<path-to-your-activate.bat>" não se esqueça das citações

Se você moveu seu projeto para outro diretório, pode definir o novo caminho na caixa de diálogo Configurações. E então você precisa definir este intérprete de projeto na caixa de diálogo Editar configuração.

Outra alternativa é usar o virtualenvwrapper para gerenciar seus ambientes virtuais. Parece que uma vez que o script virtualenvwrapper é ativado , o pycharm pode usá-lo e então o workoncomando simples estará disponível no console do pycharm e apresentará os ambientes virtuais disponíveis:

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 deve funcionar com ambientes virtuais arbitrários por projeto e não faz suposições em seu ambiente, pois usa ganchos que você cria.

Você escreve:

• Um script global que invoca o gancho
• Um script de gancho por projeto PyCharm (não obrigatório)

Dado que o PyCharm mais recente atual (Community 2016.1) não permite que as configurações do Terminal por projeto iniciem com o script que invoca o gancho específico do projeto. Este é o meu ~/.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

Se você estiver usando algo diferente do Bash, invoque seu próprio .bash_profileequivalente se desejar.

Agora configure seu PyCharm "Ferramentas -> Terminal -> Caminho do Shell" para invocar este script, por exemplo: /bin/bash --rcfile ~/.pycharmrc

Finalmente, para cada projeto PyCharm você precisa de um ambiente virtual específico ativado, crie um arquivo dentro da raiz do projeto PyCharm .pycharm/term-activate. Este é o seu gancho e ele simplesmente definirá o nome do ambiente virtual desejado para o seu projeto PyCharm:

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

É claro que você pode estender seus ganchos com qualquer coisa que achar útil no ambiente de terminal de seu projeto PyCharm específico.

Para ambientes virtuais conda no Windows, certifique-se de que seu arquivo em lote NÃO seja nomeado, activate.batpois isso causará um conflito com o activatecomando conda , resultando em uma chamada recursiva do arquivo em lote.

O que funciona para mim é o seguinte caminho do Shell:

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

E no arquivo activate-env.bat:

call activate myenvname

Eu queria um ambiente virtual separado para cada projeto e não me importava muito em ter arquivos adicionais para facilitar isso. Uma solução que você só precisa fazer uma vez e funciona para todos os projetos é adicionar o seguinte ao seu .bashrcou .bash_profile:

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

Isso verifica se há um ambiente virtual onde o terminal está sendo aberto e, se houver, o ativa (e, claro, outros caminhos relativos podem ser usados). As configurações do terminal do PyCharm podem ser deixadas como padrão.

PyCharm 4.5.4

Crie um arquivo .pycharmrc em sua pasta pessoal com o seguinte conteúdo

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

Usando seu caminho virtualenv como último parâmetro.

Em seguida, defina as Preferências do shell-> Configurações do projeto-> Caminho do shell para

/bin/bash --rcfile ~/.pycharmrc

Não sei por quê, mas não funciona para mim. PyCharm imprime um erro.

cmd.exe /K "<path-to-your-activate.bat>" Funciona, mas cria o mesmo virtualenv para cada projeto, mesmo que não seja necessário.

Este recibo está funcionando! Mas a string /env_yourenvlocate/scripts/activate.batdeve conter aspas, como esta "Full_path_to_your_env_locate\scripts\activate.bat"!

Desativar o virtualenv é muito fácil - digite no terminal 'desativar'

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

Solução para WSL (Ubuntu no Windows)

Se estiver usando WSL (Ubuntu no Windows), você também pode abrir o bash como terminal no pycharm e ativar um virtualenv do linux.

Use um .pycharmrcarquivo como descrito na resposta de Peter Gibson; Adicione o .pycharmrcarquivo ao seu diretório inicial com o seguinte conteúdo:

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

Em Arquivo Pycharm > Configurações> Ferramentas> Terminal, adicione o seguinte 'Caminho do shell':

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

Virtualenv específico do projeto

O caminho para o seu virtualenv in .pycharmrcnão precisa ser absoluto. Você pode definir um virtualenv específico do projeto definindo um caminho relativo do diretório do projeto. Meu virtualenv está sempre localizado em uma pasta 'venv' no diretório do meu projeto, então meu .pycharmrcarquivo se parece com este:

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

BÔNUS: abre automaticamente o túnel ssh para conectar o virtualenv como intérprete do projeto

Adicione o seguinte ao seu .pycharmrcarquivo:

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

Isso verifica se um túnel ssh já está aberto e abre um caso contrário. Em Arquivo -> Configurações -> Projeto -> Intérprete do projeto no Pycharm, adicione um novo interpretador remoto com a seguinte configuração:

+ -------------------------- + ---------------------- ----------- + ------- + ---- +
| Nome: | <Nome do intérprete> | | |
| Selecione | 'Credenciais SSH' | | |
| Host: | 127.0.0.1 | Porto: | 22
| Usuário: | <Nome de usuário do Linux> | | |
| Tipo de autenticação: | 'Senha' | | |
| Senha: | <Senha do Linux> | | |
| Caminho do interpretador Python: | <Caminho do Linux para seu virtualenv> | | |
| Caminho dos ajudantes Python: | <Definir automaticamente> | | |
+ -------------------------- + ---------------------- ----------- + ------- + ---- +

Agora, quando você abre seu projeto, seu bash inicia automaticamente em seu virtualenv, abre um túnel ssh e o pycharm conecta o virtualenv como interpretador remoto.

aviso: a última atualização no Windows inicia automaticamente um serviço SshBroker e SshProxy na inicialização. Eles bloqueiam o túnel ssh do Linux para o Windows. Você pode interromper esses serviços em Gerenciador de Tarefas -> Serviços, após o qual tudo funcionará novamente.

Uma opção que você tem ao entrar no terminal> Executar> Depurar> Editar Configurações

selecione o ambiente conda apropriado. Além disso, quando você cria um novo projeto - ele pede para configurar este local.