lazylabel-gui 1.3.3__py3-none-any.whl → 1.3.4__py3-none-any.whl

lazylabel/core/file_manager.py

@@ -65,7 +65,7 @@ class FileManager:
         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)}")
+        logger.debug(f"Successfully saved NPZ: {os.path.basename(npz_path)}")
         return npz_path
 
     def save_yolo_txt(

lazylabel/ui/control_panel.py

@@ -612,10 +612,10 @@ class ControlPanel(QWidget):
         layout.addWidget(crop_collapsible)
 
         # Channel Threshold - collapsible
-        threshold_collapsible = SimpleCollapsible(
+        self.channel_threshold_collapsible = SimpleCollapsible(
             "Channel Threshold", self.channel_threshold_widget
         )
-        layout.addWidget(threshold_collapsible)
+        layout.addWidget(self.channel_threshold_collapsible)
 
         # FFT Threshold - collapsible (default collapsed)
         self.fft_threshold_collapsible = SimpleCollapsible(
@@ -880,6 +880,11 @@ class ControlPanel(QWidget):
         """Update channel threshold widget for new image."""
         self.channel_threshold_widget.update_for_image(image_array)
 
+        # Auto-expand channel threshold panel when any image is loaded
+        if image_array is not None and hasattr(self, "channel_threshold_collapsible"):
+            # Find and expand the Channel Threshold panel
+            self.channel_threshold_collapsible.set_collapsed(False)
+
     def get_channel_threshold_widget(self):
         """Get the channel threshold widget."""
         return self.channel_threshold_widget

lazylabel/ui/main_window.py

@@ -19,12 +19,14 @@ from PyQt6.QtGui import (
     QShortcut,
 )
 from PyQt6.QtWidgets import (
+    QApplication,
     QDialog,
     QFileDialog,
     QGraphicsEllipseItem,
     QGraphicsLineItem,
     QGraphicsPolygonItem,
     QGraphicsRectItem,
+    QGridLayout,
     QHBoxLayout,
     QLabel,
     QMainWindow,
@@ -772,6 +774,7 @@ class MainWindow(QMainWindow):
         logger.info("Step 5/8: Discovering available models...")
         self._setup_model_manager()  # Just setup manager, don't load model
         self._setup_connections()
+        self._fix_fft_connection()  # Workaround for FFT signal connection issue
         self._setup_shortcuts()
         self._load_settings()
 
@@ -877,12 +880,7 @@ class MainWindow(QMainWindow):
         grid_widget = QWidget()
 
         # Use grid layout for 4-view, horizontal layout for 2-view
-        if use_grid:
-            from PyQt6.QtWidgets import QGridLayout
-
-            grid_layout = QGridLayout(grid_widget)
-        else:
-            grid_layout = QHBoxLayout(grid_widget)
+        grid_layout = QGridLayout(grid_widget) if use_grid else QHBoxLayout(grid_widget)
         grid_layout.setSpacing(5)
 
         self.multi_view_viewers = []
@@ -951,29 +949,30 @@ class MainWindow(QMainWindow):
         grid_mode_label = QLabel("View Mode:")
         controls_layout.addWidget(grid_mode_label)
 
-        from PyQt6.QtWidgets import QComboBox
+        from lazylabel.ui.widgets.model_selection_widget import CustomDropdown
 
-        self.grid_mode_combo = QComboBox()
+        self.grid_mode_combo = CustomDropdown()
+        self.grid_mode_combo.setText("View Mode")  # Default text
         self.grid_mode_combo.addItem("2 Views (1x2)", "2_view")
         self.grid_mode_combo.addItem("4 Views (2x2)", "4_view")
 
         # Set current selection based on settings
         current_mode = self.settings.multi_view_grid_mode
-        for i in range(self.grid_mode_combo.count()):
+        for i in range(len(self.grid_mode_combo.items)):
             if self.grid_mode_combo.itemData(i) == current_mode:
                 self.grid_mode_combo.setCurrentIndex(i)
                 break
 
-        self.grid_mode_combo.currentTextChanged.connect(self._on_grid_mode_changed)
+        self.grid_mode_combo.activated.connect(self._on_grid_mode_changed)
         controls_layout.addWidget(self.grid_mode_combo)
 
         controls_layout.addStretch()
 
         layout.addWidget(controls_widget)
 
-    def _on_grid_mode_changed(self):
+    def _on_grid_mode_changed(self, index):
         """Handle grid mode change from combo box."""
-        current_data = self.grid_mode_combo.currentData()
+        current_data = self.grid_mode_combo.itemData(index)
         if current_data and current_data != self.settings.multi_view_grid_mode:
             # Update settings
             self.settings.multi_view_grid_mode = current_data
@@ -1062,8 +1061,7 @@ class MainWindow(QMainWindow):
                 layout.deleteLater()
             except Exception as e:
                 # If layout clearing fails, just reset the viewer lists
-                print(f"Layout clearing failed: {e}")
-                pass
+                logger.error(f"Layout clearing failed: {e}")
 
     def _clear_multi_view_layout(self):
         """Clear the existing multi-view layout."""
@@ -1121,6 +1119,48 @@ class MainWindow(QMainWindow):
             # Switch to polygon mode if SAM is disabled and we're in SAM/AI mode
             self.set_polygon_mode()
 
+    def _fix_fft_connection(self):
+        """Fix FFT signal connection issue - workaround for connection timing problem."""
+        try:
+            # Get the FFT widget directly and connect to its signal
+            fft_widget = self.control_panel.get_fft_threshold_widget()
+            if fft_widget:
+                # Direct connection bypass - connect FFT widget directly to main window handler
+                # This bypasses the control panel signal forwarding which has timing issues
+                # Use a wrapper to ensure the connection works reliably
+                def fft_signal_wrapper():
+                    self._handle_fft_threshold_changed()
+
+                fft_widget.fft_threshold_changed.connect(fft_signal_wrapper)
+
+                logger.info("FFT signal connection bypass established successfully")
+            else:
+                logger.warning("FFT widget not found during connection fix")
+        except Exception as e:
+            logger.warning(f"Failed to establish FFT connection bypass: {e}")
+
+        # Also fix channel threshold connection for RGB images
+        try:
+            channel_widget = self.control_panel.get_channel_threshold_widget()
+            if channel_widget:
+                # Direct connection bypass for channel threshold widget too
+                def channel_signal_wrapper():
+                    self._handle_channel_threshold_changed()
+
+                channel_widget.thresholdChanged.connect(channel_signal_wrapper)
+
+                logger.info(
+                    "Channel threshold signal connection bypass established successfully"
+                )
+            else:
+                logger.warning(
+                    "Channel threshold widget not found during connection fix"
+                )
+        except Exception as e:
+            logger.warning(
+                f"Failed to establish channel threshold connection bypass: {e}"
+            )
+
     def _setup_connections(self):
         """Setup signal connections."""
         # Control panel connections
@@ -1169,9 +1209,13 @@ class MainWindow(QMainWindow):
         )
 
         # FFT threshold connections
-        self.control_panel.fft_threshold_changed.connect(
-            self._handle_fft_threshold_changed
-        )
+        try:
+            self.control_panel.fft_threshold_changed.connect(
+                self._handle_fft_threshold_changed
+            )
+            logger.debug("FFT threshold connection established in _setup_connections")
+        except Exception as e:
+            logger.error(f"Failed to establish FFT threshold connection: {e}")
 
         # Right panel connections
         self.right_panel.open_folder_requested.connect(self._open_folder_dialog)
@@ -1774,6 +1818,9 @@ class MainWindow(QMainWindow):
         # Update file selection in the file manager
         self.right_panel.select_file(Path(path))
 
+        # Update threshold widgets for new image (this was missing!)
+        self._update_channel_threshold_for_image(pixmap)
+
     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()
@@ -1948,6 +1995,9 @@ class MainWindow(QMainWindow):
         if changed_indices:
             self._fast_update_multi_view_images(changed_indices)
 
+        # Update threshold widgets for the loaded images
+        self._update_multi_view_channel_threshold_for_images()
+
         # Load existing segments for all loaded images
         valid_image_paths = [path for path in image_paths if path is not None]
         if valid_image_paths:
@@ -2005,7 +2055,9 @@ class MainWindow(QMainWindow):
                         all_segments.extend(viewer_segments)
                         self.segment_manager.segments.clear()
                     except Exception as e:
-                        print(f"Error loading segments for viewer {viewer_index}: {e}")
+                        logger.error(
+                            f"Error loading segments for viewer {viewer_index}: {e}"
+                        )
 
             # Set all segments at once
             self.segment_manager.segments = all_segments
@@ -2025,7 +2077,7 @@ class MainWindow(QMainWindow):
                 self._update_all_lists()
 
         except Exception as e:
-            print(f"Error in _load_multi_view_segments: {e}")
+            logger.error(f"Error in _load_multi_view_segments: {e}")
             self.segment_manager.segments.clear()
 
     def _cancel_multi_view_sam_loading(self):
@@ -3353,6 +3405,8 @@ class MainWindow(QMainWindow):
                 valid_paths = [Path(img) for img in self.multi_view_images if img]
                 if valid_paths:
                     self.right_panel.file_manager.batchUpdateFileStatus(valid_paths)
+                    # Force immediate GUI update
+                    QApplication.processEvents()
             # Clear the tracking list for next save
             self._saved_file_paths = []
 
@@ -3401,6 +3455,8 @@ class MainWindow(QMainWindow):
                 )
                 # Update UI immediately when files are deleted
                 self._update_all_lists()
+                # Force immediate GUI update
+                QApplication.processEvents()
             else:
                 self._show_warning_notification("No segments to save.")
             return
@@ -3478,15 +3534,16 @@ class MainWindow(QMainWindow):
                     )
 
             # Update FastFileManager to show NPZ/TXT checkmarks
-            if (
-                (npz_path or txt_path)
-                and hasattr(self, "right_panel")
-                and hasattr(self.right_panel, "file_manager")
+            # Always update file status after save attempt (regardless of what was saved)
+            if hasattr(self, "right_panel") and hasattr(
+                self.right_panel, "file_manager"
             ):
                 # Update the file status in the FastFileManager
                 self.right_panel.file_manager.updateFileStatus(
                     Path(self.current_image_path)
                 )
+                # Force immediate GUI update
+                QApplication.processEvents()
         except Exception as e:
             logger.error(f"Error saving file: {str(e)}", exc_info=True)
             self._show_error_notification(f"Error saving: {str(e)}")
@@ -5714,27 +5771,50 @@ class MainWindow(QMainWindow):
 
     def _update_channel_threshold_for_image(self, pixmap):
         """Update channel threshold widget for the given image pixmap."""
-        if pixmap.isNull():
+        if pixmap.isNull() or not self.current_image_path:
             self.control_panel.update_channel_threshold_for_image(None)
             return
 
-        # Convert pixmap to numpy array
-        qimage = pixmap.toImage()
-        ptr = qimage.constBits()
-        ptr.setsize(qimage.bytesPerLine() * qimage.height())
-        image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
-        # Convert from BGRA to RGB, ignore alpha
-        image_rgb = image_np[:, :, [2, 1, 0]]
+        # Use cv2.imread for more robust loading instead of QPixmap conversion
+        try:
+            import cv2
 
-        # Check if image is grayscale (all channels are the same)
-        if np.array_equal(image_rgb[:, :, 0], image_rgb[:, :, 1]) and np.array_equal(
-            image_rgb[:, :, 1], image_rgb[:, :, 2]
-        ):
-            # Convert to single channel grayscale
-            image_array = image_rgb[:, :, 0]
-        else:
-            # Keep as RGB
-            image_array = image_rgb
+            image_array = cv2.imread(self.current_image_path)
+            if image_array is None:
+                self.control_panel.update_channel_threshold_for_image(None)
+                return
+
+            # Convert from BGR to RGB
+            if len(image_array.shape) == 3 and image_array.shape[2] == 3:
+                image_array = cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB)
+
+            # Check if image is grayscale (all channels are the same)
+            if (
+                len(image_array.shape) == 3
+                and np.array_equal(image_array[:, :, 0], image_array[:, :, 1])
+                and np.array_equal(image_array[:, :, 1], image_array[:, :, 2])
+            ):
+                # Convert to single channel grayscale
+                image_array = image_array[:, :, 0]
+
+        except Exception:
+            # Fallback to QPixmap conversion if cv2 fails
+            qimage = pixmap.toImage()
+            ptr = qimage.constBits()
+            ptr.setsize(qimage.bytesPerLine() * qimage.height())
+            image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
+            # Convert from BGRA to RGB, ignore alpha
+            image_rgb = image_np[:, :, [2, 1, 0]]
+
+            # Check if image is grayscale (all channels are the same)
+            if np.array_equal(
+                image_rgb[:, :, 0], image_rgb[:, :, 1]
+            ) and np.array_equal(image_rgb[:, :, 1], image_rgb[:, :, 2]):
+                # Convert to single channel grayscale
+                image_array = image_rgb[:, :, 0]
+            else:
+                # Keep as RGB
+                image_array = image_rgb
 
         # Update the channel threshold widget
         self.control_panel.update_channel_threshold_for_image(image_array)
@@ -5762,29 +5842,51 @@ class MainWindow(QMainWindow):
             self.control_panel.update_channel_threshold_for_image(None)
             return
 
-        # Load and convert the first image to update the widget
-        pixmap = QPixmap(first_image_path)
-        if pixmap.isNull():
-            self.control_panel.update_channel_threshold_for_image(None)
-            return
+        # Use cv2.imread for more robust loading instead of QPixmap conversion
+        try:
+            import cv2
 
-        # Convert pixmap to numpy array
-        qimage = pixmap.toImage()
-        ptr = qimage.constBits()
-        ptr.setsize(qimage.bytesPerLine() * qimage.height())
-        image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
-        # Convert from BGRA to RGB, ignore alpha
-        image_rgb = image_np[:, :, [2, 1, 0]]
+            image_array = cv2.imread(first_image_path)
+            if image_array is None:
+                self.control_panel.update_channel_threshold_for_image(None)
+                return
 
-        # Check if image is grayscale (all channels are the same)
-        if np.array_equal(image_rgb[:, :, 0], image_rgb[:, :, 1]) and np.array_equal(
-            image_rgb[:, :, 1], image_rgb[:, :, 2]
-        ):
-            # Convert to single channel grayscale
-            image_array = image_rgb[:, :, 0]
-        else:
-            # Keep as RGB
-            image_array = image_rgb
+            # Convert from BGR to RGB
+            if len(image_array.shape) == 3 and image_array.shape[2] == 3:
+                image_array = cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB)
+
+            # Check if image is grayscale (all channels are the same)
+            if (
+                len(image_array.shape) == 3
+                and np.array_equal(image_array[:, :, 0], image_array[:, :, 1])
+                and np.array_equal(image_array[:, :, 1], image_array[:, :, 2])
+            ):
+                # Convert to single channel grayscale
+                image_array = image_array[:, :, 0]
+
+        except Exception:
+            # Fallback to QPixmap conversion if cv2 fails
+            pixmap = QPixmap(first_image_path)
+            if pixmap.isNull():
+                self.control_panel.update_channel_threshold_for_image(None)
+                return
+
+            qimage = pixmap.toImage()
+            ptr = qimage.constBits()
+            ptr.setsize(qimage.bytesPerLine() * qimage.height())
+            image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
+            # Convert from BGRA to RGB, ignore alpha
+            image_rgb = image_np[:, :, [2, 1, 0]]
+
+            # Check if image is grayscale (all channels are the same)
+            if np.array_equal(
+                image_rgb[:, :, 0], image_rgb[:, :, 1]
+            ) and np.array_equal(image_rgb[:, :, 1], image_rgb[:, :, 2]):
+                # Convert to single channel grayscale
+                image_array = image_rgb[:, :, 0]
+            else:
+                # Keep as RGB
+                image_array = image_rgb
 
         # Update the channel threshold widget
         self.control_panel.update_channel_threshold_for_image(image_array)
