How do I activate a virtualenv inside PyCharm's terminal?

Question

I've set up PyCharm, created my virtualenv (either through the virtual env command, or directly in PyCharm) and activated that environment as my Interpreter. Everything is working just fine.

However, if I open a terminal using "Tools, Open Terminal", the shell prompt supplied is not using the virtual env; I still have to use source ~/envs/someenv/bin/activate within that Terminal to activate it.

Another method is to activate the environment in a shell, and run PyCharm from that environment. This is "workable" but pretty ugly, and means I have major problems if I switch environments or projects from PyCharm: I'm now using the totally-wrong environment.

Is there some other, much-easier way to have "Tools, Open Terminal" automatically activate the virtual environment?

## Simple, re-start your PyCharm to see the virtualenv in your PyCharm terminal. — DataFramed, May 14 '22 at 02:41

score 120 · Accepted Answer · edited Nov 18 '21 at 16:46

120

Edit:

According to https://www.jetbrains.com/pycharm/whatsnew/#v2016-3-venv-in-terminal, PyCharm 2016.3 (released Nov 2016) has virutalenv support for terminals out of the box

Auto virtualenv is supported for bash, zsh, fish, and Windows cmd. You can customize your shell preference in Settings (Preferences) | Tools | Terminal | check Activate virtaulenv

you also need to make sure to have the path of virtual environment path included in the content root folder of your project structure. You can go to settings (preference) | project | Project Structure | if your environment is not included in the project directory.

***Old Method:***

Create a file .pycharmrc in your home folder with the following contents

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

Use your virtualenv path as the last parameter.

Then set the shell Preferences->Project Settings->Shell path to

/bin/bash --rcfile ~/.pycharmrc

edited Nov 18 '21 at 16:46

Dr. Who

3
2

answered Mar 09 '14 at 22:35

Peter Gibson

19,086
7
60
64

9

Thank you! I hadn't thought of overriding the shell's rc file. To better support pycharm working with multiple projects, each which might have a different virtualenv, I'd call the ".pycharmrc" file something different, and perhaps put it into the env directory itself. ```~/pycharmenv/bin/terminalactivate``` sounds like a good option. – Chris Cogdon Mar 10 '14 at 23:17
1

@PeterGibson, pferate's answer has nothing to do with the OP's question. The problem is terminal not the Python interpreter. The venv integration has been there way before PyCharm 4. Your answer works though. – Sam R. Aug 03 '15 at 17:46
@norbertpy I hadn't tested it so thanks for the update – Peter Gibson Aug 03 '15 at 23:18
1

This is the simplest solution, except that I place my `.pycharmrc` in the project home folder, so that I can have a different file for each project. In a properly configured project, there is no need to provide the absolute path to the `.pycharmrc` file. – tchakravarty Sep 09 '15 at 10:31
At least for macOS you have to add `-i` option after `--rcfile` to enable interactive mode or your `~/.pycharmrc` will not be executed. Here is what `man bash` says about `--rcfile` option: `Execute commands from file instead of the standard personal initialization file ~/.bashrc if the shell is interactive` – renskiy Dec 11 '16 at 17:51
macos 10.12.2, pycharm 2016.3.2 `/bin/bash --rcfile ~/.pycharmrc` or `/bin/bash --rcfile -i ~/.pycharmrc` not work for me @renskiy – Cloud Mar 03 '17 at 02:59
@SiminJie, try this one: `/bin/bash --rcfile ~/.pycharmrc -i` – renskiy Mar 03 '17 at 12:13
@renskiy `/bin/bash --rcfile ~/.pycharmrc -i` return `bash: /Users/username/pycharmvenv/bin/activate: No such file or directory ` -- Pycharm version 2016.3.2 – Cloud Mar 04 '17 at 12:39
2

