What is the correct way to make my PyQt application quit when killed from the console (Ctrl-C)?

Question

What is the correct way to make my PyQt application quit when killed from the console (Ctrl-C)?

Currently (I have done nothing special to handle unix signals), my PyQt application ignores SIGINT (Ctrl+C). I want it to behave nicely and quit when it is killed. How should I do that?

Solution 1

17.4. signal — Set handlers for asynchronous events

Although Python signal handlers are called asynchronously as far as the Python user is concerned, they can only occur between the “atomic” instructions of the Python interpreter. This means that signals arriving during long calculations implemented purely in C (such as regular expression matches on large bodies of text) may be delayed for an arbitrary amount of time.

That means Python cannot handle signals while the Qt event loop is running. Only when the Python interpreter run (when the QApplication quits, or when a Python function is called from Qt) the signal handler will be called.

A solution is to use a QTimer to let the interpreter run from time to time.

Note that, in the code below, if there are no open windows, the application will quit after the message box regardless of the user's choice because QApplication.quitOnLastWindowClosed() == True. This behaviour can be changed.

import signal
import sys

from PyQt4.QtCore import QTimer
from PyQt4.QtGui import QApplication, QMessageBox

# Your code here

def sigint_handler(*args):
    """Handler for the SIGINT signal."""
    sys.stderr.write('\r')
    if QMessageBox.question(None, '', "Are you sure you want to quit?",
                            QMessageBox.Yes | QMessageBox.No,
                            QMessageBox.No) == QMessageBox.Yes:
        QApplication.quit()

if __name__ == "__main__":
    signal.signal(signal.SIGINT, sigint_handler)
    app = QApplication(sys.argv)
    timer = QTimer()
    timer.start(500)  # You may change this if you wish.
    timer.timeout.connect(lambda: None)  # Let the interpreter run each 500 ms.
    # Your code here.
    sys.exit(app.exec_())

Another possible solution, as pointed by LinearOrbit, is signal.signal(signal.SIGINT, signal.SIG_DFL), but it doesn't allow custom handlers.

Solution 2

If you simply wish to have ctrl-c close the application - without being "nice"/graceful about it - then from http://www.mail-archive.com/[email protected]/msg13758.html, you can use this:

import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)

import sys
from PyQt4.QtCore import QCoreApplication
app = QCoreApplication(sys.argv)
app.exec_()

Apparently this works on Linux, Windows and OSX - I have only tested this on Linux so far (and it works).

Solution 3

18.8.1.1. Execution of Python signal handlers

A Python signal handler does not get executed inside the low-level (C) signal handler. Instead, the low-level signal handler sets a flag which tells the virtual machine to execute the corresponding Python signal handler at a later point(for example at the next bytecode instruction). This has consequences:
[...]
A long-running calculation implemented purely in C (such as regular expression matching on a large body of text) may run uninterrupted for an arbitrary amount of time, regardless of any signals received. The Python signal handlers will be called when the calculation finishes.

The Qt event loop is implemented in C(++). That means, that while it runs and no Python code is called (eg. by a Qt signal connected to a Python slot), the signals are noted, but the Python signal handlers aren't called.

But, since Python 2.6 and in Python 3 you can cause Qt to run a Python function when a signal with a handler is received using signal.set_wakeup_fd().

This is possible, because, contrary to the documentation, the low-level signal handler doesn't only set a flag for the virtual machine, but it may also write a byte into the file descriptor set by set_wakeup_fd(). Python 2 writes a NUL byte, Python 3 writes the signal number.

So by subclassing a Qt class that takes a file descriptor and provides a readReady() signal, like e.g. QAbstractSocket, the event loop will execute a Python function every time a signal (with a handler) is received causing the signal handler to execute nearly instantaneous without need for timers:

import sys, signal, socket
from PyQt4 import QtCore, QtNetwork

class SignalWakeupHandler(QtNetwork.QAbstractSocket):

    def __init__(self, parent=None):
        super().__init__(QtNetwork.QAbstractSocket.UdpSocket, parent)
        self.old_fd = None
        # Create a socket pair
        self.wsock, self.rsock = socket.socketpair(type=socket.SOCK_DGRAM)
        # Let Qt listen on the one end
        self.setSocketDescriptor(self.rsock.fileno())
        # And let Python write on the other end
        self.wsock.setblocking(False)
        self.old_fd = signal.set_wakeup_fd(self.wsock.fileno())
        # First Python code executed gets any exception from
        # the signal handler, so add a dummy handler first
        self.readyRead.connect(lambda : None)
        # Second handler does the real handling
        self.readyRead.connect(self._readSignal)

    def __del__(self):
        # Restore any old handler on deletion
        if self.old_fd is not None and signal and signal.set_wakeup_fd:
            signal.set_wakeup_fd(self.old_fd)

    def _readSignal(self):
        # Read the written byte.
        # Note: readyRead is blocked from occuring again until readData()
        # was called, so call it, even if you don't need the value.
        data = self.readData(1)
        # Emit a Qt signal for convenience
        self.signalReceived.emit(data[0])

    signalReceived = QtCore.pyqtSignal(int)

