debugpy 1.8.5__zip → 1.8.7__zip

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

@@ -4,13 +4,20 @@ import re
 
 from _pydev_bundle import pydev_log
 from _pydevd_bundle import pydevd_dont_trace
-from _pydevd_bundle.pydevd_constants import (RETURN_VALUES_DICT, NO_FTRACE,
-    EXCEPTION_TYPE_HANDLED, EXCEPTION_TYPE_USER_UNHANDLED, PYDEVD_IPYTHON_CONTEXT)
+from _pydevd_bundle.pydevd_constants import (
+    RETURN_VALUES_DICT,
+    NO_FTRACE,
+    EXCEPTION_TYPE_HANDLED,
+    EXCEPTION_TYPE_USER_UNHANDLED,
+    PYDEVD_IPYTHON_CONTEXT,
+    PYDEVD_USE_SYS_MONITORING,
+)
 from _pydevd_bundle.pydevd_frame_utils import add_exception_to_frame, just_raised, remove_exception_from_frame, ignore_exception_trace
 from _pydevd_bundle.pydevd_utils import get_clsname_for_code
 from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame
 from _pydevd_bundle.pydevd_comm_constants import constant_to_str, CMD_SET_FUNCTION_BREAK
 import sys
+
 try:
     from _pydevd_bundle.pydevd_bytecode_utils import get_smart_step_into_variant_from_frame_offset
 except ImportError:
@@ -18,6 +25,7 @@ except ImportError:
     def get_smart_step_into_variant_from_frame_offset(*args, **kwargs):
         return None
 
+
 # IFDEF CYTHON
 # cython_inline_constant: CMD_STEP_INTO = 107
 # cython_inline_constant: CMD_STEP_INTO_MY_CODE = 144
@@ -49,10 +57,10 @@ STATE_SUSPEND = 2
 
 basename = os.path.basename
 
-IGNORE_EXCEPTION_TAG = re.compile('[^#]*#.*@IgnoreException')
-DEBUG_START = ('pydevd.py', 'run')
-DEBUG_START_PY3K = ('_pydev_execfile.py', 'execfile')
-TRACE_PROPERTY = 'pydevd_traceproperty.py'
+IGNORE_EXCEPTION_TAG = re.compile("[^#]*#.*@IgnoreException")
+DEBUG_START = ("pydevd.py", "run")
+DEBUG_START_PY3K = ("_pydev_execfile.py", "execfile")
+TRACE_PROPERTY = "pydevd_traceproperty.py"
 
 import dis
 
@@ -63,10 +71,10 @@ except NameError:
 
 
 # IFDEF CYTHON
-# cdef is_unhandled_exception(container_obj, py_db, frame, int last_raise_line, set raise_lines):
+# def is_unhandled_exception(container_obj, py_db, frame, int last_raise_line, set raise_lines):
 # ELSE
 def is_unhandled_exception(container_obj, py_db, frame, last_raise_line, raise_lines):
-# ENDIF
+    # ENDIF
     if frame.f_lineno in raise_lines:
         return True
 
