PyQt5 QDialog in subsequent threads

Question

I have a PyQt5 program in Python 3.3 that will start a new thread every time a button is pushed. This thread will use pop-up dialog boxes. It works the first time the button is pressed, however, the second time (after the first has been completed) will crash the program. I can call the dialog box as many times as I want from within the thread, but the second time the thread is run the program freezes. This code will reproduce the problem.

import sys
from threading import Thread
from PyQt5 import QtWidgets, QtCore


class Ui_Dialog(object):
    def setupUi(self, Dialog):
        Dialog.setObjectName("Dialog")
        self.pushButton = QtWidgets.QPushButton(Dialog)
        self.pushButton.setGeometry(QtCore.QRect(100, 100, 100, 50))
        self.pushButton.setObjectName("pushButton")

        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

    def retranslateUi(self, Dialog):
        _translate = QtCore.QCoreApplication.translate
        Dialog.setWindowTitle(_translate("Dialog", "Test"))
        self.pushButton.setText(_translate("Dialog", "OK"))


class Ui_MainWindow(object):
    def setupUi(self, mainWindow):
        mainWindow.setObjectName("mainWindow")
        self.pushButton = QtWidgets.QPushButton(mainWindow)
        self.pushButton.setGeometry(QtCore.QRect(30, 20, 100, 60))
        self.pushButton.setObjectName("pushButton")

        self.retranslateUi(mainWindow)
        QtCore.QMetaObject.connectSlotsByName(mainWindow)

    def retranslateUi(self, Dialog):
        _translate = QtCore.QCoreApplication.translate
        Dialog.setWindowTitle(_translate("mainWindow", "Test"))
        self.pushButton.setText(_translate("mainWindow", "Push Me!"))


class TestDialog(QtWidgets.QDialog):
    def __init__(self, parent=None):
        super(TestDialog, self).__init__(parent)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        # This message simply needs to go away when the button is pushed
        self.ui.pushButton.clicked.connect(self.close)

    def show_message(self):
        super(TestDialog, self).exec_()


class Main(QtWidgets.QMainWindow):
    def __init__(self):
        super(Main, self).__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.dialog = TestDialog()

        self.ui.pushButton.clicked.connect(self.start_thread)

    def start_thread(self):
        t = Thread(target=self.show_dialog)
        t.daemon = True
        t.start()

    def show_dialog(self):
        # Do lots of background stuff here
        self.dialog.show_message()
        # The dialog can be shown multiple times within the same thread
        self.dialog.show_message()


if __name__ == '__main__':
    app = QtWidgets.QApplication(sys.argv)
    window = Main()
    window.show()
    sys.exit(app.exec_())

Remove the dialog box message and it works. So why can't I call the dialog box from the second thread? I'm not trying to run two threads simultaneously, but one after the other.

Answer 1

Thanks to the answer posted by @Brickmastr I was able to rework this for my own use in a slightly different scenario. In case there are others looking to do what I was, hopefully this slightly varied method can help. If you're running a program where you want to show a 'running' dialog box and then update that box once the process has completed, this is one way to achieve that. Additionally, this is how you can use the same popup message for multiple time-consuming functions.

import PyQt5

#This below import is the python file that gets created from using QtDesigner
#And running pyuic5 to create a .py file from your .ui file - hopefully
#whomever reads this is familiar with using QtDesigner
import dialogBox as fxRun

#This is the file that would contain your primary UI, also created using QtDesigner
import mainUI
import threading

class MAIN_UI(PyQt5.QtWidgets.QMainWindow, mainUI.Ui_interface):
    startSignal = PyQt5.QtCore.pyqtSignal()
    endSignal = PyQt5.QtCore.pyqtSignal()

    def __init__(self,parent=None):
        super(MAIN_UI, self).__init__(parent)
        self.setupUi(self)
        self.buttonStartFunction1.clicked.connect(self.startFunction1)
        self.buttonStartFunction2.clicked.connect(self.startFunction2)

    def startFunction1(self):
        self.startThread(self.exampleMethod1)

   def startFunction2(self):
        self.startThread(self.exampleMethod2)

    def startThread(self,functionName):
        t = threading.Thread(target=functionName)
        t.daemon = True
        t.start()

    def exampleMethod1(self):
        #This function will show the dialog box at the beginning of the process
        # and will update the text and button once the process is complete
        FULLPROGRAM.mainUI.startSignal.emit()
        #Do lots of things here that take a long time
        FULLPROGRAM.mainUI.endSignal.emit()

    def exampleMethod2(self):
        #This can be a different function, just showing that you can send
        #whatever function into the startThread() method and it will work 
        #the same way 
        FULLPROGRAM.mainUI.startSignal.emit()
        #Do lots of things here that take a long time
        FULLPROGRAM.mainUI.endSignal.emit()