@@ -7097,7 +7199,6 @@ class MainWindow(QMainWindow):
                 )
 
                 # Load existing segments for the current image
-                print(f"Loading segments for single-view: {self.current_image_path}")
                 try:
                     # Clear any leftover multi-view segments first
                     self.segment_manager.clear()
@@ -7114,7 +7215,7 @@ class MainWindow(QMainWindow):
                     self._update_all_lists()
 
                 except Exception as e:
-                    print(f"Error loading segments for single-view: {e}")
+                    logger.error(f"Error loading segments for single-view: {e}")
 
                 # Redisplay segments for single view
                 if hasattr(self, "single_view_mode_handler"):

lazylabel/ui/widgets/channel_threshold_widget.py

@@ -270,10 +270,6 @@ class MultiIndicatorSlider(QWidget):
         """Handle right-click to remove indicator."""
         slider_rect = self.get_slider_rect()
 
-        # Only allow removal if more than 1 indicator
-        if len(self.indicators) <= 1:
-            return
-
         # Check if right-clicking on an indicator
         for i, value in enumerate(self.indicators):
             x = self.value_to_x(value)
@@ -473,7 +469,7 @@ class ChannelThresholdWidget(QWidget):
 
         if self.current_image_channels == 1:
             # Grayscale image
-            if "Gray" in self.sliders:
+            if "Gray" in self.sliders and self.sliders["Gray"].is_enabled():
                 result = self._apply_channel_thresholding(
                     result, self.sliders["Gray"].get_indicators()
                 )
