MNT: fix interrupt handling in Qt event loop

signal.set_wakeup_fd() used instead, start_event_loop() is
interruptible now, allow_interrupt context manager, do not override
None, SIG_DFL, SIG_IGN

Author: vdrhtc

lib/matplotlib/backends/backend_qt.py

@@ -17,8 +17,10 @@
     QtCore, QtGui, QtWidgets, __version__, QT_API,
     _enum, _to_int,
     _devicePixelRatioF, _isdeleted, _setDevicePixelRatio,
+    _allow_interrupt
 )
 
+
 backend_version = __version__
 
 # SPECIAL_KEYS are Qt::Key that do *not* return their unicode name
@@ -399,7 +401,13 @@ def start_event_loop(self, timeout=0):
         if timeout > 0:
             timer = QtCore.QTimer.singleShot(int(timeout * 1000),
                                              event_loop.quit)
-        qt_compat._exec(event_loop)
+
+        old_sigint_handler = signal.getsignal(signal.SIGINT)
+        try:
+            with _allow_interrupt(qApp, old_sigint_handler):
+                qt_compat._exec(event_loop)
+        except ValueError:
+            qt_compat._exec(event_loop)
 
     def stop_event_loop(self, event=None):
         # docstring inherited
@@ -1005,10 +1013,7 @@ def mainloop():
         # allow SIGINT exceptions to close the plot window.
         is_python_signal_handler = old_signal is not None
         if is_python_signal_handler:
-            signal.signal(signal.SIGINT, signal.SIG_DFL)
-        try:
+            with _allow_interrupt(qApp, old_signal):
+                qt_compat._exec(qApp)
+        else:
             qt_compat._exec(qApp)
-        finally:
-            # reset the SIGINT exception handler
-            if is_python_signal_handler:
-                signal.signal(signal.SIGINT, old_signal)

lib/matplotlib/backends/qt_compat.py

@@ -16,6 +16,8 @@
 import os
 import platform
 import sys
+import signal
+import socket
 
 from packaging.version import parse as parse_version
 
@@ -74,30 +76,30 @@
 
 
 def _setup_pyqt5plus():
-    global QtCore, QtGui, QtWidgets, __version__, is_pyqt5, \
+    global QtCore, QtGui, QtWidgets, QtNetwork, __version__, is_pyqt5, \
         _isdeleted, _getSaveFileName
 
     if QT_API == QT_API_PYQT6:
-        from PyQt6 import QtCore, QtGui, QtWidgets, sip
+        from PyQt6 import QtCore, QtGui, QtWidgets, QtNetwork, sip
         __version__ = QtCore.PYQT_VERSION_STR
         QtCore.Signal = QtCore.pyqtSignal
         QtCore.Slot = QtCore.pyqtSlot
         QtCore.Property = QtCore.pyqtProperty
         _isdeleted = sip.isdeleted
     elif QT_API == QT_API_PYSIDE6:
-        from PySide6 import QtCore, QtGui, QtWidgets, __version__
+        from PySide6 import QtCore, QtGui, QtWidgets, QtNetwork, __version__
         import shiboken6
         def _isdeleted(obj): return not shiboken6.isValid(obj)
     elif QT_API == QT_API_PYQT5:
-        from PyQt5 import QtCore, QtGui, QtWidgets
+        from PyQt5 import QtCore, QtGui, QtWidgets, QtNetwork
         import sip
         __version__ = QtCore.PYQT_VERSION_STR
         QtCore.Signal = QtCore.pyqtSignal
         QtCore.Slot = QtCore.pyqtSlot
         QtCore.Property = QtCore.pyqtProperty
         _isdeleted = sip.isdeleted
     elif QT_API == QT_API_PYSIDE2:
-        from PySide2 import QtCore, QtGui, QtWidgets, __version__
+        from PySide2 import QtCore, QtGui, QtWidgets, QtNetwork, __version__
         import shiboken2
         def _isdeleted(obj): return not shiboken2.isValid(obj)
     else:
@@ -191,3 +193,49 @@ def _setDevicePixelRatio(obj, val):
     if hasattr(obj, 'setDevicePixelRatio'):
         # Not available on Qt4 or some older Qt5.
         obj.setDevicePixelRatio(val)
+
+
+class _allow_interrupt:
+    def __init__(self, qApp, old_sigint_handler):
+        self.interrupted_qobject = qApp
+        self.old_fd = None
+        if old_sigint_handler in (None, signal.SIG_IGN, signal.SIG_DFL):
+            raise ValueError(f"Old SIGINT handler {old_sigint_handler}"
+                             f" will not be overridden")
+        self.old_sigint_handler = old_sigint_handler
+        self.caught_args = None
+
+        QAS = QtNetwork.QAbstractSocket
+        self.qt_socket = QAS(QAS.TcpSocket, qApp)
+        # Create a socket pair
+        self.wsock, self.rsock = socket.socketpair()
+        # Let Qt listen on the one end
+        self.qt_socket.setSocketDescriptor(self.rsock.fileno())
+        self.wsock.setblocking(False)
+        self.qt_socket.readyRead.connect(self._readSignal)
+
+    def __enter__(self):
+        signal.signal(signal.SIGINT, self._handle)
+        # And let Python write on the other end
+        self.old_fd = signal.set_wakeup_fd(self.wsock.fileno())
+
+    def __exit__(self, type, val, traceback):
+        signal.set_wakeup_fd(self.old_fd)
+        signal.signal(signal.SIGINT, self.old_sigint_handler)
+
+        self.wsock.close()
+        self.rsock.close()
+        self.qt_socket.abort()
+        if self.caught_args is not None:
+            self.old_sigint_handler(*self.caught_args)
+
+    def _readSignal(self):
+        # Read the written byte.
+        # Note: readyRead is blocked from
+        # occurring again until readData() was called, so call it,
+        # even if you don't need the value.
+        self.qt_socket.readData(1)
+
+    def _handle(self, *args):
+        self.caught_args = args
+        self.interrupted_qobject.quit()

