debugpy 1.8.7__zip → 1.8.8__zip

{debugpy-1.8.7 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/_pydevd_sys_monitoring/_pydevd_sys_monitoring_cython.pyx

@@ -19,9 +19,9 @@ from typing import Dict, Optional, Tuple, Any
 from os.path import basename, splitext
 
 from _pydev_bundle import pydev_log
-from _pydev_bundle.pydev_is_thread_alive import is_thread_alive
 from _pydevd_bundle import pydevd_dont_trace
 from _pydevd_bundle.pydevd_constants import (
+    IS_PY313_OR_GREATER,
     GlobalDebuggerHolder,
     ForkSafeLock,
     PYDEVD_IPYTHON_CONTEXT,
@@ -29,7 +29,6 @@ from _pydevd_bundle.pydevd_constants import (
     RETURN_VALUES_DICT,
     PYTHON_SUSPEND,
 )
-from _pydevd_bundle.pydevd_frame_utils import short_tb, flag_as_unwinding, short_frame
 from pydevd_file_utils import (
     NORM_PATHS_AND_BASE_CONTAINER,
     get_abs_path_real_path_and_base_from_file,
@@ -41,6 +40,7 @@ from _pydevd_bundle.pydevd_trace_dispatch import is_unhandled_exception
 from _pydevd_bundle.pydevd_breakpoints import stop_on_unhandled_exception
 from _pydevd_bundle.pydevd_utils import get_clsname_for_code
 
+
 # fmt: off
 # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
 import cython
@@ -66,10 +66,8 @@ _thread_local_info = threading.local()
 _get_ident = threading.get_ident
 _thread_active = threading._active  # noqa
 
-STATE_SUSPEND: int = 2
 CMD_STEP_INTO: int = 107
 CMD_STEP_OVER: int = 108
-CMD_STEP_OVER_MY_CODE: int = 159
 CMD_STEP_INTO_MY_CODE: int = 144
 CMD_STEP_INTO_COROUTINE: int = 206
 CMD_SMART_STEP_INTO: int = 128
@@ -178,65 +176,62 @@ cdef _get_bootstrap_frame(depth):
 
 # fmt: off
 # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
-cdef _is_user_frame(frame: FrameType):
+cdef _get_unhandled_exception_frame(exc, int depth):
 # ELSE
-# def _is_user_frame(frame: FrameType) -> bool:
+# def _get_unhandled_exception_frame(exc, depth: int) -> Optional[FrameType]:
 # ENDIF
 # fmt: on
-    if frame is None:
-        return False
+    try:
+        # Unhandled frame has to be from the same exception.
+        if _thread_local_info.f_unhandled_exc is exc:
+            return _thread_local_info.f_unhandled_frame
+        else:
+            del _thread_local_info.f_unhandled_frame
+            del _thread_local_info.f_unhandled_exc
+            raise AttributeError('Not the same exception')
+    except:
+        f_unhandled = _getframe(depth)
 
-    filename = frame.f_code.co_filename
-    name = splitext(basename(filename))[0]
+        while f_unhandled is not None and f_unhandled.f_back is not None:
+            f_back = f_unhandled.f_back
+            filename = f_back.f_code.co_filename
+            name = splitext(basename(filename))[0]
 
-    # When the frame is the bootstrap it is not a user frame.
-    if name == "threading":
-        if frame.f_code.co_name in ("__bootstrap", "_bootstrap", "__bootstrap_inner", "_bootstrap_inner", "run"):
-            return False
+            # When the back frame is the bootstrap (or if we have no back
+            # frame) then use this frame as the one to track.
+            if name == "threading":
+                if f_back.f_code.co_name in ("__bootstrap", "_bootstrap", "__bootstrap_inner", "_bootstrap_inner", "run"):
+                    break
 
-    elif name == "pydev_monkey":
-        if frame.f_code.co_name == "__call__":
-            return False
+            elif name == "pydev_monkey":
+                if f_back.f_code.co_name == "__call__":
+                    break
 
-    elif name == "pydevd":
-        if frame.f_code.co_name in ("_exec", "run", "main"):
-            return False
+            elif name == "pydevd":
+                if f_back.f_code.co_name in ("_exec", "run", "main"):
+                    break
 
-    elif name == "pydevd_runpy":
-        if frame.f_code.co_name.startswith(("run", "_run")):
-            return False
+            elif name == "pydevd_runpy":
+                if f_back.f_code.co_name.startswith(("run", "_run")):
+                    break
 
-    elif filename == "<frozen runpy>":
-        if frame.f_code.co_name.startswith(("run", "_run")):
-            return False
+            elif name == "<frozen runpy>":
+                if f_back.f_code.co_name.startswith(("run", "_run")):
+                    break
 
-    elif name == 'runpy':
-        if frame.f_code.co_name.startswith(("run", "_run")):
-            return False
+            elif name == "runpy":
+                if f_back.f_code.co_name.startswith(("run", "_run")):
+                    break
 
-    return True
+            f_unhandled = f_back
+
+        if f_unhandled is not None:
+            _thread_local_info.f_unhandled_frame = f_unhandled
+            _thread_local_info.f_unhandled_exc = exc
+            return _thread_local_info.f_unhandled_frame
+
+        return f_unhandled
 
-# fmt: off
-# IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
-cdef _is_last_user_frame(frame: FrameType):
-# ELSE
-# def _is_last_user_frame(frame: FrameType) -> bool:
-# ENDIF
-# fmt: on 
-    # If this frame is not a user frame, then it can't be the last one
-    if not _is_user_frame(frame):
-        return False
-    
-    # If this frame is the last frame, then it is the last one
-    if frame.f_back is None:
-        return True
-    
-    # If the next frame is not a user frame, then this frame is the last one
-    if not _is_user_frame(frame.f_back):
-        return True
-    
-    # Otherwise if the next frame is a user frame, then this frame is not the last one
-    return False
 
 # fmt: off
 # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
@@ -245,6 +240,7 @@ cdef class ThreadInfo:
     cdef PyDBAdditionalThreadInfo additional_info
     thread: threading.Thread
     trace: bool
+    _use_is_stopped: bool
 # ELSE
 # class ThreadInfo:
 #     additional_info: PyDBAdditionalThreadInfo
@@ -265,6 +261,19 @@ cdef class ThreadInfo:
         self.thread_ident = thread_ident
         self.additional_info = additional_info
         self.trace = trace
+        self._use_is_stopped = hasattr(thread, '_is_stopped')
+        
+    # fmt: off
+    # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
+    cdef bint is_thread_alive(self):
+    # ELSE
+#     def is_thread_alive(self):
+    # ENDIF
+    # fmt: on
+        if self._use_is_stopped:
+            return not self.thread._is_stopped
+        else:
+            return not self.thread._handle.is_done()
 
 
 class _DeleteDummyThreadOnDel:
@@ -328,7 +337,7 @@ cdef _create_thread_info(depth):
     if t is None:
         t = _thread_active.get(thread_ident)
 
-    if isinstance(t, threading._DummyThread):
+    if isinstance(t, threading._DummyThread) and not IS_PY313_OR_GREATER:
         _thread_local_info._ref = _DeleteDummyThreadOnDel(t)
 
     if t is None:
@@ -415,8 +424,9 @@ cdef class FuncCodeInfo:
 
     def get_line_of_offset(self, offset):
         for start, end, line in self.code_obj.co_lines():
-            if offset >= start and offset <= end:
-                return line
+            if start is not None and end is not None and line is not None:
+                if offset >= start and offset <= end:
+                    return line
         return -1
 
 
@@ -447,15 +457,41 @@ cdef _get_thread_info(bint create, int depth):
         return _thread_local_info.thread_info
 
 
-_CodeLineInfo = namedtuple("_CodeLineInfo", "line_to_offset, first_line, last_line")
+# fmt: off
+# IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
+cdef class _CodeLineInfo:
+    cdef dict line_to_offset
+    cdef int first_line
+    cdef int last_line
+# ELSE
+# class _CodeLineInfo:
+#     line_to_offset: Dict[int, Any]
+#     first_line: int
+#     last_line: int
+# ENDIF
+# fmt: on
 
+    # fmt: off
+    # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
+    def __init__(self, dict line_to_offset, int first_line, int last_line):
+        self.line_to_offset = line_to_offset
+        self.first_line = first_line
+        self.last_line = last_line
+    # ELSE
+#     def __init__(self, line_to_offset, first_line, last_line):
+#         self.line_to_offset = line_to_offset
+#         self.first_line = first_line
+#         self.last_line = last_line
+# 
+    # ENDIF
+    # fmt: on
 
 # Note: this method has a version in cython too
 # fmt: off
 # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
-cdef _get_code_line_info(code_obj, _cache={}):
+cdef _CodeLineInfo _get_code_line_info(code_obj, _cache={}):
 # ELSE
-# def _get_code_line_info(code_obj, _cache={}):
+# def _get_code_line_info(code_obj, _cache={}) -> _CodeLineInfo:
 # ENDIF
 # fmt: on
     try:
@@ -838,23 +874,23 @@ cdef _unwind_event(code, instruction, exc):
         if thread_info is None:
             return
 
-    frame = _getframe(1)
-    arg = (type(exc), exc, exc.__traceback__)
 
     py_db: object = GlobalDebuggerHolder.global_dbg
     if py_db is None or py_db.pydb_disposed:
         return
 
-    if not thread_info.trace or not is_thread_alive(thread_info.thread):
+    if not thread_info.trace or not thread_info.is_thread_alive():
         # For thread-related stuff we can't disable the code tracing because other
         # threads may still want it...
         return
-    
+
     func_code_info: FuncCodeInfo = _get_func_code_info(code, 1)
     if func_code_info.always_skip_code:
         return
-    
+
     # print('_unwind_event', code, exc)
+    frame = _getframe(1)
+    arg = (type(exc), exc, exc.__traceback__)
 
     has_caught_exception_breakpoint_in_pydb = (
         py_db.break_on_caught_exceptions or py_db.break_on_user_uncaught_exceptions or py_db.has_plugin_exception_breaks
@@ -863,7 +899,7 @@ cdef _unwind_event(code, instruction, exc):
 
     if has_caught_exception_breakpoint_in_pydb:
         _should_stop, frame, user_uncaught_exc_info = should_stop_on_exception(
-            py_db, thread_info.additional_info, frame, thread_info.thread, arg, None
+            py_db, thread_info.additional_info, frame, thread_info.thread, arg, None, is_unwind=True
         )
         if user_uncaught_exc_info:
             # TODO: Check: this may no longer be needed as in the unwind we know it's
@@ -877,13 +913,14 @@ cdef _unwind_event(code, instruction, exc):
             )
 
             if is_unhandled:
-                # print('stop in user uncaught')
                 handle_exception(py_db, thread_info.thread, frame, user_uncaught_exc_info[0], EXCEPTION_TYPE_USER_UNHANDLED)
                 return
 
     break_on_uncaught_exceptions = py_db.break_on_uncaught_exceptions
-    if break_on_uncaught_exceptions and _is_last_user_frame(frame):
-        stop_on_unhandled_exception(py_db, thread_info.thread, thread_info.additional_info, arg)
+    if break_on_uncaught_exceptions:
+        if frame is _get_unhandled_exception_frame(exc, 1):
+            stop_on_unhandled_exception(py_db, thread_info.thread, thread_info.additional_info, arg)
+            return
 
 
 # fmt: off
@@ -911,15 +948,12 @@ cdef _raise_event(code, instruction, exc):
         thread_info = _get_thread_info(True, 1)
         if thread_info is None:
             return
-
-    frame = _getframe(1)
-    arg = (type(exc), exc, exc.__traceback__)
-
+        
     py_db: object = GlobalDebuggerHolder.global_dbg
     if py_db is None or py_db.pydb_disposed:
         return
 
-    if not thread_info.trace or not is_thread_alive(thread_info.thread):
+    if not thread_info.trace or not thread_info.is_thread_alive():
         # For thread-related stuff we can't disable the code tracing because other
         # threads may still want it...
         return
@@ -928,7 +962,8 @@ cdef _raise_event(code, instruction, exc):
     if func_code_info.always_skip_code:
         return
 
-    # print('_raise_event --- ', code, exc)
+    frame = _getframe(1)
+    arg = (type(exc), exc, exc.__traceback__)
 
     # Compute the previous exception info (if any). We use it to check if the exception
     # should be stopped
@@ -944,10 +979,6 @@ cdef _raise_event(code, instruction, exc):
     if should_stop:
         handle_exception(py_db, thread_info.thread, frame, arg, EXCEPTION_TYPE_HANDLED)
 
-    # Once we leave the raise event, we are no longer in the state of 'just_raised', so 
-    # indicate that this traceback is for an exception in the unwinding state
-    flag_as_unwinding(exc.__traceback__)
-
 
 # fmt: off
 # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
@@ -1037,7 +1068,7 @@ cdef _return_event(code, instruction, retval):
     if py_db is None or py_db.pydb_disposed:
         return monitor.DISABLE
 
-    if not thread_info.trace or not is_thread_alive(thread_info.thread):
+    if not thread_info.trace or not thread_info.is_thread_alive():
         # For thread-related stuff we can't disable the code tracing because other
         # threads may still want it...
         return
@@ -1348,7 +1379,11 @@ cdef _jump_event(code, int from_offset, int to_offset):
     if py_db is None or py_db.pydb_disposed:
         return monitor.DISABLE
 
-    if not thread_info.trace or not is_thread_alive(thread_info.thread):
+    # If we get another jump event, remove the extra check for the line event
+    if hasattr(_thread_local_info, "f_disable_next_line_if_match"):
+        del _thread_local_info.f_disable_next_line_if_match
+
+    if not thread_info.trace or not thread_info.is_thread_alive():
         # For thread-related stuff we can't disable the code tracing because other
         # threads may still want it...
         return
@@ -1364,9 +1399,8 @@ cdef _jump_event(code, int from_offset, int to_offset):
     if to_offset > from_offset:
         return monitor.DISABLE
 
-    from_line = func_code_info.get_line_of_offset(from_offset)
-    to_line = func_code_info.get_line_of_offset(to_offset)
-    # print('jump event', code.co_name, 'from line', from_line, 'to line', to_line)
+    from_line = func_code_info.get_line_of_offset(from_offset or 0)
+    to_line = func_code_info.get_line_of_offset(to_offset or 0)
 
     if from_line != to_line:
         # I.e.: use case: "yield from [j for j in a if j % 2 == 0]"
@@ -1376,7 +1410,8 @@ cdef _jump_event(code, int from_offset, int to_offset):
     frame = _getframe(1)
 
     # Disable the next line event as we're jumping to a line. The line event will be redundant.
-    _thread_local_info.f_disable_next_line_if_match = frame.f_lineno
+    _thread_local_info.f_disable_next_line_if_match = (func_code_info.co_filename, frame.f_lineno)
+    # pydev_log.debug('_jump_event', code.co_name, 'from line', from_line, 'to line', frame.f_lineno)
 
     return _internal_line_event(func_code_info, frame, frame.f_lineno)
 
@@ -1405,24 +1440,26 @@ cdef _line_event(code, int line):
     if py_db is None or py_db.pydb_disposed:
         return monitor.DISABLE
 
-    if not thread_info.trace or not is_thread_alive(thread_info.thread):
+    # If we get another line event, remove the extra check for the line event
+    if hasattr(_thread_local_info, "f_disable_next_line_if_match"):
+        (co_filename, line_to_skip) = _thread_local_info.f_disable_next_line_if_match
+        del _thread_local_info.f_disable_next_line_if_match
+        if line_to_skip is line and co_filename == code.co_filename:
+            # The last jump already jumped to this line and we haven't had any
+            # line events or jumps since then. We don't want to consider this line twice
+            # pydev_log.debug('_line_event skipped', line)
+            return
+
+    if not thread_info.trace or not thread_info.is_thread_alive():
         # For thread-related stuff we can't disable the code tracing because other
         # threads may still want it...
         return
     
-    if hasattr(_thread_local_info, "f_disable_next_line_if_match"):
-        if _thread_local_info.f_disable_next_line_if_match is line:
-            # If we're in a jump, we should skip this line event. The jump would have
-            # been considered a line event for this same line and we don't want to
-            # stop twice.
-            del _thread_local_info.f_disable_next_line_if_match
-            return
-
     func_code_info: FuncCodeInfo = _get_func_code_info(code, 1)
     if func_code_info.always_skip_code or func_code_info.always_filtered_out:
         return monitor.DISABLE
 
-    # print('line event', code.co_name, line)
+    # pydev_log.debug('_line_event', code.co_name, line)
 
     # We know the frame depth.
     frame = _getframe(1)
@@ -1652,7 +1689,7 @@ cdef _start_method_event(code, instruction_offset):
     if py_db is None or py_db.pydb_disposed:
         return monitor.DISABLE
 
-    if not thread_info.trace or not is_thread_alive(thread_info.thread):
+    if not thread_info.trace or not thread_info.is_thread_alive():
         # For thread-related stuff we can't disable the code tracing because other
         # threads may still want it...
         return
@@ -1849,7 +1886,10 @@ def update_monitor_events(suspend_requested: Optional[bool] = None) -> None:
         monitor.register_callback(DEBUGGER_ID, monitor.events.PY_START, _start_method_event)
         # monitor.register_callback(DEBUGGER_ID, monitor.events.PY_RESUME, _resume_method_event)
         monitor.register_callback(DEBUGGER_ID, monitor.events.LINE, _line_event)
-        monitor.register_callback(DEBUGGER_ID, monitor.events.JUMP, _jump_event)
+        if not IS_PY313_OR_GREATER:
+            # In Python 3.13+ jump_events aren't necessary as we have a line_event for every
+            # jump location. 
+            monitor.register_callback(DEBUGGER_ID, monitor.events.JUMP, _jump_event)
         monitor.register_callback(DEBUGGER_ID, monitor.events.PY_RETURN, _return_event)
 
     else:

{debugpy-1.8.7 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookqt4.py

@@ -19,8 +19,7 @@ Author: Christian Boos
 import os
 import signal
 
-import threading
-
+from _pydev_bundle._pydev_saved_modules import threading
 
 from pydev_ipython.qt_for_kernel import QtCore, QtGui
 from pydev_ipython.inputhook import allow_CTRL_C, ignore_CTRL_C, stdin_ready

{debugpy-1.8.7 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookqt5.py

@@ -19,7 +19,7 @@ Author: Christian Boos
 import os
 import signal
 
-import threading
+from _pydev_bundle._pydev_saved_modules import threading
 
 from pydev_ipython.qt_for_kernel import QtCore, QtGui
 from pydev_ipython.inputhook import allow_CTRL_C, ignore_CTRL_C, stdin_ready

{debugpy-1.8.7 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookqt6.py

@@ -19,7 +19,7 @@ Author: Christian Boos, Marijn van Vliet
 import os
 import signal
 
-import threading
+from _pydev_bundle._pydev_saved_modules import threading
 
 from pydev_ipython.qt_for_kernel import QtCore, QtGui
 from pydev_ipython.inputhook import allow_CTRL_C, ignore_CTRL_C, stdin_ready

{debugpy-1.8.7 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/pydev_ipython/qt_loaders.py

@@ -127,21 +127,44 @@ def has_binding(api):
     }
     module_name = module_name[api]
 
-    import imp
+    import importlib
 
     try:
         # importing top level PyQt4/PySide module is ok...
         mod = __import__(module_name)
         # ...importing submodules is not
-        imp.find_module("QtCore", mod.__path__)
-        imp.find_module("QtGui", mod.__path__)
-        imp.find_module("QtSvg", mod.__path__)
+
+        for check in ("QtCore", "QtGui", "QtSvg"):
+            if importlib.util.find_spec("%s.%s" % (module_name, check)) is None:
+                return False
 
         # we can also safely check PySide version
         if api == QT_API_PYSIDE:
             return check_version(mod.__version__, "1.0.3")
         else:
             return True
+
+    except ModuleNotFoundError:
+        from importlib import machinery
+
+        # importing top level PyQt4/PySide module is ok...
+        mod = __import__(module_name)
+
+        # ...importing submodules is not
+        loader_details = (machinery.ExtensionFileLoader, machinery.EXTENSION_SUFFIXES)
+        submod_finder = machinery.FileFinder(mod.__path__[0], loader_details)
+        submod_check = (
+            submod_finder.find_spec("QtCore") is not None
+            and submod_finder.find_spec("QtGui") is not None
+            and submod_finder.find_spec("QtSvg") is not None
+        )
+
+        # we can also safely check PySide version
+        if api == QT_API_PYSIDE:
+            return check_version(mod.__version__, '1.0.3') and submod_check
+        else:
+            return submod_check
+                
     except ImportError:
         return False
 

debugpy-1.8.8/src/debugpy/_vendored/pydevd/pydev_ipython/version.py

@@ -0,0 +1,50 @@
+"""
+Utility for version comparison
+"""
+
+
+class _Version:
+    def __init__(self, s):
+        parts = s.split(".")
+        version_parts = []
+        for p in parts:
+            try:
+                version_parts.append(int(p))
+            except ValueError:
+                version_parts.append(p)
+
+        self._version_parts = tuple(version_parts)
+
+    def __ge__(self, v):
+        this_parts = self._version_parts
+        other_parts = v._version_parts
+
+        while len(this_parts) < len(other_parts):
+            this_parts = this_parts + (0,)
+
+        return this_parts >= other_parts
+
+
+def check_version(found_version, expected_min_or_eq_to_version):
+    """check version string found_version >= expected_min_or_eq_to_version
+
+    If dev/prerelease tags result in TypeError for string-number comparison,
+    it is assumed that the dependency is satisfied.
+    Users on dev branches are responsible for keeping their own packages up to date.
+    """
+    try:
+        return _Version(found_version) >= _Version(expected_min_or_eq_to_version)
+    except TypeError:
+        return True
+
+
+if __name__ == "__main__":
+    assert check_version("1.2.3", "1.2.3")
+    assert check_version("1.2.4", "1.2.3")
+    assert check_version("1.2", "1.2.bar")
+    assert check_version("1.3", "1.2.bar")
+    assert check_version("1.3", "1.2b")
+    assert not check_version("1.2", "1.3")
+    assert not check_version("1.2.0", "1.2.1")
+    assert not check_version("1.2", "1.2.1")
+    print("Ok, checks passed")

{debugpy-1.8.7 → debugpy-1.8.8}/src/debugpy/_vendored/pydevd/pydevd.py

@@ -3,6 +3,7 @@ Entry point module (keep at root):
 
 This module starts the debugger.
 """
+
 import sys  # @NoMove
 
 if sys.version_info[:2] < (3, 6):
@@ -11,14 +12,11 @@ if sys.version_info[:2] < (3, 6):
     )
 import os
 
-try:
-    # Just empty packages to check if they're in the PYTHONPATH.
-    import _pydev_bundle
-except ImportError:
-    # On the first import of a pydevd module, add pydevd itself to the PYTHONPATH
-    # if its dependencies cannot be imported.
-    sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-    import _pydev_bundle
+# On the first import of a pydevd module, add pydevd itself to the PYTHONPATH
+this_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, this_dir)
+
+import _pydev_bundle
 
 # Import this first as it'll check for shadowed modules and will make sure that we import
 # things as needed for gevent.
@@ -100,7 +98,7 @@ from _pydevd_bundle.pydevd_defaults import PydevdCustomization  # Note: import a
 from _pydevd_bundle.pydevd_custom_frames import CustomFramesContainer, custom_frames_container_init
 from _pydevd_bundle.pydevd_dont_trace_files import DONT_TRACE, PYDEV_FILE, LIB_FILE, DONT_TRACE_DIRS
 from _pydevd_bundle.pydevd_extension_api import DebuggerEventHandler
-from _pydevd_bundle.pydevd_frame_utils import add_exception_to_frame, remove_exception_from_frame
+from _pydevd_bundle.pydevd_frame_utils import add_exception_to_frame, remove_exception_from_frame, short_stack
 from _pydevd_bundle.pydevd_net_command_factory_xml import NetCommandFactory
 from _pydevd_bundle.pydevd_trace_dispatch import (
     trace_dispatch as _trace_dispatch,
@@ -175,7 +173,7 @@ if SUPPORT_GEVENT:
 if USE_CUSTOM_SYS_CURRENT_FRAMES_MAP:
     from _pydevd_bundle.pydevd_constants import constructed_tid_to_last_frame
 
-__version_info__ = (3, 1, 0)
+__version_info__ = (3, 2, 2)
 __version_info_str__ = []
 for v in __version_info__:
     __version_info_str__.append(str(v))
@@ -793,10 +791,10 @@ class PyDB(object):
                     max_line = -1
                     min_line = sys.maxsize
                     for _, line in dis.findlinestarts(code_obj):
-                        if line > max_line:
+                        if line is not None and line > max_line:
                             max_line = line
 
-                        if line < min_line:
+                        if line is not None and line < min_line:
                             min_line = line
 
                     try_except_infos = [x for x in try_except_infos if min_line <= x.try_line <= max_line]
@@ -1075,20 +1073,7 @@ class PyDB(object):
             return _cache_file_type[cache_key]
         except:
             if abs_real_path_and_basename[0] == "<string>":
-                # Consider it an untraceable file unless there's no back frame (ignoring
-                # internal files and runpy.py).
-                if frame.f_back is None:
-                    _cache_file_type[cache_key] = None
-                    return None
-                
-                back_basename = pydevd_file_utils.basename(frame.f_back.f_code.co_filename)
-                if "sys_monitoring" in back_basename or "pydevd" in back_basename:
-                    # Special case, this is a string coming from pydevd itself
-                    _cache_file_type[cache_key] = PYDEV_FILE
-                    return PYDEV_FILE
-
                 f = frame.f_back
-                back_frames = ""
                 while f is not None:
                     if self.get_file_type(f) != self.PYDEV_FILE and pydevd_file_utils.basename(f.f_code.co_filename) not in (
                         "runpy.py",
@@ -1105,8 +1090,7 @@ class PyDB(object):
                         # to show it in the stack.
                         _cache_file_type[cache_key] = LIB_FILE
                         return LIB_FILE
-                    
-                    back_frames += " -> %s" % (pydevd_file_utils.basename(f.f_code.co_filename))
+
                     f = f.f_back
                 else:
                     # This is a top-level file (used in python -c), so, trace it as usual... we
@@ -2399,7 +2383,6 @@ class PyDB(object):
         while frame is not None:
             if not isinstance(frame, FrameType):
                 # This is the case for django/jinja frames.
-                pydev_log.debug("Not a frame: %s", frame)
                 frame = frame.f_back
                 continue
 
@@ -3709,5 +3692,13 @@ def main():
             debugger.wait_for_commands(globals)
 
 
+try:
+    # Remove the entry we added: it should no longer be needed as
+    # what we need should've been imported already
+    if sys.path[:1] == [this_dir]:
+        sys.path.remove(this_dir)
+except Exception:
+    pass
+
 if __name__ == "__main__":
     main()