debugpy 1.8.7__zip → 1.8.9__zip

{debugpy-1.8.7/src/debugpy.egg-info → debugpy-1.8.9}/PKG-INFO

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

{debugpy-1.8.7 → debugpy-1.8.9}/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.7 → debugpy-1.8.9}/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.12 and earlier 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.7 → debugpy-1.8.9}/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.7 → debugpy-1.8.9}/src/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_xml_rpc.py

@@ -203,7 +203,7 @@ def _encode_if_needed(obj):
 
     elif isinstance(obj, bytes):
         try:
-            return xmlrpclib.Binary(obj.decode(sys.stdin.encoding, 'replace').encode("ISO-8859-1", "xmlcharrefreplace"))
+            return xmlrpclib.Binary(obj.decode(sys.stdin.encoding, "replace").encode("ISO-8859-1", "xmlcharrefreplace"))
         except:
             return xmlrpclib.Binary(obj)  # bytes already
 

{debugpy-1.8.7 → debugpy-1.8.9}/src/debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/__main__pydevd_gen_debug_adapter_protocol.py

@@ -458,7 +458,9 @@ def update_class_to_generate_init(class_to_generate):
     # Note: added kwargs because some messages are expected to be extended by the user (so, we'll actually
     # make all extendable so that we don't have to worry about which ones -- we loose a little on typing,
     # but may be better than doing a allow list based on something only pointed out in the documentation).
-    class_to_generate["init"] = '''def __init__(self%(args)s, update_ids_from_dap=False, **kwargs):  # noqa (update_ids_from_dap may be unused)
+    class_to_generate[
+        "init"
+    ] = '''def __init__(self%(args)s, update_ids_from_dap=False, **kwargs):  # noqa (update_ids_from_dap may be unused)
     """
 %(docstring)s
     """

{debugpy-1.8.7 → debugpy-1.8.9}/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.7 → debugpy-1.8.9}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_code_to_source.py

@@ -529,8 +529,7 @@ class _PyCodeToSource(object):
             instruction = instructions[0]
             new_line_index = op_offset_to_line.get(instruction.offset)
             if new_line_index is not None:
-                if new_line_index is not None:
-                    curr_line_index = new_line_index
+                curr_line_index = new_line_index
 
             self._process_next(curr_line_index)
         return self.writer.line_to_contents

{debugpy-1.8.7 → debugpy-1.8.9}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_collect_bytecode_info.py

@@ -82,125 +82,8 @@ def debug(s):
 _Instruction = namedtuple("_Instruction", "opname, opcode, starts_line, argval, is_jump_target, offset, argrepr")
 
 
