debugpy 1.8.5__zip → 1.8.6__zip

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_net_command_factory_xml.py

@@ -4,21 +4,52 @@ from _pydev_bundle.pydev_is_thread_alive import is_thread_alive
 from _pydev_bundle._pydev_saved_modules import thread
 from _pydevd_bundle import pydevd_xml, pydevd_frame_utils, pydevd_constants, pydevd_utils
 from _pydevd_bundle.pydevd_comm_constants import (
-    CMD_THREAD_CREATE, CMD_THREAD_KILL, CMD_THREAD_SUSPEND, CMD_THREAD_RUN, CMD_GET_VARIABLE,
-    CMD_EVALUATE_EXPRESSION, CMD_GET_FRAME, CMD_WRITE_TO_CONSOLE, CMD_GET_COMPLETIONS,
-    CMD_LOAD_SOURCE, CMD_SET_NEXT_STATEMENT, CMD_EXIT, CMD_GET_FILE_CONTENTS,
-    CMD_EVALUATE_CONSOLE_EXPRESSION, CMD_RUN_CUSTOM_OPERATION,
-    CMD_GET_BREAKPOINT_EXCEPTION, CMD_SEND_CURR_EXCEPTION_TRACE,
-    CMD_SEND_CURR_EXCEPTION_TRACE_PROCEEDED, CMD_SHOW_CONSOLE, CMD_GET_ARRAY,
-    CMD_INPUT_REQUESTED, CMD_GET_DESCRIPTION, CMD_PROCESS_CREATED,
-    CMD_SHOW_CYTHON_WARNING, CMD_LOAD_FULL_VALUE, CMD_GET_THREAD_STACK,
-    CMD_GET_EXCEPTION_DETAILS, CMD_THREAD_SUSPEND_SINGLE_NOTIFICATION,
+    CMD_THREAD_CREATE,
+    CMD_THREAD_KILL,
+    CMD_THREAD_SUSPEND,
+    CMD_THREAD_RUN,
+    CMD_GET_VARIABLE,
+    CMD_EVALUATE_EXPRESSION,
+    CMD_GET_FRAME,
+    CMD_WRITE_TO_CONSOLE,
+    CMD_GET_COMPLETIONS,
+    CMD_LOAD_SOURCE,
+    CMD_SET_NEXT_STATEMENT,
+    CMD_EXIT,
+    CMD_GET_FILE_CONTENTS,
+    CMD_EVALUATE_CONSOLE_EXPRESSION,
+    CMD_RUN_CUSTOM_OPERATION,
+    CMD_GET_BREAKPOINT_EXCEPTION,
+    CMD_SEND_CURR_EXCEPTION_TRACE,
+    CMD_SEND_CURR_EXCEPTION_TRACE_PROCEEDED,
+    CMD_SHOW_CONSOLE,
+    CMD_GET_ARRAY,
+    CMD_INPUT_REQUESTED,
+    CMD_GET_DESCRIPTION,
+    CMD_PROCESS_CREATED,
+    CMD_SHOW_CYTHON_WARNING,
+    CMD_LOAD_FULL_VALUE,
+    CMD_GET_THREAD_STACK,
+    CMD_GET_EXCEPTION_DETAILS,
+    CMD_THREAD_SUSPEND_SINGLE_NOTIFICATION,
     CMD_THREAD_RESUME_SINGLE_NOTIFICATION,
-    CMD_GET_NEXT_STATEMENT_TARGETS, CMD_VERSION,
-    CMD_RETURN, CMD_SET_PROTOCOL, CMD_ERROR, MAX_IO_MSG_SIZE, VERSION_STRING,
-    CMD_RELOAD_CODE, CMD_LOAD_SOURCE_FROM_FRAME_ID)
-from _pydevd_bundle.pydevd_constants import (DebugInfoHolder, get_thread_id,
-    get_global_debugger, GetGlobalDebugger, set_global_debugger)  # Keep for backward compatibility @UnusedImport
+    CMD_GET_NEXT_STATEMENT_TARGETS,
+    CMD_VERSION,
+    CMD_RETURN,
+    CMD_SET_PROTOCOL,
+    CMD_ERROR,
+    MAX_IO_MSG_SIZE,
+    VERSION_STRING,
+    CMD_RELOAD_CODE,
+    CMD_LOAD_SOURCE_FROM_FRAME_ID,
+)
+from _pydevd_bundle.pydevd_constants import (
+    DebugInfoHolder,
+    get_thread_id,
+    get_global_debugger,
+    GetGlobalDebugger,
+    set_global_debugger,
+)  # Keep for backward compatibility @UnusedImport
 from _pydevd_bundle.pydevd_net_command import NetCommand, NULL_NET_COMMAND, NULL_EXIT_COMMAND
 from _pydevd_bundle.pydevd_utils import quote_smart as quote, get_non_pydevd_threads
 from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame
