debugpy 1.8.5__zip → 1.8.7__zip

debugpy-1.8.7/src/debugpy/_vendored/pydevd/_pydevd_sys_monitoring/pydevd_sys_monitoring.py

@@ -0,0 +1,16 @@
+from _pydevd_bundle.pydevd_constants import USE_CYTHON_FLAG, ENV_TRUE_LOWER_VALUES, ENV_FALSE_LOWER_VALUES, IS_PY312_OR_GREATER
+
+if IS_PY312_OR_GREATER:
+    if USE_CYTHON_FLAG in ENV_TRUE_LOWER_VALUES:
+        from ._pydevd_sys_monitoring_cython import *
+
+    elif USE_CYTHON_FLAG in ENV_FALSE_LOWER_VALUES:
+        from ._pydevd_sys_monitoring import *
+
+    else:
+        try:
+            from ._pydevd_sys_monitoring_cython import *
+        except:
+            from ._pydevd_sys_monitoring import *
+else:
+    from ._pydevd_sys_monitoring import *

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

@@ -1,21 +1,22 @@
 if False:
     config = None
-    
-    
+
+
 # See: https://docs.google.com/document/d/1CCSaRiIWCLgbD3OwmuKsRoHHDfBffbROWyVWWL0ZXN4/edit
-if ':' not in config.version_id:
+if ":" not in config.version_id:
     # The default server version_id does not contain ':'
-    import json 
+    import json
     import os
     import sys
-    
+
     startup = config.python_config.startup_args
     if not startup:
-        raise AssertionError('Expected --python_startup_args to be passed from the pydev debugger.')
-    
-    setup = json.loads(startup) 
-    pydevd_path = setup['pydevd']
+        raise AssertionError("Expected --python_startup_args to be passed from the pydev debugger.")
+
+    setup = json.loads(startup)
+    pydevd_path = setup["pydevd"]
     sys.path.append(os.path.dirname(pydevd_path))
-     
+
     import pydevd
-    pydevd.settrace(setup['client'], port=setup['port'], suspend=False, trace_only_current_thread=False)
+
+    pydevd.settrace(setup["client"], port=setup["port"], suspend=False, trace_only_current_thread=False)

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

@@ -1,20 +1,20 @@
-'''
+"""
 Entry point module to run code-coverage.
-'''
+"""
 
 
 def is_valid_py_file(path):
-    '''
+    """
     Checks whether the file can be read by the coverage module. This is especially
     needed for .pyx files and .py files with syntax errors.
