For Flask apps, you can create a launch.json configuration that will run your Flask app using VS Code's debugger. VS Code's launch.json supports a number of options, including the setting of environment variables that your Flask app needs.

Start with installing the Python extension for VS Code, to add support for "debugging of a number of types of Python applications, which includes Flask. Then, follow the Flask Tutorial from the VS Code docs.

Basically, you'll need to create a launch.json file in your workspace's .vscode folder.

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "run-flask-app",
            "type": "python",
            "request": "launch",
            "module": "flask",
            "env": {
                "FLASK_APP": "/path/to/app.py",
                "FLASK_ENV": "development",
                "FLASK_DEBUG": "0",
                "AAA": "value of AAA env var",
                "BBB": "value of BBB env var",
                "CCC": "value of CCC env var"
            },
            "args": [
                "run",
                "--no-debugger",
                "--no-reload"
            ],
            "jinja": true
        },
    ]
}

The env portion is where you set all the environment variables. By default, it includes the required FLASK_*-related variables because it uses the flask command line tool for running apps.

Here, as an example, I've also set custom AAA and BBB and CCC vars. You can access that from code as normal env vars:

@app.route('/test')
def root():
    aaa = os.environ.get("AAA")
    bbb = os.environ.get("BBB")
    ccc = os.environ.get("CCC")
    print(f'{aaa}, {bbb}, {ccc}')
    return f'{aaa}, {bbb}, {ccc}'

Then run it from the Debug panel:

Just hit the play button and you should be able to see the printed env values from the Terminal panel or from the browser after accessing the /test endpoint. (If you have multiple terminals, it should appear under the Python Debug Console).

Lastly, by saving the .vscode/launch.json file under the workspace folder, then it's workspace-specific, and it will only affect the runtime environment used to launch your Flask app.

I'm successfully passing them using the env property in launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "pwa-node",
      "request": "launch",
      "name": "Launch Program",
      "skipFiles": [
        "<node_internals>/**"
      ],
      "program": "${workspaceFolder}/index.js",
      "env": {
        "TEST_VAR": "foo"
      }
    }
  ]
}

You do not need to add activate to launch.json. You have 3 options (I prefer the first option):

1. Provide the complete path to python in the virtual environment. Here is one of my launch configurations. The python entry points to the python executable image in a virtual environment.

       {
         "justMyCode": false,
         "name": "Ancient Warmth / Django-Oscar",
         "type": "python",
         "request": "launch",
         "program": "${workspaceFolder}/manage.py",
         "python": "${env:oscar}/bin/python",
         "args": [
           "runserver",
           "--noreload",
           "0.0.0.0:8001",
         ],
         "django": true
       },
   

   Note that the above refers to an environment variable called oscar that points to the virtual environment. I define oscar in .bashrc like this:

   export oscar=/var/work/django/oscar
   

   It does not matter where the environment variable is defined, so long as it is defined before VSCode runs.

2. At the bottom of the VSCode window, near the left side, you will find the name of the Python environment being used.

   a. Click on it and a list of the workspaces drops down from the top.

   b. Select the workspace that you want to modify the Python for, then you will see a list of Python interpreters. The one you want is probably not shown, so click on "I can't find the interpreter I want to select...", then click "Find...".

   c. Navigate to your virtual environment and click on python.

3. This option is a manual way of producing the same change as option #2. Edit the file called .vscode/settings.json in your project directory and set python.pythonPath to point to the python program in your virtual environment. Here is my complete .vscode/settings.json file:

   {
     "python.linting.pylintEnabled": true,
     "python.linting.enabled": true,
     "python.pythonPath": "/var/work/django/oscar/bin/python"
   }
   