@@ -30,16 +61,15 @@ from _pydevd_bundle.pydevd_frame_utils import FramesList
 from io import StringIO
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # NetCommandFactory
-#=======================================================================================================================
+# =======================================================================================================================
 class NetCommandFactory(object):
-
     def __init__(self):
         self._additional_thread_id_to_thread_name = {}
 
     def _thread_to_xml(self, thread):
-        """ thread information as XML """
+        """thread information as XML"""
         name = pydevd_xml.make_valid_xml_value(thread.name)
         cmd_text = '<thread name="%s" id="%s" />' % (quote(name), get_thread_id(thread))
         return cmd_text
@@ -51,14 +81,14 @@ class NetCommandFactory(object):
         return cmd
 
     def make_protocol_set_message(self, seq):
-        return NetCommand(CMD_SET_PROTOCOL, seq, '')
+        return NetCommand(CMD_SET_PROTOCOL, seq, "")
 
     def make_thread_created_message(self, thread):
         cmdText = "<xml>" + self._thread_to_xml(thread) + "</xml>"
         return NetCommand(CMD_THREAD_CREATE, 0, cmdText)
 
     def make_process_created_message(self):
-        cmdText = '<process/>'
+        cmdText = "<process/>"
         return NetCommand(CMD_PROCESS_CREATED, 0, cmdText)
 
     def make_process_about_to_be_replaced_message(self):
@@ -66,7 +96,7 @@ class NetCommandFactory(object):
 
     def make_show_cython_warning_message(self):
         try:
-            return NetCommand(CMD_SHOW_CYTHON_WARNING, 0, '')
+            return NetCommand(CMD_SHOW_CYTHON_WARNING, 0, "")
         except:
             return self.make_error_message(0, get_exception_traceback_str())
 
@@ -76,7 +106,7 @@ class NetCommandFactory(object):
         return NetCommand(CMD_THREAD_CREATE, 0, '<xml><thread name="%s" id="%s"/></xml>' % (frame_description, frame_id))
 
     def make_list_threads_message(self, py_db, seq):
-        """ returns thread listing as XML """
+        """returns thread listing as XML"""
         try:
             threads = get_non_pydevd_threads()
             cmd_text = ["<xml>"]
@@ -90,7 +120,7 @@ class NetCommandFactory(object):
                 append('<thread name="%s" id="%s" />' % (quote(name), thread_id))
 
             append("</xml>")
-            return NetCommand(CMD_RETURN, seq, ''.join(cmd_text))
+            return NetCommand(CMD_RETURN, seq, "".join(cmd_text))
         except:
             return self.make_error_message(seq, get_exception_traceback_str())
 
@@ -119,8 +149,8 @@ class NetCommandFactory(object):
                     cmd_text.append(self.make_thread_stack_str(py_db, frames_list))
                 finally:
                     topmost_frame = None
-            cmd_text.append('</thread></xml>')
-            return NetCommand(CMD_GET_THREAD_STACK, seq, ''.join(cmd_text))
+            cmd_text.append("</thread></xml>")
+            return NetCommand(CMD_GET_THREAD_STACK, seq, "".join(cmd_text))
         except:
             return self.make_error_message(seq, get_exception_traceback_str())
 
@@ -135,18 +165,18 @@ class NetCommandFactory(object):
         return self.make_io_message(msg, 2)
 
     def make_io_message(self, msg, ctx):
