Use ruff for formatting + Fix minor issues

Author: vietanhdev

.flake8

@@ -20,17 +20,14 @@ repos:
     -   id: mixed-line-ending
     -   id: trailing-whitespace
         files: \.(py|sh|rst|yml|yaml)$
--   repo: https://github.com/psf/black
-    rev: 23.3.0
+-   repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.7
     hooks:
-    -   id: black
+    -   id: ruff
+        args: [ --fix ]
         exclude: tests/|anylabeling/resources/resources.py
--   repo: https://github.com/psf/black
-    rev: 23.3.0
-    hooks:
-    -   id: black
+    -   id: ruff-format
         exclude: tests/|anylabeling/resources/resources.py
-        args: [--check]
 -   repo: https://github.com/rstcheck/rstcheck
     rev: v6.1.2
     hooks:

.pre-commit-config.yaml

@@ -1 +1,3 @@
 from .app_info import __appdescription__, __appname__, __version__
+
+__all__ = ["__appdescription__", "__appname__", "__version__"]

anylabeling/__init__.py

@@ -23,12 +23,12 @@
 from anylabeling.views.labeling.utils import new_icon
 from anylabeling.resources import resources
 
+__all__ = ["resources"]
+
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--reset-config", action="store_true", help="reset qt config"
-    )
+    parser.add_argument("--reset-config", action="store_true", help="reset qt config")
     parser.add_argument(
         "--logger-level",
         default="info",
@@ -45,16 +45,11 @@ def main():
             "recognized as file, else as directory)"
         ),
     )
-    default_config_file = os.path.join(
-        os.path.expanduser("~"), ".anylabelingrc"
-    )
+    default_config_file = os.path.join(os.path.expanduser("~"), ".anylabelingrc")
     parser.add_argument(
         "--config",
         dest="config",
-        help=(
-            "config file or yaml-format string (default:"
-            f" {default_config_file})"
-        ),
+        help=(f"config file or yaml-format string (default: {default_config_file})"),
         default=default_config_file,
     )
     # config for the gui
@@ -167,9 +162,7 @@ def main():
 
     language = config.get("language", QtCore.QLocale.system().name())
     translator = QtCore.QTranslator()
