Come si attiva un virtualenv all'interno del terminale di PyCharm?

Ho configurato PyCharm, creato il mio virtualenv (tramite il comando virtual env o direttamente in PyCharm) e attivato quell'ambiente come mio interprete. Funziona tutto bene.

Tuttavia, se apro un terminale utilizzando "Strumenti, Apri terminale", il prompt della shell fornito non utilizza l'env virtuale; Devo ancora usare source ~/envs/someenv/bin/activateall'interno di quel terminale per attivarlo.

Un altro metodo è attivare l'ambiente in una shell ed eseguire PyCharm da quell'ambiente. Questo è "fattibile" ma piuttosto brutto, e significa che ho grossi problemi se cambio ambiente o progetto da PyCharm: ora sto usando l'ambiente totalmente sbagliato.

C'è qualche altro modo molto più semplice per fare in modo che "Strumenti, Apri terminale" attivi automaticamente l'ambiente virtuale?

Modificare:

Secondo https://www.jetbrains.com/pycharm/whatsnew/#v2016-3-venv-in-terminal , PyCharm 2016.3 (rilasciato a novembre 2016) ha il supporto virutalenv per terminali fuori dagli schemi

Auto virtualenv è supportato per bash, zsh, fish e Windows cmd. Puoi personalizzare le tue preferenze di shell in Impostazioni (Preferenze) | Strumenti | Terminale.

Crea un file .pycharmrcnella tua cartella Inizio con i seguenti contenuti

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

Usando il tuo percorso virtualenv come ultimo parametro.

Quindi impostare le Preferenze della shell-> Impostazioni progetto-> Percorso shell su

/bin/bash --rcfile ~/.pycharmrc

Aggiornare:

Le preferenze in Impostazioni (Preferenze) | Strumenti | I terminali sono globali.
Se utilizzi un venv per ogni progetto, ricorda di utilizzare la variabile del percorso corrente e un nome venv predefinito:

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

Per utenti Windows: quando si utilizza PyCharm con un ambiente virtuale, è possibile utilizzare il /Kparametro cmd.exeper impostare l'ambiente virtuale automaticamente.

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

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

PyCharm 2.016,1 2.016,2 o: Settings, Tools, Terminal, e aggiungere ""/K <path-to-your-activate.bat>""a Shell pathe aggiungere (mente le virgolette). Aggiungi anche virgolette intorno a cmd.exe, risultando in:

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

Per gli utenti Windows quando si utilizza PyCharm e un ambiente virtuale in Windows, è possibile utilizzare il parametro / k su cmd.exe per impostare automaticamente l'ambiente virtuale.

Vai su Impostazioni, Terminale, Shell predefinita e aggiungi /K <path-to-your-activate.bat>.

Non ho la reputazione di commentare la risposta precedente, quindi pubblicando questa versione corretta. Questo fa risparmiare davvero MOLTO tempo.

Aggiornare:

Nota: Pycharm ora supporta direttamente gli ambienti virtuali e sembra funzionare bene per me, quindi la mia soluzione alternativa non è più necessaria.

Sulla base delle risposte di Peter e della sperimentazione, ho trovato una buona "soluzione generale", che risolve quanto segue:

• Ripristina il comportamento di una shell di login. PyCharm normalmente esegue una shell di login, ma --rcfile ha impedito che ciò accadesse. Lo script usa ancora --rcfile, ma tenta di emulare il comportamento INVOCATION di una shell di login.
• Elimina la necessità di creare un rcfile per ogni ambiente
• Elimina la necessità di aggiornare le impostazioni del progetto se si modifica l'ambiente.

Rilascia questo script in una directory bin da qualche parte. Ad esempio ~ / 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

Quindi imposta il percorso della shell di PyCharm su:

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

PyCharm 4 ora ha virtualenvs integrato nell'IDE. Quando selezioni l'interprete del tuo progetto, puoi creare, aggiungere o selezionare un virtualenv. Hanno aggiunto una "Console Python" che viene eseguita nell'interprete del progetto configurato.

Maggiori info qui.

Grazie Chris, la tua sceneggiatura ha funzionato per alcuni progetti ma non per tutti sulla mia macchina. Ecco uno script che ho scritto e spero che qualcuno lo trovi 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

Ho visualizzato tutte le risposte sopra ma nessuna è abbastanza elegante per me. In Pycharm 2017.1.3 (nel mio computer), il modo più semplice è aprire Settings->Tools->Terminale controllare Shell integratione le Activate virtualenvopzioni.