-        '''
+        """
         @param msg: the message to pass to the debug server
         @param ctx: 1 for stdio 2 for stderr
-        '''
+        """
         try:
             msg = pydevd_constants.as_str(msg)
 
             if len(msg) > MAX_IO_MSG_SIZE:
                 msg = msg[0:MAX_IO_MSG_SIZE]
-                msg += '...'
+                msg += "..."
 
-            msg = pydevd_xml.make_valid_xml_value(quote(msg, '/>_= '))
+            msg = pydevd_xml.make_valid_xml_value(quote(msg, "/>_= "))
             return NetCommand(str(CMD_WRITE_TO_CONSOLE), 0, '<xml><io s="%s" ctx="%s"/></xml>' % (msg, ctx))
         except:
             return self.make_error_message(0, get_exception_traceback_str())
@@ -171,16 +201,16 @@ class NetCommandFactory(object):
             for frame in frames_list:
                 show_as_current_frame = frame is frames_list.current_frame
                 if frame.f_code is None:
-                    pydev_log.info('Frame without f_code: %s', frame)
+                    pydev_log.info("Frame without f_code: %s", frame)
                     continue  # IronPython sometimes does not have it!
 
                 method_name = frame.f_code.co_name  # method name (if in method) or ? if global
                 if method_name is None:
-                    pydev_log.info('Frame without co_name: %s', frame)
+                    pydev_log.info("Frame without co_name: %s", frame)
                     continue  # IronPython sometimes does not have it!
 
                 if is_chained:
-                    method_name = '[Chained Exc: %s] %s' % (frames_list.exc_desc, method_name)
+                    method_name = "[Chained Exc: %s] %s" % (frames_list.exc_desc, method_name)
 
                 abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(frame)
                 if py_db.get_file_type(frame, abs_path_real_path_and_base) == py_db.PYDEV_FILE:
@@ -196,7 +226,17 @@ class NetCommandFactory(object):
                 new_filename_in_utf8, applied_mapping = pydevd_file_utils.map_file_to_client(filename_in_utf8)
                 applied_mapping = applied_mapping or changed
 
-                yield frame_id, frame, method_name, abs_path_real_path_and_base[0], new_filename_in_utf8, lineno, applied_mapping, show_as_current_frame, line_col_info
+                yield (
+                    frame_id,
+                    frame,
+                    method_name,
+                    abs_path_real_path_and_base[0],
+                    new_filename_in_utf8,
+                    lineno,
+                    applied_mapping,
+                    show_as_current_frame,
+                    line_col_info,
+                )
 
             if not flatten_chained:
                 break
@@ -213,21 +253,28 @@ class NetCommandFactory(object):
         append = cmd_text_list.append
 
         try:
-            for frame_id, frame, method_name, _original_filename, filename_in_utf8, lineno, _applied_mapping, _show_as_current_frame, line_col_info in self._iter_visible_frames_info(
-                    py_db, frames_list, flatten_chained=True
-                ):
-
+            for (
+                frame_id,
+                frame,
+                method_name,
+                _original_filename,
+                filename_in_utf8,
+                lineno,
+                _applied_mapping,
+                _show_as_current_frame,
+                line_col_info,
+            ) in self._iter_visible_frames_info(py_db, frames_list, flatten_chained=True):
                 # print("file is ", filename_in_utf8)
                 # print("line is ", lineno)
 
                 # Note: variables are all gotten 'on-demand'.
-                append('<frame id="%s" name="%s" ' % (frame_id , make_valid_xml_value(method_name)))
-                append('file="%s" line="%s">' % (quote(make_valid_xml_value(filename_in_utf8), '/>_= \t'), lineno))
+                append('<frame id="%s" name="%s" ' % (frame_id, make_valid_xml_value(method_name)))
+                append('file="%s" line="%s">' % (quote(make_valid_xml_value(filename_in_utf8), "/>_= \t"), lineno))
                 append("</frame>")
         except:
             pydev_log.exception()
 
-        return ''.join(cmd_text_list)
+        return "".join(cmd_text_list)
 
     def make_thread_suspend_str(
         self,
@@ -236,8 +283,8 @@ class NetCommandFactory(object):
         frames_list,
         stop_reason=None,
         message=None,
-        suspend_type="trace",
-        ):
+        trace_suspend_type="trace",
+    ):
         """
         :return tuple(str,str):
             Returns tuple(thread_suspended_str, thread_stack_str).
