I am making an image gallery of sorts where I want to be able to peruse a large sample of images (~1500) at a time. Everything's alright so far but I have run into a bug that happens when I try to close the program.
There are two main heavy processes that occur during loading:
spawnThreads method)updateThumbs method)The first task I use multiple threads to perform and that works fine. The second, I have to perform on the main thread since thats the only place you can do addWidget. Before, this caused my application to freeze, but now I use QCoreApplication.processEvents() and the UI is able to continue working fine.
However, if I try to close the program (with the "X" button) while the second task is still working, the UI closes, but Python remains open in the background and the shell remains unresponsive. I have to manually kill Python from Task Manager to regain control of the shell. I have tried to use signals to tell everything to stop working when the main window is trying to close but the effect still remains. To clarify, if I try to close if after the addWidget operations are done, everything closes fine.
Here is the relevant code:
from PySide6.QtCore import QCoreApplication, QObject, QThread, QSize, Signal, Slot
from PySide6.QtWidgets import QApplication, QHBoxLayout, QLabel, QScrollArea, QVBoxLayout, QWidget
from PySide6.QtGui import QImage, QPixmap
from PIL import Image
import sys, os, time
PLACEHOLDER_PATH = "placeholder.png"
IMAGES_PATH = "gallery_images/"
class Gallery(QWidget):
tryingToClose = Signal()
def __init__(self, controller):
self.controller = controller
super().__init__()
self.stopWorking = False
self.minThumbWidth = 128
self.thumbs = []
self.thumbPlaceholderPath = PLACEHOLDER_PATH
self.thumbPlaceholderPixmap = QPixmap(self.thumbPlaceholderPath)
self.setupUI()
def closeEvent(self, event):
event.accept()
self.tryingToClose.emit() # let the window close
self.stopWorking = True
def clearThumbs(self):
self.thumbs = []
while self.thumbsLayout.count():
child = self.layout.takeAt(0)
if child.widget():
child.widget().deleteLater()
def generateThumbs(self, paths):
self.clearThumbs()
self.thumbs = [ImageThumb(path, self.minThumbWidth, self.thumbPlaceholderPixmap) for path in paths]
def updateThumbs(self):
print('Starting op2 (closing shouldn\'t work properly now)')
for i, thumb in enumerate(self.thumbs): #this is heavy operation #2
if self.stopWorking:
print('Aborting thumbs loading (closing will still be broken, but why?)')
return
self.thumbsLayout.addWidget(thumb)
#i add this sleep here to simulate having lots of images to process, in case you dont have a directory with a lot of images
# without this you have to click very fast to close the window to observe the effect
time.sleep(0.1)
QCoreApplication.processEvents()
print('Finished op2 (closing should work fine now)')
def setupUI(self):
self.mainFrame = QVBoxLayout()
self.scrollArea = QScrollArea()
self.scrollFrame = QWidget()
self.thumbsLayout = QHBoxLayout(self.scrollFrame)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setWidget(self.scrollFrame)
self.scrollFrame.setLayout(self.thumbsLayout)
self.mainFrame.addWidget(self.scrollArea)
self.setLayout(self.mainFrame)
class ImageThumb(QLabel):
def __init__(self, path, size, placeholder):
super().__init__()
self.thumbSize = size
self.placeholder = placeholder.scaled(QSize(size, size))
self.path = path
self.setMinimumSize(1, 1)
self.setPixmap(self.placeholder)
def setup(self):
pImg = Image.open(self.path)
pImg.thumbnail((self.thumbSize, self.thumbSize))
pImg = pImg.convert("RGBA")
data = pImg.tobytes("raw","RGBA")
qImg = QImage(data, pImg.size[0], pImg.size[1], QImage.Format.Format_RGBA8888)
qImg = QPixmap.fromImage(qImg)
self.setPixmap(qImg)
class ImageWorker(QObject):
tookThumb = Signal(int, int)
finishedThumb = Signal(int, int)
finished = Signal(int)
def __init__(self, workerIndex, manager):
super().__init__()
self.index = workerIndex
self.manager = manager
@Slot()
def run(self):
try:
while self.manager.doesWorkExist():
thumbIndex, thumb = self.manager.takeThumb(self.index)
if thumbIndex == -1:
self.finished.emit(self.index)
return
self.tookThumb.emit(self.index, thumbIndex)
thumb.setup()
self.finishedThumb.emit(self.index, thumbIndex)
except Exception as e:
print(f'Worker {self.index} died to {e}')
self.finished.emit(self.index)
class ImageManager(QObject):
def __init__(self, ):
super().__init__()
self.thumbWidgets = []#thumbList
self.maxThreads = 4
self.thumbLocks = {}
self.threads = [QThread() for i in range(self.maxThreads)]
self.workers = [ImageWorker(i, self) for i in range(self.maxThreads)]
self.ignoreWork = False
def setThumbsList(self, newList):
self.thumbWidgets = newList
self.thumbLocks = {i: False for i in range(len(self.thumbWidgets))}
def doesWorkExist(self):
allThumbsLocked = all(self.thumbLocks.values())
return (not allThumbsLocked) and (not self.ignoreWork)
def stopWorking(self):
self.ignoreWork = True
for thread in self.threads:
thread.quit()
def takeThumb(self, workerIndex):
for thumbIndex, isLocked in self.thumbLocks.items():
if isLocked == False:
self.thumbLocks[thumbIndex] = True
return thumbIndex, self.thumbWidgets[thumbIndex]
return -1, None
def spawnThreads(self): #heavy operation #1 but on different threads
for index, thread in enumerate(self.threads):
worker = self.workers[index]
worker.moveToThread(thread)
thread.started.connect(worker.run)
worker.finished.connect(thread.quit)
thread.start()
class GalleryController(object):
def __init__(self):
print("Controller initialized")
self.app = QApplication([])
self.window = Gallery(self)
self.thumbsLoader = ImageManager()
self.window.tryingToClose.connect(self.thumbsLoader.stopWorking)
self.paths = []
print("Window initialized")
def loadPaths(self, newPaths):
self.paths = self.filterPaths(newPaths)
self.window.generateThumbs(self.paths)
self.thumbsLoader.setThumbsList(self.window.thumbs)
self.thumbsLoader.spawnThreads()
self.window.updateThumbs()
def isPicture(self, path):
pictureExts = ['png', 'jpg', 'jpeg']
entryName = os.path.basename(path)
ext = ('.' in entryName) and entryName[entryName.index('.') + 1:]
return ext and len(ext) > 0 and (ext in pictureExts)
def filterPaths(self, pathList):
return filter(self.isPicture, pathList)
def start(self):
self.window.show()
mainPath = IMAGES_PATH
paths = os.listdir(mainPath)
paths = [os.path.join(mainPath, path) for path in paths]
self.loadPaths(paths)
sys.exit(self.app.exec())
control = GalleryController()
control.start()
If you want to try to run this, try setting the IMAGES_PATH to a directory with atleast 10-15 images, or increase the time.sleep so you can observe the effect. I removed some unnecessary code so the images will clip on each other if you load many but just to clarify that's not the problem.
Edit: Problem solved! It was pointed out by @Demi-Lune. I accidentally was running the blocking code before the main event loop:
self.loadPaths(paths) #<--- long running
sys.exit(self.app.exec()) #<--- start of event loop
Simply changing it so that the long running task starts with a pushbutton fixes the issue.
The problem was I was executing the long-running code before the start of the main event loop.
self.loadPaths(paths) #<--- long running
sys.exit(self.app.exec()) #<--- start of main event loop
@Demi-Lune points out that one way to solve this is to start a QThread before the event loop that hosts the blocking code, but my use case is solved by connecting the blocking code to the click of a QPushButton.