lazylabel-gui 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

lazylabel/__init__.py

@@ -1,9 +1,9 @@
-"""LazyLabel - AI-assisted image segmentation tool."""
-
-__version__ = "1.0.9"
-__author__ = "Deniz N. Cakan"
-__email__ = "deniz.n.cakan@gmail.com"
-
-from .main import main
-
-__all__ = ['main']
+"""LazyLabel - AI-assisted image segmentation tool."""
+
+__version__ = "1.0.9"
+__author__ = "Deniz N. Cakan"
+__email__ = "deniz.n.cakan@gmail.com"
+
+from .main import main
+
+__all__ = ["main"]

lazylabel/config/__init__.py

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

lazylabel/config/hotkeys.py

@@ -2,89 +2,128 @@
 
 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(
+                "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("bbox_mode", "Bounding Box Mode", "3", 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 +131,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 +161,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
+"""Path management for LazyLabel."""
+
+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

lazylabel/config/settings.py

@@ -1,66 +1,65 @@
-"""Application settings and configuration."""
-
-import os
-from dataclasses import dataclass, asdict
-from typing import Dict, Any
-import json
-
-
-@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:
-            json.dump(asdict(self), f, indent=4)
-    
-    @classmethod
-    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:
-                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():
-            if hasattr(self, key):
-                setattr(self, key, value)
-
-
-# Default settings instance
-DEFAULT_SETTINGS = Settings()
+"""Application settings and configuration."""
+
+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:
+            json.dump(asdict(self), f, indent=4)
+
+    @classmethod
+    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) 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():
+            if hasattr(self, key):
+                setattr(self, key, value)
+
+
+# Default settings instance
+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
-
-__all__ = ['SegmentManager', 'ModelManager', 'FileManager']
+"""Core business logic for LazyLabel."""
+
+from .file_manager import FileManager
+from .model_manager import ModelManager
+from .segment_manager import SegmentManager
+
+__all__ = ["SegmentManager", "ModelManager", "FileManager"]