@SiminJie, PyCharm 2016.3.2 has such option from the box. Go to the: settings -> Tools -> Terminal. And make sure "Activate virtualenv" option is enabled. – renskiy Mar 06 '17 at 09:58
also I used `source \`pwd\`/.env/bin/activate` instead of second line, It made me able to use same `rc` file for other projects too. – Soorena Jan 02 '18 at 11:33
@pferate @norbertpy @renskiy The Tools -> Terminal -> Activate virtual env solution works if I want to do `bash script.sh` in PyCharm terminal. But I am not able to make the virtualenv effective for the case when I right click on bash file and select `Run script.sh`. When I run this way, it doesn't respect the virtualenv. I can add virtual env for Python type run configurations, but couldn't find how to set virtual env for Bash type run configuration. Running `script.sh` as a before launch activity inside a virtual environment set Python run configuration doesn't work either. Help – Vikas Prasad Feb 16 '18 at 05:12
well for now I just did this hack where I activated the virtual env in my `script.sh` itself by adding these lines: ```source `which virtualenvwrapper.sh` workon ``` – Vikas Prasad Feb 16 '18 at 05:59
Is this option only available in PyCharm but not IntelliJ IDEA? I went to Settings -> Tools -> Terminal but there is no option related to virtual env. – xji Jul 26 '18 at 14:22
@xji I expect you'd need to use the Python specific PyCharm – Peter Gibson Jul 27 '18 at 03:42
Still you have to be careful with PyCharm's terminal. I polluted my host's python dependencies because I believed that PyCharm was intelligent enough to automatically activate the venv in the console. – Dan Jun 09 '21 at 05:04

score 61 · Answer 2 · edited Sep 27 '19 at 19:06

61

Update:

The preferences in Settings (Preferences) | Tools | Terminal are global.
If you use a venv for each project, remember to use current path variable and a default venv name:

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

For Windows users: when using PyCharm with a virtual environment, you can use the /K parameter to cmd.exe to set the virtual environment automatically.

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

PyCharm 5: Settings, Tools, Terminal, and add /K <path-to-your-activate.bat> to Shell path.

PyCharm 2016.1 or 2016.2: Settings, Tools, Terminal, and add ""/K <path-to-your-activate.bat>"" to Shell path and add (mind the quotes). Also add quotes around cmd.exe, resulting in:

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

edited Sep 27 '19 at 19:06

Gabriel

393
3
12

answered Apr 04 '14 at 11:36

SaeX

17,240
16
77
97

In this case `%CD%` is the current working directory, see [Windows shell command to get the full path to the current directory?](https://stackoverflow.com/a/607682) – bad_coder Jun 22 '20 at 02:38
is there a reason you're using double-double quotes around the bat address? – Nick Jul 20 '22 at 18:14
2

@Nick I do not recall, this is from over 8y ago :-) Meanwhile the other answer is more relevant (since the 2016.03 release). All I know is that it worked with double double quotes, I don't remember testing it with single double quotes. – SaeX Jul 21 '22 at 06:55

score 43 · Answer 3 · 2018-08-22T12:49:13.847

43

For Windows users when using PyCharm and a virtual environment under Windows, you can use the /k parameter to cmd.exe to set the virtual environment automatically.

Go to Settings, Terminal, Default shell and add /K <path-to-your-activate.bat>.

I don't have the reputation to comment on the earlier response so posting this corrected version. This really saves a LOT of time.

Update:

Note: Pycharm now supports virtual environments directly and it seems to work well for me - so my workaround not needed anymore.

edited Aug 22 '18 at 12:49

answered May 19 '14 at 05:32

1

This is great, but only when you have just one virtualenv for all your projects. Default shell setting is shared across projects – MartinM Aug 21 '18 at 11:45

Aditya Rajgor · Answer 4 · 2022-01-06T16:33:16.407

37

Somehow a small trick worked for me. All you gotta do is change the default terminal from Power shell to CMD.

Open pycharm --> Go to Settings --> Tools --> Terminal
Change the Shell Path to C:\Windows\system32\cmd.exe from PS
Check the Activate virtualenv checkbox
Hit apply and open new terminal

It's 2021 you don't need to specify the file path or add the environment variable.

Update: It's 2022 and I run into the same issue Fix: Follow the above steps and in addition, make sure you have selected the Your virtual env python.exe as your project python interpreter, and that's it

edited Jan 06 '22 at 16:33

answered Oct 26 '21 at 14:07

Aditya Rajgor

953
8
14

1

This works. The terminal on the pycharm run as it were original windows command prompt after applying the above settings. – kelvinmacharia254 Mar 22 '23 at 07:19

score 9 · Answer 5 · answered Aug 06 '17 at 12:29

9

If You are using windows version it is quite easy. If you already have the virtual environment just navigate to its folder, find activate.bat inside Scripts folder. copy it's full path and paste it in pycharm's terminal then press Enter and you're done!

If you need to create new virtual environment :

Go to files > settings then search for project interpreter, open it, click on gear button and create the environment wherever you want and then follow first paragraph.