app = QApplication(sys.argv)
SignalWakeupHandler(app)

signal.signal(signal.SIGINT, lambda sig,_: app.quit())

sys.exit(app.exec_())

Solution 4

I found a way to do this. The idea is to force qt to process events often enough and in a python callabe to catch the SIGINT signal.

import signal, sys
from PyQt4.QtGui import QApplication, QWidget # also works with PySide

# You HAVE TO reimplement QApplication.event, otherwise it does not work.
# I believe that you need some python callable to catch the signal
# or KeyboardInterrupt exception.
class Application(QApplication):
    def event(self, e):
        return QApplication.event(self, e)

app = Application(sys.argv)

# Connect your cleanup function to signal.SIGINT
signal.signal(signal.SIGINT, lambda *a: app.quit())
# And start a timer to call Application.event repeatedly.
# You can change the timer parameter as you like.
app.startTimer(200)

w = QWidget()
w.show()
app.exec_()

Solution 5

The asynchronous approach by cg909 / Michael Herrmann is quite interesting to replace timers. Thus, here is a simplified version which also uses the default type for socket.socketpair (SOCK_STREAM).

class SignalWatchdog(QtNetwork.QAbstractSocket):
def __init__(self):
    """ Propagates system signals from Python to QEventLoop """
    super().__init__(QtNetwork.QAbstractSocket.SctpSocket, None)
    self.writer, self.reader = socket.socketpair()
    self.writer.setblocking(False)
    signal.set_wakeup_fd(self.writer.fileno())  # Python hook
    self.setSocketDescriptor(self.reader.fileno())  # Qt hook
    self.readyRead.connect(lambda: None)  # Dummy function call

View more solutions

Comments

[static_rtti]

That doesn't really solve my problem, because I'd like to at least have a handle on my main window in the handler. In your example, you don't...

[static_rtti]

Doesn't seem to work... Qt seems to catch the exception before I can.

[static_rtti]

Your second solution works ... kinda. When I press Ctrl-C, the application doesn't terminate immediately like is expected, but waits until focus is restored to the application.

[static_rtti]

Anyways, thanks for your answer, I'll try to ask a more specific question if nobody gives a better answer.

[static_rtti]

Thanks! Seems a bit overkill, though :) I guess I'll ask the PyQt guys directly if your solution is really the only one :)

[static_rtti]

i haven't tested your solution, but I'm pretty sure it suffers from the same problem of one of the solution above:

[static_rtti]

The signal will not be caught before control returns to the python interpreter, ie. before the application returns from sleep; which means the application will have to wait to regain focus to exit. Unacceptable for me.

[static_rtti]

After some reflection, I think I will implement Arthur Gaspar's last solution, with a system to easily disable it when debugging.

[e-satis]

This work, but be aware it will bypass any cleaning you wish to do such as calls in finally blocks.

[Mr. B]

If you place this after the app and main window are created, but before you call app._exec(), it does indeed have a handle on your app and main window.

[Michael Clerx]

Any response from the PyQt people?

[Michael Clerx]

Such a hack! But I'm using it :)

[dashesy]

I connected it like this to get a return code too signal.signal(signal.SIGINT, lambda *a: app.exit(-2))

[coldfix]

Unfortunately, this doesn't work on windows as there is no socket.socketpair. (I tried backports.socketpair, but this doesn't work either).

[cg909]

On Windows sockets and other file-like handles seem to be handled separately, so you probably need another construct that doesn't use sockets. I don't use Windows, so I can't test what would work. As of Python 3.5 sockets seem to be supported (see docs.python.org/3/library/signal.html#signal.set_wakeup_fd ).

[Michael Herrmann]

I'm getting ValueError: the fd 10 must be in non-blocking mode when trying this with Python 3.5.3 on macOS.

[Michael Herrmann]

self.wsock.setblocking(False) fixes the problem mentioned in my previous commend.

[abey]

This, together with cg909's post, is the correct answer.

[brookbot]

Really ugly, but it works ok (linux, python 3.6.8, PyQt5). I just put the class in a separate file. Otherwise my app does not close w/CTRL-C until the GUI gains focus again. Hoping Qt/PyQt incorporates this in the future