debugpy 1.8.5__zip → 1.8.7__zip

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_trace_dispatch.py

@@ -2,8 +2,7 @@
 # Should give warning only here if cython is not available but supported.
 
 import os
-from _pydevd_bundle.pydevd_constants import USE_CYTHON_FLAG, ENV_TRUE_LOWER_VALUES, \
-    ENV_FALSE_LOWER_VALUES
+from _pydevd_bundle.pydevd_constants import USE_CYTHON_FLAG, ENV_TRUE_LOWER_VALUES, ENV_FALSE_LOWER_VALUES
 from _pydev_bundle import pydev_log
 
 dirname = os.path.dirname(os.path.dirname(__file__))
@@ -12,11 +11,13 @@ USING_CYTHON = False
 
 def delete_old_compiled_extensions():
     import _pydevd_bundle
+
     cython_extensions_dir = os.path.dirname(os.path.dirname(_pydevd_bundle.__file__))
     _pydevd_bundle_ext_dir = os.path.dirname(_pydevd_bundle.__file__)
-    _pydevd_frame_eval_ext_dir = os.path.join(cython_extensions_dir, '_pydevd_frame_eval_ext')
+    _pydevd_frame_eval_ext_dir = os.path.join(cython_extensions_dir, "_pydevd_frame_eval_ext")
     try:
         import shutil
+
         for file in os.listdir(_pydevd_bundle_ext_dir):
             if file.startswith("pydevd") and file.endswith(".so"):
                 os.remove(os.path.join(_pydevd_bundle_ext_dir, file))
@@ -27,36 +28,65 @@ def delete_old_compiled_extensions():
         if os.path.exists(build_dir):
             shutil.rmtree(os.path.join(cython_extensions_dir, "build"))
     except OSError:
-        pydev_log.error_once("warning: failed to delete old cython speedups. Please delete all *.so files from the directories "
-                       "\"%s\" and \"%s\"" % (_pydevd_bundle_ext_dir, _pydevd_frame_eval_ext_dir))
+        pydev_log.error_once(
+            "warning: failed to delete old cython speedups. Please delete all *.so files from the directories "
+            '"%s" and "%s"' % (_pydevd_bundle_ext_dir, _pydevd_frame_eval_ext_dir)
+        )
 
 
 if USE_CYTHON_FLAG in ENV_TRUE_LOWER_VALUES:
     # We must import the cython version if forcing cython
-    from _pydevd_bundle.pydevd_cython_wrapper import trace_dispatch, global_cache_skips, global_cache_frame_skips, fix_top_level_trace_and_get_trace_func
+    from _pydevd_bundle.pydevd_cython_wrapper import (
+        trace_dispatch,
+        global_cache_skips,
+        global_cache_frame_skips,
+        fix_top_level_trace_and_get_trace_func,
+    )
+    from _pydevd_bundle.pydevd_cython_wrapper import should_stop_on_exception, handle_exception, is_unhandled_exception
+
     USING_CYTHON = True
 
 elif USE_CYTHON_FLAG in ENV_FALSE_LOWER_VALUES:
     # Use the regular version if not forcing cython
-    from _pydevd_bundle.pydevd_trace_dispatch_regular import trace_dispatch, global_cache_skips, global_cache_frame_skips, fix_top_level_trace_and_get_trace_func  # @UnusedImport
+    from _pydevd_bundle.pydevd_trace_dispatch_regular import (
+        trace_dispatch,
+        global_cache_skips,
+        global_cache_frame_skips,
+        fix_top_level_trace_and_get_trace_func,
+    )  # @UnusedImport
+    from .pydevd_frame import should_stop_on_exception, handle_exception, is_unhandled_exception
 
 else:
     # Regular: use fallback if not found and give message to user
     try:
-        from _pydevd_bundle.pydevd_cython_wrapper import trace_dispatch, global_cache_skips, global_cache_frame_skips, fix_top_level_trace_and_get_trace_func
+        from _pydevd_bundle.pydevd_cython_wrapper import (
+            trace_dispatch,
+            global_cache_skips,
+            global_cache_frame_skips,
+            fix_top_level_trace_and_get_trace_func,
+        )
+        from _pydevd_bundle.pydevd_cython_wrapper import should_stop_on_exception, handle_exception, is_unhandled_exception
 
         # This version number is always available
         from _pydevd_bundle.pydevd_additional_thread_info_regular import version as regular_version