answered Aug 06 '17 at 12:29

AmiNadimi

5,129
3
39
55

Great answer! Thank you! Quick question. I have 3 different virtual environments that I created in Anaconda. Is there separate `activate.bat` for each of them? – user1700890 Oct 11 '17 at 20:04
1

@user1700890 yes! In case you haven't overwritten the environments, they should have separate folders and as a result, separate `activate.bat` files. if you like the answer, feel free to upvote ;) – AmiNadimi Oct 11 '17 at 20:15
Thank you, I just checked, there are no folders in `Scripts` folder. Also Pycharm complains that `activate.bat` is not a valid python SDK – user1700890 Oct 11 '17 at 20:17
1

So i think you should first try and find the virtual-environment folder created when you where using Anaconda and then run the `activate` batch file inside it. or if it is possible for you, just go with creating a new environment. – AmiNadimi Oct 11 '17 at 20:27

score 8 · Answer 6 · edited Nov 22 '21 at 19:14

8

I have viewed all of the answers above but none of them is elegant enough for me. In PyCharm 2017.1.3 (in my computer), the easiest way is to open Settings->Tools->Terminal and check Shell integration and Activate virtualenv options.

edited Nov 22 '21 at 19:14

bad_coder

11,289
20
44
72

answered Jul 26 '17 at 03:10

WQY

181
2
6

1

Well, the accepted answer quotes this very same thing. Its just that it doesn't have picture. – Vikas Prasad Feb 16 '18 at 04:52

score 7 · Answer 7 · answered Mar 14 '14 at 19:46

7

Based on answers from Peter and experimentation, I've come up with a good "general solution", which solves the following:

Restores the behaviour of a login shell. PyCharm normally runs a login shell, but --rcfile stopped this happening. Script still uses --rcfile, but attempts to emulate the INVOCATION behaviour of a login shell.
Removes the need to create an rcfile for each environment
Removes the need to update the project settings if you change the environment.

Drop this script into a bin directory somewhere. E.g. ~/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

Then set PyCharm's Shell path to:

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

answered Mar 14 '14 at 19:46

Chris Cogdon

7,481
5
38
30

1

THANK YOU! This worked for me after hours of unsuccessful attempts to figure out where to start bashrc and bash profiles. However it threw and error that it could'nt find my virtual env so I modified it like so, can you tell me if it's OK? `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 source ~/learnp/project1/venv/bin/activate` – zerohedge Nov 16 '15 at 19:06
@zerohedge: Your script will work fine, but it's fixed to your "project1" virtualenv. The script above was supposed to do auto-detection, but there's a bunch of assumptions being made: that the initial working directory is the location of the ".idea" directory; that the format of the workspace.xml file doesn't change significantly. Unfortunately, it looks like pycharm version 5 has made significant changes in that area. I can't actually figure out where the data is, now. – Chris Cogdon Nov 17 '15 at 21:06
well I don't mind changing my addition depending on the project, since the Shell Path to is also project specific. I could only get a prompt saying "bash 3.2$:" before finding your script, with no indication of my current directory or any resemblance of my Terminal prompt. Thank you again! – zerohedge Nov 17 '15 at 21:09

score 7 · Answer 8 · answered Apr 29 '15 at 18:19

7

PyCharm 4 now has virtualenvs integrated in the IDE. When selecting your project interpreter, you can create, add, or select a virtualenv. They've added a "Python Console" that runs in the configured project interpreter.

More info here.

answered Apr 29 '15 at 18:19

pferate

2,067
1
16
18

12

How does this answer the OP? Still have to `source /path/to/venv/bin/activate` manually in the terminal. – frnhr Jul 11 '15 at 13:21

score 6 · Answer 9 · answered Jun 07 '14 at 00:44

Thanks Chris, your script worked for some projects but not all on my machine. Here is a script that I wrote and I hope anyone finds it useful.

#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

Thanks, this worked for me! Had to do two additional things though. 1) Add `source /etc/profile` at the beginning of ~/.pycharmrc file (on Mac Yosemite) 2) In Pycharm edit Preferences > Tools > Terminal > Shell path to "/bin/bash --rcfile ~/.pycharmrc" — frnhr, Jul 11 '15 at 20:25
This is awesome, thank you! If you're using Python 3, remember to put parentheses for the print function. I myself had to put "export ~/.bashrc" before this script. — Raphaël Gomès, Jul 29 '16 at 10:00