@@ -264,7 +311,7 @@ class NetCommandFactory(object):
         cmd_text_list = []
         append = cmd_text_list.append
 
-        cmd_text_list.append('<xml>')
+        cmd_text_list.append("<xml>")
         if message:
             message = make_valid_xml_value(message)
 
@@ -273,19 +320,20 @@ class NetCommandFactory(object):
             append(' stop_reason="%s"' % (stop_reason,))
         if message is not None:
             append(' message="%s"' % (message,))
-        if suspend_type is not None:
-            append(' suspend_type="%s"' % (suspend_type,))
-        append('>')
+        if trace_suspend_type is not None:
+            append(' suspend_type="%s"' % (trace_suspend_type,))
+        append(">")
         thread_stack_str = self.make_thread_stack_str(py_db, frames_list)
         append(thread_stack_str)
         append("</thread></xml>")
 
-        return ''.join(cmd_text_list), thread_stack_str
+        return "".join(cmd_text_list), thread_stack_str
 
-    def make_thread_suspend_message(self, py_db, thread_id, frames_list, stop_reason, message, suspend_type):
+    def make_thread_suspend_message(self, py_db, thread_id, frames_list, stop_reason, message, trace_suspend_type, thread, additional_info):
         try:
             thread_suspend_str, thread_stack_str = self.make_thread_suspend_str(
-                py_db, thread_id, frames_list, stop_reason, message, suspend_type)
+                py_db, thread_id, frames_list, stop_reason, message, trace_suspend_type
+            )
             cmd = NetCommand(CMD_THREAD_SUSPEND, 0, thread_suspend_str)
             cmd.thread_stack_str = thread_stack_str
             cmd.thread_suspend_str = thread_suspend_str
@@ -295,19 +343,17 @@ class NetCommandFactory(object):
 
     def make_thread_suspend_single_notification(self, py_db, thread_id, thread, stop_reason):
         try:
-            return NetCommand(CMD_THREAD_SUSPEND_SINGLE_NOTIFICATION, 0, json.dumps(
-                {'thread_id': thread_id, 'stop_reason':stop_reason}))
+            return NetCommand(CMD_THREAD_SUSPEND_SINGLE_NOTIFICATION, 0, json.dumps({"thread_id": thread_id, "stop_reason": stop_reason}))
         except:
             return self.make_error_message(0, get_exception_traceback_str())
 
     def make_thread_resume_single_notification(self, thread_id):
         try:
-            return NetCommand(CMD_THREAD_RESUME_SINGLE_NOTIFICATION, 0, json.dumps(
-                {'thread_id': thread_id}))
+            return NetCommand(CMD_THREAD_RESUME_SINGLE_NOTIFICATION, 0, json.dumps({"thread_id": thread_id}))
         except:
             return self.make_error_message(0, get_exception_traceback_str())
 
-    def make_thread_run_message(self, thread_id, reason):
+    def make_thread_run_message(self, py_db, thread_id, reason):
         try:
             return NetCommand(CMD_THREAD_RUN, 0, "%s\t%s" % (thread_id, reason))
         except:
@@ -371,24 +417,26 @@ class NetCommandFactory(object):
     def _make_send_curr_exception_trace_str(self, py_db, thread_id, exc_type, exc_desc, trace_obj):
         frames_list = pydevd_frame_utils.create_frames_list_from_traceback(trace_obj, None, exc_type, exc_desc)
 
