debugpy 1.8.2__zip → 1.8.3__zip

{debugpy-1.8.2/src/debugpy.egg-info → debugpy-1.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: debugpy
-Version: 1.8.2
+Version: 1.8.3
 Summary: An implementation of the Debug Adapter Protocol for Python
 Home-page: https://aka.ms/debugpy
 Author: Microsoft Corporation

{debugpy-1.8.2 → debugpy-1.8.3}/pyproject.toml

@@ -16,7 +16,7 @@ exclude = '''
 [tool.pyright]
 pythonVersion = "3.8"
 include = ["src/**", "tests/**" ]
-extraPaths = ["src/debugpy/_vendored/pydevd"]
+extraPaths = ["src/debugpy/_vendored/pydevd", "src/debugpy/_vendored/pydevd/pydevd_attach_to_process"]
 ignore = ["src/debugpy/_vendored/pydevd", "src/debugpy/_version.py"]
 executionEnvironments = [
   { root = "src" }, { root = "." }

{debugpy-1.8.2 → debugpy-1.8.3}/setup.py

@@ -195,5 +195,7 @@ if __name__ == "__main__":
         ext_modules=ExtModules(),
         has_ext_modules=lambda: True,
         cmdclass=cmds,
+        # allow the user to call "debugpy" instead of "python -m debugpy"
+        entry_points={"console_scripts": ["debugpy = debugpy.server.cli:main"]},
         **extras
     )

debugpy-1.8.3/src/debugpy/__main__.py

@@ -0,0 +1,71 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+import sys
+
+if __name__ == "__main__":
+
+    # There are three ways to run debugpy:
+    #
+    # 1. Installed as a module in the current environment (python -m debugpy ...)
+    # 2. Run as a script from source code (python <repo_root>/src/debugpy ...)
+    # 3. Installed as a module in a random directory
+    #
+    # -----
+    #
+    # In the first case, no extra work is needed. Importing debugpy will work as expected.
+    # Also, running 'debugpy' instead of 'python -m debugpy' will work because of the entry point
+    # defined in setup.py.
+    #
+    # -----
+    #
+    # In the second case, sys.path[0] is the one added automatically by Python for the directory 
+    # containing this file. 'import debugpy' will not work since we need the parent directory 
+    # of debugpy/ to be in sys.path, rather than debugpy/ itself. So we need to modify sys.path[0].
+    # Running 'debugpy' will not work because the entry point is not defined in this case.
+    #
+    # -----
+    #
+    # In the third case, running 'python -m debugpy' will not work because the module is not installed
+    # in any environment. Running 'python <install_dir>/debugpy' will work, just like the second case. 
+    # But running the entry point will not work because python doesn't know where to find the debugpy module.
+    #
+    # In this case, no changes to sys.path are required. You just have to do the following before calling
+    # the entry point:
+    #   1. Add <install_dir> to PYTHONPATH.
+    #       On Windows, this is set PYTHONPATH=%PYTHONPATH%;<install_dir>
+    #   2. Add <install_dir>/bin to PATH. (OPTIONAL)
+    #       On Windows, this is set PATH=%PATH%;<install_dir>\bin
+    #   3. Run the entry point from a command prompt
+    #       On Windows, this is <install_dir>\bin\debugpy.exe, or just 'debugpy' if you did the previous step.
+    #
+    # -----
+    #
+    # If we modify sys.path, 'import debugpy' will work, but it will break other imports
+    # because they will be resolved relative to debugpy/ - e.g. `import debugger` will try
+    # to import debugpy/debugger.py.
+    #
+    # To fix both problems, we need to do the following steps:
+    # 1. Modify sys.path[0] to point at the parent directory of debugpy/ instead of debugpy/ itself.
+    # 2. Import debugpy.
+    # 3. Remove sys.path[0] so that it doesn't affect future imports. 
+    # 
+    # For example, suppose the user did:
+    #
+    #   python /foo/bar/debugpy ...
+    #
+    # At the beginning of this script, sys.path[0] will contain "/foo/bar/debugpy".
+    # We want to replace it with "/foo/bar', then 'import debugpy', then remove the replaced entry.
+    # The imported debugpy module will remain in sys.modules, and thus all future imports of it 
+    # or its submodules will resolve accordingly.
+    if "debugpy" not in sys.modules:
+
+        # Do not use dirname() to walk up - this can be a relative path, e.g. ".".
+        sys.path[0] = sys.path[0] + "/../"
+        import debugpy  # noqa
+        del sys.path[0]
+
+    from debugpy.server import cli
+
+    cli.main()

{debugpy-1.8.2 → debugpy-1.8.3}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhook.py

@@ -26,6 +26,7 @@ GUI_WX = 'wx'
 GUI_QT = 'qt'
 GUI_QT4 = 'qt4'
 GUI_QT5 = 'qt5'
+GUI_QT6 = 'qt6'
 GUI_GTK = 'gtk'
 GUI_TK = 'tk'
 GUI_OSX = 'osx'
@@ -173,8 +174,10 @@ class InputHookManager(object):
         self.clear_inputhook()
 
     def enable_qt(self, app=None):
-        from pydev_ipython.qt_for_kernel import QT_API, QT_API_PYQT5
-        if QT_API == QT_API_PYQT5:
+        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:
             self.enable_qt5(app)
         else:
             self.enable_qt4(app)
@@ -234,6 +237,21 @@ class InputHookManager(object):
             self._apps[GUI_QT5]._in_event_loop = False
         self.clear_inputhook()
 
+    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)
+
+        self._current_gui = GUI_QT6
+        app._in_event_loop = True
+        self._apps[GUI_QT6] = app
+        return app
+
+    def disable_qt6(self):
+        if GUI_QT6 in self._apps:
+            self._apps[GUI_QT6]._in_event_loop = False
+        self.clear_inputhook()
+
     def enable_gtk(self, app=None):
         """Enable event loop integration with PyGTK.
 

debugpy-1.8.3/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookqt6.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+"""
+Qt6's inputhook support function
+
+Author: Christian Boos, Marijn van Vliet
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 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 os
+import signal
+
+import threading
+
+from pydev_ipython.qt_for_kernel import QtCore, QtGui
+from pydev_ipython.inputhook import allow_CTRL_C, ignore_CTRL_C, stdin_ready
+
+
+# To minimise future merging complexity, rather than edit the entire code base below
+# we fake InteractiveShell here
+class InteractiveShell:
+    _instance = None
+
+    @classmethod
+    def instance(cls):
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def set_hook(self, *args, **kwargs):
+        # We don't consider the pre_prompt_hook because we don't have
+        # KeyboardInterrupts to consider since we are running under PyDev
+        pass
+
+#-----------------------------------------------------------------------------
+# Module Globals
+#-----------------------------------------------------------------------------
+
+
+got_kbdint = False
+sigint_timer = None
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+
+def create_inputhook_qt6(mgr, app=None):
+    """Create an input hook for running the Qt6 application event loop.
+
+    Parameters
+    ----------
+    mgr : an InputHookManager
+
+    app : Qt Application, optional.
+        Running application to use.  If not given, we probe Qt for an
+        existing application object, and create a new one if none is found.
+
+    Returns
+    -------
+    A pair consisting of a Qt Application (either the one given or the
+    one found or created) and a inputhook.
+
+    Notes
+    -----
+    We use a custom input hook instead of PyQt6's default one, as it
+    interacts better with the readline packages (issue #481).
+
+    The inputhook function works in tandem with a 'pre_prompt_hook'
+    which automatically restores the hook as an inputhook in case the
+    latter has been temporarily disabled after having intercepted a
+    KeyboardInterrupt.
+    """
+
+    if app is None:
+        app = QtCore.QCoreApplication.instance()
+        if app is None:
+            from PyQt6 import QtWidgets
+            app = QtWidgets.QApplication([" "])
+
+    # Re-use previously created inputhook if any
+    ip = InteractiveShell.instance()
+    if hasattr(ip, '_inputhook_qt6'):
+        return app, ip._inputhook_qt6
+
+    # Otherwise create the inputhook_qt6/preprompthook_qt6 pair of
+    # hooks (they both share the got_kbdint flag)
+
+    def inputhook_qt6():
+        """PyOS_InputHook python hook for Qt6.
+
+        Process pending Qt events and if there's no pending keyboard
+        input, spend a short slice of time (50ms) running the Qt event
+        loop.
+
+        As a Python ctypes callback can't raise an exception, we catch
+        the KeyboardInterrupt and temporarily deactivate the hook,
+        which will let a *second* CTRL+C be processed normally and go
+        back to a clean prompt line.
+        """
+        try:
+            allow_CTRL_C()
+            app = QtCore.QCoreApplication.instance()
+            if not app:  # shouldn't happen, but safer if it happens anyway...
+                return 0
+            app.processEvents(QtCore.QEventLoop.ProcessEventsFlag.AllEvents, 300)
+            if not stdin_ready():
+                # Generally a program would run QCoreApplication::exec()
+                # from main() to enter and process the Qt event loop until
+                # quit() or exit() is called and the program terminates.
+                #
+                # For our input hook integration, we need to repeatedly
+                # enter and process the Qt event loop for only a short
+                # amount of time (say 50ms) to ensure that Python stays
+                # responsive to other user inputs.
+                #
+                # A naive approach would be to repeatedly call
+                # QCoreApplication::exec(), using a timer to quit after a
+                # short amount of time. Unfortunately, QCoreApplication
+                # emits an aboutToQuit signal before stopping, which has
+                # the undesirable effect of closing all modal windows.
+                #
+                # To work around this problem, we instead create a
+                # QEventLoop and call QEventLoop::exec(). Other than
+                # setting some state variables which do not seem to be
+                # used anywhere, the only thing QCoreApplication adds is
+                # the aboutToQuit signal which is precisely what we are
+                # trying to avoid.
+                timer = QtCore.QTimer()
+                event_loop = QtCore.QEventLoop()
+                timer.timeout.connect(event_loop.quit)
+                while not stdin_ready():
+                    timer.start(50)
+                    event_loop.exec()
+                    timer.stop()
+        except KeyboardInterrupt:
+            global got_kbdint, sigint_timer
+
+            ignore_CTRL_C()
+            got_kbdint = True
+            mgr.clear_inputhook()
+
+            # This generates a second SIGINT so the user doesn't have to
+            # press CTRL+C twice to get a clean prompt.
+            #
+            # Since we can't catch the resulting KeyboardInterrupt here
+            # (because this is a ctypes callback), we use a timer to
+            # generate the SIGINT after we leave this callback.
+            #
+            # Unfortunately this doesn't work on Windows (SIGINT kills
+            # Python and CTRL_C_EVENT doesn't work).
+            if(os.name == 'posix'):
+                pid = os.getpid()
+                if(not sigint_timer):
+                    sigint_timer = threading.Timer(.01, os.kill,
+                                         args=[pid, signal.SIGINT])
+                    sigint_timer.start()
+            else:
+                print("\nKeyboardInterrupt - Ctrl-C again for new prompt")
+
+        except:  # NO exceptions are allowed to escape from a ctypes callback
+            ignore_CTRL_C()
+            from traceback import print_exc
+            print_exc()
+            print("Got exception from inputhook_qt6, unregistering.")
+            mgr.clear_inputhook()
+        finally:
+            allow_CTRL_C()
+        return 0
+
+    def preprompthook_qt6(ishell):
+        """'pre_prompt_hook' used to restore the Qt6 input hook
+
+        (in case the latter was temporarily deactivated after a
+        CTRL+C)
+        """
+        global got_kbdint, sigint_timer
+
+        if(sigint_timer):
+            sigint_timer.cancel()
+            sigint_timer = None
+
+        if got_kbdint:
+            mgr.set_inputhook(inputhook_qt6)
+        got_kbdint = False
+
+    ip._inputhook_qt6 = inputhook_qt6
+    ip.set_hook('pre_prompt_hook', preprompthook_qt6)
+
+    return app, inputhook_qt6

{debugpy-1.8.2 → debugpy-1.8.3}/src/debugpy/_vendored/pydevd/pydev_ipython/matplotlibtools.py

@@ -8,6 +8,7 @@ backends = {'tk': 'TkAgg',
             'qt': 'QtAgg', # Auto-choose qt4/5
             'qt4': 'Qt4Agg',
             'qt5': 'Qt5Agg',
+            'qt6': 'Qt6Agg',
             'osx': 'MacOSX'}
 
 # We also need a reverse backends2guis mapping that will properly choose which

{debugpy-1.8.2 → debugpy-1.8.3}/src/debugpy/_vendored/pydevd/pydev_ipython/qt.py

@@ -8,15 +8,15 @@ Do not use this if you need PyQt with the old QString/QVariant API.
 
 import os
 
-from pydev_ipython.qt_loaders import (load_qt, QT_API_PYSIDE,
-                                         QT_API_PYQT, QT_API_PYQT5)
+from pydev_ipython.qt_loaders import (load_qt, QT_API_PYSIDE, QT_API_PYSIDE2,
+                                         QT_API_PYQT, QT_API_PYQT5, QT_API_PYQT6)
 
 QT_API = os.environ.get('QT_API', None)
-if QT_API not in [QT_API_PYSIDE, QT_API_PYQT, QT_API_PYQT5, None]:
-    raise RuntimeError("Invalid Qt API %r, valid values are: %r, %r" %
-                       (QT_API, QT_API_PYSIDE, QT_API_PYQT, QT_API_PYQT5))
+if QT_API not in [QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT, QT_API_PYQT5, QT_API_PYQT6, None]:
+    raise RuntimeError("Invalid Qt API %r, valid values are: %r, %r, %r, %r, %r" %
+                       (QT_API, QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT, QT_API_PYQT5, QT_API_PYQT6))
 if QT_API is None:
-    api_opts = [QT_API_PYSIDE, QT_API_PYQT, QT_API_PYQT5]
+    api_opts = [QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT, QT_API_PYQT5, QT_API_PYQT6]
 else:
     api_opts = [QT_API]
 

{debugpy-1.8.2 → debugpy-1.8.3}/src/debugpy/_vendored/pydevd/pydev_ipython/qt_for_kernel.py

@@ -37,7 +37,7 @@ import sys
 from pydev_ipython.version import check_version
 from pydev_ipython.qt_loaders import (load_qt, QT_API_PYSIDE, QT_API_PYSIDE2,
                                          QT_API_PYQT, QT_API_PYQT_DEFAULT,
-                                         loaded_api, QT_API_PYQT5)
+                                         loaded_api, QT_API_PYQT5, QT_API_PYQT6)
 
 
 # Constraints placed on an imported matplotlib
@@ -71,10 +71,21 @@ def matplotlib_options(mpl):
         raise ImportError("unhandled value for backend.qt5 from matplotlib: %r" %
                           mpqt)
 
+    elif backend == 'Qt6Agg':
+        mpqt = mpl.rcParams.get('backend.qt6', None)
+        if mpqt is None:
+            return None
+        if mpqt.lower() == 'pyqt6':
+            return [QT_API_PYQT6]
+        raise ImportError("unhandled value for backend.qt6 from matplotlib: %r" %
+                          mpqt)
+
     # Fallback without checking backend (previous code)
     mpqt = mpl.rcParams.get('backend.qt4', None)
     if mpqt is None:
         mpqt = mpl.rcParams.get('backend.qt5', None)
+    if mpqt is None:
+        mpqt = mpl.rcParams.get('backend.qt6', None)
 
     if mpqt is None:
         return None
@@ -84,6 +95,8 @@ def matplotlib_options(mpl):
         return [QT_API_PYQT_DEFAULT]
     elif mpqt.lower() == 'pyqt5':
         return [QT_API_PYQT5]
+    elif mpqt.lower() == 'pyqt6':
+        return [QT_API_PYQT6]
     raise ImportError("unhandled value for qt backend from matplotlib: %r" %
                       mpqt)
 
@@ -105,7 +118,7 @@ def get_options():
 
     if os.environ.get('QT_API', None) is None:
         # no ETS variable. Ask mpl, then use either
-        return matplotlib_options(mpl) or [QT_API_PYQT_DEFAULT, QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT5]
+        return matplotlib_options(mpl) or [QT_API_PYQT_DEFAULT, QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT5, QT_API_PYQT6]
 
     # ETS variable present. Will fallback to external.qt
     return None

{debugpy-1.8.2 → debugpy-1.8.3}/src/debugpy/_vendored/pydevd/pydev_ipython/qt_loaders.py

@@ -19,7 +19,9 @@ QT_API_PYQTv1 = 'pyqtv1'
 QT_API_PYQT_DEFAULT = 'pyqtdefault'  # don't set SIP explicitly
 QT_API_PYSIDE = 'pyside'
 QT_API_PYSIDE2 = 'pyside2'
+QT_API_PYSIDE6 = 'pyside6'
 QT_API_PYQT5 = 'pyqt5'
+QT_API_PYQT6 = 'pyqt6'
 
 
 class ImportDenier(object):
@@ -58,9 +60,11 @@ def commit_api(api):
     if api == QT_API_PYSIDE:
         ID.forbid('PyQt4')
         ID.forbid('PyQt5')
+        ID.forbid('PyQt6')
     else:
         ID.forbid('PySide')
         ID.forbid('PySide2')
+        ID.forbid('PySide6')
 
 
 def loaded_api():
@@ -71,7 +75,7 @@ def loaded_api():
 
     Returns
     -------
-    None, 'pyside', 'pyside2', 'pyqt', or 'pyqtv1'
+    None, 'pyside', 'pyside2', 'pyside6', 'pyqt5', 'pyqt6', or 'pyqtv1'
     """
     if 'PyQt4.QtCore' in sys.modules:
         if qtapi_version() == 2:
@@ -82,13 +86,17 @@ def loaded_api():
         return QT_API_PYSIDE
     elif 'PySide2.QtCore' in sys.modules:
         return QT_API_PYSIDE2
+    elif 'PySide6.QtCore' in sys.modules:
+        return QT_API_PYSIDE6
     elif 'PyQt5.QtCore' in sys.modules:
         return QT_API_PYQT5
+    elif 'PyQt6.QtCore' in sys.modules:
+        return QT_API_PYQT6
     return None
 
 
 def has_binding(api):
-    """Safely check for PyQt4 or PySide, without importing
+    """Safely check for PyQt or PySide, without importing
        submodules
 
        Parameters
@@ -105,10 +113,12 @@ def has_binding(api):
     # check for complete presence before importing
     module_name = {QT_API_PYSIDE: 'PySide',
                    QT_API_PYSIDE2: 'PySide2',
+                   QT_API_PYSIDE6: 'PySide6',
                    QT_API_PYQT: 'PyQt4',
                    QT_API_PYQTv1: 'PyQt4',
                    QT_API_PYQT_DEFAULT: 'PyQt4',
                    QT_API_PYQT5: 'PyQt5',
+                   QT_API_PYQT6: 'PyQt6',
                    }
     module_name = module_name[api]
 
@@ -154,7 +164,7 @@ def can_import(api):
 
     current = loaded_api()
     if api == QT_API_PYQT_DEFAULT:
-        return current in [QT_API_PYQT, QT_API_PYQTv1, QT_API_PYQT5, None]
+        return current in [QT_API_PYQT, QT_API_PYQTv1, QT_API_PYQT5, QT_API_PYQT6, None]
     else:
         return current in [api, None]
 
@@ -211,6 +221,21 @@ def import_pyqt5():
     return QtCore, QtGui, QtSvg, QT_API_PYQT5
 
 
+def import_pyqt6():
+    """
+    Import PyQt6
+
+    ImportErrors raised within this function are non-recoverable
+    """
+    from PyQt6 import QtGui, QtCore, QtSvg
+
+    # Alias PyQt-specific functions for PySide compatibility.
+    QtCore.Signal = QtCore.pyqtSignal
+    QtCore.Slot = QtCore.pyqtSlot
+
+    return QtCore, QtGui, QtSvg, QT_API_PYQT6
+
+
 def import_pyside():
     """
     Import PySide
@@ -228,7 +253,17 @@ def import_pyside2():
     ImportErrors raised within this function are non-recoverable
     """
     from PySide2 import QtGui, QtCore, QtSvg  # @UnresolvedImport
-    return QtCore, QtGui, QtSvg, QT_API_PYSIDE
+    return QtCore, QtGui, QtSvg, QT_API_PYSIDE2
+
+
+def import_pyside6():
+    """
+    Import PySide6
+
+    ImportErrors raised within this function are non-recoverable
+    """
+    from PySide6 import QtGui, QtCore, QtSvg  # @UnresolvedImport
+    return QtCore, QtGui, QtSvg, QT_API_PYSIDE6
 
 
 def load_qt(api_options):
@@ -259,19 +294,21 @@ def load_qt(api_options):
     """
     loaders = {QT_API_PYSIDE: import_pyside,
                QT_API_PYSIDE2: import_pyside2,
+               QT_API_PYSIDE6: import_pyside6,
                QT_API_PYQT: import_pyqt4,
                QT_API_PYQTv1: partial(import_pyqt4, version=1),
                QT_API_PYQT_DEFAULT: partial(import_pyqt4, version=None),
                QT_API_PYQT5: import_pyqt5,
+               QT_API_PYQT6: import_pyqt6,
                }
 
     for api in api_options:
 
         if api not in loaders:
             raise RuntimeError(
-                "Invalid Qt API %r, valid values are: %r, %r, %r, %r, %r, %r" %
-                (api, QT_API_PYSIDE, QT_API_PYSIDE, QT_API_PYQT,
-                 QT_API_PYQTv1, QT_API_PYQT_DEFAULT, QT_API_PYQT5))
+                "Invalid Qt API %r, valid values are: %r, %r, %r, %r, %r, %r, %r" %
+                (api, QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT,
+                 QT_API_PYQTv1, QT_API_PYQT_DEFAULT, QT_API_PYQT5, QT_API_PYQT6))
 
         if not can_import(api):
             continue
@@ -290,12 +327,16 @@ def load_qt(api_options):
     Currently-imported Qt library:   %r
     PyQt4 installed:                 %s
     PyQt5 installed:                 %s
+    PyQt6 installed:                 %s
     PySide >= 1.0.3 installed:       %s
     PySide2 installed:               %s
+    PySide6 installed:               %s
     Tried to load:                   %r
     """ % (loaded_api(),
            has_binding(QT_API_PYQT),
            has_binding(QT_API_PYQT5),
+           has_binding(QT_API_PYQT6),
            has_binding(QT_API_PYSIDE),
            has_binding(QT_API_PYSIDE2),
+           has_binding(QT_API_PYSIDE6),
            api_options))

{debugpy-1.8.2 → debugpy-1.8.3}/src/debugpy/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-04-19T17:08:26-0500",
+ "date": "2024-07-31T14:46:58-0500",
  "dirty": false,
  "error": null,
- "full-revisionid": "09b5af0bb730e2707ec3bbc14c509523eca116c0",
- "version": "1.8.2"
+ "full-revisionid": "dc58df149f5f6f71d44bd3389ad0e4b98d00b4bd",
+ "version": "1.8.3"
 }
 '''  # END VERSION_JSON
 

{debugpy-1.8.2 → debugpy-1.8.3}/src/debugpy/adapter/components.py

@@ -7,7 +7,7 @@ import functools
 from debugpy.common import json, log, messaging, util
 
 
-ACCEPT_CONNECTIONS_TIMEOUT = 10
+ACCEPT_CONNECTIONS_TIMEOUT = 60
 
 
 class ComponentNotAvailable(Exception):

{debugpy-1.8.2 → debugpy-1.8.3}/src/debugpy/public_api.py

@@ -38,7 +38,7 @@ def _api(cancelable=False):
                 wrapped = getattr(api, f.__name__)
                 return wrapped.cancel(*args, **kwargs)
 
-            wrapper.cancel = cancel
+            wrapper.cancel = cancel # pyright: ignore
 
         return wrapper
 
@@ -46,7 +46,7 @@ def _api(cancelable=False):
 
 
 @_api()
-def log_to(__path: str) -> None:
+def log_to(__path: str | typing.TextIO) -> None:
     """Generate detailed debugpy logs in the specified directory.
 
     The directory must already exist. Several log files are generated,
@@ -117,7 +117,7 @@ def listen(
     adapter that it starts. Use `wait_for_client` to block execution
     until the client connects.
     """
-
+    ...
 
 @_api()
 def connect(__endpoint: Endpoint | int, *, access_token: str | None = None) -> Endpoint:
@@ -135,7 +135,7 @@ def connect(__endpoint: Endpoint | int, *, access_token: str | None = None) -> E
     adapter that it connects to. Use `wait_for_client` to block
     execution until the client connects.
     """
-
+    ...
 
 @_api(cancelable=True)
 def wait_for_client() -> None:
@@ -153,6 +153,7 @@ def is_client_connected() -> bool:
     """True if a client is connected to the debug adapter that is
     debugging this process.
     """
+    ...
 
 
 @_api()