lazylabel-gui 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

lazylabel/__init__.py

@@ -6,4 +6,4 @@ __email__ = "deniz.n.cakan@gmail.com"
 
 from .main import main
 
-__all__ = ['main']
+__all__ = ["main"]

lazylabel/config/__init__.py

@@ -1,7 +1,7 @@
 """Configuration management for LazyLabel."""
 
-from .settings import Settings, DEFAULT_SETTINGS
+from .hotkeys import HotkeyAction, HotkeyManager
 from .paths import Paths
-from .hotkeys import HotkeyManager, HotkeyAction
+from .settings import DEFAULT_SETTINGS, Settings
 
-__all__ = ['Settings', 'DEFAULT_SETTINGS', 'Paths', 'HotkeyManager', 'HotkeyAction']
+__all__ = ["Settings", "DEFAULT_SETTINGS", "Paths", "HotkeyManager", "HotkeyAction"]

lazylabel/config/hotkeys.py

@@ -2,89 +2,127 @@
 
 import json
 import os
-from dataclasses import dataclass, asdict
-from typing import Dict, Optional, List, Tuple
-from PyQt6.QtCore import Qt
+from dataclasses import dataclass
+
 from PyQt6.QtGui import QKeySequence
 
 
 @dataclass
 class HotkeyAction:
     """Represents a hotkey action with primary and secondary keys."""
+
     name: str
     description: str
     primary_key: str
-    secondary_key: Optional[str] = None
+    secondary_key: str | None = None
     category: str = "General"
     mouse_related: bool = False  # Cannot be reassigned if True
 
 
 class HotkeyManager:
     """Manages application hotkeys with persistence."""
-    
+
     def __init__(self, config_dir: str):
         self.config_dir = config_dir
         self.hotkeys_file = os.path.join(config_dir, "hotkeys.json")
-        self.actions: Dict[str, HotkeyAction] = {}
+        self.actions: dict[str, HotkeyAction] = {}
         self._initialize_default_hotkeys()
         self.load_hotkeys()