-    loaded_language = translator.load(
-        ":/languages/translations/" + language + ".qm"
-    )
+    loaded_language = translator.load(":/languages/translations/" + language + ".qm")
 
     # Enable scaling for high dpi screens
     QtWidgets.QApplication.setAttribute(

anylabeling/app.py

@@ -54,17 +54,11 @@ def get_default_config():
 
 def validate_config_item(key, value):
     if key == "validate_label" and value not in [None, "exact"]:
-        raise ValueError(
-            f"Unexpected value for config key 'validate_label': {value}"
-        )
+        raise ValueError(f"Unexpected value for config key 'validate_label': {value}")
     if key == "shape_color" and value not in [None, "auto", "manual"]:
-        raise ValueError(
-            f"Unexpected value for config key 'shape_color': {value}"
-        )
+        raise ValueError(f"Unexpected value for config key 'shape_color': {value}")
     if key == "labels" and value is not None and len(value) != len(set(value)):
-        raise ValueError(
-            f"Duplicates are detected for config key 'labels': {value}"
-        )
+        raise ValueError(f"Duplicates are detected for config key 'labels': {value}")
 
 
 def get_config(config_file_or_yaml=None, config_from_args=None):
@@ -80,14 +74,10 @@ def get_config(config_file_or_yaml=None, config_from_args=None):
             with open(config_from_yaml) as f:
                 logger.info("Loading config file from: %s", config_from_yaml)
                 config_from_yaml = yaml.safe_load(f)
-        update_dict(
-            config, config_from_yaml, validate_item=validate_config_item
-        )
+        update_dict(config, config_from_yaml, validate_item=validate_config_item)
 
     # 3. command line argument or specified config file
     if config_from_args is not None:
-        update_dict(
-            config, config_from_args, validate_item=validate_config_item
-        )
+        update_dict(config, config_from_args, validate_item=validate_config_item)
 
     return config

anylabeling/config.py

@@ -1,37 +1,29 @@
 import logging
 import os
-import pathlib
 import yaml
-import onnx
-import urllib.request
-from urllib.parse import urlparse
-
-from PyQt5.QtCore import QCoreApplication
-
-import ssl
-
-ssl._create_default_https_context = (
-    ssl._create_unverified_context
-)  # Prevent issue when downloading models behind a proxy
-
 import socket
-
-socket.setdefaulttimeout(240)  # Prevent timeout when downloading models
-
+import ssl
 from abc import abstractmethod
 
-
-from PyQt5.QtCore import QFile, QObject
+from PyQt5.QtCore import QCoreApplication, QFile, QObject
 from PyQt5.QtGui import QImage
 
 from .types import AutoLabelingResult
 from anylabeling.views.labeling.label_file import LabelFile, LabelFileError
 
+# Prevent issue when downloading models behind a proxy
+os.environ["no_proxy"] = "*"
+
+socket.setdefaulttimeout(240)  # Prevent timeout when downloading models
+
+
+ssl._create_default_https_context = (
+    ssl._create_unverified_context
+)  # Prevent issue when downloading models behind a proxy
+
 
 class Model(QObject):
-    BASE_DOWNLOAD_URL = (
-        "https://github.com/vietanhdev/anylabeling-assets/raw/main/"
-    )
+    BASE_DOWNLOAD_URL = "https://github.com/vietanhdev/anylabeling-assets/raw/main/"
 
     class Meta(QObject):
         required_config_names = []
@@ -82,9 +74,7 @@ def get_model_abs_path(self, model_config, model_path_field_name):
         config_folder = os.path.dirname(model_config["config_file"])
         model_path = model_config[model_path_field_name]
         if os.path.isfile(os.path.join(config_folder, model_path)):
-            model_abs_path = os.path.abspath(
-                os.path.join(config_folder, model_path)
-            )
+            model_abs_path = os.path.abspath(os.path.join(config_folder, model_path))
             return model_abs_path
 
         # Try getting model from assets folder

anylabeling/services/auto_labeling/model.py

@@ -61,9 +61,7 @@ def __init__(self):
     def load_model_configs(self):
         """Load model configs"""
         # Load list of default models
-        with pkg_resources.open_text(
-            auto_labeling_configs, "models.yaml"
-        ) as f:
+        with pkg_resources.open_text(auto_labeling_configs, "models.yaml") as f:
             model_list = yaml.safe_load(f)
             for model in model_list:
                 model["is_custom_model"] = False
@@ -74,9 +72,7 @@ def load_model_configs(self):
                 model_download_path = os.path.join(
                     home_dir, "anylabeling_data", "models", model["name"]
                 )
-                pathlib.Path(model_download_path).mkdir(
-                    parents=True, exist_ok=True
-                )
+                pathlib.Path(model_download_path).mkdir(parents=True, exist_ok=True)
                 config_file = os.path.join(model_download_path, "config.yaml")
                 model["config_file"] = config_file
 
@@ -126,9 +122,7 @@ def load_model_configs(self):
             if not model_config.get("is_custom_model", False):
                 model_config["last_used"] = -i
             else:
-                model_config["last_used"] = model_config.get(
-                    "last_used", time.time()
-                )
+                model_config["last_used"] = model_config.get("last_used", time.time())
         model_configs.sort(key=lambda x: x.get("last_used", 0), reverse=True)
 
         self.model_configs = model_configs
@@ -147,9 +141,7 @@ def set_output_mode(self, mode):
     def on_model_download_finished(self):
         """Handle model download thread finished"""
         if self.loaded_model_config and self.loaded_model_config["model"]:
-            self.new_model_status.emit(
-                self.tr("Model loaded. Ready for labeling.")
-            )
+            self.new_model_status.emit(self.tr("Model loaded. Ready for labeling."))
             self.model_loaded.emit(self.loaded_model_config)
             self.output_modes_changed.emit(
                 self.loaded_model_config["model"].Meta.output_modes,
@@ -165,9 +157,7 @@ def load_custom_model(self, config_file):
             self.model_download_thread is not None
             and self.model_download_thread.isRunning()
         ):
-            print(
-                "Another model is being loaded. Please wait for it to finish."
-            )
+            print("Another model is being loaded. Please wait for it to finish.")
             return
 
         # Check config file path
@@ -191,33 +181,26 @@ def load_custom_model(self, config_file):
             "type" not in model_config
             or "display_name" not in model_config
             or "name" not in model_config
-            or model_config["type"]
-            not in ["segment_anything", "yolov5", "yolov8"]
+            or model_config["type"] not in ["segment_anything", "yolov5", "yolov8"]
         ):
             self.new_model_status.emit(
-                self.tr(
-                    "Error in loading custom model: Invalid config file format."
-                )
+                self.tr("Error in loading custom model: Invalid config file format.")
             )
             return
 
         # Add or replace custom model
         custom_models = get_config().get("custom_models", [])
         matched_index = None
         for i, model in enumerate(custom_models):