Se stai usando la versione Windows è abbastanza facile. Se hai già l'ambiente virtuale, vai alla sua cartella, trova activate.batall'interno della Scriptscartella. copia il percorso completo e incollalo nel terminale di pycharm, quindi premi Entere il gioco è fatto!

Se devi creare un nuovo ambiente virtuale:

Vai su file> impostazioni quindi cerca project interpreter, aprilo, fai clic sul pulsante dell'ingranaggio e crea l'ambiente dove vuoi e poi segui il primo paragrafo.

Su Mac è PyCharm => Preferenze ... => Strumenti => Terminale => Attiva virtualenv , che dovrebbe essere abilitato di default.

Ho appena aggiunto uno script chiamato pycharmactivate alla mia home directory. Imposta il valore di PyCharm (4.0.1) File> Impostazioni> Strumenti> Terminale> Percorso shell a / bin / bash --rcfile ~ / pycharmactivate. Forse non è la soluzione migliore nel caso in cui tu abbia diversi progetti e directory / nomi virtualenv ma funziona per me. Questo script contiene le seguenti 3 righe e presuppone che virtualenv abbia lo stesso nome della directory del progetto.

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

Seguendo la risposta di Peter, ecco la versione per Mac del .pycharmrcfile:

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

Gallina

Ho una soluzione che ha funzionato sulla mia macchina Windows 7.

Credo che il terminale di PyCharm sia il risultato della sua esecuzione cmd.exe, che caricherà la PATHvariabile Windows e utilizzerà la versione di Python che trova per prima all'interno di essa PATH. Per modificare questa variabile, fare clic con il pulsante destro del mouse su Risorse del computer -> Proprietà -> Impostazioni di sistema avanzate -> scheda Avanzate -> pulsante Variabili d'ambiente ... All'interno delle variabili di sistema sezione , seleziona e modifica la PATHvariabile.

Ecco la parte rilevante del mio PATH prima di modificare:

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

... e dopo la modifica PATH(solo 3 righe ora):

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;

Per testarlo, apri un nuovo terminale Windows ( Start -> digita cmde premi Enter) e verifica se sta utilizzando il tuo ambiente virtuale. Se funziona, riavvia PyCharm e poi provalo nel terminale di PyCharm.

questo è quello che sto facendo: creare un file activ_env.bat (windows, forse .sh in linux) nella cartella del codice sorgente:

/env_yourenvlocate/scripts/activate.bat

e un altro file disable_env.bat:

/env_yourenvlocate/scripts/deactivate.bat

ogni volta che apri la finestra del terminale, esegui semplicemente il file bat per attivare / disattivare virtualenv, rimarrai nel percorso del codice sorgente, non è necessario cambiare percorso e tornare indietro.

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 il tuo Pycharm 2016.1.4v e versioni successive dovresti usare "default path" /K "<path-to-your-activate.bat>" non dimenticare le virgolette

Se hai spostato il tuo progetto in un'altra directory, puoi impostare il nuovo percorso tramite la finestra di dialogo Impostazioni. E poi devi impostare questo interprete del progetto nella finestra di dialogo Modifica configurazione.

Un'altra alternativa è usare virtualenvwrapper per gestire i tuoi ambienti virtuali. Sembra che una volta attivato lo script virtualenvwrapper , pycharm possa usarlo e quindi il semplice workoncomando sarà disponibile dalla console pycharm e ti presenterà gli ambienti virtuali disponibili:

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$ 

Questo metodo dovrebbe funzionare con ambienti virtuali arbitrari per progetto e non fa supposizioni sul tuo ambiente poiché utilizza gli hook che crei.

Scrivi:

• Uno script globale che richiama l'hook
• Uno script hook per progetto PyCharm (non obbligatorio)

Dato che l'attuale ultimo PyCharm (Community 2016.1) non consente le impostazioni del terminale per l' avvio del progetto con lo script che richiama l'hook specifico del progetto. Questo è il mio ~/.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 stai usando qualcosa di diverso da Bash, invoca il tuo .bash_profileequivalente se lo desideri.

Ora imposta il tuo PyCharm "Strumenti -> Terminale -> Percorso shell" per richiamare questo script, ad esempio: /bin/bash --rcfile ~/.pycharmrc

Infine, per ogni progetto PyCharm hai bisogno di uno specifico ambiente virtuale attivato, crea un file all'interno della root del progetto PyCharm .pycharm/term-activate. Questo è il tuo hook e definirà semplicemente il nome dell'ambiente virtuale desiderato per il tuo progetto PyCharm:

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