@@ -481,7 +477,10 @@ class ChannelThresholdWidget(QWidget):
             # RGB image
             channel_names = ["Red", "Green", "Blue"]
             for i, channel_name in enumerate(channel_names):
-                if channel_name in self.sliders:
+                if (
+                    channel_name in self.sliders
+                    and self.sliders[channel_name].is_enabled()
+                ):
                     result[:, :, i] = self._apply_channel_thresholding(
                         result[:, :, i], self.sliders[channel_name].get_indicators()
                     )
@@ -494,7 +493,7 @@ class ChannelThresholdWidget(QWidget):
         if not indicators:
             return channel_data
 
-            # Sort indicators
+        # Sort indicators
         sorted_indicators = sorted(indicators)
 
         # Create output array
@@ -527,9 +526,9 @@ class ChannelThresholdWidget(QWidget):
         return result
 
     def has_active_thresholding(self):
-        """Check if any channel has active thresholding (indicators present)."""
+        """Check if any channel has active thresholding (enabled and indicators present)."""
         for slider_widget in self.sliders.values():
-            if slider_widget.get_indicators():
+            if slider_widget.is_enabled() and slider_widget.get_indicators():
                 return True
         return False
 

lazylabel/ui/widgets/fft_threshold_widget.py

@@ -308,6 +308,8 @@ class FFTThresholdWidget(QWidget):
                 self.status_label.setStyleSheet(
                     "color: #F44336; font-size: 9px; font-style: italic;"
                 )