Here is an example, you set the value in the environment block.

    {
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
    {
        "name": "g++ - (GDB 9.2) Build and debug active file with RepoCodeInspection",
        "type": "cppdbg",
        "request": "launch",
        "program": "${fileDirname}/bin/${fileBasenameNoExtension}",
        "args": [],
        "stopAtEntry": false,
        "cwd": "${workspaceFolder}",
        "environment": [
            {
                "description": "same as commands below by using 'setenv ...",
                "info": "cant debug b/c of libBase/libRecipe now requiring dependency to boost for stacktrace dumps",
                "name": "LD_LIBRARY_PATH",
                "value": "/libs/:./"
            }
        ],
        "externalConsole": false,
        "MIMode": "gdb",
        "setupCommands": [
            {
                "description": "Enable pretty-printing for gdb",
                "text": "-enable-pretty-printing",
                "ignoreFailures": true
            }
        ],
        "logging": {
            "trace": false,
            "traceResponse": false
        },
        "preLaunchTask": "RepoCodeInspection",
        
    },
    {
        "name": "g++ - (GDB 9.2) Attach to a running process",
        "type": "cppdbg",
        "request": "attach",
        "processId":"${command:pickProcess}",
        "program": "${fileDirname}/bin/${fileBasenameNoExtension}",
        "MIMode": "gdb",
        "setupCommands": [
            {
                "description": "Enable pretty-printing for gdb",
                "text": "-enable-pretty-printing",
                "ignoreFailures": true
            }
        ],
        "logging": {
            "trace": false,
            "traceResponse": false
        },
        "preLaunchTask": "RepoCodeInspection",
       
    },
]

}

Using launch.json, I am not able to access the modified PYTHONPATH. In both interactive mode and Run mode, the path doesn't reflect the desired changes.

If you're running the file using the play button at the top right or its dropdown entries, or using the Python: Run Python File in Terminal or Jupyter: Run Current File in Interactive Window commands in the command palette, those don't pick on things you put in your launch.json configs as far as I know. You need to actually run the launch config from the Run and Debug View, select the launch config you want to run, and then click the play button in the Run and Debug View.

If you insist on using the Python: Run Python File in Terminal command, or actions based on that command, you can look into using the terminal.integrated.env.* VS Code settings- either in your user or workspace settings.json file. Ex.

"terminal.integrated.env.linux": {
    "PYTHONPATH": "${workspaceFolder}/conf/",
}

I'm not sure about workarounds for Jupyter notebooks though.

Inspired by my current area of work - which involved Python.

This is what I do for Flask.

MS Link

https://code.visualstudio.com/docs/python/debugging

For any regular Python debugging

Evidence

import os

for key in os.environ.keys():
    print(f"{key}={os.environ.get(key)}")

After doing a F5 in VS Code with a file containing the above snippet:

Update on Feb 18

After receiving a comment I think the OP wants to run a script before debugging the Fask application. The steps that worked for me are below.

Overview

I ended up with the following files:

• Add a PowerShell file dosomething.ps1 (my custom script which I intend to launch before every debug session)
• Add a task.json (launch dosomething.ps1)
• Edit the existing launch.json by linking it with the task in task.json

The file dosomething.ps1

Write-Host "Inside do something"
Write-Host "The value of the environment variable TEMP is $env:TEMPcls"
Write-Host "The current path of the script is $PSScriptroot"

The file tasks.json

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "my script task",
            "type": "shell",
            "windows": {
                "command": "pwsh -f dosomething.ps1"
            },
            "problemMatcher": []
        }
    ]
}

Linking the launch.json with task.json

After pressing F5

What if my environment variable is a secret that I do not want to add to launch.json ?

In my team, we place all confidential variables in a .env file and add the file to .gitignore. As per design of VS Code, it will look for a .env file in the root of the current workspace and load those variables before launching your Python script. Please refer documentaion from MS here: https://code.visualstudio.com/docs/python/environments

By default, the Python extension looks for and loads a file named .env in the current workspace folder, then applies those definitions. The file is identified by the default entry "python.envFile": "${workspaceFolder}/.env" in your user settings (see General Python settings). You can change the python.envFile setting at any time to use a different definitions file