-        exc_type = pydevd_xml.make_valid_xml_value(str(exc_type)).replace('\t', '  ') or 'exception: type unknown'
-        exc_desc = pydevd_xml.make_valid_xml_value(str(exc_desc)).replace('\t', '  ') or 'exception: no description'
+        exc_type = pydevd_xml.make_valid_xml_value(str(exc_type)).replace("\t", "  ") or "exception: type unknown"
+        exc_desc = pydevd_xml.make_valid_xml_value(str(exc_desc)).replace("\t", "  ") or "exception: no description"
 
         thread_suspend_str, thread_stack_str = self.make_thread_suspend_str(
-            py_db, thread_id, frames_list, CMD_SEND_CURR_EXCEPTION_TRACE, '')
+            py_db, thread_id, frames_list, CMD_SEND_CURR_EXCEPTION_TRACE, ""
+        )
         return exc_type, exc_desc, thread_suspend_str, thread_stack_str
 
     def make_send_curr_exception_trace_message(self, py_db, seq, thread_id, curr_frame_id, exc_type, exc_desc, trace_obj):
         try:
             exc_type, exc_desc, thread_suspend_str, _thread_stack_str = self._make_send_curr_exception_trace_str(
-                py_db, thread_id, exc_type, exc_desc, trace_obj)
-            payload = str(curr_frame_id) + '\t' + exc_type + "\t" + exc_desc + "\t" + thread_suspend_str
+                py_db, thread_id, exc_type, exc_desc, trace_obj
+            )
+            payload = str(curr_frame_id) + "\t" + exc_type + "\t" + exc_desc + "\t" + thread_suspend_str
             return NetCommand(CMD_SEND_CURR_EXCEPTION_TRACE, seq, payload)
         except Exception:
             return self.make_error_message(seq, get_exception_traceback_str())
 
     def make_get_exception_details_message(self, py_db, seq, thread_id, topmost_frame):
-        """Returns exception details as XML """
+        """Returns exception details as XML"""
         try:
             # If the debugger is not suspended, just return the thread and its id.
             cmd_text = ['<xml><thread id="%s" ' % (thread_id,)]
@@ -398,23 +446,24 @@ class NetCommandFactory(object):
                     frame = topmost_frame
                     topmost_frame = None
                     while frame is not None:
-                        if frame.f_code.co_name == 'do_wait_suspend' and frame.f_code.co_filename.endswith('pydevd.py'):
-                            arg = frame.f_locals.get('arg', None)
+                        if frame.f_code.co_name == "do_wait_suspend" and frame.f_code.co_filename.endswith("pydevd.py"):
+                            arg = frame.f_locals.get("arg", None)
                             if arg is not None:
                                 exc_type, exc_desc, _thread_suspend_str, thread_stack_str = self._make_send_curr_exception_trace_str(
-                                    py_db, thread_id, *arg)
+                                    py_db, thread_id, *arg
+                                )
                                 cmd_text.append('exc_type="%s" ' % (exc_type,))
                                 cmd_text.append('exc_desc="%s" ' % (exc_desc,))
-                                cmd_text.append('>')
+                                cmd_text.append(">")
                                 cmd_text.append(thread_stack_str)
                                 break
                         frame = frame.f_back
                     else:
-                        cmd_text.append('>')
+                        cmd_text.append(">")
                 finally:
                     frame = None
-            cmd_text.append('</thread></xml>')
-            return NetCommand(CMD_GET_EXCEPTION_DETAILS, seq, ''.join(cmd_text))
+            cmd_text.append("</thread></xml>")
+            return NetCommand(CMD_GET_EXCEPTION_DETAILS, seq, "".join(cmd_text))
         except:
             return self.make_error_message(seq, get_exception_traceback_str())
 
@@ -445,8 +494,7 @@ class NetCommandFactory(object):
     def make_show_console_message(self, py_db, thread_id, frame):
         try:
             frames_list = pydevd_frame_utils.create_frames_list_from_frame(frame)
-            thread_suspended_str, _thread_stack_str = self.make_thread_suspend_str(
-                py_db, thread_id, frames_list, CMD_SHOW_CONSOLE, '')
+            thread_suspended_str, _thread_stack_str = self.make_thread_suspend_str(py_db, thread_id, frames_list, CMD_SHOW_CONSOLE, "")
             return NetCommand(CMD_SHOW_CONSOLE, 0, thread_suspended_str)
         except:
             return self.make_error_message(0, get_exception_traceback_str())
@@ -459,7 +507,7 @@ class NetCommandFactory(object):
 
     def make_set_next_stmnt_status_message(self, seq, is_success, exception_msg):
         try:
-            message = str(is_success) + '\t' + exception_msg
+            message = str(is_success) + "\t" + exception_msg
             return NetCommand(CMD_SET_NEXT_STATEMENT, int(seq), message)
         except:
             return self.make_error_message(0, get_exception_traceback_str())
@@ -480,7 +528,7 @@ class NetCommandFactory(object):
         return NULL_NET_COMMAND  # Not a part of the xml protocol
 
     def make_evaluation_timeout_msg(self, py_db, expression, thread):