+                # Disable FFT processing for color images
+                self.enable_checkbox.setChecked(False)
         else:
             # Unknown format
             self.current_image_channels = 0
@@ -315,6 +317,8 @@ class FFTThresholdWidget(QWidget):
             self.status_label.setStyleSheet(
                 "color: #F44336; font-size: 9px; font-style: italic;"
             )
+            # Disable FFT processing for unsupported formats
+            self.enable_checkbox.setChecked(False)
 
     def is_active(self):
         """Check if FFT processing is active (checkbox enabled and image is grayscale)."""

lazylabel/ui/widgets/model_selection_widget.py

@@ -111,6 +111,15 @@ class CustomDropdown(QToolButton):
             text, _ = self.items[index]
             self.setText(text)
 
+    def count(self):
+        """Get number of items."""
+        return len(self.items)
+
+    def currentData(self):
+        """Get data of currently selected item."""
+        current_idx = self.currentIndex()
+        return self.itemData(current_idx)
+
     def blockSignals(self, block):
         """Block/unblock signals."""
         super().blockSignals(block)

lazylabel/utils/fast_file_manager.py

@@ -17,21 +17,159 @@ from PyQt6.QtCore import (
 )
 from PyQt6.QtGui import QPixmap
 from PyQt6.QtWidgets import (
-    QComboBox,
     QHBoxLayout,
     QHeaderView,
     QLabel,
     QLineEdit,
+    QMenu,
     QPushButton,
     QTableView,
+    QToolButton,
     QVBoxLayout,
     QWidget,
 )
 
+from ..utils.logger import logger
+
 # Image extensions supported
 IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".tiff", ".tif"}
 
 
+class CustomDropdown(QToolButton):
+    """Custom dropdown using QToolButton + QMenu for reliable closing behavior."""
+
+    activated = pyqtSignal(int)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setText("⚏")  # Grid/settings icon
+        self.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
+        self.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextOnly)
+
+        # Create the menu
+        self.menu = QMenu(self)
+        self.setMenu(self.menu)
+
+        # Store items for access
+        self.items = []
+
+        # Style to match app theme (dark theme with consistent colors)
+        self.setStyleSheet("""
+            QToolButton {
+                background-color: rgba(40, 40, 40, 0.8);
+                border: 1px solid rgba(80, 80, 80, 0.6);
+                border-radius: 6px;
+                color: #E0E0E0;
+                font-size: 10px;
+                padding: 5px 8px;
+                text-align: left;
+                min-width: 30px;
+                max-width: 30px;
+            }
+            QToolButton:hover {
+                background-color: rgba(60, 60, 60, 0.8);
+                border-color: rgba(90, 120, 150, 0.8);
+            }
+            QToolButton:pressed {
+                background-color: rgba(70, 100, 130, 0.8);
+            }
+            QToolButton::menu-indicator {
+                subcontrol-origin: padding;
+                subcontrol-position: top right;
+                width: 16px;
+                border-left: 1px solid rgba(80, 80, 80, 0.6);
+            }
+            QMenu {
+                background-color: rgba(50, 50, 50, 0.9);
+                border: 1px solid rgba(80, 80, 80, 0.4);
+                color: #E0E0E0;
+            }
+            QMenu::item {
+                padding: 4px 8px;
+            }
+            QMenu::item:selected {
+                background-color: rgba(100, 100, 200, 0.5);
+            }
+        """)
+
+    def addCheckableItem(self, text, checked=True, data=None):
+        """Add a checkable item to the dropdown."""
+        action = self.menu.addAction(text)
+        action.setCheckable(True)
+        action.setChecked(checked)
+        action.setData(data)
+        self.items.append((text, data, action))
+
+        # Connect to selection handler
+        action.triggered.connect(
+            lambda checked_state, idx=len(self.items) - 1: self._on_item_toggled(
+                idx, checked_state
+            )
+        )
+
+    def clear(self):
+        """Clear all items."""
+        self.menu.clear()
+        self.items.clear()
+
+    def _on_item_toggled(self, index, checked):
+        """Handle item toggle."""
+        if 0 <= index < len(self.items):
+            self.activated.emit(index)
+
+    def isItemChecked(self, index):
+        """Check if item at index is checked."""
+        if 0 <= index < len(self.items):
+            return self.items[index][2].isChecked()
+        return False
+
+    def setItemChecked(self, index, checked):
+        """Set checked state of item at index."""
+        if 0 <= index < len(self.items):
+            self.items[index][2].setChecked(checked)
+
+    def addItem(self, text, data=None):
+        """Add a non-checkable item to the dropdown (QComboBox compatibility)."""
+        action = self.menu.addAction(text)
+        action.setCheckable(False)
+        action.setData(data)
+        self.items.append((text, data, action))
+
+        # Connect to selection handler
+        action.triggered.connect(lambda: self._on_item_selected(len(self.items) - 1))
+
+    def _on_item_selected(self, index):
+        """Handle item selection (for non-checkable items)."""
+        if 0 <= index < len(self.items):
+            text, data, action = self.items[index]
+            self.setText(text)
+            self.activated.emit(index)
+
+    def count(self):
+        """Return number of items (QComboBox compatibility)."""
+        return len(self.items)
+
+    def itemData(self, index):
+        """Get data for item at index (QComboBox compatibility)."""
+        if 0 <= index < len(self.items):
+            return self.items[index][1]
+        return None
+
+    def setCurrentIndex(self, index):
+        """Set current selection index (QComboBox compatibility)."""
+        if 0 <= index < len(self.items):
+            text, data, action = self.items[index]
+            self.setText(text)
+
+    def currentIndex(self):
+        """Get current selection index (QComboBox compatibility)."""
+        current_text = self.text()
+        for i, (text, _data, _action) in enumerate(self.items):
+            if text == current_text:
+                return i
+        return -1
+
+
 @dataclass
 class FileInfo:
     """Information about a file"""
