debugpy 1.8.21__tar.gz → 1.8.22__tar.gz

{debugpy-1.8.21/src/debugpy.egg-info → debugpy-1.8.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: debugpy
-Version: 1.8.21
+Version: 1.8.22
 Summary: An implementation of the Debug Adapter Protocol for Python
 Home-page: https://aka.ms/debugpy
 Author: Microsoft Corporation
@@ -8,19 +8,18 @@ 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: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 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
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author

{debugpy-1.8.21 → debugpy-1.8.22}/README.md

@@ -100,6 +100,24 @@ while True:
     ...
 ```
 
+### `trigger_exception_handler()` function
+`debugpy.trigger_exception_handler(e)` starts post-mortem debugging of a caught exception, similar in spirit to `pdb.post_mortem()`: if a client is attached, it pauses execution as if the exception were uncaught. Pass an exception, a `(type, value, traceback)` tuple, or nothing inside an except block to use the current exception. On resume the program continues as normal; if no client is attached the call does nothing, like `breakpoint()`.
+
+By default (`as_uncaught=True`) the stop respects the exception breakpoint configuration in the debugger UI: if breaking on uncaught exceptions isn't enabled, or its filters exclude the exception, nothing happens. Pass `as_uncaught=False` to stop unconditionally. Since the traceback has already been unwound, you can inspect frames and evaluate expressions at the stop, but not step through the code that raised.
+
+```python
+import debugpy
+debugpy.listen(...)
+
+...
+def risky_function():
+    raise ValueError("threw an exception")
+try:
+    risky_function()
+except Exception as e:
+    debugpy.trigger_exception_handler(e)
+```
+
 ## Debugger logging
 
 To enable debugger internal logging via CLI, the `--log-to` switch can be used:

{debugpy-1.8.21 → debugpy-1.8.22}/pyproject.toml

@@ -14,13 +14,15 @@ exclude = '''
 '''
 
 [tool.pyright]
-pythonVersion = "3.8"
+pythonVersion = "3.10"
 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 = "." }
 ]
+typeCheckingMode = "standard"
+enableTypeIgnoreComments = false
 
 [tool.ruff]
 # Enable the pycodestyle (`E`) and Pyflakes (`F`) rules by default.
@@ -71,8 +73,8 @@ 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"
+# Assume Python 3.10
+target-version = "py310"
 
 [tool.ruff.per-file-ignores]
 "tests/debugpy/test_breakpoints.py" = ["F841"]

{debugpy-1.8.21 → debugpy-1.8.22}/setup.py

@@ -160,16 +160,15 @@ if __name__ == "__main__":
         project_urls={
             "Source": "https://github.com/microsoft/debugpy",
         },
-        python_requires=">=3.8",
+        python_requires=">=3.10",
         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",
             "Programming Language :: Python :: 3.13",
             "Programming Language :: Python :: 3.14",
+            "Programming Language :: Python :: 3.15",
             "Topic :: Software Development :: Debuggers",
             "Operating System :: Microsoft :: Windows",
             "Operating System :: MacOS",

{debugpy-1.8.21 → debugpy-1.8.22}/src/debugpy/__init__.py

@@ -20,6 +20,7 @@ __all__ = [  # noqa
     "listen",
     "log_to",
     "trace_this_thread",
+    "trigger_exception_handler",
     "wait_for_client",
 ]
 

{debugpy-1.8.21 → debugpy-1.8.22}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_additional_thread_info_regular.py

@@ -63,6 +63,7 @@ class PyDBAdditionalThreadInfo(object):
         "pydev_use_scoped_step_frame",
         "weak_thread",
         "is_in_wait_loop",
+        "hit_breakpoint_ids",
     ]
     # ENDIF
     # fmt: on
@@ -118,6 +119,7 @@ class PyDBAdditionalThreadInfo(object):
         # at this time (otherwise it may be suspended but still didn't reach a point.
         # to pause).
         self.is_in_wait_loop = False
+        self.hit_breakpoint_ids = None
 
     # fmt: off
     # IFDEF CYTHON

{debugpy-1.8.21 → debugpy-1.8.22}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_breakpoints.py

@@ -1,6 +1,6 @@
 from _pydev_bundle import pydev_log
 from _pydevd_bundle import pydevd_import_class
-from _pydevd_bundle.pydevd_frame_utils import add_exception_to_frame
+from _pydevd_bundle.pydevd_frame_utils import exception_on_frame
 from _pydev_bundle._pydev_saved_modules import threading
 
 
@@ -76,7 +76,8 @@ class LineBreakpoint(object):
 
 
 class FunctionBreakpoint(object):
-    def __init__(self, func_name, condition, expression, suspend_policy="NONE", hit_condition=None, is_logpoint=False):
+    def __init__(self, breakpoint_id, func_name, condition, expression, suspend_policy="NONE", hit_condition=None, is_logpoint=False):
+        self.breakpoint_id = breakpoint_id
         self.condition = condition
         self.func_name = func_name
         self.expression = expression
@@ -155,14 +156,16 @@ def stop_on_unhandled_exception(py_db, thread, additional_info, arg):
         return
 
     frames_byid = dict([(id(frame), frame) for frame in frames])
-    add_exception_to_frame(user_frame, arg)
-    if exception_breakpoint.condition is not None:
-        eval_result = py_db.handle_breakpoint_condition(additional_info, exception_breakpoint, user_frame)
-        if not eval_result:
-            return
-
-    if exception_breakpoint.expression is not None:
-        py_db.handle_breakpoint_expression(exception_breakpoint, additional_info, user_frame)
+    # Attach __exception__ so conditions/expressions can reference it; always
+    # detach as the thread may keep running (do_stop re-adds it while suspended).
+    with exception_on_frame(user_frame, arg):
+        if exception_breakpoint.condition is not None:
+            eval_result = py_db.handle_breakpoint_condition(additional_info, exception_breakpoint, user_frame)
+            if not eval_result:
+                return
+
+        if exception_breakpoint.expression is not None:
+            py_db.handle_breakpoint_expression(exception_breakpoint, additional_info, user_frame)
 
     try:
         additional_info.pydev_message = exception_breakpoint.qname

{debugpy-1.8.21 → debugpy-1.8.22}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_comm.py

@@ -68,6 +68,7 @@ import os
 
 from _pydev_bundle.pydev_imports import _queue
 from _pydev_bundle._pydev_saved_modules import time, ThreadingEvent
+from _pydev_bundle._pydev_saved_modules import threading
 from _pydev_bundle._pydev_saved_modules import socket as socket_module
 from _pydevd_bundle.pydevd_constants import (
     DebugInfoHolder,
@@ -83,6 +84,7 @@ from _pydevd_bundle.pydevd_constants import (
     silence_warnings_decorator,
     filter_all_warnings,
     IS_PY311_OR_GREATER,
+    PYDEVD_UNBLOCK_THREADS_ON_VARIABLES_TIMEOUT,
 )
 from _pydev_bundle.pydev_override import overrides
 import weakref
@@ -796,8 +798,22 @@ def internal_get_variable_json(py_db, request):
         except KeyError:
             pass
         else:
-            for child_var in variable.get_children_variables(fmt=fmt, scope=scope):
-                variables.append(child_var.get_var_data(fmt=fmt))
+            # Resolving the children of a variable may block on another (suspended) thread -- e.g. a
+            # property getter that dispatches work to a background event loop thread. Since all
+            # threads are suspended at a breakpoint, that would deadlock the debugger. If it takes
+            # too long, resume the other threads until it completes (and re-suspend afterwards).
+            timeout_message = (
+                "pydevd: Resolving variable children is taking too long (it may be waiting on another "
+                "thread). Resuming other threads until it finishes so the debugger doesn't hang."
+            )
+            with pydevd_vars.unblock_threads_on_timeout(
+                py_db,
+                threading.current_thread(),
+                PYDEVD_UNBLOCK_THREADS_ON_VARIABLES_TIMEOUT,
+                on_timeout_message=timeout_message,
+            ):
+                for child_var in variable.get_children_variables(fmt=fmt, scope=scope):
+                    variables.append(child_var.get_var_data(fmt=fmt))
     except:
         try:
             exc, exc_type, tb = sys.exc_info()

{debugpy-1.8.21 → debugpy-1.8.22}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_constants.py

@@ -364,6 +364,21 @@ PYDEVD_THREAD_DUMP_ON_WARN_EVALUATION_TIMEOUT = is_true_in_env("PYDEVD_THREAD_DU
 # elapses.
 PYDEVD_UNBLOCK_THREADS_TIMEOUT = as_float_in_env("PYDEVD_UNBLOCK_THREADS_TIMEOUT", -1.0)
 
+# This timeout is used only when the mode that all threads are stopped/resumed at once is used
+# (i.e.: multi_threads_single_notification).
+#
+# When resolving the children of a variable (i.e.: expanding it in the variables view), computing
+# one of its attributes may end up blocked waiting on another (currently suspended) thread -- for
+# instance a property getter that dispatches work to a background event loop running in another
+# thread. As all threads are suspended at a breakpoint, that would deadlock the debugger.
+#
+# If the resolution doesn't finish until this timeout elapses, we resume all other threads until it
+# finishes (and then suspend them again) so that such computations can complete instead of hanging
+# forever.
+#
+# A negative value disables this behavior.
+PYDEVD_UNBLOCK_THREADS_ON_VARIABLES_TIMEOUT = as_float_in_env("PYDEVD_UNBLOCK_THREADS_ON_VARIABLES_TIMEOUT", 3.0)
+
 # Timeout to interrupt a thread (so, if some evaluation doesn't finish until this
 # timeout, the thread doing the evaluation is interrupted).
 # A value <= 0 means this is disabled.