debugpy 1.8.6__zip → 1.8.8__zip

{debugpy-1.8.6/src/debugpy.egg-info → debugpy-1.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: debugpy
-Version: 1.8.6
+Version: 1.8.8
 Summary: An implementation of the Debug Adapter Protocol for Python
 Home-page: https://aka.ms/debugpy
 Author: Microsoft Corporation

{debugpy-1.8.6 → debugpy-1.8.8}/pyproject.toml

@@ -64,7 +64,6 @@ exclude = [
     "versioneer.py",
     "src/debugpy/_vendored/pydevd"
 ]
-per-file-ignores = {}
 
 # Same as Black.
 line-length = 88
@@ -73,4 +72,8 @@ line-length = 88
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
 # Assume Python 3.8
-target-version = "py38"
+target-version = "py38"
+
+[tool.ruff.per-file-ignores]
+"tests/debugpy/test_breakpoints.py" = ["F841"]
+"tests/debugpy/test_output.py" = ["F841"]

{debugpy-1.8.6 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/_pydev_bundle/pydev_is_thread_alive.py

@@ -4,7 +4,14 @@ from _pydev_bundle._pydev_saved_modules import threading
 # circumstances).
 # It is required to debug threads started by start_new_thread in Python 3.4
 _temp = threading.Thread()
-if hasattr(_temp, "_is_stopped"):  # Python 3.x has this
+
+if hasattr(_temp, "_handle") and hasattr(_temp, "_started"):  # Python 3.13 and later has this
+
+    def is_thread_alive(t):
+        return not t._handle.is_done()
+
+
+elif hasattr(_temp, "_is_stopped"):  # Python 3.12 and earlier has this
 
     def is_thread_alive(t):
         return not t._is_stopped

{debugpy-1.8.6 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/_pydev_bundle/pydev_monkey.py

@@ -12,17 +12,14 @@ from _pydevd_bundle.pydevd_constants import (
     set_global_debugger,
     DebugInfoHolder,
     PYDEVD_USE_SYS_MONITORING,
+    IS_PY313_OR_GREATER,
 )
 from _pydev_bundle import pydev_log
 from contextlib import contextmanager
 from _pydevd_bundle import pydevd_constants, pydevd_defaults
 from _pydevd_bundle.pydevd_defaults import PydevdCustomization
 import ast
-
-try:
-    from pathlib import Path
-except ImportError:
-    Path = None
+from pathlib import Path
 
 # ===============================================================================
 # Things that are dependent on having the pydevd debugger
@@ -299,7 +296,7 @@ def remove_quotes_from_args(args):
         new_args = []
 
         for x in args:
-            if Path is not None and isinstance(x, Path):
+            if isinstance(x, Path):
                 x = str(x)
             else:
                 if not isinstance(x, (bytes, str)):
@@ -316,7 +313,7 @@ def remove_quotes_from_args(args):
     else:
         new_args = []
         for x in args:
-            if Path is not None and isinstance(x, Path):
+            if isinstance(x, Path):
                 x = x.as_posix()
             else:
                 if not isinstance(x, (bytes, str)):
@@ -1173,15 +1170,31 @@ threading_modules_to_patch = _get_threading_modules_to_patch()
 
 
 def patch_thread_module(thread_module):
-    if getattr(thread_module, "_original_start_new_thread", None) is None:
-        if thread_module is threading:
-            if not hasattr(thread_module, "_start_new_thread"):
-                return  # Jython doesn't have it.
-            _original_start_new_thread = thread_module._original_start_new_thread = thread_module._start_new_thread
+    # Note: this is needed not just for the tracing, but to have an early way to
+    # notify that a thread was created (i.e.: tests_python.test_debugger_json.test_case_started_exited_threads_protocol)
+    start_thread_attrs = ["_start_new_thread", "start_new_thread", "start_new"]
+    start_joinable_attrs = ["start_joinable_thread", "_start_joinable_thread"]
+    check = start_thread_attrs + start_joinable_attrs
+
+    replace_attrs = []
+    for attr in check:
+        if hasattr(thread_module, attr):
+            replace_attrs.append(attr)
+
+    if not replace_attrs:
+        return
+
+    for attr in replace_attrs:
+        if attr in start_joinable_attrs:
+            if getattr(thread_module, "_original_start_joinable_thread", None) is None:
+                _original_start_joinable_thread = thread_module._original_start_joinable_thread = getattr(thread_module, attr)
+            else:
+                _original_start_joinable_thread = thread_module._original_start_joinable_thread
         else:
-            _original_start_new_thread = thread_module._original_start_new_thread = thread_module.start_new_thread
-    else:
-        _original_start_new_thread = thread_module._original_start_new_thread
+            if getattr(thread_module, "_original_start_new_thread", None) is None:
+                _original_start_new_thread = thread_module._original_start_new_thread = getattr(thread_module, attr)
+            else:
+                _original_start_new_thread = thread_module._original_start_new_thread
 
     class ClassWithPydevStartNewThread:
         def pydev_start_new_thread(self, function, args=(), kwargs={}):
@@ -1191,6 +1204,19 @@ def patch_thread_module(thread_module):
             """
             return _original_start_new_thread(_UseNewThreadStartup(function, args, kwargs), ())
 
+    class ClassWithPydevStartJoinableThread:
+        def pydev_start_joinable_thread(self, function, *args, **kwargs):
+            """
+            We need to replace the original thread_module._start_joinable_thread with this function so that threads started
+            through it and not through the threading module are properly traced.
+            """
+            # Note: only handling the case from threading.py where the handle
+            # and daemon flags are passed explicitly. This will fail if some user library
+            # actually passes those without being a keyword argument!
+            handle = kwargs.pop("handle", None)
+            daemon = kwargs.pop("daemon", True)
+            return _original_start_joinable_thread(_UseNewThreadStartup(function, args, kwargs), handle=handle, daemon=daemon)
+
     # This is a hack for the situation where the thread_module.start_new_thread is declared inside a class, such as the one below
     # class F(object):
     #    start_new_thread = thread_module.start_new_thread
@@ -1200,17 +1226,15 @@ def patch_thread_module(thread_module):
     # So, if it's an already bound method, calling self.start_new_thread won't really receive a different 'self' -- it
     # does work in the default case because in builtins self isn't passed either.
     pydev_start_new_thread = ClassWithPydevStartNewThread().pydev_start_new_thread
+    pydev_start_joinable_thread = ClassWithPydevStartJoinableThread().pydev_start_joinable_thread
 
-    try:
-        # We need to replace the original thread_module.start_new_thread with this function so that threads started through
-        # it and not through the threading module are properly traced.
-        if thread_module is threading:
-            thread_module._start_new_thread = pydev_start_new_thread
+    # We need to replace the original thread_module.start_new_thread with this function so that threads started through
+    # it and not through the threading module are properly traced.
+    for attr in replace_attrs:
+        if attr in start_joinable_attrs:
+            setattr(thread_module, attr, pydev_start_joinable_thread)
         else:
-            thread_module.start_new_thread = pydev_start_new_thread
-            thread_module.start_new = pydev_start_new_thread
-    except:
-        pass
+            setattr(thread_module, attr, pydev_start_new_thread)
 
 
 def patch_thread_modules():
@@ -1235,6 +1259,16 @@ def undo_patch_thread_modules():
         except:
             pass
 
+        try:
+            t._start_joinable_thread = t._original_start_joinable_thread
+        except:
+            pass
+
+        try:
+            t.start_joinable_thread = t._original_start_joinable_thread
+        except:
+            pass
+
 
 def disable_trace_thread_modules():
     """

{debugpy-1.8.6 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_additional_thread_info_regular.py

@@ -10,6 +10,7 @@ from _pydevd_bundle.pydevd_constants import (
 )
 from _pydev_bundle import pydev_log
 from _pydev_bundle._pydev_saved_modules import threading
+from _pydev_bundle.pydev_is_thread_alive import is_thread_alive
 import weakref
 
 version = 11
@@ -135,7 +136,7 @@ class PyDBAdditionalThreadInfo(object):
         if thread is None:
             return False
 
-        if thread._is_stopped:
+        if not is_thread_alive(thread):
             return None
 
         if thread._ident is None:  # Can this happen?

{debugpy-1.8.6 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_api.py

@@ -83,7 +83,8 @@ else:
             # bodies of nested class and function definitions, as they have their
             # own objects.
             for _, lineno in dis.findlinestarts(code):
-                yield lineno
+                if lineno is not None:
+                    yield lineno
 
             # For nested class and function definitions, their respective code objects
             # are constants referenced by this object.

{debugpy-1.8.6 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_collect_bytecode_info.py

@@ -846,6 +846,8 @@ class _Disassembler(object):
         argrepr = instruction.argrepr
         if isinstance(argrepr, str) and argrepr.startswith("NULL + "):
             argrepr = argrepr[7:]
+        if isinstance(argrepr, str) and argrepr.endswith("+ NULL"):
+            argrepr = argrepr[:-7]
         return _MsgPart(line, tok if tok is not None else dec(instruction, argrepr))
 
     def _next_instruction_to_str(self, line_to_contents):

{debugpy-1.8.6 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_comm.py

@@ -1140,7 +1140,8 @@ def internal_get_next_statement_targets(dbg, seq, thread_id, frame_id):
                 xml += "<line>%d</line>" % (frame.f_lineno,)
             else:
                 for _, line in linestarts:
-                    xml += "<line>%d</line>" % (line,)
+                    if line is not None:
+                        xml += "<line>%d</line>" % (line,)
             del frame
             xml += "</xml>"
             cmd = dbg.cmd_factory.make_get_next_statement_targets_message(seq, xml)
@@ -1342,9 +1343,10 @@ def internal_evaluate_expression(dbg, seq, thread_id, frame_id, expression, is_e
         dbg.writer.add_command(cmd)
 
 
-def _set_expression_response(py_db, request, result, error_message):
-    body = pydevd_schema.SetExpressionResponseBody(result="", variablesReference=0)
-    variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body, "success": False, "message": error_message})
+def _set_expression_response(py_db, request, error_message):
+    body = pydevd_schema.SetExpressionResponseBody(value='')
+    variables_response = pydevd_base_schema.build_response(request, kwargs={
+        'body':body, 'success':False, 'message': error_message})
     py_db.writer.add_command(NetCommand(CMD_RETURN, 0, variables_response, is_json=True))
 
 
@@ -1360,19 +1362,18 @@ def internal_set_expression_json(py_db, request, thread_id):
         fmt = fmt.to_dict()
 
     frame = py_db.find_frame(thread_id, frame_id)
-    exec_code = "%s = (%s)" % (expression, value)
-    result = pydevd_vars.evaluate_expression(py_db, frame, exec_code, is_exec=True)
-    is_error = isinstance(result, ExceptionOnEvaluate)
-
-    if is_error:
-        _set_expression_response(py_db, request, result, error_message="Error executing: %s" % (exec_code,))
+    exec_code = '%s = (%s)' % (expression, value)
+    try:
+        pydevd_vars.evaluate_expression(py_db, frame, exec_code, is_exec=True)
+    except (Exception, KeyboardInterrupt):
+        _set_expression_response(py_db, request, error_message='Error executing: %s' % (exec_code,))
         return
 
     # Ok, we have the result (could be an error), let's put it into the saved variables.
     frame_tracker = py_db.suspended_frames_manager.get_frame_tracker(thread_id)
     if frame_tracker is None:
         # This is not really expected.
-        _set_expression_response(py_db, request, result, error_message="Thread id: %s is not current thread id." % (thread_id,))
+        _set_expression_response(py_db, request, error_message='Thread id: %s is not current thread id.' % (thread_id,))
         return
 
     # Now that the exec is done, get the actual value changed to return.

{debugpy-1.8.6 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_constants.py

@@ -1,6 +1,7 @@
 """
 This module holds the constants used for specifying the states of the debugger.
 """
+
 from __future__ import nested_scopes
 import platform
 import weakref
@@ -173,9 +174,18 @@ IS_PY39_OR_GREATER = sys.version_info >= (3, 9)
 IS_PY310_OR_GREATER = sys.version_info >= (3, 10)
 IS_PY311_OR_GREATER = sys.version_info >= (3, 11)
 IS_PY312_OR_GREATER = sys.version_info >= (3, 12)
+IS_PY313_OR_GREATER = sys.version_info >= (3, 13)
+IS_PY314_OR_GREATER = sys.version_info >= (3, 14)
+
+# Bug affecting Python 3.13.0 specifically makes some tests crash the interpreter!
+# Hopefully it'll be fixed in 3.13.1.
+IS_PY313_0 = sys.version_info[:3] == (3, 13, 0)
+
+# Mark tests that need to be fixed with this.
+TODO_PY313_OR_GREATER = IS_PY313_OR_GREATER
 
-# Not currently supported in Python 3.12.
-SUPPORT_ATTACH_TO_PID = not IS_PY312_OR_GREATER
+# Not currently supported in Python 3.14.
+SUPPORT_ATTACH_TO_PID = not IS_PY314_OR_GREATER
 
 
 def version_str(v):