@@ -121,7 +259,7 @@ class FileScanner(QThread):
             self.scanComplete.emit(total_files)
 
         except Exception as e:
-            print(f"Error scanning directory: {e}")
+            logger.error(f"Error scanning directory: {e}")
 
     def stop(self):
         """Stop the scanning thread"""
@@ -139,31 +277,94 @@ class FastFileModel(QAbstractTableModel):
         self._path_to_index: dict[str, int] = {}  # For O(1) lookups
         self._scanner: FileScanner | None = None
 
+        # Column management - New order: Name, NPZ, TXT, Modified, Size
+        self._all_columns = ["Name", "NPZ", "TXT", "Modified", "Size"]
+        self._column_map = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}  # logical to physical mapping
+        self._visible_columns = [True, True, True, True, True]  # Default all visible
+
     def rowCount(self, parent=QModelIndex()):
         return len(self._files)
 
     def columnCount(self, parent=QModelIndex()):
-        return 5  # Name, Size, Modified, NPZ, TXT
+        return sum(self._visible_columns)  # Count visible columns
+
+    def getVisibleColumnIndex(self, logical_column):
+        """Convert logical column index to visible column index"""
+        if (
+            logical_column >= len(self._visible_columns)
+            or not self._visible_columns[logical_column]
+        ):
+            return -1
+
+        visible_index = 0
+        for i in range(logical_column):
+            if self._visible_columns[i]:
+                visible_index += 1
+        return visible_index
+
+    def getLogicalColumnIndex(self, visible_column):
+        """Convert visible column index to logical column index"""
+        visible_count = 0
+        for i, visible in enumerate(self._visible_columns):
+            if visible:
+                if visible_count == visible_column:
+                    return i
+                visible_count += 1
+        return -1
+
+    def setColumnVisible(self, column, visible):
+        """Set column visibility"""
+        if (
+            0 <= column < len(self._visible_columns)
+            and self._visible_columns[column] != visible
+        ):
+            self.beginResetModel()
+            self._visible_columns[column] = visible
+            self.endResetModel()
+
+    def isColumnVisible(self, column):
+        """Check if column is visible"""
+        if 0 <= column < len(self._visible_columns):
+            return self._visible_columns[column]
+        return False
+
+    def moveColumn(self, from_column, to_column):
+        """Move column to new position"""
+        if (
+            0 <= from_column < len(self._all_columns)
+            and 0 <= to_column < len(self._all_columns)
+            and from_column != to_column
+        ):
+            self.beginResetModel()
+            # Move in all arrays
+            self._all_columns.insert(to_column, self._all_columns.pop(from_column))
+            self._visible_columns.insert(
+                to_column, self._visible_columns.pop(from_column)
+            )
+            self.endResetModel()
 
     def data(self, index: QModelIndex, role=Qt.ItemDataRole.DisplayRole):
         if not index.isValid():
             return None
 
         file_info = self._files[index.row()]
-        col = index.column()
+        visible_col = index.column()
+
+        # Convert visible column to logical column
+        logical_col = self.getLogicalColumnIndex(visible_col)
+        if logical_col == -1:
+            return None
+
+        column_name = self._all_columns[logical_col]
 
         if role == Qt.ItemDataRole.DisplayRole:
-            if col == 0:  # Name
+            if column_name == "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
+            elif column_name == "NPZ":
+                return "✓" if file_info.has_npz else ""
+            elif column_name == "TXT":
+                return "✓" if file_info.has_txt else ""
+            elif column_name == "Modified":
                 # Lazy load modified time only when displayed
                 if file_info.modified == 0.0:
                     try:
@@ -177,16 +378,20 @@ class FastFileModel(QAbstractTableModel):
                     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 column_name == "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 role == Qt.ItemDataRole.UserRole:
             # Return the FileInfo object for custom access
             return file_info
