Additional fixes/tests for supporting guiEventLoop.

Author: fabioz

src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_utils.py

@@ -7,6 +7,7 @@
 import signal
 import os
 import ctypes
+from importlib import import_module
 
 try:
     from urllib import quote
@@ -506,3 +507,28 @@ def _compute_get_attr_slow(self, diff, cls, attr_name):
             pass
         return 'pydevd warning: Getting attribute %s.%s was slow (took %.2fs)\n' % (cls, attr_name, diff)
 
+
+def import_attr_from_module(import_with_attr_access):
+    if '.' not in import_with_attr_access:
+        # We need at least one '.' (we don't support just the module import, we need the attribute access too).
+        raise ImportError('Unable to import module with attr access: %s' % (import_with_attr_access,))
+
+    module_name, attr_name = import_with_attr_access.rsplit('.', 1)
+
+    while True:
+        try:
+            mod = import_module(module_name)
+        except ImportError:
+            if '.' not in module_name:
+                raise ImportError('Unable to import module with attr access: %s' % (import_with_attr_access,))
+
+            module_name, new_attr_part = module_name.rsplit('.', 1)
+            attr_name = new_attr_part + '.' + attr_name
+        else:
+            # Ok, we got the base module, now, get the attribute we need.
+            try:
+                for attr in attr_name.split('.'):
+                    mod = getattr(mod, attr)
+                return mod
+            except:
+                raise ImportError('Unable to import module with attr access: %s' % (import_with_attr_access,))

src/debugpy/_vendored/pydevd/pydev_ipython/inputhook.py

@@ -535,7 +535,7 @@ def enable_gui(gui=None, app=None):
         if gui is None or gui == '':
             gui_hook = clear_inputhook
         else:
-            e = "Invalid GUI request %r, valid ones are:%s" % (gui, guis.keys())
+            e = "Invalid GUI request %r, valid ones are:%s" % (gui, list(guis.keys()))
             raise ValueError(e)
     return gui_hook(app)
 

src/debugpy/_vendored/pydevd/pydev_ipython/inputhookqt5.py

@@ -21,36 +21,39 @@
 
 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_qt5(mgr, app=None):
     """Create an input hook for running the Qt5 application event loop.
 
@@ -107,7 +110,7 @@ def inputhook_qt5():
         try:
             allow_CTRL_C()
             app = QtCore.QCoreApplication.instance()
-            if not app: # shouldn't happen, but safer if it happens anyway...
+            if not app:  # shouldn't happen, but safer if it happens anyway...
                 return 0
             app.processEvents(QtCore.QEventLoop.AllEvents, 300)
             if not stdin_ready():
@@ -159,13 +162,12 @@ def inputhook_qt5():
                 pid = os.getpid()
                 if(not sigint_timer):
                     sigint_timer = threading.Timer(.01, os.kill,
-                                         args=[pid, signal.SIGINT] )
+                                         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
+        except:  # NO exceptions are allowed to escape from a ctypes callback
             ignore_CTRL_C()
             from traceback import print_exc
             print_exc()

src/debugpy/_vendored/pydevd/pydev_ipython/qt_for_kernel.py

@@ -35,11 +35,12 @@
 import sys
 
 from pydev_ipython.version import check_version
-from pydev_ipython.qt_loaders import (load_qt, QT_API_PYSIDE,
+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)
 
-#Constraints placed on an imported matplotlib
+
+# Constraints placed on an imported matplotlib
 def matplotlib_options(mpl):
     if mpl is None:
         return
@@ -70,7 +71,6 @@ def matplotlib_options(mpl):
         raise ImportError("unhandled value for backend.qt5 from matplotlib: %r" %
                           mpqt)
 
-
     # Fallback without checking backend (previous code)
     mpqt = mpl.rcParams.get('backend.qt4', None)
     if mpqt is None:
@@ -92,27 +92,28 @@ def get_options():
     """Return a list of acceptable QT APIs, in decreasing order of
     preference
     """
-    #already imported Qt somewhere. Use that
+    # already imported Qt somewhere. Use that
     loaded = loaded_api()
     if loaded is not None:
         return [loaded]
 
     mpl = sys.modules.get('matplotlib', None)
 
     if mpl is not None and not check_version(mpl.__version__, '1.0.2'):
-        #1.0.1 only supports PyQt4 v1
+        # 1.0.1 only supports PyQt4 v1
         return [QT_API_PYQT_DEFAULT]
 
     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_PYQT5]
+        # 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]
 
-    #ETS variable present. Will fallback to external.qt
+    # ETS variable present. Will fallback to external.qt
     return None
 
+
 api_opts = get_options()
 if api_opts is not None:
     QtCore, QtGui, QtSvg, QT_API = load_qt(api_opts)
 
-else: # use ETS variable
+else:  # use ETS variable
     from pydev_ipython.qt import QtCore, QtGui, QtSvg, QT_API

src/debugpy/_vendored/pydevd/pydev_ipython/qt_loaders.py

@@ -16,8 +16,9 @@
 # Available APIs.
 QT_API_PYQT = 'pyqt'
 QT_API_PYQTv1 = 'pyqtv1'
-QT_API_PYQT_DEFAULT = 'pyqtdefault' # don't set SIP explicitly
+QT_API_PYQT_DEFAULT = 'pyqtdefault'  # don't set SIP explicitly
 QT_API_PYSIDE = 'pyside'
+QT_API_PYSIDE2 = 'pyside2'
 QT_API_PYQT5 = 'pyqt5'
 
 
@@ -45,6 +46,7 @@ def load_module(self, fullname):
     already imported an Incompatible QT Binding: %s
     """ % (fullname, loaded_api()))
 
