Why PySide6 application crashes when hovering over custom button while executing several QRunnables in QThreadPool

Question

My first question on Stackoverflow: I'll try my best to explain the problem ;-)

I'm currently playing around with a Python application based on PySide6. There are several time-consuming calculations running as QRunnable instances in QThreadPool.globalInstance(). So far everything is working well.

I also added a modified QPushButton to the UI. Now the problem is that the application crashes when I hover over the button while QRunnables are running in the background.

I created a minimal reproducible example. A very simple worker (QRunnable) that only waits 1 second and emits Signal finished when completed.

file q_worker.py

from PySide6.QtCore import QObject, QRunnable, Signal, Slot
from time import sleep

class WorkerSignals(QObject):
finished = Signal()

class WorkerSleep(QRunnable):

    def __init__(self):
        super(WorkerSleep, self).__init__()
        self.signals = WorkerSignals()
    
    @Slot()
    def run(self):
        sleep(1)
        self.signals.finished.emit()

In main.py you find the class CustomButton where just the method paintEvent is overwritten. Further a window with one CustomButton and one QLabel is created.

file main.py

import sys
import os

from PySide6.QtWidgets import QApplication, QMainWindow, QWidget, QLabel, QVBoxLayout, QPushButton
from PySide6.QtCore import Qt, QThreadPool, QTimer, Slot
from PySide6.QtGui import QPainter, QPaintEvent, QLinearGradient

from q_worker import WorkerSleep

class CustomButton(QPushButton):
    def __init__(self, parent=None):
        super(CustomButton, self).__init__(parent)
        self.setFixedSize(650, 99)

    def paintEvent(self, event: QPaintEvent):
        fill_color = QLinearGradient.Preset.TemptingAzure

        with QPainter(self) as p:
            p.setRenderHint(QPainter.RenderHint.Antialiasing)
            rect = event.rect()
            p.fillRect(rect, fill_color)


class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()

        # set window title
        self.setWindowTitle('minimal reproducible example')

        # time in seconds, before workers are created
        self._count = 5

        # number of workers
        self._num_workers_to_create = 100
        self._num_workers_completed = 0

        self._setup_ui()
        self.show()

        # start countdown to create workers
        self._timer = QTimer(self)
        self._timer.timeout.connect(self._countdown)
        self._timer.start(1000)
    
    def _setup_ui(self):
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        central_widget_layout = QVBoxLayout(central_widget)
    
        # add ui elements
        self.label_counter = QLabel(f"<span style= font-size:25pt>{self._count}</span>")
        central_widget_layout.addWidget(self.label_counter, alignment=Qt.AlignmentFlag.AlignHCenter)
        central_widget_layout.addWidget(CustomButton(parent=self))
    
    @Slot()
    def _countdown(self):
        self._count -= 1
        self.label_counter.setText(f"<span style= font-size:25pt>{self._count}</span>")
    
        if self._count == 0:
            self._timer.stop()
            self._create_workers()
    
    def _create_workers(self):
        for i in range(self._num_workers_to_create):
            worker = WorkerSleep()
            worker.signals.finished.connect(self._update_completed_workers)
            QThreadPool.globalInstance().start(worker)
    
    @Slot()
    def _update_completed_workers(self):
        num_threads = str(QThreadPool.globalInstance().activeThreadCount())
        self._num_workers_completed += 1
        self.label_counter.setText(f"<span style= font-size:25pt>"
                                   f"{self._num_workers_completed} Workers completed "
                                   f"({num_threads} Threads running)</span>")

def main():
app = QApplication(sys.argv)
mw = MainWindow()
app.exec()

if __name__ == "__main__":
sys.exit(main())

When running the example, the window opens, a timer counts down 5 seconds, and then WorkerSleep is started 100 times in QThreadPool.globalInstance(). As long as I don't hover over the button, everything works fine. However, when I hover over the button while the workers are being processed, the application crashes.

At first I thought it was because too many QRunnables were added to QThreadPool.globalInstance(). However, according to the documentation, they will be queued when QThreadPool.maxThreadCount() is reached. And this seems to work perfectly as QThreadPool.globalInstance().activeThreadCount() is always 8 which is the default value.

After making further attempts, the problem appears to be in the CustomButton. Because if a standard QPushButton is used, everything works perfectly.

So if I remove the custom paintEvent everything works as expected. So it seems there is something wrong with this method. But no matter what changes I try to this method, it keeps crashing.

Last but not least, there is another super strange phenomenon that I have no explanation for: when I initialize the button with a smaller size

class CustomButton(QPushButton):
    def __init__(self, parent=None):
        super(CustomButton, self).__init__(parent)
        self.setFixedSize(650, 50)

the application works fine whith my CustomButton and my custom paintEvent.

I'm running Windows 10, Python 3.9.9 and PySide6 v.6.4.1

---

i tried the following:

• adding setAutoDelete(False) to WorkerSleep.__init__ did not solve the problem
• running from the (Windows) console in venv led to the same result
• i also tried on a complete different windows machine with a new venv - running from the console lead to the same result
• i upgraded PySide6 version to current v.6.6.0 and look here - then it worked

I'm not able to solve the problem with Python 3.9.9 and PySide 6.4.1?