-        elif role == Qt.ItemDataRole.TextAlignmentRole and col in [
-            3,
-            4,
+        elif role == Qt.ItemDataRole.TextAlignmentRole and column_name in [
+            "NPZ",
+            "TXT",
         ]:  # Center checkmarks
             return Qt.AlignmentFlag.AlignCenter
 
@@ -197,8 +402,9 @@ class FastFileModel(QAbstractTableModel):
             orientation == Qt.Orientation.Horizontal
             and role == Qt.ItemDataRole.DisplayRole
         ):
-            headers = ["Name", "Size", "Modified", "NPZ", "TXT"]
-            return headers[section]
+            logical_col = self.getLogicalColumnIndex(section)
+            if logical_col >= 0 and logical_col < len(self._all_columns):
+                return self._all_columns[logical_col]
         return None
 
     def _format_size(self, size: int) -> str:
@@ -244,7 +450,14 @@ class FastFileModel(QAbstractTableModel):
 
     def _on_scan_complete(self, total: int):
         """Handle scan completion"""
-        print(f"Scan complete: {total} files found")
+        pass  # Scan completion is handled by the UI status update
+
+    def getFileCounts(self):
+        """Get counts of total files, NPZ files, and TXT files"""
+        total_files = len(self._files)
+        npz_count = sum(1 for file_info in self._files if file_info.has_npz)
+        txt_count = sum(1 for file_info in self._files if file_info.has_txt)
+        return total_files, npz_count, txt_count
 
     def getFileInfo(self, index: int) -> FileInfo | None:
         """Get file info at index"""
@@ -358,12 +571,19 @@ class FileSortProxyModel(QSortFilterProxyModel):
         if not left_info or not right_info:
             return False
 
-        col = left.column()
+        visible_col = left.column()
+
+        # Convert visible column to logical column
+        logical_col = self.sourceModel().getLogicalColumnIndex(visible_col)
+        if logical_col == -1:
+            return False
+
+        column_name = self.sourceModel()._all_columns[logical_col]
 
-        # Sort based on column
-        if col == 0:  # Name
+        # Sort based on column type
+        if column_name == "Name":
             return left_info.name.lower() < right_info.name.lower()
-        elif col == 1:  # Size
+        elif column_name == "Size":
             # Lazy load size if needed for sorting
             if left_info.size == 0:
                 try:
@@ -376,7 +596,7 @@ class FileSortProxyModel(QSortFilterProxyModel):
                 except OSError:
                     right_info.size = -1
             return left_info.size < right_info.size
-        elif col == 2:  # Modified
+        elif column_name == "Modified":
             # Lazy load modified time if needed for sorting
             if left_info.modified == 0.0:
                 try:
@@ -389,9 +609,9 @@ class FileSortProxyModel(QSortFilterProxyModel):
                 except OSError:
                     right_info.modified = -1
             return left_info.modified < right_info.modified
-        elif col == 3:  # NPZ
+        elif column_name == "NPZ":
             return left_info.has_npz < right_info.has_npz
-        elif col == 4:  # TXT
+        elif column_name == "TXT":
             return left_info.has_txt < right_info.has_txt
 
         return False
@@ -437,19 +657,13 @@ class FastFileManager(QWidget):
         self._table_view.setSortingEnabled(True)
         self._table_view.sortByColumn(0, Qt.SortOrder.AscendingOrder)
 
-        # Configure headers
+        # Configure headers with drag-and-drop reordering
         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)
+        header.setSectionsMovable(True)  # Enable drag-and-drop reordering
+        header.sectionMoved.connect(self._on_column_moved)
+
+        # Initial header sizing (will be updated by _update_header_sizing)
+        self._update_header_sizing()
 
         # Style the table to match the existing UI
         self._table_view.setStyleSheet("""
@@ -515,42 +729,95 @@ class FastFileManager(QWidget):
         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);
-            }
-        """)
+        # Create custom sort dropdown
+        class SortDropdown(QToolButton):
+            activated = pyqtSignal(int)
+
+            def __init__(self, parent=None):
+                super().__init__(parent)
+                self.setText("Name (A-Z)")
+                self.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
+                self.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextOnly)
+
+                self.menu = QMenu(self)
+                self.setMenu(self.menu)
+                self.items = []
+
+                # Same style as CustomDropdown
+                self.setStyleSheet("""
+                    QToolButton {
+                        background-color: rgba(40, 40, 40, 0.8);
+                        border: 1px solid rgba(80, 80, 80, 0.6);
+                        border-radius: 6px;
+                        color: #E0E0E0;
+                        font-size: 10px;
+                        padding: 5px 8px;
+                        text-align: left;
+                        min-width: 70px;
+                        max-width: 70px;
+                    }
+                    QToolButton:hover {
+                        background-color: rgba(60, 60, 60, 0.8);
+                        border-color: rgba(90, 120, 150, 0.8);
+                    }
+                    QToolButton:pressed {
+                        background-color: rgba(70, 100, 130, 0.8);
+                    }
+                    QToolButton::menu-indicator {
+                        subcontrol-origin: padding;
+                        subcontrol-position: top right;
+                        width: 16px;
+                        border-left: 1px solid rgba(80, 80, 80, 0.6);
+                    }
+                    QMenu {
+                        background-color: rgba(50, 50, 50, 0.9);
+                        border: 1px solid rgba(80, 80, 80, 0.4);
+                        color: #E0E0E0;
+                    }
+                    QMenu::item {
+                        padding: 4px 8px;
+                    }
+                    QMenu::item:selected {
+                        background-color: rgba(100, 100, 200, 0.5);
+                    }
+                """)
+
+            def addItem(self, text, data=None):
+                action = self.menu.addAction(text)
+                action.setData(data)
+                self.items.append((text, data))
+                action.triggered.connect(
+                    lambda checked, idx=len(self.items) - 1: self._on_item_selected(idx)
+                )
+                if len(self.items) == 1:
+                    self.setText(text)
+
+            def _on_item_selected(self, index):
+                if 0 <= index < len(self.items):
+                    text, data = self.items[index]
+                    self.setText(text)
+                    self.activated.emit(index)
+
+        self._sort_combo = SortDropdown()
+        self._sort_combo.addItem("Name (A-Z)", 0)
+        self._sort_combo.addItem("Name (Z-A)", 1)
+        self._sort_combo.addItem("Date (Oldest)", 2)
+        self._sort_combo.addItem("Date (Newest)", 3)
+        self._sort_combo.addItem("Size (Smallest)", 4)
+        self._sort_combo.addItem("Size (Largest)", 5)
+        self._sort_combo.activated.connect(self._on_sort_changed)
         layout.addWidget(self._sort_combo)
 