-    '''
+    """
     import os
 
     is_valid = False
-    if os.path.isfile(path) and not os.path.splitext(path)[1] == '.pyx':
+    if os.path.isfile(path) and not os.path.splitext(path)[1] == ".pyx":
         try:
-            with open(path, 'rb') as f:
-                compile(f.read(), path, 'exec')
+            with open(path, "rb") as f:
+                compile(f.read(), path, "exec")
                 is_valid = True
         except:
             pass
@@ -26,29 +26,26 @@ def execute():
     import sys
 
     files = None
-    if 'combine' not in sys.argv:
-
-        if '--pydev-analyze' in sys.argv:
-
+    if "combine" not in sys.argv:
+        if "--pydev-analyze" in sys.argv:
             # Ok, what we want here is having the files passed through stdin (because
             # there may be too many files for passing in the command line -- we could
             # just pass a dir and make the find files here, but as that's already
             # given in the java side, let's just gather that info here).
-            sys.argv.remove('--pydev-analyze')
+            sys.argv.remove("--pydev-analyze")
             s = input()
-            s = s.replace('\r', '')
-            s = s.replace('\n', '')
+            s = s.replace("\r", "")
+            s = s.replace("\n", "")
 
             files = []
             invalid_files = []
-            for v in s.split('|'):
+            for v in s.split("|"):
                 if is_valid_py_file(v):
                     files.append(v)
                 else:
                     invalid_files.append(v)
             if invalid_files:
-                sys.stderr.write('Invalid files not passed to coverage: %s\n'
-                                 % ', '.join(invalid_files))
+                sys.stderr.write("Invalid files not passed to coverage: %s\n" % ", ".join(invalid_files))
 
             # Note that in this case we'll already be in the working dir with the coverage files,
             # so, the coverage file location is not passed.
@@ -56,39 +53,40 @@ def execute():
         else:
             # For all commands, the coverage file is configured in pydev, and passed as the first
             # argument in the command line, so, let's make sure this gets to the coverage module.
-            os.environ['COVERAGE_FILE'] = sys.argv[1]
+            os.environ["COVERAGE_FILE"] = sys.argv[1]
             del sys.argv[1]
 
     try:
         import coverage  # @UnresolvedImport
     except:
-        sys.stderr.write('Error: coverage module could not be imported\n')
-        sys.stderr.write('Please make sure that the coverage module '
-                         '(http://nedbatchelder.com/code/coverage/)\n')
-        sys.stderr.write('is properly installed in your interpreter: %s\n' % (sys.executable,))
+        sys.stderr.write("Error: coverage module could not be imported\n")
+        sys.stderr.write("Please make sure that the coverage module " "(http://nedbatchelder.com/code/coverage/)\n")
+        sys.stderr.write("is properly installed in your interpreter: %s\n" % (sys.executable,))
+
+        import traceback
 
-        import traceback;traceback.print_exc()
+        traceback.print_exc()
         return
 
-    if hasattr(coverage, '__version__'):
-        version = tuple(map(int, coverage.__version__.split('.')[:2]))
+    if hasattr(coverage, "__version__"):
+        version = tuple(map(int, coverage.__version__.split(".")[:2]))
         if version < (4, 3):
-            sys.stderr.write('Error: minimum supported coverage version is 4.3.'
-                             '\nFound: %s\nLocation: %s\n'
-                             % ('.'.join(str(x) for x in version), coverage.__file__))
+            sys.stderr.write(
+                "Error: minimum supported coverage version is 4.3."
+                "\nFound: %s\nLocation: %s\n" % (".".join(str(x) for x in version), coverage.__file__)
+            )
             sys.exit(1)
     else:
-        sys.stderr.write('Warning: Could not determine version of python module coverage.'
-                         '\nEnsure coverage version is >= 4.3\n')
+        sys.stderr.write("Warning: Could not determine version of python module coverage." "\nEnsure coverage version is >= 4.3\n")
 
     from coverage.cmdline import main  # @UnresolvedImport
 
     if files is not None:
-        sys.argv.append('xml')
+        sys.argv.append("xml")
         sys.argv += files
 
     main()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     execute()

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhook.py

@@ -3,41 +3,41 @@
 Inputhook management for GUI event loop integration.
 """
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 import sys
 import select
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Constants
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 # Constants for identifying the GUI toolkits.
-GUI_WX = 'wx'
-GUI_QT = 'qt'
-GUI_QT4 = 'qt4'
-GUI_QT5 = 'qt5'
-GUI_QT6 = 'qt6'
-GUI_GTK = 'gtk'
-GUI_TK = 'tk'
-GUI_OSX = 'osx'
-GUI_GLUT = 'glut'
-GUI_PYGLET = 'pyglet'
-GUI_GTK3 = 'gtk3'
-GUI_NONE = 'none'  # i.e. disable
-
-#-----------------------------------------------------------------------------
+GUI_WX = "wx"
+GUI_QT = "qt"
+GUI_QT4 = "qt4"
+GUI_QT5 = "qt5"
+GUI_QT6 = "qt6"
+GUI_GTK = "gtk"
+GUI_TK = "tk"
+GUI_OSX = "osx"
+GUI_GLUT = "glut"
+GUI_PYGLET = "pyglet"
+GUI_GTK3 = "gtk3"
+GUI_NONE = "none"  # i.e. disable
+
+# -----------------------------------------------------------------------------
 # Utilities
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 def ignore_CTRL_C():
@@ -49,9 +49,10 @@ def allow_CTRL_C():
     """Take CTRL+C into account (not implemented)."""
     pass
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 # Main InputHookManager class
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 class InputHookManager(object):
@@ -147,12 +148,14 @@ class InputHookManager(object):
         """
         import wx
         from distutils.version import LooseVersion as V
+
         wx_version = V(wx.__version__).version  # @UndefinedVariable
 
         if wx_version < [2, 8]:
             raise ValueError("requires wxPython >= 2.8, but you have %s" % wx.__version__)  # @UndefinedVariable
 
         from pydev_ipython.inputhookwx import inputhook_wx
+
         self.set_inputhook(inputhook_wx)
         self._current_gui = GUI_WX
 
@@ -175,6 +178,7 @@ class InputHookManager(object):
 
     def enable_qt(self, app=None):
         from pydev_ipython.qt_for_kernel import QT_API, QT_API_PYQT5, QT_API_PYQT6
+
         if QT_API == QT_API_PYQT6:
             self.enable_qt6(app)
         elif QT_API == QT_API_PYQT5:
@@ -205,6 +209,7 @@ class InputHookManager(object):
             app = QtGui.QApplication(sys.argv)
         """
         from pydev_ipython.inputhookqt4 import create_inputhook_qt4
+
         app, inputhook_qt4 = create_inputhook_qt4(self, app)
         self.set_inputhook(inputhook_qt4)
 
@@ -224,6 +229,7 @@ class InputHookManager(object):
 
     def enable_qt5(self, app=None):
         from pydev_ipython.inputhookqt5 import create_inputhook_qt5
+
         app, inputhook_qt5 = create_inputhook_qt5(self, app)
         self.set_inputhook(inputhook_qt5)
 
@@ -239,6 +245,7 @@ class InputHookManager(object):
 
     def enable_qt6(self, app=None):
         from pydev_ipython.inputhookqt6 import create_inputhook_qt6
+
         app, inputhook_qt6 = create_inputhook_qt6(self, app)
         self.set_inputhook(inputhook_qt6)
 
@@ -269,6 +276,7 @@ class InputHookManager(object):
         IPython.
         """
         from pydev_ipython.inputhookgtk import create_inputhook_gtk
+
         self.set_inputhook(create_inputhook_gtk(self._stdin_file))
         self._current_gui = GUI_GTK
 
@@ -307,6 +315,7 @@ class InputHookManager(object):
             self._apps[GUI_TK] = app
 
         from pydev_ipython.inputhooktk import create_inputhook_tk
+
         self.set_inputhook(create_inputhook_tk(app))
         return app
 
@@ -318,7 +327,7 @@ class InputHookManager(object):
         self.clear_inputhook()
 
     def enable_glut(self, app=None):
-        """ Enable event loop integration with GLUT.
+        """Enable event loop integration with GLUT.
 
         Parameters
         ----------
@@ -343,19 +352,16 @@ class InputHookManager(object):
         """
 
         import OpenGL.GLUT as glut  # @UnresolvedImport
-        from pydev_ipython.inputhookglut import glut_display_mode, \
-                                              glut_close, glut_display, \
-                                              glut_idle, inputhook_glut
+        from pydev_ipython.inputhookglut import glut_display_mode, glut_close, glut_display, glut_idle, inputhook_glut
 
         if GUI_GLUT not in self._apps:
-            argv = getattr(sys, 'argv', [])
+            argv = getattr(sys, "argv", [])
             glut.glutInit(argv)
             glut.glutInitDisplayMode(glut_display_mode)
             # This is specific to freeglut
             if bool(glut.glutSetOption):
-                glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE,
-                                    glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
-            glut.glutCreateWindow(argv[0] if len(argv) > 0 else '')
+                glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
+            glut.glutCreateWindow(argv[0] if len(argv) > 0 else "")
             glut.glutReshapeWindow(1, 1)
             glut.glutHideWindow()
             glut.glutWMCloseFunc(glut_close)
@@ -401,6 +407,7 @@ class InputHookManager(object):
 
         """
         from pydev_ipython.inputhookpyglet import inputhook_pyglet
+
         self.set_inputhook(inputhook_pyglet)
         self._current_gui = GUI_PYGLET
         return app
@@ -429,6 +436,7 @@ class InputHookManager(object):
         IPython.
         """
         from pydev_ipython.inputhookgtk3 import create_inputhook_gtk3
+
         self.set_inputhook(create_inputhook_gtk3(self._stdin_file))
         self._current_gui = GUI_GTK
 
@@ -440,7 +448,7 @@ class InputHookManager(object):
         self.clear_inputhook()
 
     def enable_mac(self, app=None):
-        """ Enable event loop integration with MacOSX.
+        """Enable event loop integration with MacOSX.
 
         We call function pyplot.pause, which updates and displays active
         figure during pause. It's not MacOSX-specific, but it enables to
@@ -452,13 +460,13 @@ class InputHookManager(object):
 
         def inputhook_mac(app=None):
             if self.pyplot_imported:
-                pyplot = sys.modules['matplotlib.pyplot']
+                pyplot = sys.modules["matplotlib.pyplot"]
                 try:
                     pyplot.pause(0.01)
                 except:
                     pass
             else:
-                if 'matplotlib.pyplot' in sys.modules:
+                if "matplotlib.pyplot" in sys.modules:
                     self.pyplot_imported = True
 
         self.set_inputhook(inputhook_mac)
@@ -535,22 +543,23 @@ def enable_gui(gui=None, app=None):
     if get_return_control_callback() is None:
         raise ValueError("A return_control_callback must be supplied as a reference before a gui can be enabled")
 
-    guis = {GUI_NONE: clear_inputhook,
-            GUI_OSX: enable_mac,
-            GUI_TK: enable_tk,
-            GUI_GTK: enable_gtk,
-            GUI_WX: enable_wx,
-            GUI_QT: enable_qt,
-            GUI_QT4: enable_qt4,
-            GUI_QT5: enable_qt5,
-            GUI_GLUT: enable_glut,
-            GUI_PYGLET: enable_pyglet,
-            GUI_GTK3: enable_gtk3,
-            }
+    guis = {
+        GUI_NONE: clear_inputhook,
+        GUI_OSX: enable_mac,
+        GUI_TK: enable_tk,
+        GUI_GTK: enable_gtk,
+        GUI_WX: enable_wx,
+        GUI_QT: enable_qt,
+        GUI_QT4: enable_qt4,
+        GUI_QT5: enable_qt5,
+        GUI_GLUT: enable_glut,
+        GUI_PYGLET: enable_pyglet,
+        GUI_GTK3: enable_gtk3,
+    }
     try:
         gui_hook = guis[gui]
     except KeyError:
-        if gui is None or gui == '':
+        if gui is None or gui == "":
             gui_hook = clear_inputhook
         else:
             e = "Invalid GUI request %r, valid ones are:%s" % (gui, list(guis.keys()))
@@ -570,14 +579,10 @@ __all__ = [
     "GUI_PYGLET",
     "GUI_GTK3",
     "GUI_NONE",
-
     "ignore_CTRL_C",
     "allow_CTRL_C",
-
     "InputHookManager",
-
     "inputhook_manager",
-
     "enable_wx",
     "disable_wx",
     "enable_qt",
@@ -601,10 +606,9 @@ __all__ = [
     "set_inputhook",
     "current_gui",
     "clear_app_refs",
-
     "stdin_ready",
     "set_return_control_callback",
     "get_return_control_callback",
     "get_inputhook",
-
-    "enable_gui"]
+    "enable_gui",
+]

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookglut.py

@@ -3,12 +3,12 @@
 GLUT Inputhook support functions
 """
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 # GLUT is quite an old library and it is difficult to ensure proper
 # integration within IPython since original GLUT does not allow to handle
@@ -26,9 +26,9 @@ GLUT Inputhook support functions
 # them later without modifying the code. This should probably be made available
 # via IPython options system.
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 import os
 import sys
 from _pydev_bundle._pydev_saved_modules import time
@@ -38,9 +38,9 @@ import OpenGL.platform as platform  # @UnresolvedImport
 from timeit import default_timer as clock
 from pydev_ipython.inputhook import stdin_ready
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Constants
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 # Frame per second : 60
 # Should probably be an IPython option
@@ -48,34 +48,30 @@ glut_fps = 60
 
 # Display mode : double buffeed + rgba + depth
 # Should probably be an IPython option
-glut_display_mode = (glut.GLUT_DOUBLE |
-                     glut.GLUT_RGBA |
-                     glut.GLUT_DEPTH)
+glut_display_mode = glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH
 
 glutMainLoopEvent = None
-if sys.platform == 'darwin':
+if sys.platform == "darwin":
     try:
         glutCheckLoop = platform.createBaseFunction(
-            'glutCheckLoop', dll=platform.GLUT, resultType=None,
+            "glutCheckLoop",
+            dll=platform.GLUT,
+            resultType=None,
             argTypes=[],
-            doc='glutCheckLoop(  ) -> None',
+            doc="glutCheckLoop(  ) -> None",
             argNames=(),
-            )
+        )
     except AttributeError:
-        raise RuntimeError(
-            '''Your glut implementation does not allow interactive sessions'''
-            '''Consider installing freeglut.''')
+        raise RuntimeError("""Your glut implementation does not allow interactive sessions""" """Consider installing freeglut.""")
     glutMainLoopEvent = glutCheckLoop
 elif glut.HAVE_FREEGLUT:
     glutMainLoopEvent = glut.glutMainLoopEvent
 else:
-    raise RuntimeError(
-        '''Your glut implementation does not allow interactive sessions. '''
-        '''Consider installing freeglut.''')
+    raise RuntimeError("""Your glut implementation does not allow interactive sessions. """ """Consider installing freeglut.""")
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Callback functions
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 def glut_display():
@@ -97,13 +93,13 @@ def glut_close():
 def glut_int_handler(signum, frame):
     # Catch sigint and print the defautl message
     signal.signal(signal.SIGINT, signal.default_int_handler)
-    print('\nKeyboardInterrupt')
+    print("\nKeyboardInterrupt")
     # Need to reprint the prompt at this stage
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 def inputhook_glut():
     """Run the pyglet event loop by processing pending events only.
 

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookgtk.py

@@ -5,32 +5,33 @@ Enable pygtk to be used interacive by setting PyOS_InputHook.
 Authors: Brian Granger
 """
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 import gtk, gobject  # @UnresolvedImport
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 def _main_quit(*args, **kwargs):
     gtk.main_quit()
     return False
 
+
 def create_inputhook_gtk(stdin_file):
     def inputhook_gtk():
         gobject.io_add_watch(stdin_file, gobject.IO_IN, _main_quit)
         gtk.main()
         return 0
-    return inputhook_gtk
 
+    return inputhook_gtk

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookgtk3.py

@@ -4,23 +4,24 @@ Enable Gtk3 to be used interacive by IPython.
 
 Authors: Thomi Richards
 """
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Copyright (c) 2012, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 from gi.repository import Gtk, GLib  # @UnresolvedImport
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
 
 def _main_quit(*args, **kwargs):
     Gtk.main_quit()
@@ -32,4 +33,5 @@ def create_inputhook_gtk3(stdin_file):
         GLib.io_add_watch(stdin_file, GLib.IO_IN, _main_quit)
         Gtk.main()
         return 0
+
     return inputhook_gtk3