Jak aktywować virtualenv w terminalu PyCharm?

Skonfigurowałem PyCharm, stworzyłem virtualenv (za pomocą wirtualnego polecenia env lub bezpośrednio w PyCharm) i aktywowałem to środowisko jako mojego tłumacza. Wszystko działa dobrze.

Jeśli jednak otworzę terminal za pomocą „Narzędzia, otwórz terminal”, podana zachęta powłoki nie używa wirtualnego środowiska env; Nadal muszę używać source ~/envs/someenv/bin/activatetego terminala, aby go aktywować.

Inną metodą jest aktywacja środowiska w powłoce i uruchomienie PyCharm z tego środowiska. Jest to „wykonalne”, ale dość brzydkie i oznacza, że ​​mam poważne problemy, jeśli zmienię środowisko lub projekty z PyCharm: teraz używam całkowicie niewłaściwego środowiska.

Czy istnieje inny, znacznie łatwiejszy sposób, aby „Narzędzia, otwórz terminal” automatycznie aktywowało środowisko wirtualne?

Edytować:

Według https://www.jetbrains.com/pycharm/whatsnew/#v2016-3-venv-in-terminal , PyCharm 2016.3 (wydany w listopadzie 2016 r.) Ma wsparcie virutalenv dla terminali po wyjęciu z pudełka

Auto virtualenv jest obsługiwane dla bash, zsh, fish i cmd systemu Windows. Możesz dostosować swoje preferencje powłoki w Ustawieniach (Preferencje) | Narzędzia | Terminal.

Utwórz plik .pycharmrcw folderze domowym o następującej zawartości

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

Używanie ścieżki virtualenv jako ostatniego parametru.

Następnie ustaw preferencje powłoki-> Ustawienia projektu-> Ścieżka powłoki do

/bin/bash --rcfile ~/.pycharmrc

Aktualizacja:

Preferencje w Ustawieniach (Preferencje) | Narzędzia | Terminal jest globalny.
Jeśli używasz venv dla każdego projektu, pamiętaj, aby użyć bieżącej zmiennej ścieżki i domyślnej nazwy venv:

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

Dla użytkowników systemu Windows: podczas korzystania z PyCharm w środowisku wirtualnym można użyć /Kparametru tocmd.exe aby automatycznie ustawić środowisko wirtualne.

Pycharm 3 lub 4: Settings, Terminal, Default shelli dodatek/K <path-to-your-activate.bat> .

Pycharm 5: Settings, Tools, Terminali dodać /K <path-to-your-activate.bat>doShell path .

Pycharm 2016,1 2016,2 lub: Settings, Tools, Terminal, i dodać ""/K <path-to-your-activate.bat>""do Shell pathi dodać (przeszkadza cytaty). Dodaj także cudzysłowy wokół cmd.exe, co spowoduje:

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

W przypadku użytkowników systemu Windows korzystających z PyCharm i środowiska wirtualnego w systemie Windows można użyć parametru / k do cmd.exe, aby automatycznie ustawić środowisko wirtualne.

Idź do Ustawienia, Terminal, Domyślna powłoka i dodaj /K <path-to-your-activate.bat>.

Nie mam reputacji, aby komentować wcześniejszą odpowiedź, więc publikuję tę poprawioną wersję. To naprawdę oszczędza dużo czasu.

Aktualizacja:

Uwaga: Pycharm obsługuje teraz bezpośrednio środowiska wirtualne i wydaje mi się, że działa dobrze - więc moje obejście nie jest już potrzebne.

Opierając się na odpowiedziach Petera i eksperymentach, znalazłem dobre „ogólne rozwiązanie”, które rozwiązuje następujące kwestie:

• Przywraca zachowanie powłoki logowania. PyCharm normalnie uruchamia powłokę logowania, ale --rcfile zatrzymał to działanie. Skrypt nadal używa --rcfile, ale próbuje emulować zachowanie INVOCATION powłoki logowania.
• Eliminuje potrzebę tworzenia pliku rc dla każdego środowiska
• Eliminuje potrzebę aktualizacji ustawień projektu w przypadku zmiany środowiska.

Upuść ten skrypt gdzieś do katalogu bin. Np. ~ / 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

Następnie ustaw ścieżkę powłoki PyCharm na:

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

PyCharm 4 ma teraz virtualenvs zintegrowane z IDE. Wybierając interpretera projektu, możesz utworzyć, dodać lub wybrać virtualenv. Dodali „konsolę Pythona”, która działa w skonfigurowanym interpretatorze projektu.

Więcej informacji tutaj.

Dzięki Chris, twój skrypt działał przy niektórych projektach, ale nie we wszystkich na moim komputerze. Oto skrypt, który napisałem i mam nadzieję, że ktoś uzna go za przydatny.

#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

Widziałem wszystkie powyższe odpowiedzi, ale żadna z nich nie jest dla mnie wystarczająco elegancka. W pycharm 2017.1.3 (w komputerze), najłatwiej jest otworzyć Settings->Tools->Terminali sprawdzić Shell integrationi Activate virtualenvopcje.

