debugpy 1.8.5__zip → 1.8.7__zip

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

@@ -7,6 +7,7 @@ from _pydev_bundle import pydev_log
 
 def set_trace_in_qt():
     from _pydevd_bundle.pydevd_comm import get_global_debugger
+
     py_db = get_global_debugger()
     if py_db is not None:
         threading.current_thread()  # Create the dummy thread for qt.
@@ -17,87 +18,94 @@ _patched_qt = False
 
 
 def patch_qt(qt_support_mode):
-    '''
+    """
     This method patches qt (PySide2, PySide, PyQt4, PyQt5) so that we have hooks to set the tracing for QThread.
-    '''
+    """
     if not qt_support_mode:
         return
 
-    if qt_support_mode is True or qt_support_mode == 'True':
+    if qt_support_mode is True or qt_support_mode == "True":
         # do not break backward compatibility
-        qt_support_mode = 'auto'
+        qt_support_mode = "auto"
 
-    if qt_support_mode == 'auto':
-        qt_support_mode = os.getenv('PYDEVD_PYQT_MODE', 'auto')
+    if qt_support_mode == "auto":
+        qt_support_mode = os.getenv("PYDEVD_PYQT_MODE", "auto")
 
     # Avoid patching more than once
     global _patched_qt
     if _patched_qt:
         return
 
-    pydev_log.debug('Qt support mode: %s', qt_support_mode)
+    pydev_log.debug("Qt support mode: %s", qt_support_mode)
 
     _patched_qt = True
 
-    if qt_support_mode == 'auto':
-
+    if qt_support_mode == "auto":
         patch_qt_on_import = None
         try:
             import PySide2  # @UnresolvedImport @UnusedImport
-            qt_support_mode = 'pyside2'
+
+            qt_support_mode = "pyside2"
         except:
             try:
                 import Pyside  # @UnresolvedImport @UnusedImport
-                qt_support_mode = 'pyside'
+
+                qt_support_mode = "pyside"
             except:
                 try:
                     import PyQt5  # @UnresolvedImport @UnusedImport
-                    qt_support_mode = 'pyqt5'
+
+                    qt_support_mode = "pyqt5"
                 except:
                     try:
                         import PyQt4  # @UnresolvedImport @UnusedImport
-                        qt_support_mode = 'pyqt4'
+
+                        qt_support_mode = "pyqt4"
                     except:
                         return
 
-    if qt_support_mode == 'pyside2':
+    if qt_support_mode == "pyside2":
         try:
             import PySide2.QtCore  # @UnresolvedImport
+
             _internal_patch_qt(PySide2.QtCore, qt_support_mode)
         except:
             return
 
-    elif qt_support_mode == 'pyside':
+    elif qt_support_mode == "pyside":
         try:
             import PySide.QtCore  # @UnresolvedImport
+
             _internal_patch_qt(PySide.QtCore, qt_support_mode)
         except:
             return
 
-    elif qt_support_mode == 'pyqt5':
+    elif qt_support_mode == "pyqt5":
         try:
             import PyQt5.QtCore  # @UnresolvedImport
+
             _internal_patch_qt(PyQt5.QtCore)
         except:
             return
 
-    elif qt_support_mode == 'pyqt4':
+    elif qt_support_mode == "pyqt4":
         # Ok, we have an issue here:
         # PyDev-452: Selecting PyQT API version using sip.setapi fails in debug mode
         # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
         # Mostly, if the user uses a different API version (i.e.: v2 instead of v1),
         # that has to be done before importing PyQt4 modules (PySide/PyQt5 don't have this issue
         # as they only implements v2).
-        patch_qt_on_import = 'PyQt4'
+        patch_qt_on_import = "PyQt4"
 
         def get_qt_core_module():
             import PyQt4.QtCore  # @UnresolvedImport
+
             return PyQt4.QtCore
 
         _patch_import_to_patch_pyqt_on_import(patch_qt_on_import, get_qt_core_module)
 
     else:
-        raise ValueError('Unexpected qt support mode: %s' % (qt_support_mode,))
+        raise ValueError("Unexpected qt support mode: %s" % (qt_support_mode,))
 
 
 def _patch_import_to_patch_pyqt_on_import(patch_qt_on_import, get_qt_core_module):
@@ -106,9 +114,9 @@ def _patch_import_to_patch_pyqt_on_import(patch_qt_on_import, get_qt_core_module
     # So, our approach is to patch PyQt4 right before the user tries to import it (at which
     # point he should've set the sip api version properly already anyways).
 
-    pydev_log.debug('Setting up Qt post-import monkeypatch.')
+    pydev_log.debug("Setting up Qt post-import monkeypatch.")
 
-    dotted = patch_qt_on_import + '.'
+    dotted = patch_qt_on_import + "."
     original_import = __import__
 
     from _pydev_bundle._pydev_sys_patch import patch_sys_module, patch_reload, cancel_patches_in_sys_module
@@ -128,15 +136,14 @@ def _patch_import_to_patch_pyqt_on_import(patch_qt_on_import, get_qt_core_module
     builtins.__import__ = patched_import
 
 
-def _internal_patch_qt(QtCore, qt_support_mode='auto'):
-    pydev_log.debug('Patching Qt: %s', QtCore)
+def _internal_patch_qt(QtCore, qt_support_mode="auto"):
+    pydev_log.debug("Patching Qt: %s", QtCore)
 
     _original_thread_init = QtCore.QThread.__init__
     _original_runnable_init = QtCore.QRunnable.__init__
     _original_QThread = QtCore.QThread
 
     class FuncWrapper:
-
         def __init__(self, original):
             self._original = original
 
@@ -145,7 +152,6 @@ def _internal_patch_qt(QtCore, qt_support_mode='auto'):
             return self._original(*args, **kwargs)
 
     class StartedSignalWrapper(QtCore.QObject):  # Wrapper for the QThread.started signal
-
         try:
             _signal = QtCore.Signal()  # @UndefinedVariable
         except:
@@ -155,14 +161,14 @@ def _internal_patch_qt(QtCore, qt_support_mode='auto'):
             QtCore.QObject.__init__(self)
             self.thread = thread
             self.original_started = original_started
-            if qt_support_mode in ('pyside', 'pyside2'):
+            if qt_support_mode in ("pyside", "pyside2"):
                 self._signal = original_started
             else:
                 self._signal.connect(self._on_call)
                 self.original_started.connect(self._signal)
 
         def connect(self, func, *args, **kwargs):
-            if qt_support_mode in ('pyside', 'pyside2'):
+            if qt_support_mode in ("pyside", "pyside2"):
                 return self._signal.connect(FuncWrapper(func), *args, **kwargs)
             else:
                 return self._signal.connect(func, *args, **kwargs)
@@ -177,7 +183,6 @@ def _internal_patch_qt(QtCore, qt_support_mode='auto'):
             set_trace_in_qt()
 
     class ThreadWrapper(QtCore.QThread):  # Wrapper for QThread
-
         def __init__(self, *args, **kwargs):
             _original_thread_init(self, *args, **kwargs)
 
@@ -201,7 +206,6 @@ def _internal_patch_qt(QtCore, qt_support_mode='auto'):
             return self._original_run()
 
     class RunnableWrapper(QtCore.QRunnable):  # Wrapper for QRunnable
-
         def __init__(self, *args, **kwargs):
             _original_runnable_init(self, *args, **kwargs)
 

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

@@ -1,12 +1,13 @@
 def overrides(method):
-    '''
+    """
     Meant to be used as
