Import Upstream version 1.6.6+ds

.CodeQL.yml

+path_classifiers:
+  library:
+    - "src/debugpy/_vendored/pydevd"
+        
\ No newline at end of file

.coveragerc

+[run]
+branch = True
+parallel = True
+include =
+    src/debugpy/*
+omit =
+    src/debugpy/__init__.py
+    src/debugpy/_version.py
+    src/debugpy/_vendored/*
+    src/debugpy/server/*
+data_file = coverage/.coverage
+
+[report]
+exclude_lines =
+    # Have to re-enable the standard pragma.
+    pragma: no cover
+
+    # __repr__ is mostly used for error messages.
+    def __repr__
+
+    # Asserts and error conditions.
+    raise AssertionError
+    raise NotImplementedError
+    \.isnt_valid\(
+    \.cant_handle\(
+
+    # Code that's deliberately excluded.
+    if 0:
+    if __name__ == .__main__.:
+ 
+[html]
+directory = coverage/html
+title = debugpy coverage report
+
+[xml]
+output = coverage/coverage.xml

.env

+PYTHONPATH=./src

.flake8

+[flake8]
+ignore = W,BLK,
+    E24,E121,E123,E125,E126,E221,E226,E266,E704,
+    E265,E722,E501,E731,E306,E401,E302,E222,E303,
+    E402,E305,E261,E262,E203
+exclude =
+    .eggs,
+    .git,
+    .tox,
+    build,
+    dist,
+    versioneer.py,
+    src/debugpy/_vendored/pydevd

.gitattributes

+src/debugpy/_version.py export-subst

.github/CODEOWNERS

+# https://help.github.com/en/articles/about-code-owners
+
+# Absolute paths match from root of the repository. Relative paths match anywhere
+# in the repository, i.e. bar/baz will match /bar/baz and /foo/bar/baz.
+
+# The default owners for everything that is not overridden by specific patterns below.
+* @int19h @karthiknadig
+
+# Order is important: the last matching pattern overrides all the preceding ones.
+/src/ptvsd/_vendored/pydevd/ @fabioz

.github/ISSUE_TEMPLATE/bug_report.md

+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+Before creating a new issue, please check the [FAQ](https://github.com/microsoft/debugpy/wiki/FAQ) to see if your question is answered there.
+
+## Environment data
+
+- debugpy version: XXX (run `import debugpy; print(debugpy.__version__)` if uncertain)
+- OS and version: XXX
+- Python version (& distribution if applicable, e.g. Anaconda): XXX
+- Using VS Code or Visual Studio:
+
+## Actual behavior
+
+XXX
+
+## Expected  behavior
+
+XXX
+
+## Steps to reproduce:
+1. XXX

.github/ISSUE_TEMPLATE/feature_request.md

+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+

.github/workflows/codeql.yml

+name: "Code scanning - action"
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: "0 19 * * 0"
+    
+permissions:
+  security-events: write    
+
+jobs:
+  CodeQL-Build:
+    # CodeQL runs on ubuntu-latest and windows-latest
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: python
+
+      # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+      # If this step fails, then you should remove it and run the build manually (see below)
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v2
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2

.gitignore

+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+pip-wheel-metadata/
+sdist/
+var/
+wheels/
+wheelhouse/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+coverage/html/
+coverage/coverage.xml
+tests/_logs/*.log
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# vs code and vs
+.vs/
+.vscode/*
+!.vscode/launch.json
+
+# PyDev
+.project
+.pydevproject
+.settings
+
+# Backup files
+*.bak

.sonarcloud.properties

+sonar.sources=src/debugpy
+sonar.exclusions=src/debugpy/_vendored/**/*,src/debugpy/_version.py
+sonar.cfamily.build-wrapper-output.bypass=true
+sonar.c.file.suffixes=-
+sonar.cpp.file.suffixes=-
+sonar.objc.file.suffixes=-
+sonar.tests=tests

.vscode/launch.json