-    
+
     def _initialize_default_hotkeys(self):
         """Initialize default hotkey mappings."""
         default_hotkeys = [
             # Navigation
-            HotkeyAction("load_next_image", "Load Next Image", "Right", category="Navigation"),
-            HotkeyAction("load_previous_image", "Load Previous Image", "Left", category="Navigation"),
-            HotkeyAction("fit_view", "Fit View", "Period", category="Navigation"),
-            
+            HotkeyAction(
+                "load_next_image", "Load Next Image", "Right", category="Navigation"
+            ),
+            HotkeyAction(
+                "load_previous_image",
+                "Load Previous Image",
+                "Left",
+                category="Navigation",
+            ),
+            HotkeyAction("fit_view", "Fit View", ".", category="Navigation"),
             # Modes
             HotkeyAction("sam_mode", "Point Mode (SAM)", "1", category="Modes"),
             HotkeyAction("polygon_mode", "Polygon Mode", "2", category="Modes"),
             HotkeyAction("selection_mode", "Selection Mode", "E", category="Modes"),
             HotkeyAction("pan_mode", "Pan Mode", "Q", category="Modes"),
             HotkeyAction("edit_mode", "Edit Mode", "R", category="Modes"),
-            
             # Actions
-            HotkeyAction("clear_points", "Clear Points/Vertices", "C", category="Actions"),
-            HotkeyAction("save_segment", "Save Current Segment", "Space", category="Actions"),
+            HotkeyAction(
+                "clear_points", "Clear Points/Vertices", "C", category="Actions"
+            ),
+            HotkeyAction(
+                "save_segment", "Save Current Segment", "Space", category="Actions"
+            ),
             HotkeyAction("save_output", "Save Output", "Return", category="Actions"),
-            HotkeyAction("save_output_alt", "Save Output (Alt)", "Enter", category="Actions"),
+            HotkeyAction(
+                "save_output_alt", "Save Output (Alt)", "Enter", category="Actions"
+            ),
             HotkeyAction("undo", "Undo Last Action", "Ctrl+Z", category="Actions"),
-            HotkeyAction("escape", "Cancel/Clear Selection", "Escape", category="Actions"),
-            
+            HotkeyAction(
+                "redo", "Redo Last Action", "Ctrl+Y", "Ctrl+Shift+Z", category="Actions"
+            ),
+            HotkeyAction(
+                "escape", "Cancel/Clear Selection", "Escape", category="Actions"
+            ),
             # Segments
-            HotkeyAction("merge_segments", "Merge Selected Segments", "M", category="Segments"),
-            HotkeyAction("delete_segments", "Delete Selected Segments", "V", category="Segments"),
-            HotkeyAction("delete_segments_alt", "Delete Selected Segments (Alt)", "Backspace", category="Segments"),
-            HotkeyAction("select_all", "Select All Segments", "Ctrl+A", category="Segments"),
-            
+            HotkeyAction(
+                "merge_segments", "Merge Selected Segments", "M", category="Segments"
+            ),
+            HotkeyAction(
+                "delete_segments", "Delete Selected Segments", "V", category="Segments"
+            ),
+            HotkeyAction(
+                "delete_segments_alt",
+                "Delete Selected Segments (Alt)",
+                "Backspace",
+                category="Segments",
+            ),
+            HotkeyAction(
+                "select_all", "Select All Segments", "Ctrl+A", category="Segments"
+            ),
             # View
             HotkeyAction("zoom_in", "Zoom In", "Ctrl+Plus", category="View"),
             HotkeyAction("zoom_out", "Zoom Out", "Ctrl+Minus", category="View"),
-            
             # Movement (WASD)
             HotkeyAction("pan_up", "Pan Up", "W", category="Movement"),
             HotkeyAction("pan_down", "Pan Down", "S", category="Movement"),
             HotkeyAction("pan_left", "Pan Left", "A", category="Movement"),
             HotkeyAction("pan_right", "Pan Right", "D", category="Movement"),
-            
             # Mouse-related (cannot be reassigned)
-            HotkeyAction("left_click", "Add Positive Point / Select", "Left Click", 
-                        category="Mouse", mouse_related=True),
-            HotkeyAction("right_click", "Add Negative Point", "Right Click", 
-                        category="Mouse", mouse_related=True),
-            HotkeyAction("mouse_drag", "Drag/Pan", "Mouse Drag", 
-                        category="Mouse", mouse_related=True),
+            HotkeyAction(
+                "left_click",
+                "Add Positive Point / Select",
+                "Left Click",
+                category="Mouse",
+                mouse_related=True,
+            ),
+            HotkeyAction(
+                "right_click",
+                "Add Negative Point",
+                "Right Click",
+                category="Mouse",
+                mouse_related=True,
+            ),
+            HotkeyAction(
+                "mouse_drag",
+                "Drag/Pan",
+                "Mouse Drag",
+                category="Mouse",
+                mouse_related=True,
+            ),
         ]
-        
+
         for action in default_hotkeys:
             self.actions[action.name] = action
-    
-    def get_action(self, action_name: str) -> Optional[HotkeyAction]:
+
+    def get_action(self, action_name: str) -> HotkeyAction | None:
         """Get hotkey action by name."""
         return self.actions.get(action_name)
-    
-    def get_actions_by_category(self) -> Dict[str, List[HotkeyAction]]:
+
+    def get_actions_by_category(self) -> dict[str, list[HotkeyAction]]:
         """Get actions grouped by category."""
         categories = {}
         for action in self.actions.values():
@@ -92,29 +130,29 @@ class HotkeyManager:
                 categories[action.category] = []
             categories[action.category].append(action)
         return categories
-    
+
     def set_primary_key(self, action_name: str, key: str) -> bool:
         """Set primary key for an action."""
         if action_name in self.actions and not self.actions[action_name].mouse_related:
             self.actions[action_name].primary_key = key
             return True
         return False
-    
-    def set_secondary_key(self, action_name: str, key: Optional[str]) -> bool:
+
+    def set_secondary_key(self, action_name: str, key: str | None) -> bool:
         """Set secondary key for an action."""
         if action_name in self.actions and not self.actions[action_name].mouse_related:
             self.actions[action_name].secondary_key = key
             return True
         return False
-    
-    def get_key_for_action(self, action_name: str) -> Tuple[Optional[str], Optional[str]]:
+
+    def get_key_for_action(self, action_name: str) -> tuple[str | None, str | None]:
         """Get primary and secondary keys for an action."""
         action = self.actions.get(action_name)
         if action:
             return action.primary_key, action.secondary_key
         return None, None
-    
-    def is_key_in_use(self, key: str, exclude_action: str = None) -> Optional[str]:
+
+    def is_key_in_use(self, key: str, exclude_action: str = None) -> str | None:
         """Check if a key is already in use by another action."""
         for name, action in self.actions.items():
             if name == exclude_action:
@@ -122,48 +160,48 @@ class HotkeyManager:
             if action.primary_key == key or action.secondary_key == key:
                 return name
         return None
-    
+
     def reset_to_defaults(self):
         """Reset all hotkeys to default values."""
         self._initialize_default_hotkeys()
-    
+
     def save_hotkeys(self):
         """Save hotkeys to file."""
         os.makedirs(self.config_dir, exist_ok=True)
-        
+
         # Convert to serializable format
         data = {}
         for name, action in self.actions.items():
             if not action.mouse_related:  # Don't save mouse-related actions
                 data[name] = {
-                    'primary_key': action.primary_key,
-                    'secondary_key': action.secondary_key
+                    "primary_key": action.primary_key,
+                    "secondary_key": action.secondary_key,
                 }
-        
-        with open(self.hotkeys_file, 'w') as f:
+
+        with open(self.hotkeys_file, "w") as f:
             json.dump(data, f, indent=4)
-    
+
     def load_hotkeys(self):
         """Load hotkeys from file."""
         if not os.path.exists(self.hotkeys_file):
             return
-        
+
         try:
-            with open(self.hotkeys_file, 'r') as f:
+            with open(self.hotkeys_file) as f:
                 data = json.load(f)
-            
+
             for name, keys in data.items():
                 if name in self.actions and not self.actions[name].mouse_related:
-                    self.actions[name].primary_key = keys.get('primary_key', '')
-                    self.actions[name].secondary_key = keys.get('secondary_key')
+                    self.actions[name].primary_key = keys.get("primary_key", "")
+                    self.actions[name].secondary_key = keys.get("secondary_key")
         except (json.JSONDecodeError, KeyError, FileNotFoundError):
             # If loading fails, keep defaults
             pass
-    
+
     def key_sequence_to_string(self, key_sequence: QKeySequence) -> str:
         """Convert QKeySequence to string representation."""
         return key_sequence.toString()
-    
+
     def string_to_key_sequence(self, key_string: str) -> QKeySequence:
         """Convert string to QKeySequence."""
-        return QKeySequence(key_string)
+        return QKeySequence(key_string)

lazylabel/config/paths.py

@@ -1,41 +1,40 @@
 """Path management for LazyLabel."""
 
-import os
 from pathlib import Path
 
 
 class Paths:
     """Centralized path management."""
-    
+
     def __init__(self):
         self.app_dir = Path(__file__).parent.parent
         self.models_dir = self.app_dir / "models"
         self.config_dir = Path.home() / ".config" / "lazylabel"
         self.cache_dir = Path.home() / ".cache" / "lazylabel"
-        
+
         # Ensure directories exist
         self.models_dir.mkdir(exist_ok=True)
         self.config_dir.mkdir(parents=True, exist_ok=True)
-        
+
     @property
     def settings_file(self) -> Path:
         """Path to settings file."""
         return self.config_dir / "settings.json"
-    
+
     @property
     def demo_pictures_dir(self) -> Path:
         """Path to demo pictures directory."""
         return self.app_dir / "demo_pictures"
-    
+
     @property
     def logo_path(self) -> Path:
         """Path to application logo."""
         return self.demo_pictures_dir / "logo2.png"
-    
+
     def get_model_path(self, filename: str) -> Path:
         """Get path for a model file."""
         return self.models_dir / filename
-    
+
     def get_old_cache_model_path(self, filename: str) -> Path:
         """Get path for model in old cache location."""
-        return self.cache_dir / filename
+        return self.cache_dir / filename

lazylabel/config/settings.py

@@ -1,60 +1,59 @@
 """Application settings and configuration."""
 
-import os
-from dataclasses import dataclass, asdict
-from typing import Dict, Any
 import json
+import os
+from dataclasses import asdict, dataclass
 
 
 @dataclass
 class Settings:
     """Application settings with defaults."""
-    
+
     # UI Settings
     window_width: int = 1600
     window_height: int = 900
     left_panel_width: int = 250
     right_panel_width: int = 350
-    
+
     # Annotation Settings
     point_radius: float = 0.3
     line_thickness: float = 0.5
     pan_multiplier: float = 1.0
     polygon_join_threshold: int = 2
-    
+
     # Model Settings
     default_model_type: str = "vit_h"
     default_model_filename: str = "sam_vit_h_4b8939.pth"
-    
+
     # Save Settings
     auto_save: bool = True
     save_npz: bool = True
     save_txt: bool = True
     save_class_aliases: bool = False
     yolo_use_alias: bool = True