+
         # This version number from the already compiled cython extension
         from _pydevd_bundle.pydevd_cython_wrapper import version as cython_version
+
         if cython_version != regular_version:
             # delete_old_compiled_extensions() -- would be ok in dev mode but we don't want to erase
             # files from other python versions on release, so, just raise import error here.
-            raise ImportError('Cython version of speedups does not match.')
+            raise ImportError("Cython version of speedups does not match.")
         else:
             USING_CYTHON = True
 
     except ImportError:
-        from _pydevd_bundle.pydevd_trace_dispatch_regular import trace_dispatch, global_cache_skips, global_cache_frame_skips, fix_top_level_trace_and_get_trace_func  # @UnusedImport
-        pydev_log.show_compile_cython_command_line()
+        from _pydevd_bundle.pydevd_trace_dispatch_regular import (
+            trace_dispatch,
+            global_cache_skips,
+            global_cache_frame_skips,
+            fix_top_level_trace_and_get_trace_func,
+        )  # @UnusedImport
+        from .pydevd_frame import should_stop_on_exception, handle_exception, is_unhandled_exception
 
+        pydev_log.show_compile_cython_command_line()

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_trace_dispatch_regular.py

@@ -1,17 +1,25 @@
 from _pydev_bundle.pydev_is_thread_alive import is_thread_alive
 from _pydev_bundle.pydev_log import exception as pydev_log_exception
 from _pydev_bundle._pydev_saved_modules import threading
-from _pydevd_bundle.pydevd_constants import (get_current_thread_id, NO_FTRACE,
-    USE_CUSTOM_SYS_CURRENT_FRAMES_MAP, ForkSafeLock)
+from _pydevd_bundle.pydevd_constants import (
+    get_current_thread_id,
+    NO_FTRACE,
+    USE_CUSTOM_SYS_CURRENT_FRAMES_MAP,
+    ForkSafeLock,
+    PYDEVD_USE_SYS_MONITORING,
+)
 from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER
 
+# fmt: off
 # IFDEF CYTHON
 # from cpython.object cimport PyObject
 # from cpython.ref cimport Py_INCREF, Py_XDECREF
 # ELSE
 from _pydevd_bundle.pydevd_frame import PyDBFrame, is_unhandled_exception
 # ENDIF
+# fmt: on
 
+# fmt: off
 # IFDEF CYTHON
 # cdef dict _global_notify_skipped_step_in
 # cython_inline_constant: CMD_STEP_INTO = 107
@@ -25,6 +33,7 @@ CMD_STEP_INTO_MY_CODE = 144
 CMD_STEP_RETURN = 109
 CMD_STEP_RETURN_MY_CODE = 160
 # ENDIF
+# fmt: on
 
 # Cache where we should keep that we completely skipped entering some context.
 # It needs to be invalidated when:
@@ -48,6 +57,8 @@ def notify_skipped_step_in_because_of_filters(py_db, frame):
         _global_notify_skipped_step_in = True
         py_db.notify_skipped_step_in_because_of_filters(frame)
 
+
+# fmt: off
 # IFDEF CYTHON
 # cdef class SafeCallWrapper:
 #     cdef method_object
@@ -65,14 +76,17 @@ def notify_skipped_step_in_because_of_filters(py_db, frame):
 #         return self.method_object
 # ELSE
 # ENDIF
+# fmt: on
 
 
 def fix_top_level_trace_and_get_trace_func(py_db, frame):
+    # fmt: off
     # IFDEF CYTHON
     # cdef str filename;
     # cdef str name;
     # cdef tuple args;
     # ENDIF
+    # fmt: on
 
     # Note: this is always the first entry-point in the tracing for any thread.
     # After entering here we'll set a new tracing function for this thread
@@ -90,45 +104,45 @@ def fix_top_level_trace_and_get_trace_func(py_db, frame):
 
         name = f_unhandled.f_code.co_filename
         # basename