+        # Column visibility dropdown
+        self._column_dropdown = CustomDropdown()
+        self._column_dropdown.addCheckableItem("Name", True, 0)
+        self._column_dropdown.addCheckableItem("NPZ", True, 1)
+        self._column_dropdown.addCheckableItem("TXT", True, 2)
+        self._column_dropdown.addCheckableItem("Modified", True, 3)
+        self._column_dropdown.addCheckableItem("Size", True, 4)
+        self._column_dropdown.activated.connect(self._on_column_visibility_changed)
+        layout.addWidget(self._column_dropdown)
+
         # Refresh button
         refresh_btn = QPushButton("Refresh")
         refresh_btn.clicked.connect(self._refresh)
@@ -584,7 +851,7 @@ class FastFileManager(QWidget):
         # 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}")
+                lambda count: self._update_detailed_status(directory.name)
             )
 
     def _on_search_changed(self, text: str):
@@ -623,6 +890,50 @@ class FastFileManager(QWidget):
         if self._current_directory:
             self.setDirectory(self._current_directory)
 
+    def _on_column_visibility_changed(self, column_index):
+        """Handle column visibility toggle"""
+        is_checked = self._column_dropdown.isItemChecked(column_index)
+        self._model.setColumnVisible(column_index, is_checked)
+
+        # Update header sizing for visible columns
+        self._update_header_sizing()
+
+    def _update_header_sizing(self):
+        """Update header column sizing for visible columns"""
+        header = self._table_view.horizontalHeader()
+        visible_columns = sum(self._model._visible_columns)
+
+        if visible_columns == 0:
+            return
+
+        # Set all columns to Interactive mode for manual resizing
+        for i in range(visible_columns):
+            # Find logical column for this visible index
+            logical_col = self._model.getLogicalColumnIndex(i)
+            if logical_col >= 0:
+                column_name = self._model._all_columns[logical_col]
+                # All columns are interactive (manually resizable)
+                header.setSectionResizeMode(i, QHeaderView.ResizeMode.Interactive)
+
+                # Set appropriate default sizes
+                if column_name == "Name":
+                    header.resizeSection(i, 200)  # Default name column width
+                elif column_name in ["NPZ", "TXT"]:
+                    header.resizeSection(i, 50)  # Compact for checkmarks
+                elif column_name == "Modified":
+                    header.resizeSection(i, 120)  # Date needs more space
+                elif column_name == "Size":
+                    header.resizeSection(i, 80)  # Size needs moderate space
+
+        # Disable stretch last section to allow all columns to be manually resized
+        header.setStretchLastSection(False)
+
+    def _on_column_moved(self, logical_index, old_visual_index, new_visual_index):
+        """Handle column reordering via drag-and-drop"""
+        # For now, just update the header sizing to maintain proper resize modes
+        # The QHeaderView handles the visual reordering automatically
+        self._update_header_sizing()
+
     def updateNpzStatus(self, image_path: Path):
         """Update NPZ status for a specific image file"""
         self._model.updateNpzStatus(image_path)
@@ -630,6 +941,12 @@ class FastFileManager(QWidget):
     def updateFileStatus(self, image_path: Path):
         """Update both NPZ and TXT status for a specific image file"""
         self._model.updateFileStatus(image_path)
+        # Update status counts when file status changes
+        if self._current_directory:
+            self._update_detailed_status(self._current_directory.name)
+        # Force table view to repaint immediately
+        self._table_view.viewport().update()
+        self._table_view.repaint()
 
     def refreshFile(self, image_path: Path):
         """Refresh status for a specific file"""
@@ -638,6 +955,12 @@ class FastFileManager(QWidget):
     def batchUpdateFileStatus(self, image_paths: list[Path]):
         """Batch update file status for multiple files"""
         self._model.batchUpdateFileStatus(image_paths)
+        # Update status counts after batch update
+        if self._current_directory:
+            self._update_detailed_status(self._current_directory.name)
+        # Force table view to repaint immediately
+        self._table_view.viewport().update()
+        self._table_view.repaint()
 
     def getSurroundingFiles(self, current_path: Path, count: int) -> list[Path]:
         """Get files in current sorted/filtered order surrounding the given path"""
@@ -730,6 +1053,27 @@ class FastFileManager(QWidget):
         """Update status label"""
         self._status_label.setText(text)
 
+    def _update_detailed_status(self, directory_name: str):
+        """Update status label with detailed file counts"""
+        total_files, npz_count, txt_count = self._model.getFileCounts()
+
+        if total_files == 0:
+            status_text = f"No files in {directory_name}"
+        else:
+            # Build the status message parts
+            parts = []
+            parts.append(f"{total_files} image{'s' if total_files != 1 else ''}")
+
+            if npz_count > 0:
+                parts.append(f"{npz_count} npz")
+
+            if txt_count > 0:
+                parts.append(f"{txt_count} txt")
+
+            status_text = f"{', '.join(parts)} in {directory_name}"
+
+        self._status_label.setText(status_text)
+
     def selectFile(self, path: Path):
         """Select a specific file in the view"""
         index = self._model.getFileIndex(path)