-    
+
     # UI State
     annotation_size_multiplier: float = 1.0
-    
+
     def save_to_file(self, filepath: str) -> None:
         """Save settings to JSON file."""
         os.makedirs(os.path.dirname(filepath), exist_ok=True)
-        with open(filepath, 'w') as f:
+        with open(filepath, "w") as f:
             json.dump(asdict(self), f, indent=4)
-    
+
     @classmethod
-    def load_from_file(cls, filepath: str) -> 'Settings':
+    def load_from_file(cls, filepath: str) -> "Settings":
         """Load settings from JSON file."""
         if not os.path.exists(filepath):
             return cls()
-        
+
         try:
-            with open(filepath, 'r') as f:
+            with open(filepath) as f:
                 data = json.load(f)
             return cls(**data)
         except (json.JSONDecodeError, TypeError):
             return cls()
-    
+
     def update(self, **kwargs) -> None:
         """Update settings with new values."""
         for key, value in kwargs.items():
@@ -63,4 +62,4 @@ class Settings:
 
 
 # Default settings instance
-DEFAULT_SETTINGS = Settings()
+DEFAULT_SETTINGS = Settings()

lazylabel/core/__init__.py

@@ -1,7 +1,7 @@
 """Core business logic for LazyLabel."""
 
-from .segment_manager import SegmentManager
-from .model_manager import ModelManager
 from .file_manager import FileManager
+from .model_manager import ModelManager
+from .segment_manager import SegmentManager
 
-__all__ = ['SegmentManager', 'ModelManager', 'FileManager']
+__all__ = ["SegmentManager", "ModelManager", "FileManager"]

lazylabel/core/file_manager.py

@@ -1,45 +1,55 @@
 """File management functionality."""
 
-import os
 import json
-import numpy as np
+import os
+
 import cv2
-from typing import List, Dict, Any, Optional, Tuple
-from pathlib import Path
+import numpy as np
 
 from .segment_manager import SegmentManager
 
 
 class FileManager:
     """Manages file operations for saving and loading."""
-    
+
     def __init__(self, segment_manager: SegmentManager):
         self.segment_manager = segment_manager
-    
-    def save_npz(self, image_path: str, image_size: Tuple[int, int], class_order: List[int]) -> str:
+
+    def save_npz(
+        self, image_path: str, image_size: tuple[int, int], class_order: list[int]
+    ) -> str:
         """Save segments as NPZ file."""
-        final_mask_tensor = self.segment_manager.create_final_mask_tensor(image_size, class_order)
+        final_mask_tensor = self.segment_manager.create_final_mask_tensor(
+            image_size, class_order
+        )
         npz_path = os.path.splitext(image_path)[0] + ".npz"
         np.savez_compressed(npz_path, mask=final_mask_tensor.astype(np.uint8))
         return npz_path
-    
-    def save_yolo_txt(self, image_path: str, image_size: Tuple[int, int], 
-                      class_order: List[int], class_labels: List[str]) -> Optional[str]:
+
+    def save_yolo_txt(
+        self,
+        image_path: str,
+        image_size: tuple[int, int],
+        class_order: list[int],
+        class_labels: list[str],
+    ) -> str | None:
         """Save segments as YOLO format TXT file."""
-        final_mask_tensor = self.segment_manager.create_final_mask_tensor(image_size, class_order)
+        final_mask_tensor = self.segment_manager.create_final_mask_tensor(
+            image_size, class_order
+        )
         output_path = os.path.splitext(image_path)[0] + ".txt"
         h, w = image_size
-        
+
         yolo_annotations = []
         for channel in range(final_mask_tensor.shape[2]):
             single_channel_image = final_mask_tensor[:, :, channel]
             if not np.any(single_channel_image):
                 continue
-            
+
             contours, _ = cv2.findContours(
                 single_channel_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
             )
-            
+
             class_label = class_labels[channel]
             for contour in contours:
                 x, y, width, height = cv2.boundingRect(contour)
@@ -49,37 +59,41 @@ class FileManager:
                 normalized_height = height / h
                 yolo_entry = f"{class_label} {center_x} {center_y} {normalized_width} {normalized_height}"
                 yolo_annotations.append(yolo_entry)
-        
+
         if not yolo_annotations:
             return None
-        
+
         os.makedirs(os.path.dirname(output_path), exist_ok=True)
         with open(output_path, "w") as file:
             for annotation in yolo_annotations:
                 file.write(annotation + "\n")
-        
+
         return output_path
