refactor: format code with ruff

Author: vietanhdev

.pre-commit-config.yaml

@@ -21,7 +21,7 @@ repos:
     -   id: trailing-whitespace
         files: \.(py|sh|rst|yml|yaml)$
 -   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.7
+    rev: v0.15.2
     hooks:
     -   id: ruff
         args: [ --fix ]

anylabeling/app.py

@@ -15,14 +15,14 @@
 import yaml
 from PyQt6 import QtCore, QtWidgets
 
+from anylabeling import config as anylabeling_config
 from anylabeling.app_info import __appname__
 from anylabeling.config import get_config
-from anylabeling import config as anylabeling_config
-from anylabeling.views.mainwindow import MainWindow
-from anylabeling.views.labeling.logger import logger
-from anylabeling.views.labeling.utils import new_icon
 from anylabeling.resources import resources
 from anylabeling.styles import AppTheme
+from anylabeling.views.labeling.logger import logger
+from anylabeling.views.labeling.utils import new_icon
+from anylabeling.views.mainwindow import MainWindow
 
 __all__ = ["resources"]
 
@@ -175,7 +175,9 @@ def main():
 
     # Enable scaling for high dpi screens
     # High DPI scaling is enabled by default in Qt 6
-    QtCore.QCoreApplication.setAttribute(QtCore.Qt.ApplicationAttribute.AA_ShareOpenGLContexts)
+    QtCore.QCoreApplication.setAttribute(
+        QtCore.Qt.ApplicationAttribute.AA_ShareOpenGLContexts
+    )
 
     app = QtWidgets.QApplication(sys.argv)
     app.processEvents()

anylabeling/config.py

@@ -12,7 +12,6 @@
 
 from .views.labeling.logger import logger
 
-
 # Save current config file
 current_config_file = None
 

anylabeling/resources/resources.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 # Resource object code
 #
 # Created by: The Resource Compiler for PyQt6 (Qt v5.15.2)
@@ -27893,18 +27891,25 @@
 \x00\x00\x01\x96\x97\x00\x2b\x5f\
 "
 
-qt_version = [int(v) for v in QtCore.qVersion().split('.')]
+qt_version = [int(v) for v in QtCore.qVersion().split(".")]
 if qt_version < [5, 8, 0]:
     rcc_version = 1
     qt_resource_struct = qt_resource_struct_v1
 else:
     rcc_version = 2
     qt_resource_struct = qt_resource_struct_v2
 
+
 def qInitResources():
-    QtCore.qRegisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
+    QtCore.qRegisterResourceData(
+        rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data
+    )
+
 
 def qCleanupResources():
-    QtCore.qUnregisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
+    QtCore.qUnregisterResourceData(
+        rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data
+    )
+
 
 qInitResources()

anylabeling/services/auto_labeling/__init__.py

@@ -1,7 +1,6 @@
-from .model import Model
-from .registry import ModelRegistry
-
-# Import models to ensure they register themselves
-from . import yolov5
-from . import yolov8
-from . import segment_anything
+# Import models to ensure they register themselves via @ModelRegistry.register
+from . import segment_anything as segment_anything  # noqa: F401
+from . import yolov5 as yolov5  # noqa: F401
+from . import yolov8 as yolov8  # noqa: F401
+from .model import Model as Model
+from .registry import ModelRegistry as ModelRegistry

anylabeling/services/auto_labeling/lru_cache.py

@@ -1,7 +1,7 @@
 """Thread-safe LRU cache implementation."""
 
-from collections import OrderedDict
 import threading
+from collections import OrderedDict
 
 
 class LRUCache:

anylabeling/services/auto_labeling/model.py

@@ -1,16 +1,17 @@
 import logging
 import os
-import yaml
 import socket
 import ssl
 from abc import abstractmethod
 
+import yaml
 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
 
+from .types import AutoLabelingResult
+
 # Prevent issue when downloading models behind a proxy
 os.environ["no_proxy"] = "*"
 
@@ -44,7 +45,7 @@ def __init__(self, model_config, on_message) -> None:
                         "Model", "Config file not found: {model_config}"
                     ).format(model_config=model_config)
                 )
-            with open(model_config, "r") as f:
+            with open(model_config) as f:
                 self.config = yaml.safe_load(f)
         elif isinstance(model_config, dict):
             self.config = model_config