score 5 · Answer 10 · answered Dec 02 '19 at 05:50

5

If you have moved your project to another directory, you can set the new path via Settings dialog. And then you need to set this Project Interpreter in the Edit Configuration dialog.

answered Dec 02 '19 at 05:50

Khachatur

921
1
12
30

1

I also had to restart PyCharm for the "Activate virtualenv" setting to kick in again. Opening an new terminal tab was not enough. – Tobias Uhmann Jan 23 '21 at 14:31

M3RS · Answer 11 · 2019-04-02T13:54:02.247

3

On Mac it's PyCharm => Preferences... => Tools => Terminal => Activate virtualenv, which should be enabled by default.

edited Apr 02 '19 at 13:54

answered Oct 18 '18 at 12:23

M3RS

6,720
6
37
47

user4304103 · Answer 12 · 2014-11-28T14:56:49.363

I just added a script named pycharmactivate to my home directory. Set value of PyCharm (4.0.1) File > Settings > Tools > Terminal > Shell path to /bin/bash --rcfile ~/pycharmactivate. Maybe not the best solution incase you have different project and virtualenv directories/names but it works for me. This script contains the following 3 lines and assumes your virtualenv has the same name as your project dir.

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

phiree · Answer 13 · 2015-07-13T08:07:29.797

this is what i am doing: create a activate_env.bat(windows,maybe .sh in linux) file in the source code folde:

/env_yourenvlocate/scripts/activate.bat

and another file deactivate_env.bat:

/env_yourenvlocate/scripts/deactivate.bat

everytime open the terminal window, just execute the bat file to activate/deactivate the virtualenv, you will stay in source code path, no need to change path to and back.

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>

score 2 · Answer 14 · answered Jun 03 '16 at 15:13

2

Following up on Peter's answer, here the Mac version of the .pycharmrc file:

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

Hen

answered Jun 03 '16 at 15:13

Hendrik Strobelt

21
2

score 2 · Answer 15 · answered Jan 10 '18 at 11:14

Solution for WSL (Ubuntu on Windows)

If you're using WSL (Ubuntu on Windows), you can also open bash as terminal in pycharm and activate a linux virtualenv.

Use a .pycharmrc file like described in Peter Gibson's answer; Add the .pycharmrc file to your home directory with following content:

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

In Pycharm File > Settings > Tools > Terminal add the following 'Shell path':

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

Project specific virtualenv

The path to your virtualenv in .pycharmrc does not have to be absolute. You can set a project specific virtualenv by setting a relative path from your project directory. My virtualenv is always located in a 'venv' folder under my project directory, so my .pycharmrc file looks like this:

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

BONUS: automatically open ssh tunnel to connect virtualenv as project interpreter

Add the following to your .pycharmrc file:

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

This checks if a ssh tunnel is already opened, and opens one otherwise. In File -> Settings -> Project -> Project Interpreter in Pycharm, add a new remote interpreter with following configuration:

+--------------------------+---------------------------------+-------+----+
| Name:                    | <Interpreter name>              |       |    |
| Select                   | 'SSH Credentials'               |       |    |
| Host:                    | 127.0.0.1                       | Port: | 22 |
| User:                    | <Linux username>                |       |    |
| Auth type:               | 'Password'                      |       |    |
| Password:                | <Linux password>                |       |    |
| Python interpreter path: | <Linux path to your virtualenv> |       |    |
| Python helpers path:     | <Set automatically>             |       |    |
+--------------------------+---------------------------------+-------+----+

Now when you open your project, your bash automatically starts in your virtualenv, opens a ssh tunnel, and pycharm connects the virtualenv as remote interpreter.

warning: the last update in Windows automatically starts a SshBroker and SshProxy service on startup. These block the ssh tunnel from linux to windows. You can stop these services in Task Manager -> Services, after which everything will work again.

This was exactly what I was looking for. As someone who enjoys Debian but is too lazy to set up a second OS, I cannot thank you enough. I would like to add that the activate script provided to me by Pycharm ended up needing to be run through dos2unix before it would run correctly. — Patrick, Apr 16 '21 at 17:16

score 2 · Answer 16 · edited Nov 04 '20 at 11:37

2

I had the same problem with venv in PyCharm. But It is not big problem! Just do:

enter in your terminal venv directory( cd venv/Scripts/ )
You will see activate.bat
Just enter activate.bat in your terminal after this you will see YOUR ( venv )