+{
+    // 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": "Launch: program",
+            "type": "python",
+            "request": "launch",
+            "console": "integratedTerminal",
+            "program": "${file}",
+            "logToFile": true,
+            "debugAdapterPath": "${workspaceFolder}/src/debugpy/adapter"
+        },
+        {
+            "name": "Launch: module",
+            "type": "python",
+            "request": "launch",
+            "console": "integratedTerminal",
+            "module": "${fileBasenameNoExtension}",
+            "cwd": "${fileDirname}",
+            "logToFile": true,
+            "debugAdapterPath": "${workspaceFolder}/src/debugpy/adapter"
+        },
+        {
+            "name": "Launch: code",
+            "type": "python",
+            "request": "launch",
+            "console": "integratedTerminal",
+            "code": ["import runpy", "runpy.run_path(r'${file}')"],
+            "logToFile": true,
+            "debugAdapterPath": "${workspaceFolder}/src/debugpy/adapter"
+        },
+        {
+            "name": "Attach: connect",
+            "type": "python",
+            "request": "attach",
+            "connect": {
+                "port": 5678,
+                "host": "127.0.0.1"
+            },
+            "logToFile": true,
+            "debugAdapterPath": "${workspaceFolder}/src/debugpy/adapter"
+        },
+        {
+            "name": "Attach: listen",
+            "type": "python",
+            "request": "attach",
+            "listen": {
+                "port": 5678,
+                "host": "127.0.0.1"
+            },
+            "logToFile": true,
+            "debugAdapterPath": "${workspaceFolder}/src/debugpy/adapter"
+        },
+        {
+            "name": "Attach: PID",
+            "type": "python",
+            "request": "attach",
+            "processId": "${command:pickProcess}",
+            "debugAdapterPath": "${workspaceFolder}/src/debugpy/adapter"
+        },
+        {
+            "name": "Debug Tests",
+            "type": "python",
+            "request": "launch",
+            "console": "integratedTerminal",
+            "purpose": ["debug-test"],
+            "debugAdapterPath": "${workspaceFolder}/src/debugpy/adapter"
+        }
+    ]
+}

CODE_OF_CONDUCT.md