-    
+
     class B:
         @overrides(A.m1)
         def m1(self):
             pass
-    '''
+    """
+
     def wrapper(func):
         if func.__name__ != method.__name__:
             msg = "Wrong @override: %r expected, but overwriting %r."
@@ -20,6 +21,7 @@ def overrides(method):
 
     return wrapper
 
+
 def implements(method):
     def wrapper(func):
         if func.__name__ != method.__name__:
@@ -32,4 +34,4 @@ def implements(method):
 
         return func
 
-    return wrapper
+    return wrapper

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

@@ -56,6 +56,7 @@ class UserModuleDeleter:
         try:
             # ignore all files in org.python.pydev/pysrc
             import pydev_pysrc, inspect
+
             self.pathlist.append(os.path.dirname(pydev_pysrc.__file__))
         except:
             pass
@@ -66,7 +67,7 @@ class UserModuleDeleter:
             if modpath.startswith(path):
                 return True
         else:
-            return set(modname.split('.')) & set(self.namelist)
+            return set(modname.split(".")) & set(self.namelist)
 
     def run(self, verbose=False):
         """
@@ -79,11 +80,11 @@ class UserModuleDeleter:
         log = []
         modules_copy = dict(sys.modules)
         for modname, module in modules_copy.items():
-            if modname == 'aaaaa':
+            if modname == "aaaaa":
                 print(modname, module)
                 print(self.previous_modules)
             if modname not in self.previous_modules:
-                modpath = getattr(module, '__file__', None)
+                modpath = getattr(module, "__file__", None)
                 if modpath is None:
                     # *module* is a C module that is statically linked into the
                     # interpreter. There is no way to know its path, so we
@@ -93,8 +94,7 @@ class UserModuleDeleter:
                     log.append(modname)
                     del sys.modules[modname]
         if verbose and log:
-            print("\x1b[4;33m%s\x1b[24m%s\x1b[0m" % ("UMD has deleted",
-                                                     ": " + ", ".join(log)))
+            print("\x1b[4;33m%s\x1b[24m%s\x1b[0m" % ("UMD has deleted", ": " + ", ".join(log)))
 
 
 __umd__ = None
@@ -118,11 +118,12 @@ def _get_globals():
             try:
                 # The import fails on IronPython
                 import __main__
+
                 namespace = __main__.__dict__
             except:
                 namespace
-        shell = namespace.get('__ipythonshell__')
-        if shell is not None and hasattr(shell, 'user_ns'):
+        shell = namespace.get("__ipythonshell__")
+        if shell is not None and hasattr(shell, "user_ns"):
             # IPython 0.12+ kernel
             return shell.user_ns
         else:
@@ -138,8 +139,8 @@ def runfile(filename, args=None, wdir=None, namespace=None):
     wdir: working directory
     """
     try:
-        if hasattr(filename, 'decode'):
-            filename = filename.decode('utf-8')
+        if hasattr(filename, "decode"):
+            filename = filename.decode("utf-8")
     except (UnicodeError, TypeError):
         pass
     global __umd__
@@ -147,7 +148,7 @@ def runfile(filename, args=None, wdir=None, namespace=None):
         if __umd__ is None:
             namelist = os.environ.get("PYDEV_UMD_NAMELIST", None)
             if namelist is not None:
-                namelist = namelist.split(',')
+                namelist = namelist.split(",")
             __umd__ = UserModuleDeleter(namelist=namelist)
         else:
             verbose = os.environ.get("PYDEV_UMD_VERBOSE", "").lower() == "true"
@@ -156,25 +157,25 @@ def runfile(filename, args=None, wdir=None, namespace=None):
         raise TypeError("expected a character buffer object")
     if namespace is None:
         namespace = _get_globals()
-    if '__file__' in namespace:
-        old_file = namespace['__file__']
+    if "__file__" in namespace:
+        old_file = namespace["__file__"]
     else:
         old_file = None
-    namespace['__file__'] = filename
+    namespace["__file__"] = filename
     sys.argv = [filename]
     if args is not None:
         for arg in args.split():
             sys.argv.append(arg)
     if wdir is not None:
         try:
-            if hasattr(wdir, 'decode'):
-                wdir = wdir.decode('utf-8')
+            if hasattr(wdir, "decode"):
+                wdir = wdir.decode("utf-8")
         except (UnicodeError, TypeError):
             pass
         os.chdir(wdir)
     execfile(filename, namespace)
-    sys.argv = ['']
+    sys.argv = [""]
     if old_file is None:
-        del namespace['__file__']
+        del namespace["__file__"]
     else:
-        namespace['__file__'] = old_file
+        namespace["__file__"] = old_file

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

@@ -1,7 +1,8 @@
 import sys
 
+
 def versionok_for_gui():
-    ''' Return True if running Python is suitable for GUI Event Integration and deeper IPython integration '''
+    """Return True if running Python is suitable for GUI Event Integration and deeper IPython integration"""
     # We require Python 2.6+ ...
     if sys.hexversion < 0x02060000:
         return False
@@ -9,8 +10,7 @@ def versionok_for_gui():
     if sys.hexversion >= 0x03000000 and sys.hexversion < 0x03020000:
         return False
     # Not supported under Jython nor IronPython
-    if sys.platform.startswith("java") or sys.platform.startswith('cli'):
+    if sys.platform.startswith("java") or sys.platform.startswith("cli"):
         return False
 
     return True
-