{lazylabel_gui-1.3.3.dist-info → lazylabel_gui-1.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.3.3
+Version: 1.3.4
 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.3.dist-info → lazylabel_gui-1.3.4.dist-info}/RECORD

@@ -6,19 +6,19 @@ 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=qVPCJdo9KEu9ESujHaWPmlpfVLjyaVXmDe9TmM9c8k4,7282
+lazylabel/core/file_manager.py,sha256=Fs4IJIm2hHvYXeDWR7mqEu2EE21o6qwSPpECv8CYQ3o,7283
 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
 lazylabel/models/sam2_model.py,sha256=lleJ6j7B2k9v4gqhfU7tP_3yxiVGAPTZG5Tq26AwKR4,15612
 lazylabel/models/sam_model.py,sha256=Q1GAaFG6n5JoZXhClcUZKN-gvA_wmtVuUYzELG7zhPg,8833
 lazylabel/ui/__init__.py,sha256=4qDIh9y6tABPmD8MAMGZn_G7oSRyrcHt2HkjoWgbGH4,268
-lazylabel/ui/control_panel.py,sha256=I2Bpij2Xe-4yW1t1iKBS0H3vomuSW_26QvkNhO0mj2I,33140
+lazylabel/ui/control_panel.py,sha256=6WsCX9MzLtYzgi93Yat4utajHHjKuROg_Nf9iGLY05s,33456
 lazylabel/ui/editable_vertex.py,sha256=ofo3r8ZZ3b8oYV40vgzZuS3QnXYBNzE92ArC2wggJOM,5122
 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=rOjzb2nLmbIPbmr7QJuKGXpd1qmvaCPtWP5FAuaU5u0,393283
+lazylabel/ui/main_window.py,sha256=-PgpY1IVqi6p0gj67I_BD44YH6anvA2N1fWTm5wqg_Q,398187
 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
@@ -30,20 +30,20 @@ lazylabel/ui/modes/single_view_mode.py,sha256=khGUXVQ_lv9cCXkOAewQN8iH7R_CPyIVtQ
 lazylabel/ui/widgets/__init__.py,sha256=6VDoMnanqVm3yjOovxie3WggPODuhUsIO75RtxOhQhI,688
 lazylabel/ui/widgets/adjustments_widget.py,sha256=5xldhdEArX3H2P7EmHPjURdwpV-Wa2WULFfspp0gxns,12750
 lazylabel/ui/widgets/border_crop_widget.py,sha256=8NTkHrk_L5_T1psVuXMspVVZRPTTeJyIEYBfVxdGeQA,7529
-lazylabel/ui/widgets/channel_threshold_widget.py,sha256=CSdqiv-x1povttaLn_mY7NtU9IlMBAsZ8RIJo8_GATs,20588
-lazylabel/ui/widgets/fft_threshold_widget.py,sha256=UT4QMMllPezK75hpUC7Fh1QqcD_bSHpn9fZEJCqc968,20630
+lazylabel/ui/widgets/channel_threshold_widget.py,sha256=9KoUK0TytGuSmSU_lO6m8j1zNHx_m9NufgogG0gLYLM,20656
+lazylabel/ui/widgets/fft_threshold_widget.py,sha256=mcbkNoP0aj-Pe57sgIWBnmg4JiEbTikrwG67Vgygnio,20859
 lazylabel/ui/widgets/fragment_threshold_widget.py,sha256=YtToua1eAUtEuJ3EwdCMvI-39TRrFnshkty4tnR4OMU,3492
-lazylabel/ui/widgets/model_selection_widget.py,sha256=mHaVMLOACL7Yc1IVA648OOYBu4yIxb6xnEGPgXTc2Ns,8160
+lazylabel/ui/widgets/model_selection_widget.py,sha256=k4zyhWszi_7e-0TPa0Go1LLPZpTNGtrYSb-yT7uGiVU,8420
 lazylabel/ui/widgets/settings_widget.py,sha256=ShTaLJeXxwrSuTV4kmtV2JiWjfREil2D1nvPUIfAgDs,4859
 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=CwojNwi8VcM2te8hceNuCa0rDaZtEh63Uj4yzHyXq0g,30689
+lazylabel/utils/fast_file_manager.py,sha256=kzbWz_xKufG5bP6sjyZV1fmOKRWPPNeL-xLYZEu_8wE,44697
 lazylabel/utils/logger.py,sha256=R7z6ifgA-NY-9ZbLlNH0i19zzwXndJ_gkG2J1zpVEhg,1306
 lazylabel/utils/utils.py,sha256=sYSCoXL27OaLgOZaUkCAhgmKZ7YfhR3Cc5F8nDIa3Ig,414
-lazylabel_gui-1.3.3.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
-lazylabel_gui-1.3.3.dist-info/METADATA,sha256=Dwol4IiBVsDeqCIyIHPgROMZSWIYWtPkxwbyMUb94b0,6898
-lazylabel_gui-1.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lazylabel_gui-1.3.3.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
-lazylabel_gui-1.3.3.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
-lazylabel_gui-1.3.3.dist-info/RECORD,,
+lazylabel_gui-1.3.4.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
+lazylabel_gui-1.3.4.dist-info/METADATA,sha256=a8ILHz7bYF4Qb0ts_2O3mGc89-6xO8Y85KhomxxsGMk,6898
+lazylabel_gui-1.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lazylabel_gui-1.3.4.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
+lazylabel_gui-1.3.4.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
+lazylabel_gui-1.3.4.dist-info/RECORD,,