-def _iter_as_bytecode_as_instructions_py2(co):
-    code = co.co_code
-    op_offset_to_line = dict(dis.findlinestarts(co))
-    labels = set(dis.findlabels(code))
-    bytecode_len = len(code)
-    i = 0
-    extended_arg = 0
-    free = None
-
-    op_to_name = opname
-
-    while i < bytecode_len:
-        c = code[i]
-        op = ord(c)
-        is_jump_target = i in labels
-
-        curr_op_name = op_to_name[op]
-        initial_bytecode_offset = i
-
-        i = i + 1
-        if op < HAVE_ARGUMENT:
-            yield _Instruction(
-                curr_op_name,
-                op,
-                _get_line(op_offset_to_line, initial_bytecode_offset, 0),
-                None,
-                is_jump_target,
-                initial_bytecode_offset,
-                "",
-            )
-
-        else:
-            oparg = ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg
-
-            extended_arg = 0
-            i = i + 2
-            if op == EXTENDED_ARG:
-                extended_arg = oparg * 65536
-
-            if op in hasconst:
-                yield _Instruction(
-                    curr_op_name,
-                    op,
-                    _get_line(op_offset_to_line, initial_bytecode_offset, 0),
-                    co.co_consts[oparg],
-                    is_jump_target,
-                    initial_bytecode_offset,
-                    repr(co.co_consts[oparg]),
-                )
-            elif op in hasname:
-                yield _Instruction(
-                    curr_op_name,
-                    op,
-                    _get_line(op_offset_to_line, initial_bytecode_offset, 0),
-                    co.co_names[oparg],
-                    is_jump_target,
-                    initial_bytecode_offset,
-                    str(co.co_names[oparg]),
-                )
-            elif op in hasjrel:
-                argval = i + oparg
-                yield _Instruction(
-                    curr_op_name,
-                    op,
-                    _get_line(op_offset_to_line, initial_bytecode_offset, 0),
-                    argval,
-                    is_jump_target,
-                    initial_bytecode_offset,
-                    "to " + repr(argval),
-                )
-            elif op in haslocal:
-                yield _Instruction(
-                    curr_op_name,
-                    op,
-                    _get_line(op_offset_to_line, initial_bytecode_offset, 0),
-                    co.co_varnames[oparg],
-                    is_jump_target,
-                    initial_bytecode_offset,
-                    str(co.co_varnames[oparg]),
-                )
-            elif op in hascompare:
-                yield _Instruction(
-                    curr_op_name,
-                    op,
-                    _get_line(op_offset_to_line, initial_bytecode_offset, 0),
-                    cmp_op[oparg],
-                    is_jump_target,
-                    initial_bytecode_offset,
-                    cmp_op[oparg],
-                )
-            elif op in hasfree:
-                if free is None:
-                    free = co.co_cellvars + co.co_freevars
-                yield _Instruction(
-                    curr_op_name,
-                    op,
-                    _get_line(op_offset_to_line, initial_bytecode_offset, 0),
-                    free[oparg],
-                    is_jump_target,
-                    initial_bytecode_offset,
-                    str(free[oparg]),
-                )
-            else:
-                yield _Instruction(
-                    curr_op_name,
-                    op,
-                    _get_line(op_offset_to_line, initial_bytecode_offset, 0),
-                    oparg,
-                    is_jump_target,
-                    initial_bytecode_offset,
-                    str(oparg),
-                )
-
-
 def iter_instructions(co):
-    if sys.version_info[0] < 3:
-        iter_in = _iter_as_bytecode_as_instructions_py2(co)
-    else:
-        iter_in = dis.Bytecode(co)
+    iter_in = dis.Bytecode(co)
     iter_in = list(iter_in)
 
     bytecode_to_instruction = {}
@@ -327,7 +210,7 @@ if sys.version_info[:2] <= (3, 9):
 
         try_except_info_lst = []
 
-        op_offset_to_line = dict(dis.findlinestarts(co))
+        op_offset_to_line = dict(entry for entry in dis.findlinestarts(co) if entry[1] is not None)
 
         offset_to_instruction_idx = {}
 
@@ -445,7 +328,7 @@ elif sys.version_info[:2] == (3, 10):
 
         try_except_info_lst = []
 
-        op_offset_to_line = dict(dis.findlinestarts(co))
+        op_offset_to_line = dict(entry for entry in dis.findlinestarts(co) if entry[1] is not None)
 
         offset_to_instruction_idx = {}
 
@@ -645,7 +528,7 @@ class _Disassembler(object):
         self.firstlineno = firstlineno
         self.level = level
         self.instructions = list(iter_instructions(co))
-        op_offset_to_line = self.op_offset_to_line = dict(dis.findlinestarts(co))
+        op_offset_to_line = self.op_offset_to_line = dict(entry for entry in dis.findlinestarts(co) if entry[1] is not None)
 
         # Update offsets so that all offsets have the line index (and update it based on
         # the passed firstlineno).
@@ -846,6 +729,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.7 → debugpy-1.8.9}/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,8 +1343,8 @@ 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)
+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))
 
@@ -1361,18 +1362,17 @@ def internal_set_expression_json(py_db, request, thread_id):
 
     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,))
+    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.7 → debugpy-1.8.9}/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
@@ -176,6 +177,13 @@ 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.14.
 SUPPORT_ATTACH_TO_PID = not IS_PY314_OR_GREATER