@@ -120,14 +121,14 @@ def load_image_from_filename(filename):
             try:
                 label_file = LabelFile(label_file)
             except LabelFileError as e:
-                logging.error("Error reading {}: {}".format(label_file, e))
+                logging.error(f"Error reading {label_file}: {e}")
                 return None, None
             image_data = label_file.image_data
         else:
             image_data = LabelFile.load_image_file(filename)
         image = QImage.fromData(image_data)
         if image.isNull():
-            logging.error("Error reading {}".format(filename))
+            logging.error(f"Error reading {filename}")
         return image
 
     def on_next_files_changed(self, next_files):

anylabeling/services/auto_labeling/model_manager.py

@@ -1,29 +1,27 @@
-import os
 import copy
-import time
-import shutil
-import pathlib
+import importlib.resources as pkg_resources
 import logging
+import os
+import pathlib
+import shutil
+import ssl
 import tempfile
+import time
+import urllib.request
 import zipfile
-import importlib.resources as pkg_resources
 from threading import Lock
-import urllib.request
 
 import yaml
-from PyQt6.QtCore import QObject, QThread, pyqtSignal, pyqtSlot
-from PyQt6.QtCore import QCoreApplication
+from huggingface_hub import snapshot_download
+from PyQt6.QtCore import QCoreApplication, QObject, QThread, pyqtSignal, pyqtSlot
 
+from anylabeling.config import get_config, save_config
 from anylabeling.configs import auto_labeling as auto_labeling_configs
 from anylabeling.services.auto_labeling.types import AutoLabelingResult
 from anylabeling.utils import GenericWorker
 
-from anylabeling.config import get_config, save_config
 from .registry import ModelRegistry
 
-import ssl
-from huggingface_hub import snapshot_download
-
 ssl._create_default_https_context = (
     ssl._create_unverified_context
 )  # Prevent issue when downloading models behind a proxy
@@ -110,7 +108,7 @@ def load_model_configs(self):
             model_config = copy.deepcopy(model)
             config_file = model.get("config_file", None)
             if config_file:
