lazylabel-gui 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

lazylabel/core/file_manager.py

@@ -24,16 +24,48 @@ class FileManager:
         crop_coords: tuple[int, int, int, int] | None = None,
     ) -> str:
         """Save segments as NPZ file."""
+        logger.debug(f"Saving NPZ for image: {image_path}")
+        logger.debug(f"Image size: {image_size}, Class order: {class_order}")
+
+        # Validate inputs
+        if not class_order:
+            raise ValueError("No classes defined for saving")
+
         final_mask_tensor = self.segment_manager.create_final_mask_tensor(
             image_size, class_order
         )
 
+        # Validate mask tensor
+        if final_mask_tensor.size == 0:
+            raise ValueError("Empty mask tensor generated")
+
+        logger.debug(f"Final mask tensor shape: {final_mask_tensor.shape}")
+
         # Apply crop if coordinates are provided
         if crop_coords:
             final_mask_tensor = self._apply_crop_to_mask(final_mask_tensor, crop_coords)
+            logger.debug(f"Applied crop: {crop_coords}")
 
         npz_path = os.path.splitext(image_path)[0] + ".npz"
-        np.savez_compressed(npz_path, mask=final_mask_tensor.astype(np.uint8))
+
+        # Create parent directory if it doesn't exist
+        parent_dir = os.path.dirname(npz_path)
+        if parent_dir:  # Only create if there's actually a parent directory
+            os.makedirs(parent_dir, exist_ok=True)
+            logger.debug(f"Ensured directory exists: {parent_dir}")
+
+        # Save the NPZ file
+        try:
+            np.savez_compressed(npz_path, mask=final_mask_tensor.astype(np.uint8))
+            logger.debug(f"Saved NPZ file: {npz_path}")
+        except Exception as e:
+            raise OSError(f"Failed to save NPZ file {npz_path}: {str(e)}") from e
+
+        # Verify the file was actually created
+        if not os.path.exists(npz_path):
+            raise OSError(f"NPZ file was not created: {npz_path}")
+
+        logger.info(f"Successfully saved NPZ: {os.path.basename(npz_path)}")
         return npz_path
 
     def save_yolo_txt(

lazylabel/ui/main_window.py

@@ -1176,6 +1176,8 @@ class MainWindow(QMainWindow):
         # Right panel connections
         self.right_panel.open_folder_requested.connect(self._open_folder_dialog)
         self.right_panel.image_selected.connect(self._load_selected_image)
+        # Connect new path-based signal from FastFileManager
+        self.right_panel.image_path_selected.connect(self._load_image_from_path)
         self.right_panel.merge_selection_requested.connect(
             self._assign_selected_to_class
         )
@@ -1625,6 +1627,13 @@ class MainWindow(QMainWindow):
             self._start_background_image_discovery()
         self.viewer.setFocus()
 
+    def _load_image_from_path(self, file_path: Path):
+        """Load image from a Path object (used by FastFileManager)."""
+        if file_path.is_file() and self.file_manager.is_image_file(str(file_path)):
+            # Convert Path to QModelIndex for compatibility
+            # This allows existing code to work while using the new file manager
+            self._load_image_by_path(str(file_path))
+
     def _load_selected_image(self, index):
         """Load the selected image. Auto-saves previous work if enabled."""
 
@@ -1686,6 +1695,131 @@ class MainWindow(QMainWindow):
 
         self._show_success_notification(f"Loaded: {Path(self.current_image_path).name}")
 
+    def _load_image_by_path(self, path: str):
+        """Load image by file path directly (for FastFileManager)."""
+        # Check if we're in multi-view mode
+        if hasattr(self, "view_mode") and self.view_mode == "multi":
+            # For multi-view, we need to handle differently
+            # Load the selected image and consecutive ones
+            self._load_multi_view_from_path(path)
+            return
+
+        if path == self.current_image_path:  # Only reset if loading a new image
+            return
+
+        # Auto-save if enabled and we have a current image (not the first load)
+        if self.current_image_path and self.control_panel.get_settings().get(
+            "auto_save", True
+        ):
+            self._save_output_to_npz()
+
+        self.segment_manager.clear()
+        # Remove all scene items except the pixmap
+        items_to_remove = [
+            item
+            for item in self.viewer.scene().items()
+            if item is not self.viewer._pixmap_item
+        ]
+        for item in items_to_remove:
+            self.viewer.scene().removeItem(item)
+        self.current_image_path = path
+
+        # Load the image
+        original_image = cv2.imread(path)
+        if original_image is None:
+            logger.error(f"Failed to load image: {path}")
+            return
+
+        # Convert BGR to RGB
+        if len(original_image.shape) == 3:
+            original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
+        self.original_image = original_image
+
+        # Convert to QImage and display
+        height, width = original_image.shape[:2]
+        bytes_per_line = 3 * width if len(original_image.shape) == 3 else width
+
+        if len(original_image.shape) == 3:
+            q_image = QImage(
+                original_image.data.tobytes(),
+                width,
+                height,
+                bytes_per_line,
+                QImage.Format.Format_RGB888,
+            )
+        else:
+            q_image = QImage(
+                original_image.data.tobytes(),
+                width,
+                height,
+                bytes_per_line,
+                QImage.Format.Format_Grayscale8,
+            )
+
+        pixmap = QPixmap.fromImage(q_image)
+        self.viewer.set_photo(pixmap)
+
+        # Load existing segments and class aliases
+        self.file_manager.load_class_aliases(path)
+        self.file_manager.load_existing_mask(path)
+
+        # Update UI lists to reflect loaded segments
+        self._update_all_lists()
+
+        # Update display if we have an update method
+        if hasattr(self, "_update_display"):
+            self._update_display()
+        self._show_success_notification(f"Loaded: {Path(path).name}")
+
+        # Update file selection in the file manager
+        self.right_panel.select_file(Path(path))
+
+    def _load_multi_view_from_path(self, path: str):
+        """Load multi-view starting from a specific path using FastFileManager."""
+        config = self._get_multi_view_config()
+        num_viewers = config["num_viewers"]
+
+        # Auto-save if enabled
+        if (
+            hasattr(self, "multi_view_images")
+            and self.multi_view_images
+            and self.multi_view_images[0]
+            and self.control_panel.get_settings().get("auto_save", True)
+        ):
+            self._save_multi_view_output()
+
+        # Get all files from the FastFileManager model
+        file_manager_model = self.right_panel.file_manager._model
+        all_files = []
+        current_idx = -1
+
+        # Collect all files from the model
+        for i in range(file_manager_model.rowCount()):
+            file_info = file_manager_model.getFileInfo(i)
+            if file_info:
+                all_files.append(str(file_info.path))
+                if str(file_info.path) == path:
+                    current_idx = i
+
+        if current_idx == -1:
+            # File not found in current list
+            return
+
+        # Load consecutive images
+        images_to_load = []
+        for i in range(num_viewers):
+            idx = current_idx + i
+            if idx < len(all_files):
+                images_to_load.append(all_files[idx])
+            else:
+                images_to_load.append(None)
+
+        # Load the images
+        self._load_multi_view_images(images_to_load)
+
+        # Update file manager selection
+        self.right_panel.select_file(Path(path))
+
     def _load_selected_image_multi_view(self, index, path):
         """Load selected image in multi-view mode starting from the selected file."""
         # Auto-save if enabled and we have current images (not the first load)
@@ -2141,17 +2275,9 @@ class MainWindow(QMainWindow):
             self._load_next_multi_batch()
             return
 
-        if not self.current_file_index.isValid():
-            return
-        parent = self.current_file_index.parent()
-        row = self.current_file_index.row()
-        # Find next valid image file
-        for next_row in range(row + 1, self.file_model.rowCount(parent)):
-            next_index = self.file_model.index(next_row, 0, parent)
-            path = self.file_model.filePath(next_index)
-            if os.path.isfile(path) and self.file_manager.is_image_file(path):
-                self._load_selected_image(next_index)
-                return
+        # Use new file manager navigation
+        self.right_panel.navigate_next_image()
+        return
 
     def _load_previous_image(self):
         """Load previous image in the file list."""
@@ -2160,17 +2286,9 @@ class MainWindow(QMainWindow):
             self._load_previous_multi_batch()
             return
 
-        if not self.current_file_index.isValid():
-            return
-        parent = self.current_file_index.parent()
-        row = self.current_file_index.row()
-        # Find previous valid image file
-        for prev_row in range(row - 1, -1, -1):
-            prev_index = self.file_model.index(prev_row, 0, parent)
-            path = self.file_model.filePath(prev_index)
-            if os.path.isfile(path) and self.file_manager.is_image_file(path):
-                self._load_selected_image(prev_index)
-                return
+        # Use new file manager navigation
+        self.right_panel.navigate_previous_image()
+        return
 
     # Segment management methods
     def _assign_selected_to_class(self):
@@ -2823,20 +2941,34 @@ class MainWindow(QMainWindow):
 
     def _handle_enter_press(self):
         """Handle enter key press."""
+        logger.debug(f"Enter pressed - mode: {self.mode}, view_mode: {self.view_mode}")
+
         if self.mode == "polygon":
-            if self.view_mode == "single" and self.polygon_points:
-                self._finalize_polygon()
-            elif self.view_mode == "multi" and hasattr(
-                self, "multi_view_polygon_points"
-            ):
+            logger.debug(
+                f"Polygon mode - polygon_points: {len(self.polygon_points) if hasattr(self, 'polygon_points') and self.polygon_points else 0}"
+            )
+            if self.view_mode == "single":
+                # If there are pending polygon points, finalize them first
+                if self.polygon_points:
+                    logger.debug("Finalizing pending polygon")
+                    self._finalize_polygon()
+                # Always save after handling pending work to show checkmarks and notifications
+                logger.debug("Saving polygon segments to NPZ")
+                self._save_output_to_npz()
+            elif self.view_mode == "multi":
                 # Complete polygons for all viewers that have points
-                for i, points in enumerate(self.multi_view_polygon_points):
-                    if points and len(points) >= 3:
-                        # Use the multi-view mode handler for proper pairing logic
-                        if hasattr(self, "multi_view_mode_handler"):
-                            self.multi_view_mode_handler._finalize_multi_view_polygon(i)
-                        else:
-                            self._finalize_multi_view_polygon(i)
+                if hasattr(self, "multi_view_polygon_points"):
+                    for i, points in enumerate(self.multi_view_polygon_points):
+                        if points and len(points) >= 3:
+                            # Use the multi-view mode handler for proper pairing logic
+                            if hasattr(self, "multi_view_mode_handler"):
+                                self.multi_view_mode_handler._finalize_multi_view_polygon(
+                                    i
+                                )
+                            else:
+                                self._finalize_multi_view_polygon(i)
+                # Always save after handling pending work to show checkmarks and notifications
+                self._save_output_to_npz()
         else:
             # First accept any AI segments (same as spacebar), then save
             self._accept_ai_segment()
@@ -3198,7 +3330,13 @@ class MainWindow(QMainWindow):
                             try:
                                 os.remove(file_path)
                                 deleted_files.append(os.path.basename(file_path))
-                                self.file_model.update_cache_for_path(file_path)
+                                # Update FastFileManager after file deletion
+                                if hasattr(self, "right_panel") and hasattr(
+                                    self.right_panel, "file_manager"
+                                ):
+                                    self.right_panel.file_manager.updateNpzStatus(
+                                        Path(image_path)
+                                    )
                             except Exception as e:
                                 self._show_error_notification(
                                     f"Error deleting {file_path}: {e}"
@@ -3213,20 +3351,15 @@ class MainWindow(QMainWindow):
                     f"Error saving {os.path.basename(image_path)}: {str(e)}"
                 )
 
-        # Update file list with green flash and tick marks (like single view mode)
-        if hasattr(self, "_saved_file_paths") and self._saved_file_paths:
-            for path in self._saved_file_paths:
-                if path:
-                    self.file_model.update_cache_for_path(path)
-                    self.file_model.set_highlighted_path(path)
-                    QTimer.singleShot(
-                        1500,
-                        lambda p=path: (
-                            self.file_model.set_highlighted_path(None)
-                            if self.file_model.highlighted_path == p
-                            else None
-                        ),
-                    )
+        # Update FastFileManager to show NPZ checkmarks for multi-view
+        if hasattr(self, "multi_view_images") and self.multi_view_images:
+            for image_path in self.multi_view_images:
+                if (
+                    image_path
+                    and hasattr(self, "right_panel")
+                    and hasattr(self.right_panel, "file_manager")
+                ):
+                    self.right_panel.file_manager.updateNpzStatus(Path(image_path))
             # Clear the tracking list for next save
             self._saved_file_paths = []
 
@@ -3258,7 +3391,13 @@ class MainWindow(QMainWindow):
                     try:
                         os.remove(file_path)
                         deleted_files.append(file_path)
-                        self.file_model.update_cache_for_path(file_path)
+                        # Update FastFileManager after file deletion
+                        if hasattr(self, "right_panel") and hasattr(
+                            self.right_panel, "file_manager"
+                        ):
+                            self.right_panel.file_manager.updateNpzStatus(
+                                Path(self.current_image_path)
+                            )
                     except Exception as e:
                         self._show_error_notification(
                             f"Error deleting {file_path}: {e}"
@@ -3276,24 +3415,35 @@ class MainWindow(QMainWindow):
         try:
             settings = self.control_panel.get_settings()
             npz_path = None
-            txt_path = None
+
+            # Debug logging
+            logger.debug(f"Starting save process for: {self.current_image_path}")
+            logger.debug(f"Number of segments: {len(self.segment_manager.segments)}")
+
             if settings.get("save_npz", True):
                 h, w = (
                     self.viewer._pixmap_item.pixmap().height(),
                     self.viewer._pixmap_item.pixmap().width(),
                 )
                 class_order = self.segment_manager.get_unique_class_ids()
+                logger.debug(f"Class order for saving: {class_order}")
+
                 if class_order:
+                    logger.debug(
+                        f"Attempting to save NPZ to: {os.path.splitext(self.current_image_path)[0]}.npz"
+                    )
                     npz_path = self.file_manager.save_npz(
                         self.current_image_path,
                         (h, w),
                         class_order,
                         self.current_crop_coords,
                     )
+                    logger.debug(f"NPZ save completed: {npz_path}")
                     self._show_success_notification(
                         f"Saved: {os.path.basename(npz_path)}"
                     )
                 else:
+                    logger.warning("No classes defined for saving")
                     self._show_warning_notification("No classes defined for saving.")
             if settings.get("save_txt", True):
                 h, w = (
@@ -3308,27 +3458,25 @@ class MainWindow(QMainWindow):
                 else:
                     class_labels = [str(cid) for cid in class_order]
                 if class_order:
-                    txt_path = self.file_manager.save_yolo_txt(
+                    self.file_manager.save_yolo_txt(
                         self.current_image_path,
                         (h, w),
                         class_order,
                         class_labels,
                         self.current_crop_coords,
                     )
-            # Efficiently update file list tickboxes and highlight
-            for path in [npz_path, txt_path]:
-                if path:
-                    self.file_model.update_cache_for_path(path)
-                    self.file_model.set_highlighted_path(path)
-                    QTimer.singleShot(
-                        1500,
-                        lambda p=path: (
-                            self.file_model.set_highlighted_path(None)
-                            if self.file_model.highlighted_path == p
-                            else None
-                        ),
-                    )
+            # Update FastFileManager to show NPZ checkmarks
+            if (
+                npz_path
+                and hasattr(self, "right_panel")
+                and hasattr(self.right_panel, "file_manager")
+            ):
+                # Update the NPZ status in the FastFileManager
+                self.right_panel.file_manager.updateNpzStatus(
+                    Path(self.current_image_path)
+                )
         except Exception as e:
+            logger.error(f"Error saving file: {str(e)}", exc_info=True)
             self._show_error_notification(f"Error saving: {str(e)}")
 
     def _handle_merge_press(self):

lazylabel/ui/right_panel.py

@@ -1,5 +1,7 @@
 """Right panel with file explorer and segment management."""
 
+from pathlib import Path
+
 from PyQt6.QtCore import Qt, pyqtSignal
 from PyQt6.QtWidgets import (
     QComboBox,
@@ -14,6 +16,7 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ..utils.fast_file_manager import FastFileManager
 from .reorderable_class_table import ReorderableClassTable
 
 
@@ -23,6 +26,7 @@ class RightPanel(QWidget):
     # Signals
     open_folder_requested = pyqtSignal()
     image_selected = pyqtSignal("QModelIndex")
+    image_path_selected = pyqtSignal(Path)  # New signal for path-based selection
     merge_selection_requested = pyqtSignal()
     delete_selection_requested = pyqtSignal()
     segments_selection_changed = pyqtSignal()
@@ -109,8 +113,13 @@ class RightPanel(QWidget):
         self.btn_open_folder.setToolTip("Open a directory of images")
         layout.addWidget(self.btn_open_folder)
 
-        self.file_tree = QTreeView()
-        layout.addWidget(self.file_tree)
+        # Use new FastFileManager instead of QTreeView
+        self.file_manager = FastFileManager()
+        layout.addWidget(self.file_manager)
+
+        # Keep file_tree reference for compatibility
+        self.file_tree = QTreeView()  # Hidden, for backward compatibility
+        self.file_tree.hide()
 
         splitter.addWidget(file_explorer_widget)
 
@@ -195,6 +204,8 @@ class RightPanel(QWidget):
         """Connect internal signals."""
         self.btn_open_folder.clicked.connect(self.open_folder_requested)
         self.file_tree.doubleClicked.connect(self.image_selected)
+        # Connect new file manager signal
+        self.file_manager.fileSelected.connect(self.image_path_selected)
         self.btn_merge_selection.clicked.connect(self.merge_selection_requested)
         self.btn_delete_selection.clicked.connect(self.delete_selection_requested)
         self.segment_table.itemSelectionChanged.connect(self.segments_selection_changed)
@@ -276,12 +287,28 @@ class RightPanel(QWidget):
 
     def setup_file_model(self, file_model):
         """Setup the file model for the tree view."""
+        # Keep for backward compatibility
         self.file_tree.setModel(file_model)
         self.file_tree.setColumnWidth(0, 200)
 
     def set_folder(self, folder_path, file_model):
         """Set the folder for file browsing."""
+        # Keep old tree view for compatibility
         self.file_tree.setRootIndex(file_model.setRootPath(folder_path))
+        # Use new file manager
+        self.file_manager.setDirectory(Path(folder_path))
+
+    def navigate_next_image(self):
+        """Navigate to next image in the file manager."""
+        self.file_manager.navigateNext()
+
+    def navigate_previous_image(self):
+        """Navigate to previous image in the file manager."""
+        self.file_manager.navigatePrevious()
+
+    def select_file(self, file_path: Path):
+        """Select a specific file in the file manager."""
+        self.file_manager.selectFile(file_path)
 
     def get_selected_segment_indices(self):
         """Get indices of selected segments."""

lazylabel/utils/fast_file_manager.py

@@ -0,0 +1,676 @@
+"""
+Fast file manager with lazy loading, sorting, and efficient navigation
+"""
+
+import os
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from PyQt6.QtCore import (
+    QAbstractTableModel,
+    QModelIndex,
+    QSortFilterProxyModel,
+    Qt,
+    QThread,
+    pyqtSignal,
+)
+from PyQt6.QtGui import QPixmap
+from PyQt6.QtWidgets import (
+    QComboBox,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QTableView,
+    QVBoxLayout,
+    QWidget,
+)
+
+# Image extensions supported
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".tiff", ".tif"}
+
+
+@dataclass
+class FileInfo:
+    """Information about a file"""
+
+    path: Path
+    name: str
+    size: int = 0  # Lazy load for speed
+    modified: float = 0.0  # Lazy load for speed
+    has_npz: bool = False
+    has_txt: bool = False
+    thumbnail: QPixmap | None = None
+
+
+class FileScanner(QThread):
+    """Background thread for scanning files"""
+
+    filesFound = pyqtSignal(list)  # Emits batches of FileInfo
+    scanComplete = pyqtSignal(int)  # Total file count
+    progress = pyqtSignal(int, int)  # Current, total
+
+    def __init__(self, directory: Path):
+        super().__init__()
+        self.directory = directory
+        self._stop_flag = False
+
+    def run(self):
+        """Scan directory in background - OPTIMIZED FOR SPEED"""
+        batch_size = 1000  # Larger batches = fewer UI updates = faster
+        batch = []
+        total_files = 0
+
+        try:
+            # Use os.scandir() - MUCH faster than Path.iterdir()
+            # Single pass to collect all file info
+            npz_stems = set()
+            txt_stems = set()
+            image_entries = []
+
+            with os.scandir(self.directory) as entries:
+                for entry in entries:
+                    if self._stop_flag:
+                        break
+
+                    # Check file extension
+                    name = entry.name
+                    ext = os.path.splitext(name)[1].lower()
+
+                    if ext == ".npz":
+                        npz_stems.add(os.path.splitext(name)[0])
+                    elif ext == ".txt":
+                        txt_stems.add(os.path.splitext(name)[0])
+                    elif ext in IMAGE_EXTENSIONS:
+                        image_entries.append((entry.path, name))
+
+            # Process images in batches
+            total_count = len(image_entries)
+
+            for i, (path, name) in enumerate(image_entries):
+                if self._stop_flag:
+                    break
+
+                stem = os.path.splitext(name)[0]
+
+                # Create FileInfo - NO STAT CALLS for speed!
+                file_info = FileInfo(
+                    path=Path(path),
+                    name=name,
+                    has_npz=stem in npz_stems,
+                    has_txt=stem in txt_stems,
+                )
+
+                batch.append(file_info)
+                total_files += 1
+
+                if len(batch) >= batch_size:
+                    self.filesFound.emit(batch)
+                    batch = []
+
+                # Progress updates less frequently
+                if i % 1000 == 0 and i > 0:
+                    self.progress.emit(i, total_count)
+
+            # Emit remaining files
+            if batch:
+                self.filesFound.emit(batch)
+
+            self.scanComplete.emit(total_files)
+
+        except Exception as e:
+            print(f"Error scanning directory: {e}")
+
+    def stop(self):
+        """Stop the scanning thread"""
+        self._stop_flag = True
+
+
+class FastFileModel(QAbstractTableModel):
+    """High-performance file model with background loading"""
+
+    fileSelected = pyqtSignal(Path)
+
+    def __init__(self):
+        super().__init__()
+        self._files: list[FileInfo] = []
+        self._scanner: FileScanner | None = None
+
+    def rowCount(self, parent=QModelIndex()):
+        return len(self._files)
+
+    def columnCount(self, parent=QModelIndex()):
+        return 5  # Name, Size, Modified, NPZ, TXT
+
+    def data(self, index: QModelIndex, role=Qt.ItemDataRole.DisplayRole):
+        if not index.isValid():
+            return None
+
+        file_info = self._files[index.row()]
+        col = index.column()
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            if col == 0:  # Name
+                return file_info.name
+            elif col == 1:  # Size
+                # Lazy load size only when displayed
+                if file_info.size == 0:
+                    try:
+                        file_info.size = file_info.path.stat().st_size
+                    except OSError:
+                        file_info.size = -1  # Mark as error
+                return self._format_size(file_info.size) if file_info.size >= 0 else "-"
+            elif col == 2:  # Modified
+                # Lazy load modified time only when displayed
+                if file_info.modified == 0.0:
+                    try:
+                        file_info.modified = file_info.path.stat().st_mtime
+                    except OSError:
+                        file_info.modified = -1  # Mark as error
+                return (
+                    datetime.fromtimestamp(file_info.modified).strftime(
+                        "%Y-%m-%d %H:%M"
+                    )
+                    if file_info.modified > 0
+                    else "-"
+                )
+            elif col == 3:  # NPZ
+                return "✓" if file_info.has_npz else ""
+            elif col == 4:  # TXT
+                return "✓" if file_info.has_txt else ""
+        elif role == Qt.ItemDataRole.UserRole:
+            # Return the FileInfo object for custom access
+            return file_info
+        elif role == Qt.ItemDataRole.TextAlignmentRole and col in [
+            3,
+            4,
+        ]:  # Center checkmarks
+            return Qt.AlignmentFlag.AlignCenter
+
+        return None
+
+    def headerData(self, section, orientation, role):
+        if (
+            orientation == Qt.Orientation.Horizontal
+            and role == Qt.ItemDataRole.DisplayRole
+        ):
+            headers = ["Name", "Size", "Modified", "NPZ", "TXT"]
+            return headers[section]
+        return None
+
+    def _format_size(self, size: int) -> str:
+        """Format file size in human readable format"""
+        for unit in ["B", "KB", "MB", "GB"]:
+            if size < 1024:
+                return f"{size:.1f} {unit}"
+            size /= 1024
+        return f"{size:.1f} TB"
+
+    def setDirectory(self, directory: Path):
+        """Set directory to scan"""
+        # Stop previous scanner if running
+        if self._scanner and self._scanner.isRunning():
+            self._scanner.stop()
+            self._scanner.wait()
+
+        # Clear current files
+        self.beginResetModel()
+        self._files.clear()
+        self.endResetModel()
+
+        # Start new scan
+        self._scanner = FileScanner(directory)
+        self._scanner.filesFound.connect(self._on_files_found)
+        self._scanner.scanComplete.connect(self._on_scan_complete)
+        self._scanner.start()
+
+    def _on_files_found(self, files: list[FileInfo]):
+        """Handle batch of files found"""
+        start_row = len(self._files)
+        end_row = start_row + len(files) - 1
+        self.beginInsertRows(QModelIndex(), start_row, end_row)
+        self._files.extend(files)
+        self.endInsertRows()
+
+    def _on_scan_complete(self, total: int):
+        """Handle scan completion"""
+        print(f"Scan complete: {total} files found")
+
+    def getFileInfo(self, index: int) -> FileInfo | None:
+        """Get file info at index"""
+        if 0 <= index < len(self._files):
+            return self._files[index]
+        return None
+
+    def updateNpzStatus(self, image_path: Path):
+        """Update NPZ status for a specific image file"""
+        image_path_str = str(image_path)
+        npz_path = image_path.with_suffix(".npz")
+        has_npz = npz_path.exists()
+
+        # Find and update the file info
+        for i, file_info in enumerate(self._files):
+            if str(file_info.path) == image_path_str:
+                old_has_npz = file_info.has_npz
+                file_info.has_npz = has_npz
+
+                # Only emit dataChanged if status actually changed
+                if old_has_npz != has_npz:
+                    index = self.index(i, 3)  # NPZ column
+                    self.dataChanged.emit(index, index)
+                break
+
+    def getFileIndex(self, path: Path) -> int:
+        """Get index of file by path"""
+        for i, file_info in enumerate(self._files):
+            if file_info.path == path:
+                return i
+        return -1
+
+
+class FileSortProxyModel(QSortFilterProxyModel):
+    """Custom proxy model for proper sorting of file data."""
+
+    def lessThan(self, left: QModelIndex, right: QModelIndex) -> bool:
+        """Custom sorting comparison."""
+        # Get the file info objects
+        left_info = self.sourceModel().getFileInfo(left.row())
+        right_info = self.sourceModel().getFileInfo(right.row())
+
+        if not left_info or not right_info:
+            return False
+
+        col = left.column()
+
+        # Sort based on column
+        if col == 0:  # Name
+            return left_info.name.lower() < right_info.name.lower()
+        elif col == 1:  # Size
+            # Lazy load size if needed for sorting
+            if left_info.size == 0:
+                try:
+                    left_info.size = left_info.path.stat().st_size
+                except OSError:
+                    left_info.size = -1
+            if right_info.size == 0:
+                try:
+                    right_info.size = right_info.path.stat().st_size
+                except OSError:
+                    right_info.size = -1
+            return left_info.size < right_info.size
+        elif col == 2:  # Modified
+            # Lazy load modified time if needed for sorting
+            if left_info.modified == 0.0:
+                try:
+                    left_info.modified = left_info.path.stat().st_mtime
+                except OSError:
+                    left_info.modified = -1
+            if right_info.modified == 0.0:
+                try:
+                    right_info.modified = right_info.path.stat().st_mtime
+                except OSError:
+                    right_info.modified = -1
+            return left_info.modified < right_info.modified
+        elif col == 3:  # NPZ
+            return left_info.has_npz < right_info.has_npz
+        elif col == 4:  # TXT
+            return left_info.has_txt < right_info.has_txt
+
+        return False
+
+
+class FastFileManager(QWidget):
+    """Main file manager widget with improved performance"""
+
+    fileSelected = pyqtSignal(Path)
+
+    def __init__(self):
+        super().__init__()
+        self._current_directory = None
+        self._init_ui()
+
+    def _init_ui(self):
+        """Initialize the UI"""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        # Header with controls
+        header = self._create_header()
+        layout.addWidget(header)
+
+        # File table view
+        self._table_view = QTableView()
+        self._table_view.setAlternatingRowColors(True)
+        self._table_view.setSelectionBehavior(QTableView.SelectionBehavior.SelectRows)
+        self._table_view.setSelectionMode(QTableView.SelectionMode.SingleSelection)
+        self._table_view.setSortingEnabled(False)  # We'll handle sorting manually
+        self._table_view.setEditTriggers(QTableView.EditTrigger.NoEditTriggers)
+
+        # Set up model and proxy
+        self._model = FastFileModel()
+        self._model.fileSelected.connect(self.fileSelected)
+
+        # Set up custom sorting proxy
+        self._proxy_model = FileSortProxyModel()
+        self._proxy_model.setSourceModel(self._model)
+        self._table_view.setModel(self._proxy_model)
+
+        # Enable sorting
+        self._table_view.setSortingEnabled(True)
+        self._table_view.sortByColumn(0, Qt.SortOrder.AscendingOrder)
+
+        # Configure headers
+        header = self._table_view.horizontalHeader()
+        header.setSectionResizeMode(
+            0, QHeaderView.ResizeMode.Stretch
+        )  # Name column stretches
+        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)  # Size
+        header.setSectionResizeMode(
+            2, QHeaderView.ResizeMode.ResizeToContents
+        )  # Modified
+        header.setSectionResizeMode(3, QHeaderView.ResizeMode.Fixed)  # NPZ
+        header.setSectionResizeMode(4, QHeaderView.ResizeMode.Fixed)  # TXT
+        header.resizeSection(3, 50)
+        header.resizeSection(4, 50)
+
+        # Style the table to match the existing UI
+        self._table_view.setStyleSheet("""
+            QTableView {
+                background-color: transparent;
+                alternate-background-color: rgba(255, 255, 255, 0.03);
+                gridline-color: rgba(255, 255, 255, 0.1);
+                color: #E0E0E0;
+            }
+            QTableView::item {
+                padding: 2px;
+                color: #E0E0E0;
+            }
+            QTableView::item:selected {
+                background-color: rgba(100, 100, 200, 0.5);
+            }
+            QHeaderView::section {
+                background-color: rgba(60, 60, 60, 0.5);
+                color: #E0E0E0;
+                padding: 4px;
+                border: 1px solid rgba(80, 80, 80, 0.4);
+                font-weight: bold;
+            }
+        """)
+
+        # Connect selection
+        self._table_view.clicked.connect(self._on_item_clicked)
+        self._table_view.doubleClicked.connect(self._on_item_double_clicked)
+
+        layout.addWidget(self._table_view)
+
+        # Status bar
+        self._status_label = QLabel("No folder selected")
+        self._status_label.setStyleSheet(
+            "padding: 5px; background: rgba(60, 60, 60, 0.3); color: #E0E0E0;"
+        )
+        layout.addWidget(self._status_label)
+
+    def _create_header(self) -> QWidget:
+        """Create header with controls"""
+        header = QWidget()
+        header.setStyleSheet("background: rgba(60, 60, 60, 0.3); padding: 5px;")
+        layout = QHBoxLayout(header)
+        layout.setContentsMargins(5, 5, 5, 5)
+
+        # Search box
+        self._search_box = QLineEdit()
+        self._search_box.setPlaceholderText("Search files...")
+        self._search_box.textChanged.connect(self._on_search_changed)
+        self._search_box.setStyleSheet("""
+            QLineEdit {
+                background-color: rgba(50, 50, 50, 0.5);
+                border: 1px solid rgba(80, 80, 80, 0.4);
+                color: #E0E0E0;
+                padding: 4px;
+                border-radius: 3px;
+            }
+        """)
+        layout.addWidget(self._search_box)
+
+        # Sort dropdown
+        sort_label = QLabel("Sort:")
+        sort_label.setStyleSheet("color: #E0E0E0;")
+        layout.addWidget(sort_label)
+
+        self._sort_combo = QComboBox()
+        self._sort_combo.addItems(
+            [
+                "Name (A-Z)",
+                "Name (Z-A)",
+                "Date (Oldest)",
+                "Date (Newest)",
+                "Size (Smallest)",
+                "Size (Largest)",
+            ]
+        )
+        self._sort_combo.currentIndexChanged.connect(self._on_sort_changed)
+        self._sort_combo.setStyleSheet("""
+            QComboBox {
+                background-color: rgba(50, 50, 50, 0.5);
+                border: 1px solid rgba(80, 80, 80, 0.4);
+                color: #E0E0E0;
+                padding: 4px;
+                border-radius: 3px;
+            }
+            QComboBox::drop-down {
+                border: none;
+            }
+            QComboBox::down-arrow {
+                width: 12px;
+                height: 12px;
+            }
+            QComboBox QAbstractItemView {
+                background-color: rgba(50, 50, 50, 0.9);
+                border: 1px solid rgba(80, 80, 80, 0.4);
+                color: #E0E0E0;
+                selection-background-color: rgba(100, 100, 200, 0.5);
+            }
+        """)
+        layout.addWidget(self._sort_combo)
+
+        # Refresh button
+        refresh_btn = QPushButton("Refresh")
+        refresh_btn.clicked.connect(self._refresh)
+        refresh_btn.setStyleSheet("""
+            QPushButton {
+                background-color: rgba(70, 70, 70, 0.6);
+                border: 1px solid rgba(80, 80, 80, 0.4);
+                color: #E0E0E0;
+                padding: 4px 8px;
+                border-radius: 3px;
+            }
+            QPushButton:hover {
+                background-color: rgba(90, 90, 90, 0.8);
+            }
+            QPushButton:pressed {
+                background-color: rgba(50, 50, 50, 0.8);
+            }
+        """)
+        layout.addWidget(refresh_btn)
+
+        layout.addStretch()
+
+        return header
+
+    def setDirectory(self, directory: Path):
+        """Set the directory to display"""
+        self._current_directory = directory
+        self._model.setDirectory(directory)
+        self._update_status(f"Loading: {directory.name}")
+
+        # Connect to scan complete signal
+        if self._model._scanner:
+            self._model._scanner.scanComplete.connect(
+                lambda count: self._update_status(f"{count} files in {directory.name}")
+            )
+
+    def _on_search_changed(self, text: str):
+        """Handle search text change"""
+        self._proxy_model.setFilterFixedString(text)
+        self._proxy_model.setFilterCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
+        self._proxy_model.setFilterKeyColumn(0)  # Filter on name column
+
+    def _on_sort_changed(self, index: int):
+        """Handle sort order change"""
+        # Map combo index to column and order
+        column_map = {
+            0: 0,
+            1: 0,
+            2: 2,
+            3: 2,
+            4: 1,
+            5: 1,
+        }  # Name, Name, Date, Date, Size, Size
+        order_map = {
+            0: Qt.SortOrder.AscendingOrder,
+            1: Qt.SortOrder.DescendingOrder,
+            2: Qt.SortOrder.AscendingOrder,
+            3: Qt.SortOrder.DescendingOrder,
+            4: Qt.SortOrder.AscendingOrder,
+            5: Qt.SortOrder.DescendingOrder,
+        }
+
+        column = column_map.get(index, 0)
+        order = order_map.get(index, Qt.SortOrder.AscendingOrder)
+
+        self._table_view.sortByColumn(column, order)
+
+    def _refresh(self):
+        """Refresh current directory"""
+        if self._current_directory:
+            self.setDirectory(self._current_directory)
+
+    def updateNpzStatus(self, image_path: Path):
+        """Update NPZ status for a specific image file"""
+        self._model.updateNpzStatus(image_path)
+
+    def refreshFile(self, image_path: Path):
+        """Refresh status for a specific file (alias for updateNpzStatus)"""
+        self.updateNpzStatus(image_path)
+
+    def _on_item_clicked(self, index: QModelIndex):
+        """Handle item click"""
+        # Map proxy index to source index
+        source_index = self._proxy_model.mapToSource(index)
+        file_info = self._model.getFileInfo(source_index.row())
+        if file_info:
+            self.fileSelected.emit(file_info.path)
+
+    def _on_item_double_clicked(self, index: QModelIndex):
+        """Handle item double click"""
+        # Map proxy index to source index
+        source_index = self._proxy_model.mapToSource(index)
+        file_info = self._model.getFileInfo(source_index.row())
+        if file_info:
+            self.fileSelected.emit(file_info.path)
+
+    def _update_status(self, text: str):
+        """Update status label"""
+        self._status_label.setText(text)
+
+    def selectFile(self, path: Path):
+        """Select a specific file in the view"""
+        index = self._model.getFileIndex(path)
+        if index >= 0:
+            source_index = self._model.index(index, 0)
+            proxy_index = self._proxy_model.mapFromSource(source_index)
+            self._table_view.setCurrentIndex(proxy_index)
+            self._table_view.scrollTo(proxy_index)
+            # Select the entire row
+            selection_model = self._table_view.selectionModel()
+            selection_model.select(
+                proxy_index,
+                selection_model.SelectionFlag.ClearAndSelect
+                | selection_model.SelectionFlag.Rows,
+            )
+
+    def getSelectedFile(self) -> Path | None:
+        """Get currently selected file"""
+        index = self._table_view.currentIndex()
+        if index.isValid():
+            source_index = self._proxy_model.mapToSource(index)
+            file_info = self._model.getFileInfo(source_index.row())
+            if file_info:
+                return file_info.path
+        return None
+
+    def navigateNext(self):
+        """Navigate to next file"""
+        current = self._table_view.currentIndex()
+
+        # If no current selection and we have files, select first
+        if not current.isValid() and self._proxy_model.rowCount() > 0:
+            first_index = self._proxy_model.index(0, 0)
+            self._table_view.setCurrentIndex(first_index)
+            selection_model = self._table_view.selectionModel()
+            selection_model.select(
+                first_index,
+                selection_model.SelectionFlag.ClearAndSelect
+                | selection_model.SelectionFlag.Rows,
+            )
+            # Emit file selection
+            source_index = self._proxy_model.mapToSource(first_index)
+            file_info = self._model.getFileInfo(source_index.row())
+            if file_info:
+                self.fileSelected.emit(file_info.path)
+            return
+
+        if current.isValid() and current.row() < self._proxy_model.rowCount() - 1:
+            next_index = self._proxy_model.index(current.row() + 1, 0)
+            self._table_view.setCurrentIndex(next_index)
+            # Select entire row
+            selection_model = self._table_view.selectionModel()
+            selection_model.select(
+                next_index,
+                selection_model.SelectionFlag.ClearAndSelect
+                | selection_model.SelectionFlag.Rows,
+            )
+            # Emit file selection
+            source_index = self._proxy_model.mapToSource(next_index)
+            file_info = self._model.getFileInfo(source_index.row())
+            if file_info:
+                self.fileSelected.emit(file_info.path)
+
+    def navigatePrevious(self):
+        """Navigate to previous file"""
+        current = self._table_view.currentIndex()
+
+        # If no current selection and we have files, select last
+        if not current.isValid() and self._proxy_model.rowCount() > 0:
+            last_index = self._proxy_model.index(self._proxy_model.rowCount() - 1, 0)
+            self._table_view.setCurrentIndex(last_index)
+            selection_model = self._table_view.selectionModel()
+            selection_model.select(
+                last_index,
+                selection_model.SelectionFlag.ClearAndSelect
+                | selection_model.SelectionFlag.Rows,
+            )
+            # Emit file selection
+            source_index = self._proxy_model.mapToSource(last_index)
+            file_info = self._model.getFileInfo(source_index.row())
+            if file_info:
+                self.fileSelected.emit(file_info.path)
+            return
+
+        if current.isValid() and current.row() > 0:
+            prev_index = self._proxy_model.index(current.row() - 1, 0)
+            self._table_view.setCurrentIndex(prev_index)
+            # Select entire row
+            selection_model = self._table_view.selectionModel()
+            selection_model.select(
+                prev_index,
+                selection_model.SelectionFlag.ClearAndSelect
+                | selection_model.SelectionFlag.Rows,
+            )
+            # Emit file selection
+            source_index = self._proxy_model.mapToSource(prev_index)
+            file_info = self._model.getFileInfo(source_index.row())
+            if file_info:
+                self.fileSelected.emit(file_info.path)

{lazylabel_gui-1.3.1.dist-info → lazylabel_gui-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.3.1
+Version: 1.3.2
 Summary: An image segmentation GUI for generating ML ready mask tensors and annotations.
 Author-email: "Deniz N. Cakan" <deniz.n.cakan@gmail.com>
 License: MIT License

{lazylabel_gui-1.3.1.dist-info → lazylabel_gui-1.3.2.dist-info}/RECORD

@@ -6,7 +6,7 @@ lazylabel/config/hotkeys.py,sha256=PwxBUy7RvIUU3HCXT74NnexPbg2VFQrbR5FTGek31h8,8
 lazylabel/config/paths.py,sha256=ZVKbtaNOxmYO4l6JgsY-8DXaE_jaJfDg2RQJJn3-5nw,1275
 lazylabel/config/settings.py,sha256=myBqkgnYv_P1OomieXt8luCOSNjBiDVN-TybSqHkAgA,1990
 lazylabel/core/__init__.py,sha256=FmRjop_uIBSJwKMGhaZ-3Iwu34LkoxTuD-hnq5vbTSY,232
-lazylabel/core/file_manager.py,sha256=CmRLd3FtOa64mt9Wz-eYErDerFOm1gt3roGlibviqwo,6013
+lazylabel/core/file_manager.py,sha256=qVPCJdo9KEu9ESujHaWPmlpfVLjyaVXmDe9TmM9c8k4,7282
 lazylabel/core/model_manager.py,sha256=NmgnIrw9sb_vSwRVkBr2Z_Mc2kFfdFukFgUhqs2e-L0,6829
 lazylabel/core/segment_manager.py,sha256=M6kHcYeiub3WqL01NElCvKOc2GNmf72LUM1W8XwSaxc,6465
 lazylabel/models/__init__.py,sha256=fIlk_0DuZfiClcm0XlZdimeHzunQwBmTMI4PcGsaymw,91
@@ -18,12 +18,11 @@ lazylabel/ui/editable_vertex.py,sha256=ofo3r8ZZ3b8oYV40vgzZuS3QnXYBNzE92ArC2wggJ
 lazylabel/ui/hotkey_dialog.py,sha256=U_B76HLOxWdWkfA4d2XgRUaZTJPAAE_m5fmwf7Rh-5Y,14743
 lazylabel/ui/hoverable_pixelmap_item.py,sha256=UbWVxpmCTaeae_AeA8gMOHYGUmAw40fZBFTS3sZlw48,1821
 lazylabel/ui/hoverable_polygon_item.py,sha256=gZalImJ_PJYM7xON0iiSjQ335ZBREOfSscKLVs-MSh8,2314
-lazylabel/ui/main_window.py,sha256=r1Vk3aY346O3T1H8-4xmha0KpeWxANV27JthFQNX7ss,381615
+lazylabel/ui/main_window.py,sha256=b30amNwHkSXDi2_WvXFYlmzd6TTlRnjNRgShGIoatiQ,387531
 lazylabel/ui/numeric_table_widget_item.py,sha256=dQUlIFu9syCxTGAHVIlmbgkI7aJ3f3wmDPBz1AGK9Bg,283
 lazylabel/ui/photo_viewer.py,sha256=D_t2DS0AYckzlXjotTVC5ZxCsMYC-0xjBjeVQCrhqws,5631
 lazylabel/ui/reorderable_class_table.py,sha256=sxHhQre5O_MXLDFgKnw43QnvXXoqn5xRKMGitgO7muI,2371
-lazylabel/ui/right_panel.py,sha256=-PeXcu7Lr-xhZniBMvWLDPiFb_RAHYAcILyw8fPJs6I,13139
-lazylabel/ui/test_hover.py,sha256=5H7J2jhMlhDYwbvGJXgfTupwO9VRylK30ESAG85Ju7I,1521
+lazylabel/ui/right_panel.py,sha256=D69XgPXpLleflsIl8xCtoBZzFleLqx0SezdwfcEJhUg,14280
 lazylabel/ui/modes/__init__.py,sha256=ikg47aeexLQavSda_3tYn79xGJW38jKoUCLXRe2w8ok,219
 lazylabel/ui/modes/base_mode.py,sha256=0R3AkjN_WpYwetF3uuOvkTxb6Q1HB-Z1NQPvLh9eUTY,1315
 lazylabel/ui/modes/multi_view_mode.py,sha256=TKdqTHokIk267aFVvwXikAtAcuxpG6ezIOlQwoque9c,50606
@@ -39,11 +38,12 @@ lazylabel/ui/widgets/settings_widget.py,sha256=ShTaLJeXxwrSuTV4kmtV2JiWjfREil2D1
 lazylabel/ui/widgets/status_bar.py,sha256=wTbMQNEOBfmtNj8EVFZS_lxgaemu-CbRXeZzEQDaVz8,4014
 lazylabel/utils/__init__.py,sha256=V6IR5Gim-39HgM2NyTVT-n8gy3mjilCSFW9y0owN5nc,179
 lazylabel/utils/custom_file_system_model.py,sha256=-3EimlybvevH6bvqBE0qdFnLADVtayylmkntxPXK0Bk,4869
+lazylabel/utils/fast_file_manager.py,sha256=lOc7Lu7lcOFME-5EO3K6PiEE_oW6I3LhxpeizwgkhsM,24628
 lazylabel/utils/logger.py,sha256=R7z6ifgA-NY-9ZbLlNH0i19zzwXndJ_gkG2J1zpVEhg,1306
 lazylabel/utils/utils.py,sha256=sYSCoXL27OaLgOZaUkCAhgmKZ7YfhR3Cc5F8nDIa3Ig,414
-lazylabel_gui-1.3.1.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
-lazylabel_gui-1.3.1.dist-info/METADATA,sha256=8Q4xKBHglQ2KIOuIzCM1W84pUQ4h_k-omx6uuzO_naw,6898
-lazylabel_gui-1.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lazylabel_gui-1.3.1.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
-lazylabel_gui-1.3.1.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
-lazylabel_gui-1.3.1.dist-info/RECORD,,
+lazylabel_gui-1.3.2.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
+lazylabel_gui-1.3.2.dist-info/METADATA,sha256=LflKLfur3j-0agOkaMDITRzavzagyFrKI_JzZJIBCk0,6898
+lazylabel_gui-1.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lazylabel_gui-1.3.2.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
+lazylabel_gui-1.3.2.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
+lazylabel_gui-1.3.2.dist-info/RECORD,,

lazylabel/ui/test_hover.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to check hover functionality.
-Run this before starting LazyLabel to enable debug logging.
-"""
-
-# First, enable debug logging
-import logging
-import os
-import sys
-
-# Add the src directory to path so we can import LazyLabel modules
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
-
-from lazylabel.utils.logger import logger
-
-# Set logger to DEBUG level
-logger.setLevel(logging.DEBUG)
-
-# Add console handler if not already present
-if not logger.handlers:
-    console_handler = logging.StreamHandler()
-    console_handler.setLevel(logging.DEBUG)
-    formatter = logging.Formatter(
-        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    )
-    console_handler.setFormatter(formatter)
-    logger.addHandler(console_handler)
-
-print("=" * 50)
-print("HOVER DEBUG MODE ENABLED")
-print("=" * 50)
-print("Logger level:", logger.level)
-print("Logger handlers:", len(logger.handlers))
-print()
-print("Now run LazyLabel and test hover functionality:")
-print("1. Load images in multi-view mode")
-print("2. Create some segments (AI or polygon)")
-print("3. Try hovering over segments")
-print("4. Watch the console for debug messages")
-print()
-print("Expected debug messages:")
-print("- HoverablePolygonItem.set_segment_info")
-print("- HoverablePixmapItem.set_segment_info")
-print("- HoverablePolygonItem.hoverEnterEvent")
-print("- HoverablePixmapItem.hoverEnterEvent")
-print("- _trigger_segment_hover called")
-print("=" * 50)