+
 ID = ImportDenier()
 sys.meta_path.append(ID)
 
@@ -58,6 +60,7 @@ def commit_api(api):
         ID.forbid('PyQt5')
     else:
         ID.forbid('PySide')
+        ID.forbid('PySide2')
 
 
 def loaded_api():
@@ -68,7 +71,7 @@ def loaded_api():
 
     Returns
     -------
-    None, 'pyside', 'pyqt', or 'pyqtv1'
+    None, 'pyside', 'pyside2', 'pyqt', or 'pyqtv1'
     """
     if 'PyQt4.QtCore' in sys.modules:
         if qtapi_version() == 2:
@@ -77,6 +80,8 @@ def loaded_api():
             return QT_API_PYQTv1
     elif 'PySide.QtCore' in sys.modules:
         return QT_API_PYSIDE
+    elif 'PySide2.QtCore' in sys.modules:
+        return QT_API_PYSIDE2
     elif 'PyQt5.QtCore' in sys.modules:
         return QT_API_PYQT5
     return None
@@ -99,6 +104,7 @@ def has_binding(api):
     # this will cause a crash in sip (#1431)
     # check for complete presence before importing
     module_name = {QT_API_PYSIDE: 'PySide',
+                   QT_API_PYSIDE2: 'PySide2',
                    QT_API_PYQT: 'PyQt4',
                    QT_API_PYQTv1: 'PyQt4',
                    QT_API_PYQT_DEFAULT: 'PyQt4',
@@ -108,14 +114,14 @@ def has_binding(api):
 
     import imp
     try:
-        #importing top level PyQt4/PySide module is ok...
+        # importing top level PyQt4/PySide module is ok...
         mod = __import__(module_name)
-        #...importing submodules is not
+        # ...importing submodules is not
         imp.find_module('QtCore', mod.__path__)
         imp.find_module('QtGui', mod.__path__)
         imp.find_module('QtSvg', mod.__path__)
 
-        #we can also safely check PySide version
+        # we can also safely check PySide version
         if api == QT_API_PYSIDE:
             return check_version(mod.__version__, '1.0.3')
         else:
@@ -189,6 +195,7 @@ def import_pyqt4(version=2):
     api = QT_API_PYQTv1 if version == 1 else QT_API_PYQT
     return QtCore, QtGui, QtSvg, api
 
+
 def import_pyqt5():
     """
     Import PyQt5
@@ -214,6 +221,16 @@ def import_pyside():
     return QtCore, QtGui, QtSvg, QT_API_PYSIDE
 
 