-        msg = '''pydevd: Evaluating: %s did not finish after %.2f seconds.
+        msg = """pydevd: Evaluating: %s did not finish after %.2f seconds.
 This may mean a number of things:
 - This evaluation is really slow and this is expected.
     In this case it's possible to silence this error by raising the timeout, setting the
@@ -498,12 +546,12 @@ This may mean a number of things:
     environment variable to true so that a thread dump is shown along with this message and
     optionally, set the PYDEVD_INTERRUPT_THREAD_TIMEOUT to some value so that the debugger
     tries to interrupt the evaluation (if possible) when this happens.
-''' % (expression, pydevd_constants.PYDEVD_WARN_EVALUATION_TIMEOUT)
+""" % (expression, pydevd_constants.PYDEVD_WARN_EVALUATION_TIMEOUT)
 
         if pydevd_constants.PYDEVD_THREAD_DUMP_ON_WARN_EVALUATION_TIMEOUT:
             stream = StringIO()
             pydevd_utils.dump_threads(stream, show_pydevd_threads=False)
-            msg += '\n\n%s\n' % stream.getvalue()
+            msg += "\n\n%s\n" % stream.getvalue()
         return self.make_warning_message(msg)
 
     def make_exit_command(self, py_db):

debugpy-1.8.6/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_plugin_utils.py

@@ -0,0 +1,208 @@
+import types
+
+from _pydev_bundle import pydev_log
+from typing import Tuple, Literal
+
+try:
+    from pydevd_plugins import django_debug
+except:
+    django_debug = None
+    pydev_log.debug("Unable to load django_debug plugin")
+
+try:
+    from pydevd_plugins import jinja2_debug
+except:
+    jinja2_debug = None
+    pydev_log.debug("Unable to load jinja2_debug plugin")
+
+
+def load_plugins():
+    plugins = []
+    if django_debug is not None:
+        plugins.append(django_debug)
+
+    if jinja2_debug is not None:
+        plugins.append(jinja2_debug)
+    return plugins
+
+
+def bind_func_to_method(func, obj, method_name):
+    bound_method = types.MethodType(func, obj)
+
+    setattr(obj, method_name, bound_method)
+    return bound_method
+
+
+class PluginManager(object):
+    EMPTY_SENTINEL = object()
+
+    def __init__(self, main_debugger):
+        self.plugins = load_plugins()
+
+        # When some breakpoint is added for a given plugin it becomes active.
+        self.active_plugins = []
+
+        self.main_debugger = main_debugger
+
+    def add_breakpoint(self, func_name, *args, **kwargs):
+        # add breakpoint for plugin
+        for plugin in self.plugins:
+            if hasattr(plugin, func_name):
+                func = getattr(plugin, func_name)
+                result = func(*args, **kwargs)
+                if result:
+                    self.activate(plugin)
+                    return result
+        return None
+
+    def activate(self, plugin):
+        if plugin not in self.active_plugins:
+            self.active_plugins.append(plugin)
+
+    # These are not a part of the API, rather, `add_breakpoint` should be used with `add_line_breakpoint` or `add_exception_breakpoint`
+    # which will call it for all plugins and then if it's valid it'll be activated.
+    #
+    # def add_line_breakpoint(self, py_db, type, canonical_normalized_filename, breakpoint_id, line, condition, expression, func_name, hit_condition=None, is_logpoint=False, add_breakpoint_result=None, on_changed_breakpoint_state=None):
+    # def add_exception_breakpoint(plugin, py_db, type, exception):
+
+    def after_breakpoints_consolidated(self, py_db, canonical_normalized_filename, id_to_pybreakpoint, file_to_line_to_breakpoints):
+        for plugin in self.active_plugins:
+            plugin.after_breakpoints_consolidated(py_db, canonical_normalized_filename, id_to_pybreakpoint, file_to_line_to_breakpoints)
+
+    def remove_exception_breakpoint(self, py_db, exception_type, exception):
+        """
+        :param exception_type: 'django', 'jinja2' (can be extended)
+        """
+        for plugin in self.active_plugins:
+            ret = plugin.remove_exception_breakpoint(py_db, exception_type, exception)
+            if ret:
+                return ret
+
+        return None
+
+    def remove_all_exception_breakpoints(self, py_db):
+        for plugin in self.active_plugins:
+            plugin.remove_all_exception_breakpoints(py_db)
+
+    def get_breakpoints(self, py_db, breakpoint_type):
+        """
+        :param breakpoint_type: 'django-line', 'jinja2-line'
+        """
+        for plugin in self.active_plugins:
+            ret = plugin.get_breakpoints(py_db, breakpoint_type)
+            if ret:
+                return ret
+
+    def can_skip(self, py_db, frame):
+        for plugin in self.active_plugins:
+            if not plugin.can_skip(py_db, frame):
+                return False
+        return True
+
+    def required_events_breakpoint(self) -> Tuple[Literal["line", "call"], ...]:
+        ret = ()
+        for plugin in self.active_plugins:
+            new = plugin.required_events_breakpoint()
+            if new:
+                ret += new
+
+        return ret
+
+    def required_events_stepping(self) -> Tuple[Literal["line", "call", "return"], ...]:
+        ret = ()
+        for plugin in self.active_plugins:
+            new = plugin.required_events_stepping()
+            if new:
+                ret += new
+
+        return ret
+
+    def is_tracked_frame(self, frame) -> bool:
+        for plugin in self.active_plugins:
+            if plugin.is_tracked_frame(frame):
+                return True
+        return False
+
+    def has_exception_breaks(self, py_db) -> bool:
+        for plugin in self.active_plugins:
+            if plugin.has_exception_breaks(py_db):
+                return True
+        return False
+
+    def has_line_breaks(self, py_db) -> bool:
+        for plugin in self.active_plugins:
+            if plugin.has_line_breaks(py_db):
+                return True
+        return False
+
+    def cmd_step_into(self, py_db, frame, event, info, thread, stop_info, stop: bool):
+        """
+        :param stop_info: in/out information. If it should stop then it'll be
+            filled by the plugin.
+        :param stop: whether the stop has already been flagged for this frame.
+        :returns:
+            tuple(stop, plugin_stop)
+        """
+        plugin_stop = False
+        for plugin in self.active_plugins:
+            stop, plugin_stop = plugin.cmd_step_into(py_db, frame, event, info, thread, stop_info, stop)
+            if plugin_stop:
+                return stop, plugin_stop
+        return stop, plugin_stop
+
+    def cmd_step_over(self, py_db, frame, event, info, thread, stop_info, stop):
+        plugin_stop = False
+        for plugin in self.active_plugins:
+            stop, plugin_stop = plugin.cmd_step_over(py_db, frame, event, info, thread, stop_info, stop)
+            if plugin_stop:
+                return stop, plugin_stop
+        return stop, plugin_stop
+
+    def stop(self, py_db, frame, event, thread, stop_info, arg, step_cmd):
+        """
+        The way this works is that the `cmd_step_into` or `cmd_step_over`
+        is called which then fills the `stop_info` and then this method
+        is called to do the actual stop.
+        """
+        for plugin in self.active_plugins:
+            stopped = plugin.stop(py_db, frame, event, thread, stop_info, arg, step_cmd)
+            if stopped:
+                return stopped
+        return False
+
+    def get_breakpoint(self, py_db, frame, event, info):
+        for plugin in self.active_plugins:
+            ret = plugin.get_breakpoint(py_db, frame, event, info)
+            if ret:
+                return ret
+        return None
+
+    def suspend(self, py_db, thread, frame, bp_type):
+        """
+        :param bp_type: 'django' or 'jinja2'
+
+        :return:
+            The frame for the suspend or None if it should not be suspended.
+        """
+        for plugin in self.active_plugins:
+            ret = plugin.suspend(py_db, thread, frame, bp_type)
+            if ret is not None:
+                return ret
+
+        return None
+
+    def exception_break(self, py_db, frame, thread, arg):
+        for plugin in self.active_plugins:
+            ret = plugin.exception_break(py_db, frame, thread, arg)
+            if ret is not None:
+                return ret
+
+        return None
+
+    def change_variable(self, frame, attr, expression):
+        for plugin in self.active_plugins:
+            ret = plugin.change_variable(frame, attr, expression, self.EMPTY_SENTINEL)
+            if ret is not self.EMPTY_SENTINEL:
+                return ret
+
+        return self.EMPTY_SENTINEL