class PROCESS_BOX(PyQt5.QtWidgets.QDialog, fxRun.Ui_dialogBox):
    def __init__(self,parent=None): 
        super(PROCESS_BOX,self).__init__(parent)
        self.setupUi(self)
        self.buttonProcessCompleted.clicked.connect(self.close)

    def show_dialogbox(self): 
        self.setWindowTitle("RUNNING")
        self.labelProcessStatus.setText("PROCESSING REQUEST... \n PLEASE WAIT...")
        self.buttonProcessCompleted.setEnabled(False)
        super(PROCESS_BOX,self).exec_()

    def processComplete(self): 
        self.setWindowTitle("FINISHED")
        self.labelProcessStatus.setText("PROCESS COMPLETE! \n CLICK OK")
        self.buttonProcessCompleted.setEnabled(True)    

class FULLPROGRAM: 
    def __init__(self):
        app = PyQt5.QtWidgets.QApplication(sys.argv)
        FULLPROGRAM.fxRun = PROCESS_BOX()
        FULLPROGRAM.mainUI = MAIN_UI()
        FULLPROGRAM.mainUI.startSignal.connect(FULLPROGRAM.fxRun.show_dialogbox)
        FULLPROGRAM.mainUI.endSignal.connect(FULLPROGRAM.fxRun.processComplete)
        FULLPROGRAM.mainUI.show()
        app.exec_()

def main():
    program = FULLPROGRAM()

if __name__ == '__main__':
    main()

Answer 2

I figured it out, thanks to help from sebastian. I created a signal object, connected it to the show_message function. I also added a signal to tell the thread when the dialog has been accepted. Here is the working code.

import sys
from threading import Thread
from PyQt5 import QtWidgets, QtCore


class Ui_Dialog(object):
    def setupUi(self, Dialog):
        Dialog.setObjectName("Dialog")
        self.pushButton = QtWidgets.QPushButton(Dialog)
        self.pushButton.setGeometry(QtCore.QRect(100, 100, 100, 50))
        self.pushButton.setObjectName("pushButton")

        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

    def retranslateUi(self, Dialog):
        _translate = QtCore.QCoreApplication.translate
        Dialog.setWindowTitle(_translate("Dialog", "Test"))
        self.pushButton.setText(_translate("Dialog", "OK"))


class Ui_MainWindow(object):
    def setupUi(self, mainWindow):
        mainWindow.setObjectName("mainWindow")
        self.pushButton = QtWidgets.QPushButton(mainWindow)
        self.pushButton.setGeometry(QtCore.QRect(30, 20, 100, 60))
        self.pushButton.setObjectName("pushButton")

        self.retranslateUi(mainWindow)
        QtCore.QMetaObject.connectSlotsByName(mainWindow)

    def retranslateUi(self, Dialog):
        _translate = QtCore.QCoreApplication.translate
        Dialog.setWindowTitle(_translate("mainWindow", "Test"))
        self.pushButton.setText(_translate("mainWindow", "Push Me!"))


class TestDialog(QtWidgets.QDialog):
    signal = QtCore.pyqtSignal()

    def __init__(self, parent=None):
        super(TestDialog, self).__init__(parent)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        # This message simply needs to go away
        self.ui.pushButton.clicked.connect(self.close)

    def show_message(self):
        # Use this to display the pop-up so the text can be altered
        super(TestDialog, self).exec_()
        self.signal.emit()


class Main(QtWidgets.QMainWindow):
    signal = QtCore.pyqtSignal()

    def __init__(self):
        super(Main, self).__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.dialog = TestDialog()
        self.dialog_done = False

        self.ui.pushButton.clicked.connect(self.start_thread)

    def complete_dialog(self):
        self.dialog_done = True

    def wait_for_dialog(self):
        while not self.dialog_done:
            pass
        self.dialog_done = False

    def start_thread(self):
        t = Thread(target=self.show_dialog)
        t.daemon = True
        t.start()

    def show_dialog(self):
        # Do lots of background stuff here
        self.signal.emit()
        # Wait for the dialog to get closed
        self.wait_for_dialog()


if __name__ == '__main__':
    app = QtWidgets.QApplication(sys.argv)
    window = Main()
    window.show()
    dialog = TestDialog()
    window.signal.connect(dialog.show_message)
    dialog.signal.connect(window.complete_dialog)
    sys.exit(app.exec_())