Jeśli używasz wersji Windows, jest to całkiem proste. Jeśli masz już środowisko wirtualne, po prostu przejdź do jego folderu, znajdź activate.batwewnątrz Scriptsfolderu. skopiuj pełną ścieżkę i wklej ją w terminalu Pycharm, a następnie naciśnij Enteri gotowe!

Jeśli potrzebujesz stworzyć nowe środowisko wirtualne:

Przejdź do plików> ustawienia, a następnie wyszukaj project interpreter, otwórz, kliknij przycisk koła zębatego i stwórz środowisko w dowolnym miejscu, a następnie wykonaj pierwszy akapit.

Na Macu jest to PyCharm => Preferencje ... => Narzędzia => Terminal => Aktywuj virtualenv , które powinno być domyślnie włączone.

Właśnie dodałem skrypt o nazwie pycharmactivate do mojego katalogu domowego. Ustaw wartość PyCharm (4.0.1) Plik> Ustawienia> Narzędzia> Terminal> Ścieżka powłoki do / bin / bash --rcfile ~ / pycharmactivate. Może nie jest to najlepsze rozwiązanie, jeśli masz różne katalogi / nazwy projektów i virtualenv, ale działa dla mnie. Ten skrypt zawiera następujące 3 wiersze i zakłada, że ​​twój virtualenv ma taką samą nazwę jak twój katalog projektu.

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

Kontynuując odpowiedź Petera, tutaj wersja .pycharmrcpliku dla komputerów Mac :

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

Kura

Mam rozwiązanie, które działało na moim komputerze z systemem Windows 7.

Uważam, że terminal PyCharm jest wynikiem jego działania cmd.exe, który załaduje PATHzmienną systemu Windows i użyje wersji Pythona, którą znajdzie jako pierwszą w tym PATH. Aby edytować tę zmienną, kliknij prawym przyciskiem myszy Mój komputer -> Właściwości -> Zaawansowane ustawienia systemu -> karta Zaawansowane -> przycisk Zmienne środowiskowe ... W sekcji Zmienne systemowe wybierz i edytuj plikPATH zmienną.

Oto odpowiednia część mojego PATH przed edycją:

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

... i po edycji PATH(teraz tylko 3 linie):

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

Aby to przetestować, otwórz nowy terminal Windows ( Start -> wpisz cmdi naciśnij Enter) i sprawdź, czy korzysta z twojego wirtualnego środowiska. Jeśli to zadziała , uruchom ponownie PyCharm a następnie przetestuj go w terminalu PyCharm.

oto co robię: utwórz plik activ_env.bat (windows, może .sh w linuksie) w kodzie źródłowym folde:

/env_yourenvlocate/scripts/activate.bat

i inny plik dezaktywuj_env.bat:

/env_yourenvlocate/scripts/deactivate.bat

za każdym razem, gdy otwierasz okno terminala, po prostu uruchom plik bat, aby aktywować / dezaktywować virtualenv, pozostaniesz w ścieżce kodu źródłowego, nie musisz zmieniać ścieżki do iz powrotem.

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>

Jeśli Twój Pycharm 2016.1.4v i nowszy, powinieneś używać "default path" /K "<path-to-your-activate.bat>" notowań nie zapomnij

Jeśli przeniosłeś projekt do innego katalogu, możesz ustawić nową ścieżkę w oknie dialogowym Ustawienia. Następnie musisz ustawić ten Interpreter projektu w oknie dialogowym Edytuj konfigurację.

Inną alternatywą jest użycie virtualenvwrapper do zarządzania środowiskami wirtualnymi. Wygląda na to, że po aktywacji skryptu virtualenvwrapper , pycharm może go użyć, a wtedy prosta workonkomenda będzie dostępna z konsoli pycharm i przedstawi dostępne środowiska wirtualne:

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$ 

Ta metoda powinna działać z dowolnymi środowiskami wirtualnymi na projekt i nie przyjmuje założeń dotyczących twojego środowiska, ponieważ używa utworzonych haków.

Ty piszesz:

• Globalny skrypt, który wywołuje hook
• Skrypt przechwytujący na projekt PyCharm (nieobowiązkowy)

Biorąc pod uwagę, że aktualna najnowsza PyCharm (Społeczność 2016.1) nie zezwala na ustawienia terminala na projekt, rozpoczynając od skryptu, który wywołuje zaczep specyficzny dla projektu. To jest moje ~/.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

Jeśli używasz czegoś innego niż Bash, wywołaj własny .bash_profileodpowiednik, jeśli chcesz.

Teraz ustaw PyCharm „Narzędzia -> Terminal -> Ścieżka powłoki”, aby wywołać ten skrypt, np .: /bin/bash --rcfile ~/.pycharmrc

Wreszcie, dla każdego projektu PyCharm, które potrzebujesz aktywować określone środowisko wirtualne, utwórz plik w katalogu głównym projektu PyCharm .pycharm/term-activate. To jest Twój punkt zaczepienia i po prostu zdefiniuje nazwę żądanego środowiska wirtualnego dla projektu PyCharm:

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