-                with open(config_file, "r") as f:
+                with open(config_file) as f:
                     model_config = yaml.safe_load(f)
                     model_config["config_file"] = os.path.normpath(
                         os.path.abspath(config_file)
@@ -183,7 +181,7 @@ def load_custom_model(self, config_file):
 
         # Check config file content
         model_config = {}
-        with open(config_file, "r") as f:
+        with open(config_file) as f:
             model_config = yaml.safe_load(f)
             model_config["config_file"] = os.path.abspath(config_file)
         if not model_config:
@@ -324,7 +322,7 @@ def _progress(count, block_size, total_size):
         tmp_extract_dir = os.path.join(tmp_dir, "extract")
         with zipfile.ZipFile(zip_model_path, "r") as zip_ref:
             zip_ref.extractall(tmp_extract_dir)
-                # Find model folder (containing config.yaml)
+            # Find model folder (containing config.yaml)
         model_folder = None
         for root, _, files in os.walk(tmp_extract_dir):
             if "config.yaml" in files:
@@ -333,16 +331,16 @@ def _progress(count, block_size, total_size):
         if model_folder is None:
             raise ValueError(self.tr("Could not find config.yaml in zip file."))
         return model_folder
-    
+
     def download_hf(self, tmp_dir, download_url, model_config):
-        repo_id = download_url.replace('https://huggingface.co/', '').strip('/')
+        repo_id = download_url.replace("https://huggingface.co/", "").strip("/")
         # Only take the first two segments: namespace/repo_name
-        repo_id = "/".join(repo_id.split('/')[:2])
-        
+        repo_id = "/".join(repo_id.split("/")[:2])
+
         tmp_extract_dir = os.path.join(tmp_dir, "extract")
-        local_dir = snapshot_download(
+        snapshot_download(
             repo_id=repo_id,
-            local_dir=tmp_extract_dir  # where to store everything
+            local_dir=tmp_extract_dir,  # where to store everything
         )
         with open(tmp_extract_dir + "/config.yaml", "w") as f:
             yaml.dump(model_config, f, default_flow_style=False)
@@ -355,7 +353,7 @@ def _download_and_extract_model(self, model_config):
         # Check if model is already downloaded
         if not os.path.exists(config_file):
             raise ValueError(self.tr("Error in loading config file."))
-        with open(config_file, "r") as f:
+        with open(config_file) as f:
             model_config = yaml.safe_load(f)
         if model_config.get("has_downloaded", False):
             return
@@ -364,19 +362,18 @@ def _download_and_extract_model(self, model_config):
         download_url = model_config.get("download_url", None)
         if not download_url:
             raise ValueError(self.tr("Missing download_url in config file."))
-        
+
         tmp_dir = tempfile.mkdtemp()
         model_folder = None
-        if download_url.endswith('.zip'):
+        if download_url.endswith(".zip"):
             model_folder = self.download_zip(tmp_dir, download_url)
-        elif download_url.startswith('https://huggingface.co'):
+        elif download_url.startswith("https://huggingface.co"):
             model_folder = self.download_hf(tmp_dir, download_url, model_config)
 
         if model_folder is None:
             shutil.rmtree(tmp_dir)
             raise ValueError(self.tr("Could not download model."))
 
-
         # Move model folder to correct location
         shutil.rmtree(extract_dir)
         shutil.move(model_folder, extract_dir)
@@ -385,7 +382,7 @@ def _download_and_extract_model(self, model_config):
         shutil.rmtree(tmp_dir)
 
         # Update config file
-        with open(config_file, "r") as f:
+        with open(config_file) as f:
             model_config = yaml.safe_load(f)
         model_config["has_downloaded"] = True
         model_config["config_file"] = config_file
@@ -422,7 +419,7 @@ def _load_model(self, model_id):
             model_config["model"] = model_class(
                 model_config, on_message=self.new_model_status.emit
             )
-            
+
             # Specific logic for interactive models (like SAM) vs detection models
             # Ideally this should be a property of the model class (capabilities)
             if model_type == "segment_anything":
@@ -433,18 +430,8 @@ def _load_model(self, model_id):
                 self.auto_segmentation_model_unselected.emit()
 
         except Exception as e:  # noqa
-            self.new_model_status.emit(
-                self.tr(
-                    "Error in loading model: {error_message}".format(
-                        error_message=str(e)
-                    )
-                )
-            )
-            print(
-                "Error in loading model: {error_message}".format(
-                    error_message=str(e)
-                )
-            )
+            self.new_model_status.emit(self.tr(f"Error in loading model: {str(e)}"))
+            print(f"Error in loading model: {str(e)}")
             return
 
         self.loaded_model_config = model_config
@@ -530,7 +517,7 @@ def predict_shapes_threading(self, image, filename=None):
             ):
                 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):

anylabeling/services/auto_labeling/registry.py

@@ -1,11 +1,12 @@
-from typing import Dict, Type, Any
 import logging
 
+
 class ModelRegistry:
     """
     Singleton registry to manage auto-labeling model classes.
     """
-    _registry: Dict[str, Type] = {}
+
+    _registry: dict[str, type] = {}
 
     @classmethod
     def register(cls, name: str):
@@ -15,15 +16,19 @@ def register(cls, name: str):
             @ModelRegistry.register("yolov8")
             class YOLOv8(Model): ...
         """
+
         def decorator(model_class):
             if name in cls._registry:
-                logging.warning(f"Model type '{name}' is already registered. Overwriting.")
+                logging.warning(
+                    f"Model type '{name}' is already registered. Overwriting."
+                )
             cls._registry[name] = model_class
             return model_class
+
         return decorator
 
     @classmethod
-    def get(cls, name: str) -> Type:
+    def get(cls, name: str) -> type:
         """Get a model class by type name."""
         return cls._registry.get(name)
 

anylabeling/services/auto_labeling/sam2_coreml.py

@@ -1,13 +1,14 @@
 import os
+
 import cv2
 import numpy as np
-from pathlib import Path
 from PIL import Image
 
 
 class SegmentAnything2CoreML:
     def __init__(self, model_path: str) -> None:
         import coremltools as ct  # macOS-only; imported lazily to avoid failure on Windows/Linux
+
         print("using CoreML", model_path)
         image_decoder_path = os.path.join(
             model_path, "SAM2_1LargeImageEncoderFLOAT16.mlpackage"