+def import_pyside2():
+    """
+    Import PySide2
+
+    ImportErrors raised within this function are non-recoverable
+    """
+    from PySide2 import QtGui, QtCore, QtSvg  # @UnresolvedImport
+    return QtCore, QtGui, QtSvg, QT_API_PYSIDE
+
+
 def load_qt(api_options):
     """
     Attempt to import Qt, given a preference list
@@ -241,6 +258,7 @@ def load_qt(api_options):
     an incompatible library has already been installed)
     """
     loaders = {QT_API_PYSIDE: import_pyside,
+               QT_API_PYSIDE2: import_pyside2,
                QT_API_PYQT: import_pyqt4,
                QT_API_PYQTv1: partial(import_pyqt4, version=1),
                QT_API_PYQT_DEFAULT: partial(import_pyqt4, version=None),
@@ -251,14 +269,14 @@ def load_qt(api_options):
 
         if api not in loaders:
             raise RuntimeError(
-                "Invalid Qt API %r, valid values are: %r, %r, %r, %r, %r" %
-                (api, QT_API_PYSIDE, QT_API_PYQT,
+                "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))
 
         if not can_import(api):
             continue
 
-        #cannot safely recover from an ImportError during this
+        # cannot safely recover from an ImportError during this
         result = loaders[api]()
         api = result[-1]  # changed if api = QT_API_PYQT_DEFAULT
         commit_api(api)
@@ -273,9 +291,11 @@ def load_qt(api_options):
     PyQt4 installed:                 %s
     PyQt5 installed:                 %s
     PySide >= 1.0.3 installed:       %s
+    PySide2 installed:               %s
     Tried to load:                   %r
     """ % (loaded_api(),
            has_binding(QT_API_PYQT),
            has_binding(QT_API_PYQT5),
            has_binding(QT_API_PYSIDE),
+           has_binding(QT_API_PYSIDE2),
            api_options))

src/debugpy/_vendored/pydevd/pydevd.py

@@ -64,7 +64,8 @@
 from _pydevd_bundle.pydevd_net_command_factory_xml import NetCommandFactory
 from _pydevd_bundle.pydevd_trace_dispatch import (
     trace_dispatch as _trace_dispatch, global_cache_skips, global_cache_frame_skips, fix_top_level_trace_and_get_trace_func)
-from _pydevd_bundle.pydevd_utils import save_main_module, is_current_thread_main_thread
+from _pydevd_bundle.pydevd_utils import save_main_module, is_current_thread_main_thread, \
+    import_attr_from_module
 from _pydevd_frame_eval.pydevd_frame_eval_main import (
     frame_eval_func, dummy_trace_dispatch)
 import pydev_ipython  # @UnusedImport
@@ -1536,34 +1537,38 @@ def init_gui_support(self):
         if self._installed_gui_support:
             return
         self._installed_gui_support = True
-        # prepare debugger for integration with GUI event loop
-        from pydev_ipython.matplotlibtools import activate_matplotlib, activate_pylab, activate_pyplot, do_enable_gui
-        from pydev_ipython.inputhook import enable_gui
 
-        # enalbe_gui and enable_gui_function in activate_matplotlib should be called in main thread. Unlike integrated console,
+        # enable_gui and enable_gui_function in activate_matplotlib should be called in main thread. Unlike integrated console,
         # in the debug console we have no interpreter instance with exec_queue, but we run this code in the main
         # thread and can call it directly.
-        class _MatplotlibHelper:
+        class _ReturnGuiLoopControlHelper:
             _return_control_osc = False
 
         def return_control():
             # Some of the input hooks (e.g. Qt4Agg) check return control without doing
             # a single operation, so we don't return True on every
             # call when the debug hook is in place to allow the GUI to run
-            _MatplotlibHelper._return_control_osc = not _MatplotlibHelper._return_control_osc
-            return _MatplotlibHelper._return_control_osc
+            _ReturnGuiLoopControlHelper._return_control_osc = not _ReturnGuiLoopControlHelper._return_control_osc
+            return _ReturnGuiLoopControlHelper._return_control_osc
+
+        from pydev_ipython.inputhook import set_return_control_callback, enable_gui
 
-        from pydev_ipython.inputhook import set_return_control_callback
         set_return_control_callback(return_control)
 
         if self._gui_event_loop == 'matplotlib':
+            # prepare debugger for matplotlib integration with GUI event loop
+            from pydev_ipython.matplotlibtools import activate_matplotlib, activate_pylab, activate_pyplot, do_enable_gui
+
             self.mpl_modules_for_patching = {"matplotlib": lambda: activate_matplotlib(do_enable_gui),
                                 "matplotlib.pyplot": activate_pyplot,
                                 "pylab": activate_pylab }
         else:
             self.activate_gui_function = enable_gui
 
     def _activate_gui_if_needed(self):
+        if self.gui_in_use:
+            return
+
         if len(self.mpl_modules_for_patching) > 0:
             if is_current_thread_main_thread():  # Note that we call only in the main thread.
                 for module in dict_keys(self.mpl_modules_for_patching):
@@ -1574,20 +1579,17 @@ def _activate_gui_if_needed(self):
                         self.gui_in_use = True
 
         if self.activate_gui_function:
-            if is_current_thread_main_thread(): # Only call enable_gui in the main thread.
+            if is_current_thread_main_thread():  # Only call enable_gui in the main thread.
                 try:
                     # First try to activate builtin GUI event loops.
                     self.activate_gui_function(self._gui_event_loop)
                     self.activate_gui_function = None
                     self.gui_in_use = True
                 except ValueError:
                     # The user requested a custom GUI event loop, try to import it.
-                    from importlib import import_module
                     from pydev_ipython.inputhook import set_inputhook
                     try:
-                        module_name, inputhook_name = self._gui_event_loop.rsplit('.', 1)
-                        module = import_module(module_name)
-                        inputhook_function = getattr(module, inputhook_name)
+                        inputhook_function = import_attr_from_module(self._gui_event_loop)
                         set_inputhook(inputhook_function)
                         self.gui_in_use = True
                     except Exception as e:
@@ -1736,7 +1738,7 @@ def process_internal_commands(self):
                         while True:
                             int_cmd = queue.get(False)
 
-                            if not self.mpl_hooks_in_debug_console and isinstance(int_cmd, InternalConsoleExec):
+                            if not self.mpl_hooks_in_debug_console and isinstance(int_cmd, InternalConsoleExec) and not self.gui_in_use:
                                 # add import hooks for matplotlib patches if only debug console was started
                                 try:
                                     self.init_matplotlib_in_debug_console()