-            if os.path.normpath(model["config_file"]) == os.path.normpath(
-                config_file
-            ):
+            if os.path.normpath(model["config_file"]) == os.path.normpath(config_file):
                 matched_index = i
                 break
         if matched_index is not None:
             model_config["last_used"] = time.time()
             custom_models[matched_index] = model_config
         else:
             if len(custom_models) >= self.MAX_NUM_CUSTOM_MODELS:
-                custom_models.sort(
-                    key=lambda x: x.get("last_used", 0), reverse=True
-                )
+                custom_models.sort(key=lambda x: x.get("last_used", 0), reverse=True)
                 removed_model = custom_models.pop()
                 # Remove old model folder
                 config_file = removed_model["config_file"]
@@ -245,9 +228,7 @@ def load_model(self, config_file):
             self.model_download_thread is not None
             and self.model_download_thread.isRunning()
         ):
-            print(
-                "Another model is being loaded. Please wait for it to finish."
-            )
+            print("Another model is being loaded. Please wait for it to finish.")
             return
         if not config_file:
             if self.model_download_worker is not None:
@@ -280,16 +261,10 @@ 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.on_model_download_finished)
+        self.model_download_worker.finished.connect(self.model_download_thread.quit)
         self.model_download_worker.moveToThread(self.model_download_thread)
-        self.model_download_thread.started.connect(
-            self.model_download_worker.run
-        )
+        self.model_download_thread.started.connect(self.model_download_worker.run)
         self.model_download_thread.start()
 
     def _download_and_extract_model(self, model_config):
@@ -313,22 +288,16 @@ def _download_and_extract_model(self, model_config):
         # Download url
         ellipsis_download_url = download_url
         if len(download_url) > 40:
-            ellipsis_download_url = (
-                download_url[:20] + "..." + download_url[-20:]
-            )
-        logging.info(
-            "Downloading %s to %s", ellipsis_download_url, zip_model_path
-        )
+            ellipsis_download_url = download_url[:20] + "..." + download_url[-20:]
+        logging.info("Downloading %s to %s", ellipsis_download_url, zip_model_path)
         try:
             # Download and show progress
             def _progress(count, block_size, total_size):
                 percent = int(count * block_size * 100 / total_size)
                 self.new_model_status.emit(
                     QCoreApplication.translate(
                         "Model", "Downloading {download_url}: {percent}%"
-                    ).format(
-                        download_url=ellipsis_download_url, percent=percent
-                    )
+                    ).format(download_url=ellipsis_download_url, percent=percent)
                 )
 
             urllib.request.urlretrieve(
@@ -352,9 +321,7 @@ def _progress(count, block_size, total_size):
                 model_folder = root
                 break
         if model_folder is None:
-            raise ValueError(
-                self.tr("Could not find config.yaml in zip file.")
-            )
+            raise ValueError(self.tr("Could not find config.yaml in zip file."))
 
         # Move model folder to correct location
         shutil.rmtree(extract_dir)
@@ -494,9 +461,9 @@ def predict_shapes(self, image, filename=None):
             self.prediction_finished.emit()
             return
         try:
-            auto_labeling_result = self.loaded_model_config[
-                "model"
-            ].predict_shapes(image, filename)
+            auto_labeling_result = self.loaded_model_config["model"].predict_shapes(
+                image, filename
+            )
             self.new_auto_labeling_result.emit(auto_labeling_result)
         except Exception as e:  # noqa
             print(f"Error in predict_shapes: {e}")
@@ -518,9 +485,7 @@ 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.new_model_status.emit(self.tr("Inferencing AI model. Please wait..."))
         self.prediction_started.emit()
 
         with self.model_execution_thread_lock:
@@ -530,8 +495,7 @@ def predict_shapes_threading(self, image, filename=None):
             ):
                 self.new_model_status.emit(
                     self.tr(
-                        "Another model is being executed."
-                        " Please wait for it to finish."
+                        "Another model is being executed. Please wait for it to finish."
                     )
                 )
                 self.prediction_finished.emit()
@@ -544,12 +508,8 @@ def predict_shapes_threading(self, image, filename=None):
             self.model_execution_worker.finished.connect(
                 self.model_execution_thread.quit
             )
-            self.model_execution_worker.moveToThread(
-                self.model_execution_thread
-            )
-            self.model_execution_thread.started.connect(
-                self.model_execution_worker.run
-            )
+            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()
 
     def on_next_files_changed(self, next_files):