-        i = name.rfind('/')
-        j = name.rfind('\\')
+        i = name.rfind("/")
+        j = name.rfind("\\")
         if j > i:
             i = j
         if i >= 0:
-            name = name[i + 1:]
+            name = name[i + 1 :]
         # remove ext
-        i = name.rfind('.')
+        i = name.rfind(".")
         if i >= 0:
             name = name[:i]
 
-        if name == 'threading':
-            if f_unhandled.f_code.co_name in ('__bootstrap', '_bootstrap'):
+        if name == "threading":
+            if f_unhandled.f_code.co_name in ("__bootstrap", "_bootstrap"):
                 # We need __bootstrap_inner, not __bootstrap.
                 return None, False
 
-            elif f_unhandled.f_code.co_name in ('__bootstrap_inner', '_bootstrap_inner'):
+            elif f_unhandled.f_code.co_name in ("__bootstrap_inner", "_bootstrap_inner"):
                 # Note: be careful not to use threading.currentThread to avoid creating a dummy thread.
-                t = f_unhandled.f_locals.get('self')
+                t = f_unhandled.f_locals.get("self")
                 force_only_unhandled_tracer = True
                 if t is not None and isinstance(t, threading.Thread):
                     thread = t
                     break
 
-        elif name == 'pydev_monkey':
-            if f_unhandled.f_code.co_name == '__call__':
+        elif name == "pydev_monkey":
+            if f_unhandled.f_code.co_name == "__call__":
                 force_only_unhandled_tracer = True
                 break
 
-        elif name == 'pydevd':
-            if f_unhandled.f_code.co_name in ('run', 'main'):
+        elif name == "pydevd":
+            if f_unhandled.f_code.co_name in ("run", "main"):
                 # We need to get to _exec
                 return None, False
 
-            if f_unhandled.f_code.co_name == '_exec':
+            if f_unhandled.f_code.co_name == "_exec":
                 force_only_unhandled_tracer = True
                 break
 
-        elif name == 'pydevd_tracing':
+        elif name == "pydevd_tracing":
             return None, False
 
         elif f_unhandled.f_back is None:
@@ -147,7 +161,7 @@ def fix_top_level_trace_and_get_trace_func(py_db, frame):
             # Jython does not have threading.get_ident().
             thread = py_db.threading_current_thread()
 
-    if getattr(thread, 'pydev_do_not_trace', None):
+    if getattr(thread, "pydev_do_not_trace", None):
         py_db.disable_tracing()
         return None, False
 
@@ -165,19 +179,25 @@ def fix_top_level_trace_and_get_trace_func(py_db, frame):
         if f_unhandled.f_back is None and not force_only_unhandled_tracer:
             # Happens when we attach to a running program (cannot reuse instance because it's mutable).
             top_level_thread_tracer = TopLevelThreadTracerNoBackFrame(ThreadTracer(args), args)
-            additional_info.top_level_thread_tracer_no_back_frames.append(top_level_thread_tracer)  # Hack for cython to keep it alive while the thread is alive (just the method in the SetTrace is not enough).
+            additional_info.top_level_thread_tracer_no_back_frames.append(
+                top_level_thread_tracer
+            )  # Hack for cython to keep it alive while the thread is alive (just the method in the SetTrace is not enough).
         else:
             top_level_thread_tracer = additional_info.top_level_thread_tracer_unhandled
             if top_level_thread_tracer is None:
                 # Stop in some internal place to report about unhandled exceptions
                 top_level_thread_tracer = TopLevelThreadTracerOnlyUnhandledExceptions(args)
-                additional_info.top_level_thread_tracer_unhandled = top_level_thread_tracer  # Hack for cython to keep it alive while the thread is alive (just the method in the SetTrace is not enough).
+                additional_info.top_level_thread_tracer_unhandled = (
+                    top_level_thread_tracer
+                )  # Hack for cython to keep it alive while the thread is alive (just the method in the SetTrace is not enough).
 
         # print(' --> found to trace unhandled', f_unhandled.f_code.co_name, f_unhandled.f_code.co_filename, f_unhandled.f_code.co_firstlineno)
         f_trace = top_level_thread_tracer.get_trace_dispatch_func()