lib/matplotlib/tests/test_backend_qt.py

@@ -33,8 +33,22 @@ def qt_core(request):
     return QtCore
 
 
+@pytest.fixture
+def platform_simulate_ctrl_c(request):
+    import signal
+    from functools import partial
+
+    if hasattr(signal, "CTRL_C_EVENT"):
+        from win32api import GenerateConsoleCtrlEvent
+        return partial(GenerateConsoleCtrlEvent, 0, 0)
+    else:
+        # we're not on windows
+        return partial(os.kill, os.getpid(), signal.SIGINT)
+
+
 @pytest.mark.backend('QtAgg', skip_on_importerror=True)
 def test_fig_close():
+
     # save the state of Gcf.figs
     init_figs = copy.copy(Gcf.figs)
 
@@ -51,18 +65,39 @@ def test_fig_close():
 
 
 @pytest.mark.backend('QtAgg', skip_on_importerror=True)
-def test_fig_signals(qt_core):
+@pytest.mark.parametrize("target, kwargs", [
+    (plt.show, {"block": True}),
+    (plt.pause, {"interval": 10})
+])
+def test_sigint(qt_core, platform_simulate_ctrl_c, target,
+                kwargs):
+    plt.figure()
+    def fire_signal():
+        platform_simulate_ctrl_c()
+
+    qt_core.QTimer.singleShot(100, fire_signal)
+    try:
+        target(**kwargs)
+    except KeyboardInterrupt as e:
+        assert True
+    else:
+        assert False  # KeyboardInterrupt must be raised
+
+
+@pytest.mark.backend('QtAgg', skip_on_importerror=True)
+def test_fig_sigint_override(qt_core):
+    from matplotlib.backends.backend_qt5 import _BackendQT5
     # Create a figure
     plt.figure()
 
-    # Access signals
-    event_loop_signal = None
+    # Variable to access the handler from the inside of the event loop
+    event_loop_handler = None
 
     # Callback to fire during event loop: save SIGINT handler, then exit
     def fire_signal_and_quit():
         # Save event loop signal
-        nonlocal event_loop_signal
-        event_loop_signal = signal.getsignal(signal.SIGINT)
+        nonlocal event_loop_handler
+        event_loop_handler = signal.getsignal(signal.SIGINT)
 
         # Request event loop exit
         qt_core.QCoreApplication.exit()
@@ -71,26 +106,37 @@ def fire_signal_and_quit():
     qt_core.QTimer.singleShot(0, fire_signal_and_quit)
 
     # Save original SIGINT handler
-    original_signal = signal.getsignal(signal.SIGINT)
+    original_handler = signal.getsignal(signal.SIGINT)
 
     # Use our own SIGINT handler to be 100% sure this is working
-    def CustomHandler(signum, frame):
+    def custom_handler(signum, frame):
         pass
 
-    signal.signal(signal.SIGINT, CustomHandler)
+    signal.signal(signal.SIGINT, custom_handler)
 
     # mainloop() sets SIGINT, starts Qt event loop (which triggers timer and
     # exits) and then mainloop() resets SIGINT
     matplotlib.backends.backend_qt._BackendQT.mainloop()
 
-    # Assert: signal handler during loop execution is signal.SIG_DFL
-    assert event_loop_signal == signal.SIG_DFL
+    # Assert: signal handler during loop execution is changed
+    # (can't test equality with func)
+    assert event_loop_handler != custom_handler
 
     # Assert: current signal handler is the same as the one we set before
-    assert CustomHandler == signal.getsignal(signal.SIGINT)
+    assert signal.getsignal(signal.SIGINT) == custom_handler
+
+    # Repeat again to test that SIG_DFL and SIG_IGN will not be overridden
+    for custom_handler in (signal.SIG_DFL, signal.SIG_IGN):
+        qt_core.QTimer.singleShot(0, fire_signal_and_quit)
+        signal.signal(signal.SIGINT, custom_handler)
+
+        _BackendQT5.mainloop()
+
+        assert event_loop_handler == custom_handler
+        assert signal.getsignal(signal.SIGINT) == custom_handler
 
     # Reset SIGINT handler to what it was before the test
-    signal.signal(signal.SIGINT, original_signal)
+    signal.signal(signal.SIGINT, original_handler)
 
 
 @pytest.mark.parametrize(