debugpy 1.8.10__tar.gz

debugpy-1.8.10/DESCRIPTION.md

@@ -0,0 +1,3 @@
+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/).

debugpy-1.8.10/LICENSE

@@ -0,0 +1,24 @@
+    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.
+

debugpy-1.8.10/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include DESCRIPTION.md
+global-exclude *.py[cdo]
+include versioneer.py
+include src/debugpy/_version.py

debugpy-1.8.10/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: debugpy
+Version: 1.8.10
+Summary: An implementation of the Debug Adapter Protocol for Python
+Home-page: https://aka.ms/debugpy
+Author: Microsoft Corporation
+Author-email: ptvshelp@microsoft.com
+License: MIT
+Project-URL: Source, https://github.com/microsoft/debugpy
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+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/).

debugpy-1.8.10/README.md

@@ -0,0 +1,118 @@
+# 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
+
+For full details, see the [Command Line Reference](https://github.com/microsoft/debugpy/wiki/Command-Line-Reference).
+
+### 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
+
+For full details, see the [API reference](https://github.com/microsoft/debugpy/wiki/API-Reference).
+
+### 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.

debugpy-1.8.10/pyproject.toml

@@ -0,0 +1,79 @@
+[build-system]
+requires = ["wheel", "setuptools"]
+build-backend = "setuptools.build_meta"
+
+
+[tool.black]
+exclude = '''
+( __pycache__
+| ^/.tox
+| ^/versioneer.py
+| ^/src/debugpy/_vendored
+| ^/src/debugpy/_version.py
+)
+'''
+
+[tool.pyright]
+pythonVersion = "3.8"
+include = ["src/**", "tests/**" ]
+extraPaths = ["src/debugpy/_vendored/pydevd", "src/debugpy/_vendored/pydevd/pydevd_attach_to_process"]
+ignore = ["src/debugpy/_vendored/pydevd", "src/debugpy/_version.py"]
+executionEnvironments = [
+  { root = "src" }, { root = "." }
+]
+
+[tool.ruff]
+# Enable the pycodestyle (`E`) and Pyflakes (`F`) rules by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E", "F"]
+ignore = [
+    "E203", "E221", "E222", "E226", "E261", "E262", "E265", "E266",
+    "E401", "E402",
+    "E501",
+    "E722", "E731" 
+]
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+    "versioneer.py",
+    "src/debugpy/_vendored/pydevd"
+]
+
+# Same as Black.
+line-length = 88
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+# Assume Python 3.8
+target-version = "py38"
+
+[tool.ruff.per-file-ignores]
+"tests/debugpy/test_breakpoints.py" = ["F841"]
+"tests/debugpy/test_output.py" = ["F841"]

debugpy-1.8.10/setup.cfg

@@ -0,0 +1,18 @@
+[metadata]
+license_files = LICENSE
+
+[versioneer]
+VCS = git
+style = pep440
+versionfile_source = src/debugpy/_version.py
+versionfile_build = debugpy/_version.py
+tag_prefix = v
+parentdir_prefix = debugpy-
+
+[aliases]
+test = pytest
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

debugpy-1.8.10/setup.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python
+
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+import os
+import os.path
+import setuptools
+import subprocess
+import sys
+
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import versioneer  # noqa
+
+del sys.path[0]
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "src"))
+import debugpy
+import debugpy._vendored
+
+del sys.path[0]
+
+
+PYDEVD_ROOT = debugpy._vendored.project_root("pydevd")
+DEBUGBY_ROOT = os.path.dirname(os.path.abspath(debugpy.__file__))
+
+
+def get_buildplatform():
+    if "-p" in sys.argv:
+        return sys.argv[sys.argv.index("-p") + 1]
+    return None
+
+
+# bdist_wheel determines whether the package is pure or not based on ext_modules.
+# However, all pydevd native modules are prebuilt and packaged as data, so they
+# should not be in the list.
+#
+# The proper way to handle this is by overriding has_ext_modules. However, due to
+# https://bugs.python.org/issue32957, in setuptools 57.0.0 and below, it is not
+# always called when it should be, with ext_modules tested directly instead.
+#
+# So, for non-pure builds, we provide a customized empty list for ext_modules that
+# tests as truthful - this causes the package to be treated as non-pure on all
+# relevant setuptools versions.
+class ExtModules(list):
+    def __bool__(self):
+        return True
+
+
+def override_build(cmds):
+    def finalize_options(self):
+        # Mark all packages as pure if requested to build a universal wheel.
+        # Otherwise, bdist_wheel will silently ignore the request.
+        bdist_wheel = self.distribution.get_command_obj("bdist_wheel", 0)
+        if bdist_wheel is not None and bdist_wheel.universal:
+            self.distribution.ext_modules = []
+            self.distribution.has_ext_modules = lambda: False
+        original(self)
+
+    try:
+        build = cmds["build"]
+    except KeyError:
+        from distutils.command.build import build
+    original = build.finalize_options
+    build.finalize_options = finalize_options
+
+
+def override_build_py(cmds):
+    # Add vendored packages as data files for this package, and filter platform-specific binaries
+    # in data files for binary builds.
+    def finalize_options(self):
+        original(self)
+
+        # Ensure that pydevd extensions are present for inclusion into data_files.
+        self.announce(
+            "Compiling pydevd Cython extension modules (set SKIP_CYTHON_BUILD=1 to omit)."
+        )
+        try:
+            subprocess.check_call(
+                [
+                    sys.executable,
+                    os.path.join(PYDEVD_ROOT, "setup_pydevd_cython.py"),
+                    "build_ext",
+                    "--inplace",
+                ]
+            )
+        except subprocess.SubprocessError:
+            # pydevd Cython extensions are optional performance enhancements, and debugpy is
+            # usable without them. Thus, we want to ignore build errors here by default, so
+            # that a user can do `pip install debugpy` on a platform for which we don't supply
+            # prebuild wheels even if they don't have the C build tools installed. On the other
+            # hand, for our own official builds and for local development, we want to know if
+            # the extensions fail to build.
+            if int(os.getenv("REQUIRE_CYTHON_BUILD", "0")):
+                raise
+            self.warn(
+                "Failed to compile pydevd Cython extension modules (set SKIP_CYTHON_BUILD=1 to omit); proceeding without them."
+            )
+
+        # Register pydevd and other vendored packages as package data for debugpy.
+        vendored_files = self.package_data["debugpy._vendored"]
+        for project in debugpy._vendored.list_all():
+            for filename in debugpy._vendored.iter_packaging_files(project):
+                vendored_files.append(filename)
+
+        # Don't filter anything for universal wheels.
+        if not self.distribution.ext_modules:
+            return
+
+        plat = self.get_finalized_command("build").plat_name
+
+        def is_applicable(filename):
+            def tail_is(*suffixes):
+                return any((filename.endswith(ext) for ext in suffixes))
+
+            if tail_is(".dylib"):
+                return plat.startswith("macosx")
+            if tail_is(".exe", ".dll", ".pdb", ".pyd"):
+                return plat in ("win32", "win-amd64")
+            if tail_is("-i386-linux-gnu.so", "_linux_x86.so"):
+                return plat == "linux-i686"
+            if tail_is("-x86_64-linux-gnu.so", "_linux_amd64.so"):
+                return plat == "linux-x86_64"
+            return True
+
+        vendored_files[:] = list(filter(is_applicable, vendored_files))
+
+    try:
+        build_py = cmds["build_py"]
+    except KeyError:
+        from setuptools.command.build_py import build_py
+    original = build_py.finalize_options
+    build_py.finalize_options = finalize_options
+
+
+with open("DESCRIPTION.md", "r") as fh:
+    long_description = fh.read()
+
+
+if __name__ == "__main__":
+    extras = {}
+    platforms = get_buildplatform()
+    if platforms is not None:
+        extras["platforms"] = platforms
+
+    cmds = versioneer.get_cmdclass()
+    override_build(cmds)
+    override_build_py(cmds)
+
+    setuptools.setup(
+        name="debugpy",
+        version=versioneer.get_version(),
+        description="An implementation of the Debug Adapter Protocol for Python",  # noqa
+        long_description=long_description,
+        long_description_content_type="text/markdown",
+        license="MIT",
+        author="Microsoft Corporation",
+        author_email="ptvshelp@microsoft.com",
+        url="https://aka.ms/debugpy",
+        project_urls={
+            "Source": "https://github.com/microsoft/debugpy",
+        },
+        python_requires=">=3.8",
+        classifiers=[
+            "Development Status :: 5 - Production/Stable",
+            "Programming Language :: Python :: 3.8",
+            "Programming Language :: Python :: 3.9",
+            "Programming Language :: Python :: 3.10",
+            "Programming Language :: Python :: 3.11",
+            "Programming Language :: Python :: 3.12",
+            "Topic :: Software Development :: Debuggers",
+            "Operating System :: Microsoft :: Windows",
+            "Operating System :: MacOS",
+            "Operating System :: POSIX",
+            "License :: OSI Approved :: MIT License",
+        ],
+        package_dir={"": "src"},
+        packages=[
+            "debugpy",
+            "debugpy.adapter",
+            "debugpy.common",
+            "debugpy.launcher",
+            "debugpy.server",
+            "debugpy._vendored",
+        ],
+        package_data={
+            "debugpy": ["ThirdPartyNotices.txt"],
+            "debugpy._vendored": [
+                # pydevd extensions must be built before this list can be computed properly,
+                # so it is populated in the overridden build_py.finalize_options().
+            ],
+        },
+        ext_modules=ExtModules(),
+        has_ext_modules=lambda: True,
+        cmdclass=cmds,
+        # allow the user to call "debugpy" instead of "python -m debugpy"
+        entry_points={"console_scripts": ["debugpy = debugpy.server.cli:main"]},
+        **extras
+    )