When no gui event loop is running, propagate callback exceptions.

anntzer · anntzer · commit f3ecbd011adb · 2019-09-15T21:07:50.000+02:00
CallbackRegistry currently defaults to suppressing exceptions that occur
in callbacks because they cause PyQt5 to abort() the program with no
chance of even catching the exception, but such a behavior is annoying
when writing tests involving callbacks (e.g., mplcursors), because in
that case we actually want to see whether an exception occurred, and
typically fail the test in that case.

Instead we can detect whether a GUI event loop is currently running and
propagate the exception if none is running.

Part of the patch is just moving `_get_running_interactive_framework`
from `backends` to `cbook`, so that `cbook` keeps its property of being
importable independent of the rest of mpl.
diff --git a/doc/api/next_api_changes/2018-09-15-AL.rst b/doc/api/next_api_changes/2018-09-15-AL.rst
@@ -0,0 +1,8 @@
+API changes
+```````````
+
+`.cbook.CallbackRegistry` now defaults to propagating exceptions thrown by
+callbacks when no interactive GUI event loop is running.  If a GUI event loop
+*is* running, `.cbook.CallbackRegistry` still defaults to just printing a
+traceback, as unhandled exceptions can make the program completely ``abort()``
+in that case.
diff --git a/lib/matplotlib/backends/__init__.py b/lib/matplotlib/backends/__init__.py
@@ -1,54 +1,2 @@
-import importlib
-import logging
-import os
-import sys
-
-import matplotlib
-from matplotlib import cbook
-from matplotlib.backend_bases import _Backend
-
-_log = logging.getLogger(__name__)
-
-
 # NOTE: plt.switch_backend() (called at import time) will add a "backend"
 # attribute here for backcompat.
-
-
-def _get_running_interactive_framework():
-    """
-    Return the interactive framework whose event loop is currently running, if
-    any, or "headless" if no event loop can be started, or None.
-
-    Returns
-    -------
-    Optional[str]
-        One of the following values: "qt5", "qt4", "gtk3", "wx", "tk",
-        "macosx", "headless", ``None``.
-    """
-    QtWidgets = (sys.modules.get("PyQt5.QtWidgets")
-                 or sys.modules.get("PySide2.QtWidgets"))
-    if QtWidgets and QtWidgets.QApplication.instance():
-        return "qt5"
-    QtGui = (sys.modules.get("PyQt4.QtGui")
-             or sys.modules.get("PySide.QtGui"))
-    if QtGui and QtGui.QApplication.instance():
-        return "qt4"
-    Gtk = sys.modules.get("gi.repository.Gtk")
-    if Gtk and Gtk.main_level():
-        return "gtk3"
-    wx = sys.modules.get("wx")
-    if wx and wx.GetApp():
-        return "wx"
-    tkinter = sys.modules.get("tkinter")
-    if tkinter:
-        for frame in sys._current_frames().values():
-            while frame:
-                if frame.f_code == tkinter.mainloop.__code__:
-                    return "tk"
-                frame = frame.f_back
-    if 'matplotlib.backends._macosx' in sys.modules:
-        if sys.modules["matplotlib.backends._macosx"].event_loop_is_running():
-            return "macosx"
-    if sys.platform.startswith("linux") and not os.environ.get("DISPLAY"):
-        return "headless"
-    return None
diff --git a/lib/matplotlib/cbook/__init__.py b/lib/matplotlib/cbook/__init__.py
@@ -22,13 +22,17 @@
 import shlex
 import subprocess
 import sys
+import threading
 import time
 import traceback
 import types
 import warnings
 import weakref
 from weakref import WeakMethod
 
+import matplotlib
+from matplotlib import cbook
+
 import numpy as np
 
 import matplotlib
@@ -39,8 +43,51 @@
     MatplotlibDeprecationWarning, mplDeprecation)
 
 
+def _get_running_interactive_framework():
+    """
+    Return the interactive framework whose event loop is currently running, if
+    any, or "headless" if no event loop can be started, or None.
+
+    Returns
+    -------
+    Optional[str]
+        One of the following values: "qt5", "qt4", "gtk3", "wx", "tk",
+        "macosx", "headless", ``None``.
+    """
+    QtWidgets = (sys.modules.get("PyQt5.QtWidgets")
+                 or sys.modules.get("PySide2.QtWidgets"))
+    if QtWidgets and QtWidgets.QApplication.instance():
+        return "qt5"
+    QtGui = (sys.modules.get("PyQt4.QtGui")
+             or sys.modules.get("PySide.QtGui"))
+    if QtGui and QtGui.QApplication.instance():
+        return "qt4"
+    Gtk = sys.modules.get("gi.repository.Gtk")
+    if Gtk and Gtk.main_level():
+        return "gtk3"
+    wx = sys.modules.get("wx")
+    if wx and wx.GetApp():
+        return "wx"
+    tkinter = sys.modules.get("tkinter")
+    if tkinter:
+        for frame in sys._current_frames().values():
+            while frame:
+                if frame.f_code == tkinter.mainloop.__code__:
+                    return "tk"
+                frame = frame.f_back
+    if 'matplotlib.backends._macosx' in sys.modules:
+        if sys.modules["matplotlib.backends._macosx"].event_loop_is_running():
+            return "macosx"
+    if sys.platform.startswith("linux") and not os.environ.get("DISPLAY"):
+        return "headless"
+    return None
+
+
 def _exception_printer(exc):
-    traceback.print_exc()
+    if _get_running_interactive_framework() in ["headless", None]:
+        raise exc
+    else:
+        traceback.print_exc()
 
 
 class _StrongRef:
diff --git a/lib/matplotlib/figure.py b/lib/matplotlib/figure.py
@@ -17,7 +17,7 @@
 import numpy as np
 
 from matplotlib import rcParams
-from matplotlib import backends, docstring, projections
+from matplotlib import docstring, projections
 from matplotlib import __version__ as _mpl_version
 from matplotlib import get_backend
 
@@ -444,8 +444,7 @@ def show(self, warn=True):
                 return
             except NonGuiException:
                 pass
-        if (backends._get_running_interactive_framework() != "headless"
-                and warn):
+        if cbook._get_running_interactive_framework() != "headless" and warn:
             cbook._warn_external('Matplotlib is currently using %s, which is '
                                  'a non-GUI backend, so cannot show the '
                                  'figure.' % get_backend())
diff --git a/lib/matplotlib/pyplot.py b/lib/matplotlib/pyplot.py
@@ -67,7 +67,6 @@
            Locator, IndexLocator, FixedLocator, NullLocator,\
            LinearLocator, LogLocator, AutoLocator, MultipleLocator,\
            MaxNLocator
-from matplotlib.backends import _get_running_interactive_framework
 
 _log = logging.getLogger(__name__)
 
@@ -220,15 +219,14 @@ def switch_backend(newbackend):
 
     backend_mod = importlib.import_module(backend_name)
     Backend = type(
-        "Backend", (matplotlib.backends._Backend,), vars(backend_mod))
+        "Backend", (matplotlib.backend_bases._Backend,), vars(backend_mod))
     _log.debug("Loaded backend %s version %s.",
                newbackend, Backend.backend_version)
 
     required_framework = getattr(
         Backend.FigureCanvas, "required_interactive_framework", None)
     if required_framework is not None:
-        current_framework = \
-            matplotlib.backends._get_running_interactive_framework()
+        current_framework = cbook._get_running_interactive_framework()
         if (current_framework and required_framework
                 and current_framework != required_framework):
             raise ImportError(
@@ -2304,7 +2302,7 @@ def getname_val(identifier):
 # is compatible with the current running interactive framework.
 if (rcParams["backend_fallback"]
         and dict.__getitem__(rcParams, "backend") in _interactive_bk
-        and _get_running_interactive_framework()):
+        and cbook._get_running_interactive_framework()):
     dict.__setitem__(rcParams, "backend", rcsetup._auto_backend_sentinel)
 # Set up the backend.
 switch_backend(rcParams["backend"])
diff --git a/lib/matplotlib/tests/test_cbook.py b/lib/matplotlib/tests/test_cbook.py
@@ -233,6 +233,16 @@ def test_pickling(self):
                        "callbacks")
 
 
+def test_callbackregistry_default_exception_handler(monkeypatch):
+    cb = cbook.CallbackRegistry()
+    cb.connect("foo", lambda: None)
+    with pytest.raises(TypeError):
+        cb.process("foo", "argument mismatch")
+    monkeypatch.setattr(
+        cbook, "_get_running_interactive_framework", lambda: "not-none")
+    cb.process("foo", "argument mismatch")  # No error in that case.
+
+
 def raising_cb_reg(func):
     class TestException(Exception):
         pass
@@ -245,10 +255,6 @@ def transformer(excp):
             raise TestException
         raise excp
 
-    # default behavior
-    cb = cbook.CallbackRegistry()
-    cb.connect('foo', raising_function)
-
     # old default
     cb_old = cbook.CallbackRegistry(exception_handler=None)
     cb_old.connect('foo', raising_function)
@@ -258,13 +264,14 @@ def transformer(excp):
     cb_filt.connect('foo', raising_function)
 
     return pytest.mark.parametrize('cb, excp',
-                                   [[cb, None],
-                                    [cb_old, RuntimeError],
+                                   [[cb_old, RuntimeError],
                                     [cb_filt, TestException]])(func)
 
 
 @raising_cb_reg
-def test_callbackregistry_process_exception(cb, excp):
+def test_callbackregistry_custom_exception_handler(monkeypatch, cb, excp):
+    monkeypatch.setattr(
+        cbook, "_get_running_interactive_framework", lambda: None)
     if excp is not None:
         with pytest.raises(excp):
             cb.process('foo')