Możesz oczywiście rozszerzyć swoje hooki o wszystko, co uznasz za przydatne w środowisku terminala danego projektu PyCharm.

W przypadku środowisk wirtualnych Conda w systemie Windows upewnij się, że plik wsadowy NIE ma nazwy, activate.batponieważ spowoduje to konflikt z activatepoleceniem conda , co spowoduje rekurencyjne wywołanie pliku wsadowego.

U mnie działa następująca ścieżka Shell:

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

A w pliku activ-env.bat:

call activate myenvname

Chciałem osobne środowisko wirtualne dla każdego projektu i nie przejmowałem się zbytnio posiadaniem dodatkowych plików, które to ułatwiły. Rozwiązaniem, które wystarczy zrobić tylko raz i działa dla wszystkich projektów, jest dodanie następujących elementów do .bashrclub .bash_profile:

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

Sprawdza, czy istnieje wirtualne środowisko, w którym terminal jest otwierany, a jeśli tak, aktywuje go (i oczywiście można użyć innych ścieżek względnych). Ustawienia terminala PyCharm można pozostawić jako domyślne.

PyCharm 4.5.4

Utwórz plik .pycharmrc w swoim folderze domowym o następującej zawartości

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

Używanie ścieżki virtualenv jako ostatniego parametru.

Następnie ustaw preferencje powłoki-> Ustawienia projektu-> Ścieżka powłoki do

/bin/bash --rcfile ~/.pycharmrc

Nie wiem dlaczego, ale to nie działa na mnie. PyCharm drukuje błąd.

cmd.exe /K "<path-to-your-activate.bat>" Działa, ale tworzy to samo virtualenv dla każdego projektu, nawet jeśli nie jest to konieczne.

Ten paragon działa! Ale ciąg /env_yourenvlocate/scripts/activate.batmusi zawierać cudzysłowy, w ten sposób"Full_path_to_your_env_locate\scripts\activate.bat" !

Dezaktywacja virtualenv jest bardzo łatwa - wpisz w terminalu „dezaktywuj”

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

Rozwiązanie dla WSL (Ubuntu w systemie Windows)

Jeśli używasz WSL (Ubuntu w systemie Windows), możesz także otworzyć bash jako terminal w pycharm i aktywować linux virtualenv.

Użyj .pycharmrcpliku opisanego w odpowiedzi Petera Gibsona; Dodaj .pycharmrcplik do katalogu domowego z następującą zawartością:

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

W Pycharm File> Settings> Tools> Terminal dodaj następującą `` ścieżkę powłoki '':

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

Specyficzny dla projektu virtualenv

Droga do twojego virtualenv .pycharmrcnie musi być absolutna. Możesz ustawić virtualenv dla konkretnego projektu, ustawiając ścieżkę względną z katalogu projektu. Mój virtualenv zawsze znajduje się w folderze „venv” w katalogu mojego projektu, więc mój .pycharmrcplik wygląda następująco:

źródło ~ / .bashrc
 źródło ~ / pycharmvenv / bin / aktywuj path
source ./venv/bin/activate #relative path

BONUS: automatycznie otwórz tunel ssh, aby podłączyć virtualenv jako tłumacza projektu

Dodaj do swojego .pycharmrcpliku:

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

Sprawdza, czy tunel ssh jest już otwarty, aw przeciwnym razie otwiera. W File -> Settings -> Project -> Project Interpreter in Pycharm, dodaj nowy zdalny interpreter o następującej konfiguracji:

+ -------------------------- + ---------------------- ----------- + ------- + ---- +
| Imię: | <Nazwa tłumacza> | | |
| Wybierz | „Poświadczenia SSH” | | |
| Gospodarz: | 127.0.0.1 | Port: | 22 |
| Użytkownik: | <Nazwa użytkownika Linux> | | |
| Typ autoryzacji: | „Hasło” | | |
| Hasło: | <Hasło Linuksa> | | |
| Ścieżka interpretera Pythona: | <Linuxowa ścieżka do twojego virtualenv> | | |
| Ścieżka pomocników Pythona: | <Ustaw automatycznie> | | |
+ -------------------------- + ---------------------- ----------- + ------- + ---- +

Teraz, kiedy otwierasz projekt, twój bash automatycznie uruchamia się w twoim virtualenv, otwiera tunel ssh, a pycharm łączy virtualenv jako zdalny interpreter.

ostrzeżenie: ostatnia aktualizacja w systemie Windows automatycznie uruchamia usługę SshBroker i SshProxy podczas uruchamiania. Blokują one tunel ssh z systemu Linux do systemu Windows. Możesz zatrzymać te usługi w Menedżerze zadań -> Usługi, po czym wszystko znów będzie działać.

Jedna opcja, którą masz po wejściu do terminala> Uruchom> Debuguj> Edytuj konfiguracje

wybierz odpowiednie środowisko conda. Również podczas tworzenia nowego projektu - prosi o skonfigurowanie tej lokalizacji.