+        # fmt: off
         # IFDEF CYTHON
         # f_trace = SafeCallWrapper(f_trace)
         # ENDIF
+        # fmt: on
         f_unhandled.f_trace = f_trace
 
         if frame is f_unhandled:
@@ -188,22 +208,25 @@ def fix_top_level_trace_and_get_trace_func(py_db, frame):
         thread_tracer = ThreadTracer(args)
         additional_info.thread_tracer = thread_tracer
 
-# IFDEF CYTHON
-#     return SafeCallWrapper(thread_tracer), True
-# ELSE
+    # fmt: off
+    # IFDEF CYTHON
+    # return SafeCallWrapper(thread_tracer), True
+    # ELSE
     return thread_tracer, True
-# ENDIF
+    # ENDIF
+    # fmt: on
 
 
 def trace_dispatch(py_db, frame, event, arg):
     thread_trace_func, apply_to_settrace = py_db.fix_top_level_trace_and_get_trace_func(py_db, frame)
     if thread_trace_func is None:
-        return None if event == 'call' else NO_FTRACE
+        return None if event == "call" else NO_FTRACE
     if apply_to_settrace:
         py_db.enable_tracing(thread_trace_func)
     return thread_trace_func(frame, event, arg)
 
 
+# fmt: off
 # IFDEF CYTHON
 # cdef class TopLevelThreadTracerOnlyUnhandledExceptions:
 #     cdef public tuple _args;
@@ -211,15 +234,16 @@ def trace_dispatch(py_db, frame, event, arg):
 #         self._args = args
 # ELSE
 class TopLevelThreadTracerOnlyUnhandledExceptions(object):
-
     def __init__(self, args):
         self._args = args
+
 # ENDIF
+# fmt: on
 
     def trace_unhandled_exceptions(self, frame, event, arg):
         # Note that we ignore the frame as this tracing method should only be put in topmost frames already.
         # print('trace_unhandled_exceptions', event, frame.f_code.co_name, frame.f_code.co_filename, frame.f_code.co_firstlineno)
-        if event == 'exception' and arg is not None:
+        if event == "exception" and arg is not None:
             py_db, t, additional_info = self._args[0:3]
             if arg is not None:
                 if not additional_info.suspended_at_unhandled:
@@ -233,7 +257,7 @@ class TopLevelThreadTracerOnlyUnhandledExceptions(object):
     def get_trace_dispatch_func(self):
         return self.trace_unhandled_exceptions
 
-
+# fmt: off
 # IFDEF CYTHON
 # cdef class TopLevelThreadTracerNoBackFrame:
 #
@@ -253,7 +277,7 @@ class TopLevelThreadTracerOnlyUnhandledExceptions(object):
 #         self._last_raise_line = -1
 # ELSE
 class TopLevelThreadTracerNoBackFrame(object):