@@ -95,10 +103,7 @@ def is_unhandled_exception(container_obj, py_db, frame, last_raise_line, raise_l
                 # and it's gotten in the except line.
                 for try_except_info in try_except_infos:
                     if try_except_info.is_line_in_except_block(frame.f_lineno):
-                        if (
-                                frame.f_lineno == try_except_info.except_line or
-                                frame.f_lineno in try_except_info.raise_lines_in_except
-                            ):
+                        if frame.f_lineno == try_except_info.except_line or frame.f_lineno in try_except_info.raise_lines_in_except:
                             # In a raise inside a try..except block or some except which doesn't
                             # match the raised exception.
                             return True
@@ -112,50 +117,54 @@ def is_unhandled_exception(container_obj, py_db, frame, last_raise_line, raise_l
 #         self.try_except_infos = None
 # ELSE
 class _TryExceptContainerObj(object):
-    '''
-    A dumb container object just to containe the try..except info when needed. Meant to be
-    persisent among multiple PyDBFrames to the same code object.
-    '''
+    """
+    A dumb container object just to contain the try..except info when needed. Meant to be
+    persistent among multiple PyDBFrames to the same code object.
+    """
+
     try_except_infos = None
+
+
 # ENDIF
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # PyDBFrame
-#=======================================================================================================================
+# =======================================================================================================================
 # IFDEF CYTHON
 # cdef class PyDBFrame:
 # ELSE
 class PyDBFrame:
-    '''This makes the tracing for a given frame, so, the trace_dispatch
+    """This makes the tracing for a given frame, so, the trace_dispatch
     is used initially when we enter into a new context ('call') and then
     is reused for the entire context.
-    '''
-# ENDIF
-
-    # Note: class (and not instance) attributes.
+    """
 
-    # Same thing in the main debugger but only considering the file contents, while the one in the main debugger
-    # considers the user input (so, the actual result must be a join of both).
-    filename_to_lines_where_exceptions_are_ignored = {}
-    filename_to_stat_info = {}
+    # ENDIF
 
     # IFDEF CYTHON
     # cdef tuple _args
     # cdef int should_skip
     # cdef object exc_info
     # def __init__(self, tuple args):
-        # self._args = args # In the cython version we don't need to pass the frame
-        # self.should_skip = -1  # On cythonized version, put in instance.
-        # self.exc_info = ()
+    #     self._args = args # In the cython version we don't need to pass the frame
+    #     self.should_skip = -1  # On cythonized version, put in instance.
+    #     self.exc_info = ()
     # ELSE
     should_skip = -1  # Default value in class (put in instance on set).
     exc_info = ()  # Default value in class (put in instance on set).
 
-    def __init__(self, args):
-        # args = main_debugger, abs_path_canonical_path_and_base, base, info, t, frame
-        # yeap, much faster than putting in self and then getting it from self later on
-        self._args = args
+    if PYDEVD_USE_SYS_MONITORING:
+
+        def __init__(self, *args, **kwargs):
+            raise RuntimeError("Not expected to be used in sys.monitoring.")
+
+    else:
+
+        def __init__(self, args):
+            # args = py_db, abs_path_canonical_path_and_base, base, info, t, frame
+            # yeap, much faster than putting in self and then getting it from self later on
+            self._args = args
     # ENDIF
 
     def set_suspend(self, *args, **kwargs):
@@ -170,291 +179,42 @@ class PyDBFrame:
     #     cdef tuple exc_info;
     # ELSE
     def trace_exception(self, frame, event, arg):
-    # ENDIF
-        if event == 'exception':
-            should_stop, frame = self._should_stop_on_exception(frame, event, arg)
+        # ENDIF
+        if event == "exception":
+            should_stop, frame, exc_info = should_stop_on_exception(self._args[0], self._args[2], frame, self._args[3], arg, self.exc_info)
+            self.exc_info = exc_info
 
             if should_stop:
-                if self._handle_exception(frame, event, arg, EXCEPTION_TYPE_HANDLED):
+                if handle_exception(self._args[0], self._args[3], frame, arg, EXCEPTION_TYPE_HANDLED):
                     return self.trace_dispatch
 
-        elif event == 'return':
+        elif event == "return":
             exc_info = self.exc_info
             if exc_info and arg is None:
                 frame_skips_cache, frame_cache_key = self._args[4], self._args[5]
-                custom_key = (frame_cache_key, 'try_exc_info')
+                custom_key = (frame_cache_key, "try_exc_info")
                 container_obj = frame_skips_cache.get(custom_key)
                 if container_obj is None:
                     container_obj = frame_skips_cache[custom_key] = _TryExceptContainerObj()
-                if is_unhandled_exception(container_obj, self._args[0], frame, exc_info[1], exc_info[2]) and \
-                        self.handle_user_exception(frame):
+                if is_unhandled_exception(container_obj, self._args[0], frame, exc_info[1], exc_info[2]) and self.handle_user_exception(
+                    frame
+                ):
                     return self.trace_dispatch
 
         return self.trace_exception
 
-    # IFDEF CYTHON
-    # cdef _should_stop_on_exception(self, frame, str event, arg):
-    #     cdef PyDBAdditionalThreadInfo info;
-    #     cdef bint should_stop;
-    #     cdef bint was_just_raised;
-    #     cdef list check_excs;
-    # ELSE
-    def _should_stop_on_exception(self, frame, event, arg):
-    # ENDIF
-
-        # main_debugger, _filename, info, _thread = self._args
-        main_debugger = self._args[0]
-        info = self._args[2]
-        should_stop = False
-
-        # STATE_SUSPEND = 2
-        if info.pydev_state != 2:  # and breakpoint is not None:
-            exception, value, trace = arg
-
-            if trace is not None and hasattr(trace, 'tb_next'):
-                # on jython trace is None on the first event and it may not have a tb_next.
-
-                should_stop = False
-                exception_breakpoint = None
-                try:
-                    if main_debugger.plugin is not None:
-                        result = main_debugger.plugin.exception_break(main_debugger, self, frame, self._args, arg)
-                        if result:
-                            should_stop, frame = result
-                except:
-                    pydev_log.exception()
-
-                if not should_stop:
-                    # Apply checks that don't need the exception breakpoint (where we shouldn't ever stop).
-                    if exception == SystemExit and main_debugger.ignore_system_exit_code(value):
-                        pass
-
-                    elif exception in (GeneratorExit, StopIteration, StopAsyncIteration):
-                        # These exceptions are control-flow related (they work as a generator
-                        # pause), so, we shouldn't stop on them.
-                        pass
-
-                    elif ignore_exception_trace(trace):
-                        pass
-
-                    else:
-                        was_just_raised = trace.tb_next is None
-
-                        # It was not handled by any plugin, lets check exception breakpoints.
-                        check_excs = []
-
-                        # Note: check user unhandled before regular exceptions.
-                        exc_break_user = main_debugger.get_exception_breakpoint(
-                            exception, main_debugger.break_on_user_uncaught_exceptions)
-                        if exc_break_user is not None:
-                            check_excs.append((exc_break_user, True))
-
-                        exc_break_caught = main_debugger.get_exception_breakpoint(
-                            exception, main_debugger.break_on_caught_exceptions)
-                        if exc_break_caught is not None:
-                            check_excs.append((exc_break_caught, False))
-
-                        for exc_break, is_user_uncaught in check_excs:
-                            # Initially mark that it should stop and then go into exclusions.
-                            should_stop = True
-
-                            if main_debugger.exclude_exception_by_filter(exc_break, trace):
-                                pydev_log.debug("Ignore exception %s in library %s -- (%s)" % (exception, frame.f_code.co_filename, frame.f_code.co_name))
-                                should_stop = False
-
-                            elif exc_break.condition is not None and \
-                                    not main_debugger.handle_breakpoint_condition(info, exc_break, frame):
-                                should_stop = False
-
-                            elif is_user_uncaught:
-                                # Note: we don't stop here, we just collect the exc_info to use later on...
-                                should_stop = False
-                                if not main_debugger.apply_files_filter(frame, frame.f_code.co_filename, True) \
-                                        and (frame.f_back is None or main_debugger.apply_files_filter(frame.f_back, frame.f_back.f_code.co_filename, True)):
-                                    # User uncaught means that we're currently in user code but the code
-                                    # up the stack is library code.
-                                    exc_info = self.exc_info
-                                    if not exc_info:
-                                        exc_info = (arg, frame.f_lineno, set([frame.f_lineno]))
-                                    else:
-                                        lines = exc_info[2]
-                                        lines.add(frame.f_lineno)
-                                        exc_info = (arg, frame.f_lineno, lines)
-                                    self.exc_info = exc_info
-                            else:
-                                # I.e.: these are only checked if we're not dealing with user uncaught exceptions.
-                                if exc_break.notify_on_first_raise_only and main_debugger.skip_on_exceptions_thrown_in_same_context \
-                                        and not was_just_raised and not just_raised(trace.tb_next):
-                                    # In this case we never stop if it was just raised, so, to know if it was the first we
-                                    # need to check if we're in the 2nd method.
-                                    should_stop = False  # I.e.: we stop only when we're at the caller of a method that throws an exception
-
-                                elif exc_break.notify_on_first_raise_only and not main_debugger.skip_on_exceptions_thrown_in_same_context \
-                                        and not was_just_raised:
-                                    should_stop = False  # I.e.: we stop only when it was just raised
-
-                                elif was_just_raised and main_debugger.skip_on_exceptions_thrown_in_same_context:
-                                    # Option: Don't break if an exception is caught in the same function from which it is thrown
-                                    should_stop = False
-
-                            if should_stop:
-                                exception_breakpoint = exc_break
-                                try:
-                                    info.pydev_message = exc_break.qname
-                                except:
-                                    info.pydev_message = exc_break.qname.encode('utf-8')
-                                break
-
-                if should_stop:
-                    # Always add exception to frame (must remove later after we proceed).
-                    add_exception_to_frame(frame, (exception, value, trace))
-
-                    if exception_breakpoint is not None and exception_breakpoint.expression is not None:
-                        main_debugger.handle_breakpoint_expression(exception_breakpoint, info, frame)
-
-        return should_stop, frame
-
     def handle_user_exception(self, frame):
         exc_info = self.exc_info
         if exc_info:
-            return self._handle_exception(frame, 'exception', exc_info[0], EXCEPTION_TYPE_USER_UNHANDLED)
+            return handle_exception(self._args[0], self._args[3], frame, exc_info[0], EXCEPTION_TYPE_USER_UNHANDLED)
         return False
 
-    # IFDEF CYTHON
-    # cdef _handle_exception(self, frame, str event, arg, str exception_type):
-    #     cdef bint stopped;
-    #     cdef tuple abs_real_path_and_base;
-    #     cdef str absolute_filename;
-    #     cdef str canonical_normalized_filename;
-    #     cdef dict filename_to_lines_where_exceptions_are_ignored;
-    #     cdef dict lines_ignored;
-    #     cdef dict frame_id_to_frame;
-    #     cdef dict merged;
-    #     cdef object trace_obj;
-    #     cdef object main_debugger;
-    # ELSE
-    def _handle_exception(self, frame, event, arg, exception_type):
-    # ENDIF
-        stopped = False
-        try:
-            # print('_handle_exception', frame.f_lineno, frame.f_code.co_name)
-
-            # We have 3 things in arg: exception type, description, traceback object
-            trace_obj = arg[2]
-            main_debugger = self._args[0]
-
-            initial_trace_obj = trace_obj
-            if trace_obj.tb_next is None and trace_obj.tb_frame is frame:
-                # I.e.: tb_next should be only None in the context it was thrown (trace_obj.tb_frame is frame is just a double check).
-                pass
-            else:
-                # Get the trace_obj from where the exception was raised...
-                while trace_obj.tb_next is not None:
-                    trace_obj = trace_obj.tb_next
-
-            if main_debugger.ignore_exceptions_thrown_in_lines_with_ignore_exception:
-                for check_trace_obj in (initial_trace_obj, trace_obj):
-                    abs_real_path_and_base = get_abs_path_real_path_and_base_from_frame(check_trace_obj.tb_frame)
-                    absolute_filename = abs_real_path_and_base[0]
-                    canonical_normalized_filename = abs_real_path_and_base[1]
-
-                    filename_to_lines_where_exceptions_are_ignored = self.filename_to_lines_where_exceptions_are_ignored
-
-                    lines_ignored = filename_to_lines_where_exceptions_are_ignored.get(canonical_normalized_filename)
-                    if lines_ignored is None:
-                        lines_ignored = filename_to_lines_where_exceptions_are_ignored[canonical_normalized_filename] = {}
-
-                    try:
-                        curr_stat = os.stat(absolute_filename)
-                        curr_stat = (curr_stat.st_size, curr_stat.st_mtime)
-                    except:
-                        curr_stat = None
-
-                    last_stat = self.filename_to_stat_info.get(absolute_filename)
-                    if last_stat != curr_stat:
-                        self.filename_to_stat_info[absolute_filename] = curr_stat
-                        lines_ignored.clear()
-                        try:
-                            linecache.checkcache(absolute_filename)
-                        except:
-                            pydev_log.exception('Error in linecache.checkcache(%r)', absolute_filename)
-
-                    from_user_input = main_debugger.filename_to_lines_where_exceptions_are_ignored.get(canonical_normalized_filename)
-                    if from_user_input:
-                        merged = {}
-                        merged.update(lines_ignored)
-                        # Override what we have with the related entries that the user entered
-                        merged.update(from_user_input)
-                    else:
-                        merged = lines_ignored
-
-                    exc_lineno = check_trace_obj.tb_lineno
-
-                    # print ('lines ignored', lines_ignored)
-                    # print ('user input', from_user_input)
-                    # print ('merged', merged, 'curr', exc_lineno)
-
-                    if exc_lineno not in merged:  # Note: check on merged but update lines_ignored.
-                        try:
-                            line = linecache.getline(absolute_filename, exc_lineno, check_trace_obj.tb_frame.f_globals)
-                        except:
-                            pydev_log.exception('Error in linecache.getline(%r, %s, f_globals)', absolute_filename, exc_lineno)
-                            line = ''
-
-                        if IGNORE_EXCEPTION_TAG.match(line) is not None:
-                            lines_ignored[exc_lineno] = 1
-                            return False
-                        else:
-                            # Put in the cache saying not to ignore
-                            lines_ignored[exc_lineno] = 0
-                    else:
-                        # Ok, dict has it already cached, so, let's check it...
-                        if merged.get(exc_lineno, 0):
-                            return False
-
-            thread = self._args[3]
-
-            try:
-                frame_id_to_frame = {}
-                frame_id_to_frame[id(frame)] = frame
-                f = trace_obj.tb_frame
-                while f is not None:
-                    frame_id_to_frame[id(f)] = f
-                    f = f.f_back
-                f = None
-
-                stopped = True
-                main_debugger.send_caught_exception_stack(thread, arg, id(frame))
-                try:
-                    self.set_suspend(thread, CMD_STEP_CAUGHT_EXCEPTION)
-                    self.do_wait_suspend(thread, frame, event, arg, exception_type=exception_type)
-                finally:
-                    main_debugger.send_caught_exception_stack_proceeded(thread)
-            except:
-                pydev_log.exception()
-
-            main_debugger.set_trace_for_frame_and_parents(frame)
-        finally:
-            # Make sure the user cannot see the '__exception__' we added after we leave the suspend state.
-            remove_exception_from_frame(frame)
-            # Clear some local variables...
-            frame = None
-            trace_obj = None
-            initial_trace_obj = None
-            check_trace_obj = None
-            f = None
-            frame_id_to_frame = None
-            main_debugger = None
-            thread = None
-
-        return stopped
-
     # IFDEF CYTHON
     # cdef get_func_name(self, frame):
     #     cdef str func_name
     # ELSE
     def get_func_name(self, frame):
-    # ENDIF
+        # ENDIF
         code_obj = frame.f_code
         func_name = code_obj.co_name
         try:
@@ -471,7 +231,7 @@ class PyDBFrame:
     # cdef _show_return_values(self, frame, arg):
     # ELSE
     def _show_return_values(self, frame, arg):
-    # ENDIF
+        # ENDIF
         try:
             try:
                 f_locals_back = getattr(frame.f_back, "f_locals", None)
@@ -488,10 +248,10 @@ class PyDBFrame:
             f_locals_back = None
 
     # IFDEF CYTHON
-    # cdef _remove_return_values(self, main_debugger, frame):
+    # cdef _remove_return_values(self, py_db, frame):
     # ELSE
-    def _remove_return_values(self, main_debugger, frame):
-    # ENDIF
+    def _remove_return_values(self, py_db, frame):
+        # ENDIF
         try:
             try:
                 # Showing return values was turned off, we should remove them from locals dict.
@@ -507,17 +267,17 @@ class PyDBFrame:
             f_locals_back = None
 
     # IFDEF CYTHON
-    # cdef _get_unfiltered_back_frame(self, main_debugger, frame):
+    # cdef _get_unfiltered_back_frame(self, py_db, frame):
     # ELSE
-    def _get_unfiltered_back_frame(self, main_debugger, frame):
-    # ENDIF
+    def _get_unfiltered_back_frame(self, py_db, frame):
+        # ENDIF
         f = frame.f_back
         while f is not None:
-            if not main_debugger.is_files_filter_enabled:
+            if not py_db.is_files_filter_enabled:
                 return f
 
             else:
-                if main_debugger.apply_files_filter(f, f.f_code.co_filename, False):
+                if py_db.apply_files_filter(f, f.f_code.co_filename, False):
                     f = f.f_back
 
                 else:
@@ -530,7 +290,7 @@ class PyDBFrame:
     #     cdef PyDBAdditionalThreadInfo info;
     # ELSE
     def _is_same_frame(self, target_frame, current_frame):
-    # ENDIF
+        # ENDIF
         if target_frame is current_frame:
             return True
 
@@ -582,7 +342,7 @@ class PyDBFrame:
     #     cdef tuple pydev_smart_step_into_variants
     # ELSE
     def trace_dispatch(self, frame, event, arg):
-    # ENDIF
+        # ENDIF
         # Note: this is a big function because most of the logic related to hitting a breakpoint and
         # stepping is contained in it. Ideally this could be split among multiple functions, but the
         # problem in this case is that in pure-python function calls are expensive and even more so
@@ -592,8 +352,8 @@ class PyDBFrame:
         # generation be better split among what each part does).
 
         try:
-            # DEBUG = '_debugger_case_generator.py' in frame.f_code.co_filename
-            main_debugger, abs_path_canonical_path_and_base, info, thread, frame_skips_cache, frame_cache_key = self._args
+            # DEBUG = '_debugger_case_yield_from.py' in frame.f_code.co_filename
+            py_db, abs_path_canonical_path_and_base, info, thread, frame_skips_cache, frame_cache_key = self._args
             # if DEBUG: print('frame trace_dispatch %s %s %s %s %s %s, stop: %s' % (frame.f_lineno, frame.f_code.co_name, frame.f_code.co_filename, event, constant_to_str(info.pydev_step_cmd), arg, info.pydev_step_stop))
             info.is_tracing += 1
 
@@ -603,36 +363,35 @@ class PyDBFrame:
             line = frame.f_lineno or 0  # Workaround or case where frame.f_lineno is None
             line_cache_key = (frame_cache_key, line)
 
-            if main_debugger.pydb_disposed:
-                return None if event == 'call' else NO_FTRACE
+            if py_db.pydb_disposed:
+                return None if event == "call" else NO_FTRACE
 
-            plugin_manager = main_debugger.plugin
+            plugin_manager = py_db.plugin
             has_exception_breakpoints = (
-                main_debugger.break_on_caught_exceptions
-                or main_debugger.break_on_user_uncaught_exceptions
-                or main_debugger.has_plugin_exception_breaks)
+                py_db.break_on_caught_exceptions or py_db.break_on_user_uncaught_exceptions or py_db.has_plugin_exception_breaks
+            )
 
             stop_frame = info.pydev_step_stop
             step_cmd = info.pydev_step_cmd
             function_breakpoint_on_call_event = None
 
-            if frame.f_code.co_flags & 0xa0:  # 0xa0 ==  CO_GENERATOR = 0x20 | CO_COROUTINE = 0x80
+            if frame.f_code.co_flags & 0xA0:  # 0xa0 ==  CO_GENERATOR = 0x20 | CO_COROUTINE = 0x80
                 # Dealing with coroutines and generators:
                 # When in a coroutine we change the perceived event to the debugger because
                 # a call, StopIteration exception and return are usually just pausing/unpausing it.
-                if event == 'line':
+                if event == "line":
                     is_line = True
                     is_call = False
                     is_return = False
                     is_exception_event = False
 
-                elif event == 'return':
+                elif event == "return":
                     is_line = False
                     is_call = False
                     is_return = True
                     is_exception_event = False
 
-                    returns_cache_key = (frame_cache_key, 'returns')
+                    returns_cache_key = (frame_cache_key, "returns")
                     return_lines = frame_skips_cache.get(returns_cache_key)
                     if return_lines is None:
                         # Note: we're collecting the return lines by inspecting the bytecode as
@@ -640,7 +399,7 @@ class PyDBFrame:
                         # it doesn't give any clear indication when a coroutine or generator is
                         # finishing or just pausing.
                         return_lines = set()
-                        for x in main_debugger.collect_return_info(frame.f_code):
+                        for x in py_db.collect_return_info(frame.f_code):
                             # Note: cython does not support closures in cpdefs (so we can't use
                             # a list comprehension).
                             return_lines.add(x.return_line)
@@ -673,7 +432,7 @@ class PyDBFrame:
                         # frame in this case).
                         if stop_frame is frame and not info.pydev_use_scoped_step_frame:
                             if step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE, CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE):
-                                f = self._get_unfiltered_back_frame(main_debugger, frame)
+                                f = self._get_unfiltered_back_frame(py_db, frame)
                                 if f is not None:
                                     info.pydev_step_cmd = CMD_STEP_INTO_COROUTINE
                                     info.pydev_step_stop = f
@@ -688,19 +447,22 @@ class PyDBFrame:
 
                             elif step_cmd == CMD_STEP_INTO_COROUTINE:
                                 # We're exiting this one, so, mark the new coroutine context.
-                                f = self._get_unfiltered_back_frame(main_debugger, frame)
+                                f = self._get_unfiltered_back_frame(py_db, frame)
                                 if f is not None:
                                     info.pydev_step_stop = f
                                 else:
                                     info.pydev_step_cmd = CMD_STEP_INTO
                                     info.pydev_step_stop = None
 
-                elif event == 'exception':
+                elif event == "exception":
                     breakpoints_for_file = None
                     if has_exception_breakpoints:
-                        should_stop, frame = self._should_stop_on_exception(frame, event, arg)
+                        should_stop, frame, exc_info = should_stop_on_exception(
+                            self._args[0], self._args[2], frame, self._args[3], arg, self.exc_info
+                        )
+                        self.exc_info = exc_info
                         if should_stop:
-                            if self._handle_exception(frame, event, arg, EXCEPTION_TYPE_HANDLED):
+                            if handle_exception(self._args[0], self._args[3], frame, arg, EXCEPTION_TYPE_HANDLED):
                                 return self.trace_dispatch
 
                     return self.trace_dispatch
@@ -709,13 +471,13 @@ class PyDBFrame:
                     return self.trace_dispatch
 
             else:  # Not coroutine nor generator
-                if event == 'line':
+                if event == "line":
                     is_line = True
                     is_call = False
                     is_return = False
                     is_exception_event = False
 
-                elif event == 'return':
+                elif event == "return":
                     is_line = False
                     is_return = True
                     is_call = False
@@ -728,11 +490,12 @@ class PyDBFrame:
                     # Note: this is especially troublesome when we're skipping code with the
                     # @DontTrace comment.
                     if (
-                            stop_frame is frame and
-                            not info.pydev_use_scoped_step_frame and is_return and
-                            step_cmd in (CMD_STEP_OVER, CMD_STEP_RETURN, CMD_STEP_OVER_MY_CODE, CMD_STEP_RETURN_MY_CODE, CMD_SMART_STEP_INTO)
-                        ):
-
+                        stop_frame is frame
+                        and not info.pydev_use_scoped_step_frame
+                        and is_return
+                        and step_cmd
+                        in (CMD_STEP_OVER, CMD_STEP_RETURN, CMD_STEP_OVER_MY_CODE, CMD_STEP_RETURN_MY_CODE, CMD_SMART_STEP_INTO)
+                    ):
                         if step_cmd in (CMD_STEP_OVER, CMD_STEP_RETURN, CMD_SMART_STEP_INTO):
                             info.pydev_step_cmd = CMD_STEP_INTO
                         else:
@@ -743,21 +506,24 @@ class PyDBFrame:
                         if self.handle_user_exception(frame):
                             return self.trace_dispatch
 
-                elif event == 'call':
+                elif event == "call":
                     is_line = False
                     is_call = True
                     is_return = False
                     is_exception_event = False
                     if frame.f_code.co_firstlineno == frame.f_lineno:  # Check line to deal with async/await.
-                        function_breakpoint_on_call_event = main_debugger.function_breakpoint_name_to_breakpoint.get(frame.f_code.co_name)
+                        function_breakpoint_on_call_event = py_db.function_breakpoint_name_to_breakpoint.get(frame.f_code.co_name)
 
-                elif event == 'exception':
+                elif event == "exception":
                     is_exception_event = True
                     breakpoints_for_file = None
                     if has_exception_breakpoints:
-                        should_stop, frame = self._should_stop_on_exception(frame, event, arg)
+                        should_stop, frame, exc_info = should_stop_on_exception(
+                            self._args[0], self._args[2], frame, self._args[3], arg, self.exc_info
+                        )
+                        self.exc_info = exc_info
                         if should_stop:
-                            if self._handle_exception(frame, event, arg, EXCEPTION_TYPE_HANDLED):
+                            if handle_exception(self._args[0], self._args[3], frame, arg, EXCEPTION_TYPE_HANDLED):
                                 return self.trace_dispatch
                     is_line = False
                     is_return = False
@@ -768,7 +534,7 @@ class PyDBFrame:
                     return self.trace_dispatch
 
             if not is_exception_event:
-                breakpoints_for_file = main_debugger.breakpoints.get(abs_path_canonical_path_and_base[1])
+                breakpoints_for_file = py_db.breakpoints.get(abs_path_canonical_path_and_base[1])
 
                 can_skip = False
 
@@ -780,22 +546,27 @@ class PyDBFrame:
                     if step_cmd == -1:
                         can_skip = True
 
-                    elif step_cmd in (CMD_STEP_OVER, CMD_STEP_RETURN, CMD_STEP_OVER_MY_CODE, CMD_STEP_RETURN_MY_CODE) and not self._is_same_frame(stop_frame, frame):
+                    elif step_cmd in (
+                        CMD_STEP_OVER,
+                        CMD_STEP_RETURN,
+                        CMD_STEP_OVER_MY_CODE,
+                        CMD_STEP_RETURN_MY_CODE,
+                    ) and not self._is_same_frame(stop_frame, frame):
                         can_skip = True
 
                     elif step_cmd == CMD_SMART_STEP_INTO and (
-                            stop_frame is not None and
-                            stop_frame is not frame and
-                            stop_frame is not frame.f_back and
-                            (frame.f_back is None or stop_frame is not frame.f_back.f_back)):
+                        stop_frame is not None
+                        and stop_frame is not frame
+                        and stop_frame is not frame.f_back
+                        and (frame.f_back is None or stop_frame is not frame.f_back.f_back)
+                    ):
                         can_skip = True
 
                     elif step_cmd == CMD_STEP_INTO_MY_CODE:
-                        if (
-                            main_debugger.apply_files_filter(frame, frame.f_code.co_filename, True)
-                            and (frame.f_back is None or main_debugger.apply_files_filter(frame.f_back, frame.f_back.f_code.co_filename, True))
-                            ):
-                                can_skip = True
+                        if py_db.apply_files_filter(frame, frame.f_code.co_filename, True) and (
+                            frame.f_back is None or py_db.apply_files_filter(frame.f_back, frame.f_back.f_code.co_filename, True)
+                        ):
+                            can_skip = True
 
                     elif step_cmd == CMD_STEP_INTO_COROUTINE:
                         f = frame
@@ -807,11 +578,15 @@ class PyDBFrame:
                             can_skip = True
 
                     if can_skip:
-                        if plugin_manager is not None and (
-                                main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks):
-                            can_skip = plugin_manager.can_skip(main_debugger, frame)
+                        if plugin_manager is not None and (py_db.has_plugin_line_breaks or py_db.has_plugin_exception_breaks):
+                            can_skip = plugin_manager.can_skip(py_db, frame)
 
-                        if can_skip and main_debugger.show_return_values and info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE) and self._is_same_frame(stop_frame, frame.f_back):
+                        if (
+                            can_skip
+                            and py_db.show_return_values
+                            and info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE)
+                            and self._is_same_frame(stop_frame, frame.f_back)
+                        ):
                             # trace function for showing return values after step over
                             can_skip = False
 
@@ -859,12 +634,12 @@ class PyDBFrame:
                             curr_func_name = frame.f_code.co_name
 
                             # global context is set with an empty name
-                            if curr_func_name in ('?', '<module>', '<lambda>'):
-                                curr_func_name = ''
+                            if curr_func_name in ("?", "<module>", "<lambda>"):
+                                curr_func_name = ""
 
                             for bp in breakpoints_for_file.values():
                                 # will match either global or some function
-                                if bp.func_name in ('None', curr_func_name):
+                                if bp.func_name in ("None", curr_func_name):
                                     has_breakpoint_in_frame = True
                                     break
                         else:
@@ -910,26 +685,29 @@ class PyDBFrame:
                     new_frame = frame
                     stop = True
 
-                elif plugin_manager is not None and main_debugger.has_plugin_line_breaks:
-                    result = plugin_manager.get_breakpoint(main_debugger, self, frame, event, self._args)
+                elif plugin_manager is not None and py_db.has_plugin_line_breaks:
+                    result = plugin_manager.get_breakpoint(py_db, frame, event, self._args[2])
                     if result:
-                        stop_on_plugin_breakpoint, breakpoint, new_frame, bp_type = result
+                        stop_on_plugin_breakpoint = True
+                        breakpoint, new_frame, bp_type = result
 
                 if breakpoint:
                     # ok, hit breakpoint, now, we have to discover if it is a conditional breakpoint
                     # lets do the conditional stuff here
                     if breakpoint.expression is not None:
-                        main_debugger.handle_breakpoint_expression(breakpoint, info, new_frame)
+                        py_db.handle_breakpoint_expression(breakpoint, info, new_frame)
 
                     if stop or stop_on_plugin_breakpoint:
                         eval_result = False
                         if breakpoint.has_condition:
-                            eval_result = main_debugger.handle_breakpoint_condition(info, breakpoint, new_frame)
+                            eval_result = py_db.handle_breakpoint_condition(info, breakpoint, new_frame)
                             if not eval_result:
                                 stop = False
                                 stop_on_plugin_breakpoint = False
 
-                    if is_call and (frame.f_code.co_name in ('<lambda>', '<module>') or (line == 1 and frame.f_code.co_name.startswith('<cell'))):
+                    if is_call and (
+                        frame.f_code.co_name in ("<lambda>", "<module>") or (line == 1 and frame.f_code.co_name.startswith("<cell"))
+                    ):
                         # If we find a call for a module, it means that the module is being imported/executed for the
                         # first time. In this case we have to ignore this hit as it may later duplicated by a
                         # line event at the same place (so, if there's a module with a print() in the first line
@@ -949,27 +727,30 @@ class PyDBFrame:
                         stop_on_plugin_breakpoint = False
 
                         if info.pydev_message is not None and len(info.pydev_message) > 0:
-                            cmd = main_debugger.cmd_factory.make_io_message(info.pydev_message + os.linesep, '1')
-                            main_debugger.writer.add_command(cmd)
+                            cmd = py_db.cmd_factory.make_io_message(info.pydev_message + os.linesep, "1")
+                            py_db.writer.add_command(cmd)
 
-                if main_debugger.show_return_values:
+                if py_db.show_return_values:
                     if is_return and (
-                            (info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE, CMD_SMART_STEP_INTO) and (self._is_same_frame(stop_frame, frame.f_back))) or
-                            (info.pydev_step_cmd in (CMD_STEP_RETURN, CMD_STEP_RETURN_MY_CODE) and (self._is_same_frame(stop_frame, frame))) or
-                            (info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_COROUTINE)) or
-                            (
-                                info.pydev_step_cmd == CMD_STEP_INTO_MY_CODE
-                                and frame.f_back is not None
-                                and not main_debugger.apply_files_filter(frame.f_back, frame.f_back.f_code.co_filename, True)
-                            )
-                        ):
+                        (
+                            info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE, CMD_SMART_STEP_INTO)
+                            and (self._is_same_frame(stop_frame, frame.f_back))
+                        )
+                        or (info.pydev_step_cmd in (CMD_STEP_RETURN, CMD_STEP_RETURN_MY_CODE) and (self._is_same_frame(stop_frame, frame)))
+                        or (info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_COROUTINE))
+                        or (
+                            info.pydev_step_cmd == CMD_STEP_INTO_MY_CODE
+                            and frame.f_back is not None
+                            and not py_db.apply_files_filter(frame.f_back, frame.f_back.f_code.co_filename, True)
+                        )
+                    ):
                         self._show_return_values(frame, arg)
 
-                elif main_debugger.remove_return_values_flag:
+                elif py_db.remove_return_values_flag:
                     try:
-                        self._remove_return_values(main_debugger, frame)
+                        self._remove_return_values(py_db, frame)
                     finally:
-                        main_debugger.remove_return_values_flag = False
+                        py_db.remove_return_values_flag = False
 
                 if stop:
                     self.set_suspend(
@@ -979,7 +760,7 @@ class PyDBFrame:
                     )
 
                 elif stop_on_plugin_breakpoint and plugin_manager is not None:
-                    result = plugin_manager.suspend(main_debugger, thread, frame, bp_type)
+                    result = plugin_manager.suspend(py_db, thread, frame, bp_type)
                     if result:
                         frame = result
 
@@ -996,9 +777,14 @@ class PyDBFrame:
                 # Unfortunately Python itself stops the tracing when it originates from
                 # the tracing function, so, we can't do much about it (just let the user know).
                 exc = sys.exc_info()[0]
-                cmd = main_debugger.cmd_factory.make_console_message(
-                    '%s raised from within the callback set in sys.settrace.\nDebugging will be disabled for this thread (%s).\n' % (exc, thread,))
-                main_debugger.writer.add_command(cmd)
+                cmd = py_db.cmd_factory.make_console_message(
+                    "%s raised from within the callback set in sys.settrace.\nDebugging will be disabled for this thread (%s).\n"
+                    % (
+                        exc,
+                        thread,
+                    )
+                )
+                py_db.writer.add_command(cmd)
                 if not issubclass(exc, (KeyboardInterrupt, SystemExit)):
                     pydev_log.exception()
 
@@ -1012,7 +798,7 @@ class PyDBFrame:
                         # I.e.: cache the result on self.should_skip (no need to evaluate the same frame multiple times).
                         # Note that on a code reload, we won't re-evaluate this because in practice, the frame.f_code
                         # Which will be handled by this frame is read-only, so, we can cache it safely.
-                        if not pydevd_dont_trace.should_trace_hook(frame, abs_path_canonical_path_and_base[0]):
+                        if not pydevd_dont_trace.should_trace_hook(frame.f_code, abs_path_canonical_path_and_base[0]):
                             # -1, 0, 1 to be Cython-friendly
                             should_skip = self.should_skip = 1
                         else:
@@ -1028,19 +814,19 @@ class PyDBFrame:
                     force_check_project_scope = step_cmd == CMD_STEP_INTO_MY_CODE
                     if is_line:
                         if not info.pydev_use_scoped_step_frame:
-                            if force_check_project_scope or main_debugger.is_files_filter_enabled:
-                                stop = not main_debugger.apply_files_filter(frame, frame.f_code.co_filename, force_check_project_scope)
+                            if force_check_project_scope or py_db.is_files_filter_enabled:
+                                stop = not py_db.apply_files_filter(frame, frame.f_code.co_filename, force_check_project_scope)
                             else:
                                 stop = True
                         else:
-                            if force_check_project_scope or main_debugger.is_files_filter_enabled:
+                            if force_check_project_scope or py_db.is_files_filter_enabled:
                                 # Make sure we check the filtering inside ipython calls too...
-                                if not not main_debugger.apply_files_filter(frame, frame.f_code.co_filename, force_check_project_scope):
+                                if not not py_db.apply_files_filter(frame, frame.f_code.co_filename, force_check_project_scope):
                                     return None if is_call else NO_FTRACE
 
                             # We can only stop inside the ipython call.
                             filename = frame.f_code.co_filename
-                            if filename.endswith('.pyc'):
+                            if filename.endswith(".pyc"):
                                 filename = filename[:-1]
 
                             if not filename.endswith(PYDEVD_IPYTHON_CONTEXT[0]):
@@ -1049,7 +835,7 @@ class PyDBFrame:
                                     if f.f_code.co_name == PYDEVD_IPYTHON_CONTEXT[1]:
                                         f2 = f.f_back
                                         if f2 is not None and f2.f_code.co_name == PYDEVD_IPYTHON_CONTEXT[2]:
-                                            pydev_log.debug('Stop inside ipython call')
+                                            pydev_log.debug("Stop inside ipython call")
                                             stop = True
                                             break
                                     f = f.f_back
@@ -1062,11 +848,13 @@ class PyDBFrame:
                                 return None if is_call else NO_FTRACE
 
                     elif is_return and frame.f_back is not None and not info.pydev_use_scoped_step_frame:
-                        if main_debugger.get_file_type(frame.f_back) == main_debugger.PYDEV_FILE:
+                        if py_db.get_file_type(frame.f_back) == py_db.PYDEV_FILE:
                             stop = False
                         else:
-                            if force_check_project_scope or main_debugger.is_files_filter_enabled:
-                                stop = not main_debugger.apply_files_filter(frame.f_back, frame.f_back.f_code.co_filename, force_check_project_scope)
+                            if force_check_project_scope or py_db.is_files_filter_enabled:
+                                stop = not py_db.apply_files_filter(
+                                    frame.f_back, frame.f_back.f_code.co_filename, force_check_project_scope
+                                )
                                 if stop:
                                     # Prevent stopping in a return to the same location we were initially
                                     # (i.e.: double-stop at the same place due to some filtering).
@@ -1089,7 +877,7 @@ class PyDBFrame:
                                 stop = False
 
                     if plugin_manager is not None:
-                        result = plugin_manager.cmd_step_into(main_debugger, frame, event, self._args, stop_info, stop)
+                        result = plugin_manager.cmd_step_into(py_db, frame, event, self._args[2], self._args[3], stop_info, stop)
                         if result:
                             stop, plugin_stop = result
 
@@ -1102,7 +890,7 @@ class PyDBFrame:
                     # i.e.: don't stop in: (stop_frame is frame.f_back and is_return) as we'd stop twice in that line.
 
                     if plugin_manager is not None:
-                        result = plugin_manager.cmd_step_over(main_debugger, frame, event, self._args, stop_info, stop)
+                        result = plugin_manager.cmd_step_over(py_db, frame, event, self._args[2], self._args[3], stop_info, stop)
                         if result:
                             stop, plugin_stop = result
 
@@ -1126,16 +914,19 @@ class PyDBFrame:
                             if pydev_smart_parent_offset >= 0 and pydev_smart_step_into_variants:
                                 # Preferred mode (when the smart step into variants are available
                                 # and the offset is set).
-                                stop = get_smart_step_into_variant_from_frame_offset(back.f_lasti, pydev_smart_step_into_variants) is \
-                                       get_smart_step_into_variant_from_frame_offset(pydev_smart_parent_offset, pydev_smart_step_into_variants)
+                                stop = get_smart_step_into_variant_from_frame_offset(
+                                    back.f_lasti, pydev_smart_step_into_variants
+                                ) is get_smart_step_into_variant_from_frame_offset(
+                                    pydev_smart_parent_offset, pydev_smart_step_into_variants
+                                )
 
                             else:
                                 # Only the name/line is available, so, check that.
                                 curr_func_name = frame.f_code.co_name
 
                                 # global context is set with an empty name
-                                if curr_func_name in ('?', '<module>') or curr_func_name is None:
-                                    curr_func_name = ''
+                                if curr_func_name in ("?", "<module>") or curr_func_name is None:
+                                    curr_func_name = ""
                                 if curr_func_name == info.pydev_func_name and stop_frame.f_lineno == info.pydev_next_line:
                                     stop = True
 
@@ -1162,13 +953,15 @@ class PyDBFrame:
                                 # the child (because this is a generator, the parent may have moved forward
                                 # already -- and that's ok, so, we just check that the parent frame
                                 # matches in this case).
-                                smart_step_into_variant = get_smart_step_into_variant_from_frame_offset(pydev_smart_parent_offset, pydev_smart_step_into_variants)
+                                smart_step_into_variant = get_smart_step_into_variant_from_frame_offset(
+                                    pydev_smart_parent_offset, pydev_smart_step_into_variants
+                                )
                                 # print('matched parent offset', pydev_smart_parent_offset)
                                 # Ok, now, check the child variant
                                 children_variants = smart_step_into_variant.children_variants
                                 stop = children_variants and (
-                                    get_smart_step_into_variant_from_frame_offset(back.f_lasti, children_variants) is \
-                                    get_smart_step_into_variant_from_frame_offset(pydev_smart_child_offset, children_variants)
+                                    get_smart_step_into_variant_from_frame_offset(back.f_lasti, children_variants)
+                                    is get_smart_step_into_variant_from_frame_offset(pydev_smart_child_offset, children_variants)
                                 )
                                 # print('stop at child', stop)
 
@@ -1184,13 +977,13 @@ class PyDBFrame:
                     stop = False
 
                 if stop and step_cmd != -1 and is_return and hasattr(frame, "f_back"):
-                    f_code = getattr(frame.f_back, 'f_code', None)
+                    f_code = getattr(frame.f_back, "f_code", None)
                     if f_code is not None:
-                        if main_debugger.get_file_type(frame.f_back) == main_debugger.PYDEV_FILE:
+                        if py_db.get_file_type(frame.f_back) == py_db.PYDEV_FILE:
                             stop = False
 
                 if plugin_stop:
-                    stopped_on_plugin = plugin_manager.stop(main_debugger, frame, event, self._args, stop_info, arg, step_cmd)
+                    plugin_manager.stop(py_db, frame, event, self._args[3], stop_info, arg, step_cmd)
                 elif stop:
                     if is_line:
                         self.set_suspend(thread, step_cmd, original_step_cmd=info.pydev_original_step_cmd)
@@ -1211,13 +1004,13 @@ class PyDBFrame:
                                 return None if is_call else NO_FTRACE
 
                             elif pydevd_dont_trace.should_trace_hook is not None:
-                                if not pydevd_dont_trace.should_trace_hook(back, back_absolute_filename):
+                                if not pydevd_dont_trace.should_trace_hook(back.f_code, back_absolute_filename):
                                     # In this case, we'll have to skip the previous one because it shouldn't be traced.
                                     # Also, we have to reset the tracing, because if the parent's parent (or some
                                     # other parent) has to be traced and it's not currently, we wouldn't stop where
                                     # we should anymore (so, a step in/over/return may not stop anywhere if no parent is traced).
                                     # Related test: _debugger_case17a.py
-                                    main_debugger.set_trace_for_frame_and_parents(back)
+                                    py_db.set_trace_for_frame_and_parents(thread.ident, back)
                                     return None if is_call else NO_FTRACE
 
                         if back is not None:
@@ -1230,9 +1023,10 @@ class PyDBFrame:
                             info.pydev_original_step_cmd = -1
                             info.pydev_step_cmd = -1
                             info.pydev_state = STATE_RUN
+                            info.update_stepping_info()
 
                 # if we are quitting, let's stop the tracing
-                if main_debugger.quitting:
+                if py_db.quitting:
                     return None if is_call else NO_FTRACE
 
                 return self.trace_dispatch
@@ -1240,9 +1034,14 @@ class PyDBFrame:
                 # Unfortunately Python itself stops the tracing when it originates from
                 # the tracing function, so, we can't do much about it (just let the user know).
                 exc = sys.exc_info()[0]
-                cmd = main_debugger.cmd_factory.make_console_message(
-                    '%s raised from within the callback set in sys.settrace.\nDebugging will be disabled for this thread (%s).\n' % (exc, thread,))
-                main_debugger.writer.add_command(cmd)
+                cmd = py_db.cmd_factory.make_console_message(
+                    "%s raised from within the callback set in sys.settrace.\nDebugging will be disabled for this thread (%s).\n"
+                    % (
+                        exc,
+                        thread,
+                    )
+                )
+                py_db.writer.add_command(cmd)
                 if not issubclass(exc, (KeyboardInterrupt, SystemExit)):
                     pydev_log.exception()
                 raise
@@ -1251,3 +1050,259 @@ class PyDBFrame:
             info.is_tracing -= 1
 
         # end trace_dispatch
+
+
+# IFDEF CYTHON
+# def should_stop_on_exception(py_db, PyDBAdditionalThreadInfo info, frame, thread, arg, prev_user_uncaught_exc_info):
+#     cdef bint should_stop;
+#     cdef bint was_just_raised;
+#     cdef list check_excs;
+# ELSE
+def should_stop_on_exception(py_db, info, frame, thread, arg, prev_user_uncaught_exc_info):
+    # ENDIF
+
+    should_stop = False
+    maybe_user_uncaught_exc_info = prev_user_uncaught_exc_info
+
+    # STATE_SUSPEND = 2
+    if info.pydev_state != 2:  # and breakpoint is not None:
+        exception, value, trace = arg
+
+        if trace is not None and hasattr(trace, "tb_next"):
+            # on jython trace is None on the first event and it may not have a tb_next.
+
+            should_stop = False
+            exception_breakpoint = None
+            try:
+                if py_db.plugin is not None:
+                    result = py_db.plugin.exception_break(py_db, frame, thread, arg)
+                    if result:
+                        should_stop, frame = result
+            except:
+                pydev_log.exception()
+
+            if not should_stop:
+                # Apply checks that don't need the exception breakpoint (where we shouldn't ever stop).
+                if exception == SystemExit and py_db.ignore_system_exit_code(value):
+                    pass
+
+                elif exception in (GeneratorExit, StopIteration, StopAsyncIteration):
+                    # These exceptions are control-flow related (they work as a generator
+                    # pause), so, we shouldn't stop on them.
+                    pass
+
+                elif ignore_exception_trace(trace):
+                    pass
+
+                else:
+                    was_just_raised = just_raised(trace)
+
+                    # It was not handled by any plugin, lets check exception breakpoints.
+                    check_excs = []
+
+                    # Note: check user unhandled before regular exceptions.
+                    exc_break_user = py_db.get_exception_breakpoint(exception, py_db.break_on_user_uncaught_exceptions)
+                    if exc_break_user is not None:
+                        check_excs.append((exc_break_user, True))
+
+                    exc_break_caught = py_db.get_exception_breakpoint(exception, py_db.break_on_caught_exceptions)
+                    if exc_break_caught is not None:
+                        check_excs.append((exc_break_caught, False))
+
+                    for exc_break, is_user_uncaught in check_excs:
+                        # Initially mark that it should stop and then go into exclusions.
+                        should_stop = True
+
+                        if py_db.exclude_exception_by_filter(exc_break, trace):
+                            pydev_log.debug(
+                                "Ignore exception %s in library %s -- (%s)" % (exception, frame.f_code.co_filename, frame.f_code.co_name)
+                            )
+                            should_stop = False
+
+                        elif exc_break.condition is not None and not py_db.handle_breakpoint_condition(info, exc_break, frame):
+                            should_stop = False
+
+                        elif is_user_uncaught:
+                            # Note: we don't stop here, we just collect the exc_info to use later on...
+                            should_stop = False
+                            if not py_db.apply_files_filter(frame, frame.f_code.co_filename, True) and (
+                                frame.f_back is None or py_db.apply_files_filter(frame.f_back, frame.f_back.f_code.co_filename, True)
+                            ):
+                                # User uncaught means that we're currently in user code but the code
+                                # up the stack is library code.
+                                exc_info = prev_user_uncaught_exc_info
+                                if not exc_info:
+                                    exc_info = (arg, frame.f_lineno, set([frame.f_lineno]))
+                                else:
+                                    lines = exc_info[2]
+                                    lines.add(frame.f_lineno)
+                                    exc_info = (arg, frame.f_lineno, lines)
+                                maybe_user_uncaught_exc_info = exc_info
+                        else:
+                            # I.e.: these are only checked if we're not dealing with user uncaught exceptions.
+                            if (
+                                exc_break.notify_on_first_raise_only
+                                and py_db.skip_on_exceptions_thrown_in_same_context
+                                and not was_just_raised
+                                and not just_raised(trace.tb_next)
+                            ):
+                                # In this case we never stop if it was just raised, so, to know if it was the first we
+                                # need to check if we're in the 2nd method.
+                                should_stop = False  # I.e.: we stop only when we're at the caller of a method that throws an exception
+
+                            elif (
+                                exc_break.notify_on_first_raise_only
+                                and not py_db.skip_on_exceptions_thrown_in_same_context
+                                and not was_just_raised
+                            ):
+                                should_stop = False  # I.e.: we stop only when it was just raised
+
+                            elif was_just_raised and py_db.skip_on_exceptions_thrown_in_same_context:
+                                # Option: Don't break if an exception is caught in the same function from which it is thrown
+                                should_stop = False
+
+                        if should_stop:
+                            exception_breakpoint = exc_break
+                            try:
+                                info.pydev_message = exc_break.qname
+                            except:
+                                info.pydev_message = exc_break.qname.encode("utf-8")
+                            break
+
+            if should_stop:
+                # Always add exception to frame (must remove later after we proceed).
+                add_exception_to_frame(frame, (exception, value, trace))
+
+                if exception_breakpoint is not None and exception_breakpoint.expression is not None:
+                    py_db.handle_breakpoint_expression(exception_breakpoint, info, frame)
+
+    return should_stop, frame, maybe_user_uncaught_exc_info
+
+
+# Same thing in the main debugger but only considering the file contents, while the one in the main debugger
+# considers the user input (so, the actual result must be a join of both).
+filename_to_lines_where_exceptions_are_ignored: dict = {}
+filename_to_stat_info: dict = {}
+
+
+# IFDEF CYTHON
+# def handle_exception(py_db, thread, frame, arg, str exception_type):
+#     cdef bint stopped;
+#     cdef tuple abs_real_path_and_base;
+#     cdef str absolute_filename;
+#     cdef str canonical_normalized_filename;
+#     cdef dict lines_ignored;
+#     cdef dict frame_id_to_frame;
+#     cdef dict merged;
+#     cdef object trace_obj;
+# ELSE
+def handle_exception(py_db, thread, frame, arg, exception_type):
+    # ENDIF
+    stopped = False
+    try:
+        # print('handle_exception', frame.f_lineno, frame.f_code.co_name)
+
+        # We have 3 things in arg: exception type, description, traceback object
+        trace_obj = arg[2]
+
+        initial_trace_obj = trace_obj
+        if trace_obj.tb_next is None and trace_obj.tb_frame is frame:
+            # I.e.: tb_next should be only None in the context it was thrown (trace_obj.tb_frame is frame is just a double check).
+            pass
+        else:
+            # Get the trace_obj from where the exception was raised...
+            while trace_obj.tb_next is not None:
+                trace_obj = trace_obj.tb_next
+
+        if py_db.ignore_exceptions_thrown_in_lines_with_ignore_exception:
+            for check_trace_obj in (initial_trace_obj, trace_obj):
+                abs_real_path_and_base = get_abs_path_real_path_and_base_from_frame(check_trace_obj.tb_frame)
+                absolute_filename = abs_real_path_and_base[0]
+                canonical_normalized_filename = abs_real_path_and_base[1]
+
+                lines_ignored = filename_to_lines_where_exceptions_are_ignored.get(canonical_normalized_filename)
+                if lines_ignored is None:
+                    lines_ignored = filename_to_lines_where_exceptions_are_ignored[canonical_normalized_filename] = {}
+
+                try:
+                    curr_stat = os.stat(absolute_filename)
+                    curr_stat = (curr_stat.st_size, curr_stat.st_mtime)
+                except:
+                    curr_stat = None
+
+                last_stat = filename_to_stat_info.get(absolute_filename)
+                if last_stat != curr_stat:
+                    filename_to_stat_info[absolute_filename] = curr_stat
+                    lines_ignored.clear()
+                    try:
+                        linecache.checkcache(absolute_filename)
+                    except:
+                        pydev_log.exception("Error in linecache.checkcache(%r)", absolute_filename)
+
+                from_user_input = py_db.filename_to_lines_where_exceptions_are_ignored.get(canonical_normalized_filename)
+                if from_user_input:
+                    merged = {}
+                    merged.update(lines_ignored)
+                    # Override what we have with the related entries that the user entered
+                    merged.update(from_user_input)
+                else:
+                    merged = lines_ignored
+
+                exc_lineno = check_trace_obj.tb_lineno
+
+                # print ('lines ignored', lines_ignored)
+                # print ('user input', from_user_input)
+                # print ('merged', merged, 'curr', exc_lineno)
+
+                if exc_lineno not in merged:  # Note: check on merged but update lines_ignored.
+                    try:
+                        line = linecache.getline(absolute_filename, exc_lineno, check_trace_obj.tb_frame.f_globals)
+                    except:
+                        pydev_log.exception("Error in linecache.getline(%r, %s, f_globals)", absolute_filename, exc_lineno)
+                        line = ""
+
+                    if IGNORE_EXCEPTION_TAG.match(line) is not None:
+                        lines_ignored[exc_lineno] = 1
+                        return False
+                    else:
+                        # Put in the cache saying not to ignore
+                        lines_ignored[exc_lineno] = 0
+                else:
+                    # Ok, dict has it already cached, so, let's check it...
+                    if merged.get(exc_lineno, 0):
+                        return False
+
+        try:
+            frame_id_to_frame = {}
+            frame_id_to_frame[id(frame)] = frame
+            f = trace_obj.tb_frame
+            while f is not None:
+                frame_id_to_frame[id(f)] = f
+                f = f.f_back
+            f = None
+
+            stopped = True
+            py_db.send_caught_exception_stack(thread, arg, id(frame))
+            try:
+                py_db.set_suspend(thread, CMD_STEP_CAUGHT_EXCEPTION)
+                py_db.do_wait_suspend(thread, frame, "exception", arg, exception_type=exception_type)
+            finally:
+                py_db.send_caught_exception_stack_proceeded(thread)
+        except:
+            pydev_log.exception()
+
+        py_db.set_trace_for_frame_and_parents(thread.ident, frame)
+    finally:
+        # Make sure the user cannot see the '__exception__' we added after we leave the suspend state.
+        remove_exception_from_frame(frame)
+        # Clear some local variables...
+        frame = None
+        trace_obj = None
+        initial_trace_obj = None
+        check_trace_obj = None
+        f = None
+        frame_id_to_frame = None
+        py_db = None
+        thread = None
+
+    return stopped