-    
+
     def save_class_aliases(self, image_path: str) -> str:
         """Save class aliases as JSON file."""
         aliases_path = os.path.splitext(image_path)[0] + ".json"
-        aliases_to_save = {str(k): v for k, v in self.segment_manager.class_aliases.items()}
+        aliases_to_save = {
+            str(k): v for k, v in self.segment_manager.class_aliases.items()
+        }
         with open(aliases_path, "w") as f:
             json.dump(aliases_to_save, f, indent=4)
         return aliases_path
-    
+
     def load_class_aliases(self, image_path: str) -> None:
         """Load class aliases from JSON file."""
         json_path = os.path.splitext(image_path)[0] + ".json"
         if os.path.exists(json_path):
             try:
-                with open(json_path, "r") as f:
+                with open(json_path) as f:
                     loaded_aliases = json.load(f)
-                    self.segment_manager.class_aliases = {int(k): v for k, v in loaded_aliases.items()}
+                    self.segment_manager.class_aliases = {
+                        int(k): v for k, v in loaded_aliases.items()
+                    }
             except (json.JSONDecodeError, ValueError) as e:
                 print(f"Error loading class aliases from {json_path}: {e}")
                 self.segment_manager.class_aliases.clear()
-    
+
     def load_existing_mask(self, image_path: str) -> None:
         """Load existing mask from NPZ file."""
         npz_path = os.path.splitext(image_path)[0] + ".npz"
@@ -89,18 +103,20 @@ class FileManager:
                     mask_data = data["mask"]
                     if mask_data.ndim == 2:
                         mask_data = np.expand_dims(mask_data, axis=-1)
-                    
+
                     num_classes = mask_data.shape[2]
                     for i in range(num_classes):
                         class_mask = mask_data[:, :, i].astype(bool)
                         if np.any(class_mask):
-                            self.segment_manager.add_segment({
-                                "mask": class_mask,
-                                "type": "Loaded",
-                                "vertices": None,
-                                "class_id": i,
-                            })
-    
+                            self.segment_manager.add_segment(
+                                {
+                                    "mask": class_mask,
+                                    "type": "Loaded",
+                                    "vertices": None,
+                                    "class_id": i,
+                                }
+                            )
+
     def is_image_file(self, filepath: str) -> bool:
         """Check if file is a supported image format."""
-        return filepath.lower().endswith((".png", ".jpg", ".jpeg", ".tiff", ".tif"))
+        return filepath.lower().endswith((".png", ".jpg", ".jpeg", ".tiff", ".tif"))

lazylabel/core/model_manager.py

@@ -1,12 +1,10 @@
 """Model management functionality."""
 
 import os
-import glob
-from typing import List, Tuple, Optional, Callable
-from pathlib import Path
+from collections.abc import Callable
 
-from ..models.sam_model import SamModel
 from ..config import Paths
+from ..models.sam_model import SamModel
 
 
 class ModelManager:
@@ -14,11 +12,11 @@ class ModelManager:
 
     def __init__(self, paths: Paths):
         self.paths = paths
-        self.sam_model: Optional[SamModel] = None
-        self.current_models_folder: Optional[str] = None
-        self.on_model_changed: Optional[Callable[[str], None]] = None
+        self.sam_model: SamModel | None = None
+        self.current_models_folder: str | None = None
+        self.on_model_changed: Callable[[str], None] | None = None
 
-    def initialize_default_model(self, model_type: str = "vit_h") -> Optional[SamModel]:
+    def initialize_default_model(self, model_type: str = "vit_h") -> SamModel | None:
         """Initialize the default SAM model.
 
         Returns:
@@ -34,14 +32,14 @@ class ModelManager:
             self.sam_model = None
             return None
 
-    def get_available_models(self, folder_path: str) -> List[Tuple[str, str]]:
+    def get_available_models(self, folder_path: str) -> list[tuple[str, str]]:
         """Get list of available .pth models in folder.
 
         Returns:
             List of (display_name, full_path) tuples
         """
         pth_files = []
-        for root, dirs, files in os.walk(folder_path):
+        for root, _dirs, files in os.walk(folder_path):
             for file in files:
                 if file.lower().endswith(".pth"):
                     full_path = os.path.join(root, file)
@@ -86,7 +84,7 @@ class ModelManager:
         """Set the current models folder."""
         self.current_models_folder = folder_path
 
-    def get_models_folder(self) -> Optional[str]:
+    def get_models_folder(self) -> str | None:
         """Get the current models folder."""
         return self.current_models_folder