Ovviamente puoi estendere i tuoi hook con qualsiasi cosa trovi utile nell'ambiente terminale del tuo particolare progetto PyCharm.

Per ambienti virtuali conda su Windows, assicurati che il tuo file batch NON abbia un nome activate.batpoiché ciò causerà un conflitto con il activatecomando conda , con conseguente chiamata ricorsiva del file batch.

Quello che funziona per me è il seguente percorso Shell:

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

E nel file activ-env.bat:

call activate myenvname

Volevo un ambiente virtuale separato per ogni progetto e non mi importava molto di avere file aggiuntivi per facilitare questo. Una soluzione che devi fare solo una volta e funziona per tutti i progetti è quindi aggiungere quanto segue al tuo .bashrco .bash_profile:

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

Questo controlla se esiste un ambiente virtuale in cui il terminale viene aperto, e in tal caso lo attiva (e ovviamente potrebbero essere utilizzati altri percorsi relativi). Le impostazioni del terminale di PyCharm possono essere lasciate come predefinite.

PyCharm 4.5.4

Crea un file .pycharmrc nella tua cartella Inizio con i seguenti contenuti

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

Usando il tuo percorso virtualenv come ultimo parametro.

Quindi impostare le Preferenze della shell-> Impostazioni progetto-> Percorso shell su

/bin/bash --rcfile ~/.pycharmrc

Non so perché, ma non funziona per me. PyCharm stampa un errore.

cmd.exe /K "<path-to-your-activate.bat>" Funziona, ma crea lo stesso virtualenv per ogni progetto, e anche se questo non è necessario.

Questa ricevuta funziona! Ma la stringa /env_yourenvlocate/scripts/activate.batdeve contenere virgolette, come questa "Full_path_to_your_env_locate\scripts\activate.bat"!

Disattivare il virtualenv è molto semplice: digita nel terminale 'disattiva'

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

Soluzione per WSL (Ubuntu su Windows)

Se stai usando WSL (Ubuntu su Windows), puoi anche aprire bash come terminale in pycharm e attivare un virtualenv di linux.

Usa un .pycharmrcfile come descritto nella risposta di Peter Gibson; Aggiungi il .pycharmrcfile alla tua home directory con il seguente contenuto:

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

In Pycharm File> Impostazioni> Strumenti> Terminale aggiungi il seguente "Percorso shell":

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

Virtualenv

Il percorso per il tuo virtualenv in .pycharmrcnon deve essere assoluto. Puoi impostare un virtualenv specifico del progetto impostando un percorso relativo dalla directory del progetto. Il mio virtualenv si trova sempre in una cartella 'venv' nella directory del mio progetto, quindi il mio .pycharmrcfile ha questo aspetto:

fonte ~ / .bashrc
 fonte ~ / pycharmvenv / bin / attivare il percorso #absolute
source ./venv/bin/activate #percorso relativo

BONUS: apri automaticamente il tunnel ssh per connettere virtualenv come interprete del progetto

Aggiungi quanto segue al tuo .pycharmrcfile:

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

Questo controlla se un tunnel ssh è già aperto e ne apre uno altrimenti. In File -> Impostazioni -> Progetto -> Interprete del progetto in Pycharm, aggiungi un nuovo interprete remoto con la seguente configurazione:

+ -------------------------- + ---------------------- ----------- + ------- + ---- +
| Nome: | <Nome interprete> | | |
| Seleziona | "Credenziali SSH" | | |
| Host: | 127.0.0.1 | Porta: | 22 |
| Utente: | <Nome utente Linux> | | |
| Tipo di autenticazione: | "Password" | | |
| Password: | <Password Linux> | | |
| Percorso interprete Python: | <Percorso Linux per il tuo virtualenv> | | |
| Percorso degli helper Python: | <Imposta automaticamente> | | |
+ -------------------------- + ---------------------- ----------- + ------- + ---- +

Ora, quando apri il tuo progetto, il tuo bash si avvia automaticamente nel tuo virtualenv, apre un tunnel ssh e pycharm connette virtualenv come interprete remoto.

avviso: l'ultimo aggiornamento in Windows avvia automaticamente un servizio SshBroker e SshProxy all'avvio. Questi bloccano il tunnel ssh da Linux a Windows. Puoi interrompere questi servizi in Task Manager -> Servizi, dopodiché tutto funzionerà di nuovo.

Un'opzione che hai quando accedi al terminale> Esegui> Debug> Modifica configurazioni

selezionare l'ambiente conda appropriato .. Anche quando si crea un nuovo progetto, viene chiesto di configurare questa posizione.