-    '''
+    """
     This tracer is pretty special in that it's dealing with a frame without f_back (i.e.: top frame
     on remote attach or QThread).
 
@@ -263,7 +287,7 @@ class TopLevelThreadTracerNoBackFrame(object):
     work with in the tracing -- see: https://bugs.python.org/issue34099, so, we inspect bytecode to
     determine if some exception will be traced or not... note that if this is not available -- such
     as on Jython -- we consider any top-level exception to be unnhandled).
-    '''
+    """
 
     def __init__(self, frame_trace_dispatch, args):
         self._frame_trace_dispatch = frame_trace_dispatch
@@ -272,7 +296,9 @@ class TopLevelThreadTracerNoBackFrame(object):
         self._last_exc_arg = None
         self._raise_lines = set()
         self._last_raise_line = -1
+
 # ENDIF
+# fmt: on
 
     def trace_dispatch_and_unhandled_exceptions(self, frame, event, arg):
         # DEBUG = 'code_to_debug' in frame.f_code.co_filename
@@ -281,12 +307,12 @@ class TopLevelThreadTracerNoBackFrame(object):
         if frame_trace_dispatch is not None:
             self._frame_trace_dispatch = frame_trace_dispatch(frame, event, arg)
 
-        if event == 'exception':
+        if event == "exception":
             self._last_exc_arg = arg
             self._raise_lines.add(frame.f_lineno)
             self._last_raise_line = frame.f_lineno
 
-        elif event == 'return' and self._last_exc_arg is not None:
+        elif event == "return" and self._last_exc_arg is not None:
             # For unhandled exceptions we actually track the return when at the topmost level.
             try:
                 py_db, t, additional_info = self._args[0:3]
@@ -300,17 +326,20 @@ class TopLevelThreadTracerNoBackFrame(object):
         ret = self.trace_dispatch_and_unhandled_exceptions
 
         # Need to reset (the call to _frame_trace_dispatch may have changed it).
+        # fmt: off
         # IFDEF CYTHON
         # frame.f_trace = SafeCallWrapper(ret)
         # ELSE
         frame.f_trace = ret
         # ENDIF
+        # fmt: on
         return ret
 
     def get_trace_dispatch_func(self):
         return self.trace_dispatch_and_unhandled_exceptions
 
 
+# fmt: off
 # IFDEF CYTHON
 # cdef class ThreadTracer:
 #     cdef public tuple _args;
@@ -318,13 +347,14 @@ class TopLevelThreadTracerNoBackFrame(object):
 #         self._args = args
 # ELSE
 class ThreadTracer(object):
-
     def __init__(self, args):
         self._args = args
+
 # ENDIF
+# fmt: on
 
     def __call__(self, frame, event, arg):
-        ''' This is the callback used when we enter some context in the debugger.
+        """This is the callback used when we enter some context in the debugger.
 
         We also decorate the thread we are in with info about the debugging.
         The attributes added are:
@@ -335,7 +365,8 @@ class ThreadTracer(object):
 
         :param PyDB py_db:
             This is the global debugger (this method should actually be added as a method to it).
