refactor: upgrade to pyqt6

Author: vietanhdev

.cursorrules

@@ -1,4 +1,4 @@
-- Use PyQt5 for GUI.
+- Use PyQt6 for GUI.
 - Split code into files when possible.
 - Make code clean and understandable.
 - Optimize code for performance and memory usage.

README.md

@@ -61,10 +61,10 @@ conda create -n anylabeling python=3.12
 conda activate anylabeling
 ```
 
-- **(For macOS only)** Install PyQt5 using Conda:
+- **(For macOS only)** Install PyQt6 using Conda:
 
 ```bash
-conda install -c conda-forge pyqt==5.15.9
+conda install -c conda-forge pyqt=6
 ```
 
 - Install anylabeling:

anylabeling/app.py

@@ -13,7 +13,7 @@
 import sys
 
 import yaml
-from PyQt5 import QtCore, QtWidgets
+from PyQt6 import QtCore, QtWidgets
 
 from anylabeling.app_info import __appname__
 from anylabeling.config import get_config
@@ -174,13 +174,8 @@ def main():
     loaded_language = translator.load(":/languages/translations/" + language + ".qm")
 
     # Enable scaling for high dpi screens
-    QtWidgets.QApplication.setAttribute(
-        QtCore.Qt.AA_EnableHighDpiScaling, True
-    )  # enable highdpi scaling
-    QtWidgets.QApplication.setAttribute(
-        QtCore.Qt.AA_UseHighDpiPixmaps, True
-    )  # use highdpi icons
-    QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_ShareOpenGLContexts)
+    # High DPI scaling is enabled by default in Qt 6
+    QtCore.QCoreApplication.setAttribute(QtCore.Qt.ApplicationAttribute.AA_ShareOpenGLContexts)
 
     app = QtWidgets.QApplication(sys.argv)
     app.processEvents()

anylabeling/resources/resources.py

@@ -2,11 +2,11 @@
 
 # Resource object code
 #
-# Created by: The Resource Compiler for PyQt5 (Qt v5.15.2)
+# Created by: The Resource Compiler for PyQt6 (Qt v5.15.2)
 #
 # WARNING! All changes made in this file will be lost!
 
-from PyQt5 import QtCore
+from PyQt6 import QtCore
 
 qt_resource_data = b"\
 \x00\x00\x68\xc2\

anylabeling/services/auto_labeling/model.py

@@ -5,8 +5,8 @@
 import ssl
 from abc import abstractmethod
 
-from PyQt5.QtCore import QCoreApplication, QFile, QObject
-from PyQt5.QtGui import QImage
+from PyQt6.QtCore import QCoreApplication, QFile, QObject
+from PyQt6.QtGui import QImage
 
 from .types import AutoLabelingResult
 from anylabeling.views.labeling.label_file import LabelFile, LabelFileError

anylabeling/services/auto_labeling/model_manager.py

@@ -11,8 +11,8 @@
 import urllib.request
 
 import yaml
-from PyQt5.QtCore import QObject, QThread, pyqtSignal, pyqtSlot
-from PyQt5.QtCore import QCoreApplication
+from PyQt6.QtCore import QObject, QThread, pyqtSignal, pyqtSlot
+from PyQt6.QtCore import QCoreApplication
 
 from anylabeling.configs import auto_labeling as auto_labeling_configs
 from anylabeling.services.auto_labeling.types import AutoLabelingResult
@@ -144,6 +144,16 @@ def set_output_mode(self, mode):
     @pyqtSlot()
     def on_model_download_finished(self):
         """Handle model download thread finished"""
+        if self.model_download_thread:
+            try:
+                self.model_download_thread.quit()
+                if not self.model_download_thread.wait(1000):
+                    logging.warning("Model download thread did not stop in time")
+            except RuntimeError:
+                pass
+            self.model_download_thread = None
+        self.model_download_worker = None
+
         if self.loaded_model_config and self.loaded_model_config["model"]:
             self.new_model_status.emit(self.tr("Model loaded. Ready for labeling."))
             self.model_loaded.emit(self.loaded_model_config)
@@ -269,6 +279,12 @@ def load_model(self, config_file):
         self.model_download_worker = GenericWorker(self._load_model, model_id)
         self.model_download_worker.finished.connect(self.on_model_download_finished)
         self.model_download_worker.finished.connect(self.model_download_thread.quit)
+        self.model_download_worker.finished.connect(
+            self.model_download_worker.deleteLater
+        )
+        self.model_download_thread.finished.connect(
+            self.model_download_thread.deleteLater
+        )
         self.model_download_worker.moveToThread(self.model_download_thread)
         self.model_download_thread.started.connect(self.model_download_worker.run)
         self.model_download_thread.start()
@@ -382,6 +398,7 @@ def _load_model(self, model_id):
         """Load and return model info"""
         if self.loaded_model_config is not None:
             self.loaded_model_config["model"].unload()
+            # If the model has a thread, it should have been joined in unload()
             self.loaded_model_config = None
             self.auto_segmentation_model_unselected.emit()
 
@@ -504,22 +521,25 @@ def predict_shapes_threading(self, image, filename=None):
                 self.tr("Model is not loaded. Choose a mode to continue.")
             )
             return
-        self.new_model_status.emit(self.tr("Inferencing AI model. Please wait..."))
-        self.prediction_started.emit()
-        QCoreApplication.processEvents()
 
         with self.model_execution_thread_lock:
+            # If a model is already running, try to stop it first
             if (
                 self.model_execution_thread is not None
                 and self.model_execution_thread.isRunning()
             ):
-                self.new_model_status.emit(
-                    self.tr(
-                        "Another model is being executed. Please wait for it to finish."
-                    )
-                )
-                self.prediction_finished.emit()
-                return
+                if hasattr(self.loaded_model_config["model"], "unload"):
+                    self.loaded_model_config["model"].unload()
+                
+                # Wait for the thread to finish
+                self.model_execution_thread.quit()
+                if not self.model_execution_thread.wait(1000):
+                    # If still running, we skip this request to avoid over-queuing
+                    self.prediction_finished.emit()
+                    return
+
+            self.new_model_status.emit(self.tr("Inferencing AI model. Please wait..."))
+            self.prediction_started.emit()
 
             self.model_execution_thread = QThread()
             self.model_execution_worker = GenericWorker(
@@ -528,6 +548,15 @@ def predict_shapes_threading(self, image, filename=None):
             self.model_execution_worker.finished.connect(
                 self.model_execution_thread.quit
             )
+            self.model_execution_worker.finished.connect(
+                self.model_execution_worker.deleteLater
+            )
+            self.model_execution_thread.finished.connect(
+                lambda: setattr(self, "model_execution_thread", None)
+            )
+            self.model_execution_thread.finished.connect(
+                self.model_execution_thread.deleteLater
+            )
             self.model_execution_worker.moveToThread(self.model_execution_thread)
             self.model_execution_thread.started.connect(self.model_execution_worker.run)
             self.model_execution_thread.start()

anylabeling/services/auto_labeling/segment_anything.py

@@ -5,9 +5,9 @@
 import cv2
 import onnx
 import numpy as np
-from PyQt5 import QtCore
-from PyQt5.QtCore import QThread
-from PyQt5.QtCore import QCoreApplication
+from PyQt6 import QtCore
+from PyQt6.QtCore import QThread
+from PyQt6.QtCore import QCoreApplication
 
 from anylabeling.utils import GenericWorker
 from anylabeling.views.labeling.shape import Shape
@@ -179,6 +179,10 @@ def post_process(self, masks, label="AUTOLABEL_OBJECT"):
         masks:
             2-D array of shape ``(H, W)``.  May be bool, float, or uint8.
         """
+        # Ensure the mask is 2D
+        while len(masks.shape) > 2:
+            masks = masks[0]
+
         # Ensure the mask is a float/uint8 array so that assignment of the
         # value 255 works correctly (bool arrays raise an error in NumPy ≥ 2).
         masks = masks.astype(np.float32)
@@ -199,7 +203,7 @@ def post_process(self, masks, label="AUTOLABEL_OBJECT"):
         if len(approx_contours) > 1:
             image_size = masks.shape[0] * masks.shape[1]
             areas = [cv2.contourArea(contour) for contour in approx_contours]
-            filtered_approx_contours = [
+            approx_contours = [
                 contour
                 for contour, area in zip(approx_contours, areas)
                 if area < image_size * 0.9
@@ -210,12 +214,11 @@ def post_process(self, masks, label="AUTOLABEL_OBJECT"):
             areas = [cv2.contourArea(contour) for contour in approx_contours]
             avg_area = np.mean(areas)
 
-            filtered_approx_contours = [
+            approx_contours = [
                 contour
                 for contour, area in zip(approx_contours, areas)
                 if area > avg_area * 0.2
             ]
-            approx_contours = filtered_approx_contours
 
         # Contours to shapes
         shapes = []
@@ -284,6 +287,7 @@ def predict_shapes(self, image, filename=None) -> AutoLabelingResult:
         """
         Predict shapes from image
         """
+        self.stop_inference = False
         if image is None or (not self.marks and self.prompt_mode != "text"):
             return AutoLabelingResult([], replace=False)
 
@@ -361,7 +365,9 @@ def predict_shapes(self, image, filename=None) -> AutoLabelingResult:
                 if masks is None or len(masks) == 0:
                     return AutoLabelingResult([], replace=False)
 
-                mask_2d = masks[0]  # (H, W)
+                mask_2d = masks
+                while len(mask_2d.shape) > 2:
+                    mask_2d = mask_2d[0]
                 shapes = self.post_process(mask_2d, label="AUTOLABEL_OBJECT")
         except Exception as e:  # noqa
             logging.warning("Could not inference model")
@@ -375,7 +381,15 @@ def predict_shapes(self, image, filename=None) -> AutoLabelingResult:
     def unload(self):
         self.stop_inference = True
         if self.pre_inference_thread:
-            self.pre_inference_thread.quit()
+            try:
+                self.pre_inference_thread.quit()
+                # Wait for the thread to actually finish (increased to 3s)
+                if not self.pre_inference_thread.wait(3000):
+                    logging.warning("Pre-inference thread did not stop in time")
+                else:
+                    self.pre_inference_thread = None
+            except RuntimeError:
+                self.pre_inference_thread = None
 
     def preload_worker(self, files):
         """
@@ -409,6 +423,16 @@ def on_next_files_changed(self, next_files):
             self.pre_inference_thread = QThread()
             self.pre_inference_worker = GenericWorker(self.preload_worker, next_files)
             self.pre_inference_worker.finished.connect(self.pre_inference_thread.quit)
+            self.pre_inference_worker.finished.connect(
+                self.pre_inference_worker.deleteLater
+            )
+            # Reset reference when the thread actually finishes
+            self.pre_inference_thread.finished.connect(
+                lambda: setattr(self, "pre_inference_thread", None)
+            )
+            self.pre_inference_thread.finished.connect(
+                self.pre_inference_thread.deleteLater
+            )
             self.pre_inference_worker.moveToThread(self.pre_inference_thread)
             self.pre_inference_thread.started.connect(self.pre_inference_worker.run)
             self.pre_inference_thread.start()

anylabeling/services/auto_labeling/yolov5.py

@@ -3,8 +3,8 @@
 
 import cv2
 import numpy as np
-from PyQt5 import QtCore
-from PyQt5.QtCore import QCoreApplication
+from PyQt6 import QtCore
+from PyQt6.QtCore import QCoreApplication
 
 from anylabeling.app_info import __preferred_device__
 from anylabeling.views.labeling.shape import Shape

anylabeling/services/auto_labeling/yolov8.py

@@ -3,8 +3,8 @@
 
 import cv2
 import numpy as np
-from PyQt5 import QtCore
-from PyQt5.QtCore import QCoreApplication
+from PyQt6 import QtCore
+from PyQt6.QtCore import QCoreApplication
 
 from anylabeling.app_info import __preferred_device__
 from anylabeling.views.labeling.shape import Shape

anylabeling/styles/theme.py

@@ -1,5 +1,5 @@
 import darkdetect
-from PyQt5.QtGui import QPalette, QColor
+from PyQt6.QtGui import QPalette, QColor
 import os
 
 
@@ -100,21 +100,21 @@ def apply_theme(app):
 
         # Create and apply palette
         palette = QPalette()
-        palette.setColor(QPalette.Window, QColor(colors["window"]))
-        palette.setColor(QPalette.WindowText, QColor(colors["window_text"]))
-        palette.setColor(QPalette.Base, QColor(colors["base"]))
-        palette.setColor(QPalette.AlternateBase, QColor(colors["alternate_base"]))
-        palette.setColor(QPalette.Text, QColor(colors["text"]))
-        palette.setColor(QPalette.Button, QColor(colors["button"]))
-        palette.setColor(QPalette.ButtonText, QColor(colors["button_text"]))
-        palette.setColor(QPalette.BrightText, QColor(colors["bright_text"]))
-        palette.setColor(QPalette.Highlight, QColor(colors["highlight"]))
-        palette.setColor(QPalette.HighlightedText, QColor(colors["highlighted_text"]))
-        palette.setColor(QPalette.Link, QColor(colors["link"]))
-        palette.setColor(QPalette.Dark, QColor(colors["dark"]))
-        palette.setColor(QPalette.Mid, QColor(colors["mid"]))
-        palette.setColor(QPalette.Midlight, QColor(colors["midlight"]))
-        palette.setColor(QPalette.Light, QColor(colors["light"]))
+        palette.setColor(QPalette.ColorRole.Window, QColor(colors["window"]))
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(colors["window_text"]))
+        palette.setColor(QPalette.ColorRole.Base, QColor(colors["base"]))
+        palette.setColor(QPalette.ColorRole.AlternateBase, QColor(colors["alternate_base"]))
+        palette.setColor(QPalette.ColorRole.Text, QColor(colors["text"]))
+        palette.setColor(QPalette.ColorRole.Button, QColor(colors["button"]))
+        palette.setColor(QPalette.ColorRole.ButtonText, QColor(colors["button_text"]))
+        palette.setColor(QPalette.ColorRole.BrightText, QColor(colors["bright_text"]))
+        palette.setColor(QPalette.ColorRole.Highlight, QColor(colors["highlight"]))
+        palette.setColor(QPalette.ColorRole.HighlightedText, QColor(colors["highlighted_text"]))
+        palette.setColor(QPalette.ColorRole.Link, QColor(colors["link"]))
+        palette.setColor(QPalette.ColorRole.Dark, QColor(colors["dark"]))
+        palette.setColor(QPalette.ColorRole.Mid, QColor(colors["mid"]))
+        palette.setColor(QPalette.ColorRole.Midlight, QColor(colors["midlight"]))
+        palette.setColor(QPalette.ColorRole.Light, QColor(colors["light"]))
 
         app.setPalette(palette)