edited Nov 04 '20 at 11:37

Pierre.Vriens

2,117
75
29
42

answered Nov 03 '20 at 17:44

tima

21
1

score 2 · Answer 17 · edited Oct 05 '21 at 19:42

I had the similar problem of not having venv activated in pycharm terminal (Pycharm version 2021.2.2). Just simply follow the steps below.

Go to "settings -> tools -> terminal" then at the bottom of that window check if "Activate virtualenv" is having a tick or not, if not then make sure that box is ticked.

Then in the middle part of that window check the the shell path is set to "cmd.exe" or not, if not then set it to "cmd.exe" (it will have it's path associated with it so no need to do anything just click on "cmd.exe" from the drop down list) then click on "apply" button below and click "ok".

Now it's done, just close your opened terminal and re-open it. You will see "venv" in front of your project path.

P.S: Don't mind the double quotes in my answer they are just for highlighting the texts, nothing more.

Beef Coin · Answer 18 · 2022-01-08T13:01:36.843

2

Windows Simple and Easy Solution:

In Pycharm inside the Projects menu on the left there will be folders.
Find the Scripts folder
Inside there you'll find activate.bat
Right click on activate.bat
Copy/Path Reference
Select Absolute Path
Find the Terminal tab located in the middle at the bottom of Pycharm.
Paste it into the terminal console and press enter
If you did it right the terminal path will have brackets (venv) around the name of the folder you activated.
Before: "PS C:\"
After: "(venv) C:\"
Note The folder name may be different than yours the important part is the (brackets) :D

edited Jan 08 '22 at 13:01

answered Jan 08 '22 at 09:48

Beef Coin

39
2

not working . it is PS still please help – Anshuman Jayaprakash Jul 05 '23 at 10:42
I got the answer you should use the file activate.ps1 for powershell and activate.bat for cmd prompt – Anshuman Jayaprakash Jul 05 '23 at 10:45

score 1 · Answer 19 · edited Nov 22 '14 at 10:14

I have a solution that worked on my Windows 7 machine.

I believe PyCharm's terminal is a result of it running cmd.exe, which will load the Windows PATH variable, and use the version of Python that it finds first within that PATH. To edit this variable, right click My Computer --> Properties --> Advanced System Settings --> Advanced tab --> Environment Variables... button. Within the System variables section, select and edit the PATH variable.

Here is the relevant part of my PATH before editing:

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

...and after editing PATH (only 3 lines now):

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;

To test this, open a new windows terminal (Start --> type in cmd and hit Enter) and see if it's using your virtual environment. If that works, restart PyCharm and then test it out in PyCharm's terminal.

score 1 · Answer 20 · answered Jun 23 '16 at 04:56

1

If your Pycharm 2016.1.4v and higher you should use "default path" /K "<path-to-your-activate.bat>" don't forget quotes

answered Jun 23 '16 at 04:56

Koblikov Mihail

73
4

score 1 · Answer 21 · answered Feb 04 '21 at 04:19

On Windows, if you have already have the virtualenvironment eg. 'myvenv' located within the project root, you can activate it from the terminal as below:

.\myvenv\Scripts\activate

Calling the activate from the virtualenv you desire to activate, activates the virtualenv.

You know it is activated when you see the change:

C:\Projects\Trunk\MyProject>

to

(myvenv)C:\Projects\Trunk\MyProject>

score 1 · Answer 22 · answered Apr 05 '22 at 00:02

1

Had the same issue, this is how I solved it:

All you gotta do is change the default terminal from Power shell to CMD. Open pycharm --> Go to Settings --> Tools --> Terminal. Change the Shell Path to C:\Windows\system32\cmd.exe from PS. Check the Activate virtualenv checkbox. Hit apply and open new terminal.

answered Apr 05 '22 at 00:02

Sherar MDP

241
1
5

This is by far the simplest yet workable answer I saw on Internet. – hokwanhung Sep 15 '22 at 01:00

score 1 · Answer 23 · answered Nov 10 '22 at 16:06

If you're using windows with wsl2, the only thing that worked for me (November 2022) was:

go into Pycharm terminal definition
paste:

wsl.exe -- bash --rcfile <(echo '. ~/.bashrc; source <path-to-your-virtial-env>/bin/activate')

inside the 'Shell path' box.

Then every time you open the terminal the virtual environment would be activated.

score 0 · Answer 24 · answered Feb 14 '15 at 21:31

Another alternative is to use virtualenvwrapper to manage your virtual environments. It appears that once the virtualenvwrapper script is activated, pycharm can use that and then the simple workon command will be available from the pycharm console and present you with the available virtual environments:

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$

However, that requires me have to activate the workon script every time I open the terminal, _and_ know which virtual environment pycharm is currently using for running the program, both of which I was explicitly trying to avoid. — Chris Cogdon, Feb 15 '15 at 23:40

score 0 · Answer 25 · answered Apr 25 '16 at 14:37

This method should work with arbitrary virtual environments per project and it doesn't make assumptions on your environment as it is using hooks you create.

You write:

A global script that invokes the hook
A hook script per PyCharm project (not mandatory)

Given that the current latest PyCharm (Community 2016.1) does not allow for Terminal settings per project start with the script that invokes the project specific hook. This is my ~/.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

If you are using something other than Bash, invoke your own .bash_profile equivalent should you wish to.

Now set your PyCharm "Tools -> Terminal -> Shell Path" to invoke this script, e.g.: /bin/bash --rcfile ~/.pycharmrc

Finally, for every PyCharm project you need a specific virtual environment activated, create a file within the PyCharm project root .pycharm/term-activate. This is your hook and it will simply define the name of the desired virtual environment for your PyCharm project:

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

You can of course extend your hooks with anything you find useful in the terminal environment of your particular PyCharm project.

score 0 · Answer 26 · answered Jul 19 '16 at 09:14

For conda virtual environments on Windows, make sure your batch file is NOT named activate.bat as this will cause a conflict with the conda activate command, resulting in a recursive calling of the batch file.

What works for me is the following Shell path:

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

And in the activate-env.bat file:

call activate myenvname

score 0 · Answer 27 · answered Nov 22 '16 at 23:37

I wanted a separate virtual environment for each project, and didn't care much for having additional files to facilitate this. A solution which you only need to do once and works for all projects is then adding the following to your .bashrc or .bash_profile:

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

This checks if there is a virtual environment where the terminal is being opened, and if so activates it (and of course other relative paths could be used). PyCharm's terminal settings can be left as their default.

score 0 · Answer 28 · edited May 23 '17 at 12:34

PyCharm 4.5.4

Create a file .pycharmrc in your home folder with the following contents
source ~/.bashrc
source ~/pycharmvenv/bin/activate
Using your virtualenv path as the last parameter.

Then set the shell Preferences->Project Settings->Shell path to
/bin/bash --rcfile ~/.pycharmrc

I don't why, but it doesn't work for me. PyCharm prints an error.

cmd.exe /K "<path-to-your-activate.bat>" It works, but it creates the same virtualenv for each project, and even if this is not necessary.

This receipt is working! But the string /env_yourenvlocate/scripts/activate.bat must contain quotes, like this "Full_path_to_your_env_locate\scripts\activate.bat"!

Deactivate the virtualenv is very easy - type in the terminal 'deactivate'

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

"I don't why, but it doesn't work for me" - maybe because this solution is good for linux/mac - not for windows ? ;) — Nir Alfasi, May 15 '17 at 23:17

score 0 · Answer 29 · answered Feb 09 '18 at 03:16

0

One option you have when you enter the terminal > Run > Debug > Edit Configurations

select the appropriate conda environmnent.. Also when you create a new project - it asks to configure this location.

answered Feb 09 '18 at 03:16

johndpope

5,035
2
41
43

score 0 · Answer 30 · answered Aug 13 '22 at 16:15

As you can see, python interpreter is located in venv/bin/python. If you go to this folder, you will see all libraries listed in there Sooo... as you will think, you use python command with it's path - that means in project path, for example

./venv/bin/pytest

score 0 · Answer 31 · answered Mar 21 '23 at 18:34

In my case, on Windows, I solved it by installing PowerShell 7 and selecting it in PyCharm on Settings > Tools > Terminal > Shell Path using the new option that appeared after installing it.

C:\Program Files\PowerShell\7\pwsh.exe

PowerShell 7 - Install from Windows Documentation

score -2 · Answer 32 · answered Jan 22 '21 at 02:30

-2

Set an existing virtual environment, Official Document: https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html?keymap=secondary_macos#existing-environment

answered Jan 22 '21 at 02:30

Chen Anguo

1
1

How do I activate a virtualenv inside PyCharm's terminal?

32 Answers32

Linked

Related