-        '''
+        """
+        # fmt: off
         # IFDEF CYTHON
         # cdef str filename;
         # cdef str base;
@@ -346,24 +377,25 @@ class ThreadTracer(object):
         # cdef tuple abs_path_canonical_path_and_base;
         # cdef PyDBAdditionalThreadInfo additional_info;
         # ENDIF
+        # fmt: on
 
         # DEBUG = 'code_to_debug' in frame.f_code.co_filename
         # if DEBUG: print('ENTER: trace_dispatch: %s %s %s %s' % (frame.f_code.co_filename, frame.f_lineno, event, frame.f_code.co_name))
         py_db, t, additional_info, cache_skips, frame_skips_cache = self._args
         if additional_info.is_tracing:
-            return None if event == 'call' else NO_FTRACE  # we don't wan't to trace code invoked from pydevd_frame.trace_dispatch
+            return None if event == "call" else NO_FTRACE  # we don't wan't to trace code invoked from pydevd_frame.trace_dispatch
 
         additional_info.is_tracing += 1
         try:
             pydev_step_cmd = additional_info.pydev_step_cmd
             is_stepping = pydev_step_cmd != -1
             if py_db.pydb_disposed:
-                return None if event == 'call' else NO_FTRACE
+                return None if event == "call" else NO_FTRACE
 
             # if thread is not alive, cancel trace_dispatch processing
             if not is_thread_alive(t):
                 py_db.notify_thread_not_alive(get_current_thread_id(t))
-                return None if event == 'call' else NO_FTRACE
+                return None if event == "call" else NO_FTRACE
 
             # Note: it's important that the context name is also given because we may hit something once
             # in the global context and another in the local context.
@@ -371,23 +403,30 @@ class ThreadTracer(object):
             if frame_cache_key in cache_skips:
                 if not is_stepping:
                     # if DEBUG: print('skipped: trace_dispatch (cache hit)', frame_cache_key, frame.f_lineno, event, frame.f_code.co_name)
-                    return None if event == 'call' else NO_FTRACE
+                    return None if event == "call" else NO_FTRACE
                 else:
                     # When stepping we can't take into account caching based on the breakpoints (only global filtering).
                     if cache_skips.get(frame_cache_key) == 1:
-
-                        if additional_info.pydev_original_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE) and not _global_notify_skipped_step_in:
+                        if (
+                            additional_info.pydev_original_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE)
+                            and not _global_notify_skipped_step_in
+                        ):
                             notify_skipped_step_in_because_of_filters(py_db, frame)
 
                         back_frame = frame.f_back
-                        if back_frame is not None and pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_RETURN, CMD_STEP_RETURN_MY_CODE):
+                        if back_frame is not None and pydev_step_cmd in (
+                            CMD_STEP_INTO,
+                            CMD_STEP_INTO_MY_CODE,
+                            CMD_STEP_RETURN,
+                            CMD_STEP_RETURN_MY_CODE,
+                        ):
                             back_frame_cache_key = back_frame.f_code
                             if cache_skips.get(back_frame_cache_key) == 1:
                                 # if DEBUG: print('skipped: trace_dispatch (cache hit: 1)', frame_cache_key, frame.f_lineno, event, frame.f_code.co_name)
-                                return None if event == 'call' else NO_FTRACE
+                                return None if event == "call" else NO_FTRACE
                         else:
                             # if DEBUG: print('skipped: trace_dispatch (cache hit: 2)', frame_cache_key, frame.f_lineno, event, frame.f_code.co_name)
-                            return None if event == 'call' else NO_FTRACE
+                            return None if event == "call" else NO_FTRACE
 
             try:
                 # Make fast path faster!
@@ -395,39 +434,50 @@ class ThreadTracer(object):
             except:
                 abs_path_canonical_path_and_base = get_abs_path_real_path_and_base_from_frame(frame)
 
-            file_type = py_db.get_file_type(frame, abs_path_canonical_path_and_base)  # we don't want to debug threading or anything related to pydevd
+            file_type = py_db.get_file_type(
+                frame, abs_path_canonical_path_and_base
+            )  # we don't want to debug threading or anything related to pydevd
 
             if file_type is not None:
                 if file_type == 1:  # inlining LIB_FILE = 1
                     if not py_db.in_project_scope(frame, abs_path_canonical_path_and_base[0]):
                         # if DEBUG: print('skipped: trace_dispatch (not in scope)', abs_path_canonical_path_and_base[2], frame.f_lineno, event, frame.f_code.co_name, file_type)
                         cache_skips[frame_cache_key] = 1
-                        return None if event == 'call' else NO_FTRACE
+                        return None if event == "call" else NO_FTRACE
                 else:
                     # if DEBUG: print('skipped: trace_dispatch', abs_path_canonical_path_and_base[2], frame.f_lineno, event, frame.f_code.co_name, file_type)
                     cache_skips[frame_cache_key] = 1
-                    return None if event == 'call' else NO_FTRACE
+                    return None if event == "call" else NO_FTRACE
 
             if py_db.is_files_filter_enabled:
                 if py_db.apply_files_filter(frame, abs_path_canonical_path_and_base[0], False):
                     cache_skips[frame_cache_key] = 1
 
-                    if is_stepping and additional_info.pydev_original_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE) and not _global_notify_skipped_step_in:
+                    if (
+                        is_stepping
+                        and additional_info.pydev_original_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE)
+                        and not _global_notify_skipped_step_in
+                    ):
                         notify_skipped_step_in_because_of_filters(py_db, frame)
 
                     # A little gotcha, sometimes when we're stepping in we have to stop in a
                     # return event showing the back frame as the current frame, so, we need
                     # to check not only the current frame but the back frame too.
                     back_frame = frame.f_back
-                    if back_frame is not None and pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_RETURN, CMD_STEP_RETURN_MY_CODE):
+                    if back_frame is not None and pydev_step_cmd in (
+                        CMD_STEP_INTO,
+                        CMD_STEP_INTO_MY_CODE,
+                        CMD_STEP_RETURN,
+                        CMD_STEP_RETURN_MY_CODE,
+                    ):
                         if py_db.apply_files_filter(back_frame, back_frame.f_code.co_filename, False):
                             back_frame_cache_key = back_frame.f_code
                             cache_skips[back_frame_cache_key] = 1
                             # if DEBUG: print('skipped: trace_dispatch (filtered out: 1)', frame_cache_key, frame.f_lineno, event, frame.f_code.co_name)
-                            return None if event == 'call' else NO_FTRACE
+                            return None if event == "call" else NO_FTRACE
                     else:
                         # if DEBUG: print('skipped: trace_dispatch (filtered out: 2)', frame_cache_key, frame.f_lineno, event, frame.f_code.co_name)
-                        return None if event == 'call' else NO_FTRACE
+                        return None if event == "call" else NO_FTRACE
 
             # if DEBUG: print('trace_dispatch', filename, frame.f_lineno, event, frame.f_code.co_name, file_type)
 
@@ -435,28 +485,35 @@ class ThreadTracer(object):
             # reference to the frame).
             ret = PyDBFrame(
                 (
-                    py_db, abs_path_canonical_path_and_base, additional_info, t, frame_skips_cache, frame_cache_key,
+                    py_db,
+                    abs_path_canonical_path_and_base,
+                    additional_info,
+                    t,
+                    frame_skips_cache,
+                    frame_cache_key,
                 )
             ).trace_dispatch(frame, event, arg)
             if ret is None:
                 # 1 means skipped because of filters.
                 # 2 means skipped because no breakpoints were hit.
                 cache_skips[frame_cache_key] = 2
-                return None if event == 'call' else NO_FTRACE
+                return None if event == "call" else NO_FTRACE
 
+            # fmt: off
             # IFDEF CYTHON
             # frame.f_trace = SafeCallWrapper(ret)  # Make sure we keep the returned tracer.
             # ELSE
             frame.f_trace = ret  # Make sure we keep the returned tracer.
             # ENDIF
+            # fmt: on
             return ret
 
         except SystemExit:
-            return None if event == 'call' else NO_FTRACE
+            return None if event == "call" else NO_FTRACE
 
         except Exception:
             if py_db.pydb_disposed:
-                return None if event == 'call' else NO_FTRACE  # Don't log errors when we're shutting down.
+                return None if event == "call" else NO_FTRACE  # Don't log errors when we're shutting down.
             # Log it
             try:
                 if pydev_log_exception is not None:
@@ -466,7 +523,7 @@ class ThreadTracer(object):
                 # Error logging? We're really in the interpreter shutdown...
                 # (https://github.com/fabioz/PyDev.Debugger/issues/8)
                 pass
-            return None if event == 'call' else NO_FTRACE
+            return None if event == "call" else NO_FTRACE
         finally:
             additional_info.is_tracing -= 1
 
@@ -488,3 +545,8 @@ if USE_CUSTOM_SYS_CURRENT_FRAMES_MAP:
         return _original_call(self, frame, event, arg)
 
     ThreadTracer.__call__ = __call__
+
+if PYDEVD_USE_SYS_MONITORING:
+
+    def fix_top_level_trace_and_get_trace_func(*args, **kwargs):
+        raise RuntimeError("Not used in sys.monitoring mode.")

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_traceproperty.py

@@ -1,27 +1,28 @@
-'''For debug purpose we are replacing actual builtin property by the debug property
-'''
+"""For debug purpose we are replacing actual builtin property by the debug property
+"""
 from _pydevd_bundle.pydevd_comm import get_global_debugger
 from _pydev_bundle import pydev_log
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # replace_builtin_property
-#=======================================================================================================================
+# =======================================================================================================================
 def replace_builtin_property(new_property=None):
     if new_property is None:
         new_property = DebugProperty
     original = property
     try:
         import builtins
-        builtins.__dict__['property'] = new_property
+
+        builtins.__dict__["property"] = new_property
     except:
         pydev_log.exception()  # @Reimport
     return original
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # DebugProperty
-#=======================================================================================================================
+# =======================================================================================================================
 class DebugProperty(object):
     """A custom property which allows python property to get
     controlled by the debugger and selectively disable/re-enable
@@ -73,20 +74,16 @@ class DebugProperty(object):
                 global_debugger.enable_tracing()
 
     def getter(self, fget):
-        """Overriding getter decorator for the property
-        """
+        """Overriding getter decorator for the property"""
         self.fget = fget
         return self
 
     def setter(self, fset):
-        """Overriding setter decorator for the property
-        """
+        """Overriding setter decorator for the property"""
         self.fset = fset
         return self
 
     def deleter(self, fdel):
-        """Overriding deleter decorator for the property
-        """
+        """Overriding deleter decorator for the property"""
         self.fdel = fdel
         return self
-