CODEWITHSUNDEEP
pythonloggingpyqt5python-multithreading
toto
toto

Reputation: 360

QtApp and logging in Python

I am developing an application with Qt GUI (PyQt5) in python. In the main window I have a QTextEdit that is connected to the logging handler more or less as described below.

class ConsolePanelHandler(logging.Handler):
    
    def __init__(self, parent):
        logging.Handler.__init__(self)
        self.parent = parent
        
    def emit(self, record):
        self.parent.write_log_message(self.format(record))

class MyAppWindow(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setupUi(self)
        self.connectSignalsSlot()
        
    def write_log_message(self, s):
        self.messagewindow.setFontWeight(QtGui.QFont.Normal)
        self.messagewindow.append(s)


if __name__ == "__main__":

    
    # prepare the logging machinery
    log = logging.getLogger(__name__)
    log.setLevel(level=logging.INFO)
    
    
    # start the Qt App
    app = QApplication(sys.argv)
    win = MyAppWindow()
    
    # connect the logging handler to the Qt App
    handler = ConsolePanelHandler(win)
    handler.setFormatter(logging.Formatter('[%(asctime)s] - %(levelname)s: %(message)s',datefmt='%Y%m%d-%H:%M:%S'))
    log.addHandler(handler)
    
    # show the main window 
    win.show()
    
    # execute the main window and eventually exit when done!
    sys.exit(app.exec())

In general everything works fine, but as soon as the application load is becoming high (CPU and/or I/O), then the GUI is becoming unresponsive and the QTextEdit is not updated. From the user point of view, it looks like that the program crashed, but actually it is just busy working.

When the high load task is done, the GUI returns to be responsive and all log entries are displayed all together.

I guess that the solution would be to spawn a new thread where the high load task is done in order to leave the Qt thread almost free.

Do you have a better solution?

Thanks for your help

Update: implemented multithreading

I've tried to implemented a multithread solution, it is to say that when the user click on the button to start the I/O heavy operation, this is executed in a new thread as below.

from threading import Thread

class MyAppWindow(QMainWindow, Ui_MaindWindow):
    # skipping all unnnecessary lines of code

    def on_mouse_click(self):
        self.thread = threading.Thread(target=self.perform_IO_task)
        self.thread.start()
        # don't put self.thread.join() here

    def perform_IO_task(self):
        # do the job
        # print log messages
        # ...
        # self.thread.join() FAILS!

This implementation is working, the IO task is executed and the GUI remains workable. Now the question is when should I join the thread?

If I put the join() statement as last line of the on_mouse_click method, the application will 'freeze' the GUI and wait for the thread to finish without showing updates on the log. This is the correct behaviour according to the documentation.

If I put it in end of the target call back, the application fails saying that it is not possible to join the thread.

If I got it right, join() is needed to force a thread to wait for the output of another one before continuing. In my case, it is not needed, so I'm tempted to skip the join() statement... Will this cause any issue?

Upvotes: 0

Views: 376

Answers (1)

Vinay Sajip
Vinay Sajip

Reputation: 99365

There are various things you need to think about when using Qt and updating the GUI (updates should be from the main thread). I recommend you look at the logging cookbook which has a working example, and adapt that approach to your needs.

Upvotes: 1

Related Questions