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

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 signalimport sysfrom PyQt4.QtCore import QTimerfrom PyQt4.QtGui import QApplication, QMessageBox# Your code heredef 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.

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

import signalsignal.signal(signal.SIGINT, signal.SIG_DFL)import sysfrom PyQt4.QtCore import QCoreApplicationapp = 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).

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, socketfrom PyQt4 import QtCore, QtNetworkclass 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_())