+# Microsoft Open Source Code of Conduct
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+
+Resources:
+
+- [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/)
+- [Microsoft Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+- Contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with questions or concerns

CONTRIBUTING.md

+# Contributing to `debugpy`
+
+[![Build Status](https://dev.azure.com/debugpy/debugpy/_apis/build/status/debugpy-test-automation?branchName=main)](https://dev.azure.com/debugpy/debugpy/_build/latest?definitionId=1&branchName=main)
+[![GitHub](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://raw.githubusercontent.com/microsoft/debugpy/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/ptvsd.svg)](https://pypi.org/project/ptvsd/)
+
+
+## Contributing a pull request
+This project welcomes contributions and suggestions. Most contributions require you to agree to a
+Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
+the rights to use your contribution. For details, visit https://cla.microsoft.com.
+
+When you submit a pull request, a CLA-bot will automatically determine whether you need to provide
+a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions
+provided by the bot. You will only need to do this once across all repos using our CLA.
+
+## Development tools
+
+The following tools are required to work on debugpy:
+
+- At least one version of [Python 3](https://www.python.org/downloads/)
+- [Python 2.7](https://www.python.org/downloads/release/python-2717/) (to run tests)
+- [Flake8](http://flake8.pycqa.org/en/stable/)
+- [Black](https://black.readthedocs.io/en/stable/)
+- [tox](https://tox.readthedocs.io/en/latest/)
+
+We recommend using [Visual Studio Code](https://code.visualstudio.com/) with the (Python extension)[https://marketplace.visualstudio.com/items?itemName=ms-python.python] to work on debugpy, but it's not a requirement. A workspace file, [debugpy.code-workspace], is provided for the convenience of VSCode users, and sets it up to use the other tools listed above properly.
+
+Tools that are Python packages should be installed via pip corresponding to the Python 3 installation. On Windows:
+```
+...> py -m pip install black flake8 tox
+```
+On Linux or macOS:
+```
+...$ python3 -m pip install black flake8 tox
+```
+
+## Linting
+We use Flake8 for linting. It should be run from the root of the repository, where [.flake8](.flake8) with project-specific linting settings is located. On Windows:
+```
+...\debugpy> py -m flake8
+```
+On Linux or macOS:
+```
+.../debugpy$ python3 -m flake8
+```
+
+## Formatting
+We use Black for formatting. All new code files, and all code files that were edited, should be reformatted before submitting a PR. On Windows:
+```
+...\debugpy> py -m black
+```
+On Linux or macOS:
+```
+.../debugpy$ python3 -m black
+```
+
+## Running tests
+
+We use tox to run tests in an isolated environment. This ensures that debugpy is first built as a package, and tox also takes care of installing all the test prerequisites into the environment. On Windows:
+```
+...\debugpy> py -m tox
+```
+On Linux or macOS:
+```
+.../debugpy$ python3 -m tox
+```
+This will perform a full run with the default settings. A full run will run tests on Python 2.7 and 3.5-3.8, and requires all of those to be installed. If some versions are missing, or it is desired to skip them for a particular run, tox can be directed to only run tests on specific versions with `-e`. In addition, the `--developer` option can be used to skip the packaging step, running tests directly against the source code in `src/debugpy`. This should only be used when iterating on the code, and a proper run should be performed before submitting a PR. On Windows:
+```
+...\debugpy> py -m tox -e py27,py37 --develop
+```
+On Linux or macOS:
+```
+.../debugpy$ python3 -m tox -e py27,py37 --develop
+```
+
+### Running tests without tox
+
+While tox is the recommended way to run the test suite, pytest can also be invoked directly from the root of the repository. This requires packages in tests/test_requirements.txt to be installed first.
+
+## Using modified debugpy in Visual Studio Code
+To test integration between debugpy and Visual Studio Code, the latter can be directed to use a custom version of debugpy in lieu of the one bundled with the Python extension. This is done by specifying `"debugAdapterPath"` in `launch.json` - it must point at the root directory of the *package*, which is `src/debugpy` inside the repository:
+
+```json5
+{
+    "type": "python",
+    "debugAdapterPath": ".../debugpy/src/debugpy/adapter",
+    ...
+}
+```

DESCRIPTION.md

+debugpy is an implementation of the Debug Adapter Protocol for Python.
+
+The source code and the issue tracker is [hosted on GitHub](https://github.com/microsoft/debugpy/).

LICENSE

+    debugpy
+
+    Copyright (c) Microsoft Corporation
+    All rights reserved.
+
+    MIT License
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy of
+    this software and associated documentation files (the "Software"), to deal in
+    the Software without restriction, including without limitation the rights to
+    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+    the Software, and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+    FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+    COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

MANIFEST.in

+include LICENSE
+include DESCRIPTION.md
+global-exclude *.py[cdo]
+include versioneer.py
+include src/debugpy/_version.py

README.md

+# debugpy - a debugger for Python
+
+An implementation of the [Debug Adapter Protocol](https://microsoft.github.io/debug-adapter-protocol/) for Python 3.
+
+[![Build Status](https://dev.azure.com/debugpy/debugpy/_apis/build/status/debugpy-test-automation?branchName=main)](https://dev.azure.com/debugpy/debugpy/_build/latest?definitionId=1&branchName=main)
+[![GitHub](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://raw.githubusercontent.com/microsoft/debugpy/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/debugpy.svg)](https://pypi.org/project/debugpy/)
+[![PyPI](https://img.shields.io/pypi/pyversions/debugpy.svg)](https://pypi.org/project/debugpy/)
+
+#### Coverage
+
+| OS | Coverage |
+|---|---|
+| Windows | ![Azure DevOps coverage](https://img.shields.io/azure-devops/coverage/debugpy/debugpy/2) |
+| Linux | ![Azure DevOps coverage](https://img.shields.io/azure-devops/coverage/debugpy/debugpy/3) |
+| Mac | ![Azure DevOps coverage](https://img.shields.io/azure-devops/coverage/debugpy/debugpy/4) |
+
+## `debugpy` CLI Usage
+### Debugging a script file
+To run a script file with debugging enabled, but without waiting for the client to attach (i.e. code starts executing immediately):
+```console
+-m debugpy --listen localhost:5678 myfile.py
+```
+To wait until the client attaches before running your code, use the `--wait-for-client` switch.
+```console
+-m debugpy --listen localhost:5678 --wait-for-client myfile.py
+```
+The hostname passed to `--listen` specifies the interface on which the debug adapter will be listening for connections from DAP clients. It can be omitted, with only the port number specified:
+```console
+-m debugpy --listen 5678 ...
+```
+in which case the default interface is 127.0.0.1.
+
+To be able to attach from another machine, make sure that the adapter is listening on a public interface - using `0.0.0.0` will make it listen on all available interfaces:
+```console
+-m debugpy --listen 0.0.0.0:5678 myfile.py
+```
+This should only be done on secure networks, since anyone who can connect to the specified port can then execute arbitrary code within the debugged process.
+
+To pass arguments to the script, just specify them after the filename. This works the same as with Python itself - everything up to  the filename is processed by debugpy, but everything after that becomes `sys.argv` of the running process.
+
+### Debugging a module
+To run a module, use the `-m` switch instead of filename:
+```console
+-m debugpy --listen localhost:5678 -m mymodule
+```
+Same as with scripts, command line arguments can be passed to the module by specifying them after the module name. All other debugpy switches work identically in this mode; in particular, `--wait-for-client` can be used to block execution until the client attaches.
+
+### Attaching to a running process by ID
+The following command injects the debugger into a process with a given PID that is running Python code. Once the command returns, a debugpy server is running within the process, as if that process was launched via `-m debugpy` itself.
+```console
+-m debugpy --listen localhost:5678 --pid 12345
+```
+
+### Ignoring subprocesses
+The following command will ignore subprocesses started by the debugged process.
+```console
+-m debugpy --listen localhost:5678 --pid 12345 --configure-subProcess False
+```
+
+
+## `debugpy` Import usage
+### Enabling debugging
+At the beginning of your script, import debugpy, and call `debugpy.listen()` to start the debug adapter, passing a `(host, port)` tuple as the first argument.
+```python
+import debugpy
+debugpy.listen(("localhost", 5678))
+...
+```
+As with the `--listen` command line switch, hostname can be omitted, and defaults to `"127.0.0.1"`:
+```python
+debugpy.listen(5678)
+...
+```
+
+### Waiting for the client to attach
+Use the `debugpy.wait_for_client()` function to block program execution until the client is attached.
+```python
+import debugpy
+debugpy.listen(5678)
+debugpy.wait_for_client()  # blocks execution until client is attached
+...
+```
+
+### `breakpoint()` function
+Where available, debugpy supports the standard `breakpoint()` function for programmatic breakpoints. Use `debugpy.breakpoint()` function to get the same behavior when `breakpoint()` handler installed by debugpy is overridden by another handler. If the debugger is attached when either of these functions is invoked, it will pause execution on the calling line, as if it had a breakpoint set. If there's no client attached, the functions do nothing, and the code continues to execute normally.
+```python
+import debugpy
+debugpy.listen(...)
+
+while True:
+    ...
+    breakpoint()  # or debugpy.breakpoint()
+    ...
+```
+
+## Debugger logging
+
+To enable debugger internal logging via CLI, the `--log-to` switch can be used:
+```console
+-m debugpy --log-to path/to/logs ...
+```
+
+When using the API, the same can be done with `debugpy.log_to()`:
+```py
+debugpy.log_to('path/to/logs')
+debugpy.listen(...)
+```
+
+In both cases, the environment variable `DEBUGPY_LOG_DIR` can also be set to the same effect.
+
+When logging is enabled, debugpy will create several log files with names matching `debugpy*.log` in the specified directory, corresponding to different components of the debugger. When subprocess debugging is enabled, separate logs are created for every subprocess.

SECURITY.md

+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.3 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets Microsoft's [Microsoft's definition of a security vulnerability](https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)) of a security vulnerability, please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the the [Microsoft Security Response Center PGP Key page](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc).
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

TROUBLESHOOTING.md

+# Troubleshooting
+
+If you're having trouble with debugpy, check below for information which may help. If something isn't covered here, please file an issue with the information given in [Filing an issue](#filing-an-issue).
+
+## Known Issues
+
+There are a few known issues in the current version of the debugger:
+
+### Breakpoints not set
+If you receive an error saying **breakpoint not set**, then look at your path mappings in `launch.json`. See Meta-Issue [#2976](https://github.com/Microsoft/vscode-python/issues/2976) for more details. 
+
+### Debugging Library Files
+If you want to debug library files, you have to disable `justMyCode` in `launch.json`. Previously this setting was `debugStdLib`. For example:
+```js
+{
+    "name": "Terminal",
+    "type": "python",
+    "request": "launch",
+    "pythonPath": "${config:python.pythonPath}",
+    "program": "${file}",
+    "console": "integratedTerminal",
+    "justMyCode": false
+},
+```
+
+## Filing an issue
+
+When filing an issue, make sure you do the following:
+
+- Check existing issues for the same problem (also see the "Known Issues" section above for widespread problems).
+- Follow instructions in [this](https://github.com/microsoft/debugpy/blob/main/.github/ISSUE_TEMPLATE/bug_report.md) template for filing a bug report.
+- Include any debugger logs that you may have. See [here](https://github.com/microsoft/debugpy#debugger-logging) for instructions on how to enable logging.