Following this manual page:
https://code.visualstudio.com/docs/python/environments
I would have to set PYTHONPATH "through the terminal settings":
The PYTHONPATH environment variable specifies additional locations
where the Python interpreter should look for modules. In VS Code,
PYTHONPATH can be set through the terminal settings
(terminal.integrated.env.*) and/or within an .env file.
How do I do that? If I write (I ssh to a Linux server):
terminal.integrated.env.linux
I get "command not found".
It seems you tried to enter this
terminal.integrated.env.linux
into the terminal prompt itself, which treated it as a literal command.
What that guide on PYTHONPATH meant when it said "through the terminal settings" was Visual Studio Code's Integrated Terminal settings: https://code.visualstudio.com/docs/getstarted/settings. Specifically the settings under Terminal (filtered on terminal.integrated.env):
Depending on your OS/platform, you put a terminal.integrated.env.<os> block in your VS Code's settings.json file to specify the environment variables to inject when using VS Code's integrated terminal:
From https://code.visualstudio.com/docs/getstarted/settings#_default-settings:
// Object with environment variables that will be added to the
// VS Code process to be used by the terminal on Linux. Set to
// `null` to delete the environment variable.
"terminal.integrated.env.linux": {},
So if you are on Linux:
"terminal.integrated.env.linux": {
"PYTHONPATH": "<absolute path>"
},
Note: see the Python docs on PYTHONPATH on what exactly needs to be specified here.
Or, as the guide says, you can also specify a .env file.
I am not able to source my .zshrc file when I open VSCode by clicking on the icon. This causes my pytest discovery to fail because it is looking for an environment variable that is not loaded (but is included in my .zshrc).
I have this in my VSCode settings:
"terminal.integrated.defaultProfile.osx": "zsh", # I am using a Mac
I've tried both
"terminal.integrated.inheritEnv": false,
and
"terminal.integrated.inheritEnv": true,
However, if I open a terminal and type code ., then it will load VSCode with my environment variables and all will work as expected. Is there a way to get the same behavior when I load it from clicking the icon? Is there some setting that I'm missing?
EDIT:
My environment variables are actually in ~/.profile, which is sourced by .zshrc, so I'm happy if it reads either .profile or .zshrc.
This problem disappeared for me with a recent release of VSCode. For anyone having this problem, make sure your version is at least 1.63.
How to use the Laragon terminal in VSCode with Laragon PATH environment variable (on Windows)?
I want to use the Laragon terminal in Visual Studio Code.
I want to use the local Laragon PHP, Composer, MySQL, Node.js, etc. in the terminal.
Open Laragon, right click > Tools > Path > Manage Path.
Copy everything between the --- Laragon --- and the next section (probably --- User ---).
I also put the three lines starting with C:\\Users\\[YOUR_USERNAME]\\AppData\\ at the start, so the Laragon composer and npm are used instead of the global ones.
Put all the paths on one line (they should be separated by a semicolon), and double all the backslashes.
Open your project settings.json, and add these values:
"terminal.integrated.shell.windows": "C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\git\\bin\\bash.exe",
"terminal.integrated.env.windows": {
"PATH": "[PASTE_THE_PATHS_HERE];${env:PATH}"
}
The first line makes the Laragon terminal default.
The second one makes the terminal use the Laragon paths/binaries.
6. You can also add the Laragon php path as the language validation executable:
"php.validate.executablePath": "C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\php\\php-8.0.3-Win32-vs16-x64\\php.exe"
On my computer settings.json looks like this:
{
"terminal.integrated.shell.windows": "C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\git\\bin\\bash.exe",
"terminal.integrated.env.windows": {
"PATH": "C:\\Users\\[YOUR_USERNAME]\\AppData\\Local\\Yarn\\config\\global\\node_modules\\.bin;C:\\Users\\[YOUR_USERNAME]\\AppData\\Roaming\\Composer\\vendor\\bin;C:\\Users\\[YOUR_USERNAME]\\AppData\\Roaming\\npm;C:\\[PATH_TO_LARAGON]\\Laragon\\bin;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\apache\\httpd-2.4.35-win64-VC15\\bin;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\composer;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\git\\bin;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\git\\cmd;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\git\\mingw64\\bin;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\git\\usr\\bin;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\laragon\\utils;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\mysql\\mysql-5.7.24-winx64\\bin;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\nginx\\nginx-1.16.0;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\ngrok;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\nodejs\\node-v12;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\notepad++;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\php\\php-8.0.3-Win32-vs16-x64;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\putty;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\redis\\redis-x64-3.2.100;C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\telnet;C:\\[PATH_TO_LARAGON]\\Laragon\\usr\\bin;${env:PATH}"
},
"php.validate.executablePath": "C:\\[PATH_TO_LARAGON]\\Laragon\\bin\\php\\php-8.0.3-Win32-vs16-x64\\php.exe"
}
You can check what's in the PATH environment variable by opening the terminal and typing env.
To check which path to binary is used for php, composer, etc., type which php, which composer, etc.
Of course, [YOUR_USERNAME] should be your username, and [PATH_TO_LARAGON] should be the path to the folder containing Laragon.
Don't forget to change the paths if you start using another versphp ion (of php, apache, ...).
On other operating systems, the solution should be similar, but this answer is for Windows.
I use Visual Studio Code for developing in Django. I did all of the following inside a virtual environment.
Whenever I save the Python (.py) files, an alert pops up at the bottom right of the screen telling me: "Formatter autopep8 is not installed. Install?". It gives me three options - "Yes", "Use black, and "Use yapf".
If I click "Yes", it gives me another alert saying that there is no pip installer available in the selected environment. I then tried to go inside the integrated terminal and run pip install autopep8 and it says in the terminal that it was installed successfully. But when I save the Python files, it still gives me the same alert. Check the photo below.
Open your command palette with Shift + ⌘ + P. Type in Preferences: Open Workspace Settings. I'll share the settings I use with you, some of which may be of interest:
{
"python.pythonPath": "${workspaceFolder}/backend/env/bin/python3",
"python.venvPath": "${workspaceFolder}/backend/env",
"python.linting.flake8Enabled": true,
"python.linting.flake8Path": "flake8",
"python.linting.flake8Args": ["--ignore", "E501"],
"python.linting.pylintEnabled": true,
"python.linting.pylintPath": "pylint",
"python.linting.pylintArgs": ["--load-plugins", "pylint_django"]
}
python.pythonPath is the location of the Python interpreter executable within your virtual environment. In this case it's an environment named env in a folder named backend. *${workspaceFolder} is a reference to where your project lives.
python.venvPath is the folder of your virtual environment(s).
The remaining six key/values are for enabling and execution for flake8 and pylint. Experiment with either.
Note that these are the workspace settings and not the user settings. User settings are applied across all of your Visual Studio Code projects.
How do I correctly set up the $PYTHONPATH variable for my workspace in VisualStudio Code?
Background Information
I have installed two versions of GNURadio:
GNURadio version 3.7.11 installed by the Linux Mint package manager in /usr/lib/python2.7/dist-packages/gnuradio
GNURadio version 3.7.13.4 installed by PyBOMBS in /home/tejul/Documents/gr13/default/lib/python2.7/dist-packages/gnuradio (my prefix directory is ~/Documents/gr13/default)
I can use the newer version of GNURadio version only after I run the setup_env.sh script (which -- among other things -- adds /home/tejul/Documents/gr13/default/lib/python2.7/dist-packages to $PYTHONPATH) and then start python in the terminal
tejul#Wacom:~/Documents/gr13/default$ ls
bin etc include lib libexec setup_env.sh share src
tejul#Wacom:~/Documents/gr13/default$ source ./setup_env.sh
tejul#Wacom:~/Documents/gr13/default$ python
Python 2.7.15rc1 (default, Nov 12 2018, 14:31:15)
[GCC 7.3.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from gnuradio import gr
>>> gr.version()
'3.7.13.4'
>>>
Without modifying the $PYTHONPATH python -- naturally -- imports the older version of GNURadio.
I want to write, run, and debug python scripts for the new version of GNURadio in the VisualStudio Code. I've been trying to understand the selection of python interpreters, workspaces, and environments for VSCode.
As far as I understand it, the VSCode workspace setting python.pythonPath is not to be confused with the environment variable $PYTHONPATH. python.pythonPath is the path to the python interpreter used for debugging or running the code, while $PYTHONPATH is the environment variable which python uses to search for modules.
It looks like PyBOMBS did not install its own python interpreter into my prefix directory. So I need to use VSCode with my normal python interpreter located in /usr/bin/python2.7. So redefining VSCode's python.pythonPath or selecting another python interpreter would not help me.
I need to let VSCode use my own version of the environment variable $PYTHONPATH which would tell my regular python interpreter to import modules preferably from /home/tejul/Documents/gr13/default/lib/python2.7/dist-packages.
Problem
Following the documentation, I have created my own .env file in the workspace directory which sets the order of preference for locations from which python should import the modules. Alas, it has no effect on the python interpreter.
Can you see anything that I am doing wrong here? I have also tried:
Setting the PYTHONPATH to one folder level higher, i.e. /home/tejul/Documents/gr13/default/lib/python2.7, this did not help
Calling the variable $PYTHONPATH instead of PYTHONPATH, this did not help
Restarting VSCode after each change of the .env file, this did not help
Using double quotes around the path string, e.g. PYTHONPATH="/home/tejul/Documents/gr13/default/lib/python2.7:/usr/lib/python2.7", this did not help
I have a situation that I believe is relatively common. I want a script to import a module from another directory. My python project is laid out as follows:
~/project/
|
|---modules/
|
|---mod.py
|---scripts/
|---script.py
in script.py, I have from modules import mod. So my PYTHONPATH needs to be set to ~/project/ (something that PyCharm does automatically).
VSCode is a great editor, but everywhere else, it falls short, in my opinion. This is a perfect example of that.
I create a default launch.json file to "run the current file". A "cwd": "${fileDirname}" line has to be added to make things work like they do in PyCharm (FYI, a list of the built-in variables can be found here).
Debugging
For debugging (the "play" button on the sidebar, or the F5 key), the PYTHONPATH set in launch.json or your .env file takes effect. Note that in the .env file, you cannot use variables such as ${workspaceRoot}, but you can easily append or insert to the path by using the proper separator for your platform (; for Windows and : for everyone else).
Because I want to take advantage of that variable, I put this in my launch.json:
"env": {"PYTHONPATH": "${workspaceFolder}${pathSeparator}${env:PYTHONPATH}"}
(Thanks to #someonr for the suggestion to use ${pathSeparator}.)
It appears that you can prepend/append to whatever is inherited from the environment (this is not true for settings.json; see below).
This will also work for the hotkey Ctrl+F5 (run without debugging).
For reference, here's the full file, which replicates what PyCharm does automatically:
{
"version": "0.2.0",
"configurations": [
{
"name": "Python: Current File",
"type": "python",
"request": "launch",
"program": "${file}",
"console": "integratedTerminal",
"cwd": "${fileDirname}",
"env": {"PYTHONPATH": "${workspaceFolder}${pathSeparator}${env:PYTHONPATH}"}
}
]
}
Run in terminal
If I hit the "play" button that appears on the top right of the editor window (when a python file is the active tab), it will not work. This runs the current file in a terminal, which doesn't pay attention to launch.json at all. To make that work, you have to define PYTHONPATH in a settings.json file, by adding this:
"terminal.integrated.env.osx": {"PYTHONPATH": "${workspaceFolder}"}
(Note there are different values for each platform.) If you've selected a python interpreter (e.g. from a virtual environment), you will already have a settings.json file in the .vscode directory. Mine looks like this:
{
"python.pythonPath": "/Users/me/project/venv/bin/python3",
"terminal.integrated.env.osx": {"PYTHONPATH": "${workspaceFolder}"}
}
You can't append or insert values into the inherited PYTHONPATH via the settings.json file. It will only take one string, and it will not parse separators. So even though you could get the value using ${env:PYTHONPATH}, you won't be able to do anything with it.
Moreover, you can't set the current working directory. Even though it would seem you could set it with "terminal.integrated.cwd": "${workspaceFolder}", it doesn't work. So if any of your scripts do anything with paths relative to their location in the tree, they won't work. The working directory will be your project root.
Note that any changes to the settings.json file will require that you exit the integrated terminal and restart it.
Linting
Nothing I do to launch.json regarding PYTHONPATH makes any difference to pylint, which will red-underline from modules import mod, despite the fact I can put the cursor on mod, hit F12, and the file opens. Snooping around linting settings, the defaults for mypy include --ignore-missing-imports. To replicate this behavior with pylint, add this to your settings.json:
"python.linting.pylintArgs": [
"--disable=F0401"
]
Shame that we just have to work around this, but the autocomplete helps a lot when writing the import statements to begin with.
Conclusion
There are many layers to VSCode and it's hard to get things to work together. It seems multiple environments are floating around. In the end:
I cannot "run in terminal" because I can't set the current working directory to be the path containing the current file.
I cannot set PYTHONPATH for pylint as that runs in some environment different than the integrated terminal and whatever is controlled by launch.json, so I can only tell pylint to ignore import errors.
Running with F5 works if you set PYTHONPATH either via an .env file or in launch.json
This question deserves an upvote because the documentation is missing some important details.
Example
Suppose your project layout is like this
myproject/
.vscode/
settings.json
.env
src/
a_module.py
tests/
test_a.py
Open the settings.json fie and insert these lines
"terminal.integrated.env.windows": {
"PYTHONPATH": "${workspaceFolder}/src;${workspaceFolder}/tests"
},
"python.envFile": "${workspaceFolder}/.env",
Note that ${workspaceFolder} evaluates to myproject, it is not to the .vscode folder.
In the .env file enter this
WORKSPACE_FOLDER=C:/full/path/to/myproject
PYTHONPATH=${WORKSPACE_FOLDER}/src;${WORKSPACE_FOLDER}/tests
Note that on Windows the slashes in the path lean forward, like so /. Different paths are separated with a ; (on other platforms with a :).
This blog was helpful.
OP seemed to have asked about path syntax for the .env file and the vscode set up so that it finds and reads some custom module files. My problem was similar in that I wanted code to find my custom modules for import in a script. I did not want to put my custom modules in a folder inside my python environment. I also wanted to avoid setting one or more paths as PYTHONPATH for the User Variables in the Windows Environment Variables - but this will work if you want to do it.
I am working in vscode in Windows 10.
1) SYNTAX:
a) I found that the following path syntax works in the env file:
PYTHONPATH = C:/0APPS/PYTHON/_MODULES
My .py module files are in this folder.
b) # works for comments in the .env file.
2) VSCODE SET-UP: I found that the following works:
a) Like sunew said at #2 My setup: Use the Explorer in vscode to open at your selected project workspace folder. For me that is Q:\420 PYTHON
b) Give the env file a name, like vscode.env file and place it in that folder at the top level of the workspace.
c) Open vscode settings and search .env where under the Extensions > Python you will find "Python: env file". Edit the box to add your env file name just before .env.
e.g. ${workspaceFolder}/vscode.env
d) import custom_modulename now work for me - in the python interactive window and in a script.
Setting PYTHONPATH in .env works for me.
Note that the effect just is for vscode and the tools it runs, such as pylint.
My situation:
I have a project that is not a pip installable package, but simply a source folder. (For historical reasons...)
myproject/src
The project has dependencies defined in a pip requires file.
My setup:
I create a virtualenv, and install the packages from the requires file.
I open vscode in the folder myproject - so this becomes the root of the vscode "project".
I point vscode to use the virtualenv as the python interpreter. This will make imports of dependencies installed with pip work. (For linters, intellisense, etc)
To also make imports from my project source work for the linters (pylint especially) in vscode, I add a .env with this content, adding my project source folder to the PYTHONPATH:
PYTHONPATH=./src:${PYTHONPATH}
For tools like Pyright you can edit python.analysis.extraPaths in the workspace settings.json.
Example:
{
...
"python.analysis.extraPaths": [
"src/apps",
"src/override_apps"
],
...
// next lines can be different
"python.linting.enabled": true,
"python.linting.pylintEnabled": true,
"python.linting.mypyEnabled": false,
"python.pythonPath": "environment/bin/python",
...
}
Linux user here. I had trouble getting it to work and there is a lot of interaction with other vscode Python extension settings, but the following worked for me:
Close all workspaces.
Add a single folder that you wish to be the root folder of your new workspace.
Put your .env file there containing PYTHONPATH=/path/to/a:/path/to/b on a single line by itself. Do not use double quotes around the value.
Restart vscode
Create a test.py script that imports a package or module within your folder
vscode should allow your import statement, and should autocomplete to code within your folder.
Edit settings.json in your vs code workspace folder
{
"python.pythonPath": "*python package path*",
"terminal.integrated.env.windows": {
"PYTHONPATH": "${workspaceFolder}/*sub folder*;*python package path*"
},
"python.defaultInterpreterPath": "*path to python exe*",
"python.analysis.extraPaths": [
"*python package path*",
"*python package path*"
],
"python.autoComplete.extraPaths": [
"*python package path*",
"*python package path*"
]}
Works good!
I also had a similar issue where I was using the vs-code on a remote server over ssh, the server had multiple user-accounts so the typical ubuntu python path did not work for me.
The easiest way, I have found for doing debugging was to first find out my own python install location using "which python". The output would be something like "/home/user_name/anaconda3/bin/python".
Then in vs-code, I manually set the python interpreter location to be the above location. I did this by clicking on the python tab on the bottom of vs code. like the Python 3.8.5 64-bit in this picture.
This will open the command pallete asking for the location of python interpreter, as shown in this image. manually put the location of python install here.
After doing all these steps, my python debugging is working smoothly.
Running VSCode 1.6.2, with Python extension v2021.10.1365161279 on Windows 10.
Debugging works based on the env file, I used the default file .env:
PYTHONPATH=<full_path_to_the_workspace_folder>
Running works based on the .vscode/settings.json file with such a setting
"terminal.integrated.env.windows": {"PYTHONPATH": "<full_path_to_the_workspace_folder>"}
just that I found I needed to disable+reload+enable the extension if I changed the path.
Two other issues that I spent a long time figuring out (despite the great answers above) which may help others:
Make sure that you have configured VS Code to allow terminal
configurations to amend your shell settings (via Manage Workspace
Shell Permissions (see
https://code.visualstudio.com/docs/editor/integrated-terminal#_configuration). Otherwise VS Code silently ignores your
terminal.integrated.env.{platform} settings.
Pylint will only search for other modules in the worspace directory if the module from which it is launched is in a folder which is a package (ie has _init_.py file) (See https://docs.pylint.org/en/1.6.0/run.html) meaning that pylint will continue to highlight import errors despite the code running properly due to the VS Code launch.json configured as above.
These are 3 different ways to solve the issue :
1/ Editing PYTHONPATH :
export PYTHONPATH=/Users/.../Projects/MyNewProject/src
python3 myfile.py to run the file
2/ Editing VSCode settings :
add "terminal.integrated.env.osx": {"PYTHONPATH": "${workspaceFolder}/src"} to settings.json in VScode
3/ Adding a setup.py file to your src/ directory.
create the file src/setup.py
from setuptools import find_packages, setup
setup(
name="sample",
description="Sample Python Project",
packages=find_packages(),
)
run python -m pip install -e ./src/ to install all modules in src/ as packages
After for reasons unknown my .venv/Lib/site-packages/.pth solution failed, as well as my subsequent .vscode\settings.json one, and an .env didn't work on my Windows 10*, I settled for the environment-independent way to import ./src/lib.py in ./test/test_lib.py:
import os, sys
sys.path.append(os.path.join(os.path.dirname(__file__), '../src'))
from lib import foo
That also works in non-IDE terminals, and VS Code's pycodestyle still complains when I forget an extra newline between functions.
*: VS Code 1.70.0 release note:
Loading environment variables from .env files
A number of fixes have been made to loading environment variables from
.env files, including detecting changes to the .env files. Python
kernels will now load environment variables from the file defined in
the setting python.envFile.
Using VS Code, a pip virtual env, you can put at the end of the .venv/bin/activate file:
export PYTHONPATH="${PYTHONPATH}:/path/to/your/package"
package -> module1 -> abc.py and you can use: import module.abc etc.