napari-tmidas 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

napari_tmidas/_file_selector.py

@@ -558,6 +558,10 @@ class ProcessingWorker(QThread):
         self.stop_requested = False
         self.thread_count = max(1, (os.cpu_count() or 4) - 1)  # Default value
 
+    def stop(self):
+        """Request the worker to stop processing"""
+        self.stop_requested = True
+
     def run(self):
         """Process files in a separate thread"""
         # Track processed files
@@ -585,7 +589,8 @@ class ProcessingWorker(QThread):
                 filepath = future_to_file[future]
                 try:
                     result = future.result()
-                    if result:
+                    # Only process result if it's not None (folder functions may return None)
+                    if result is not None:
                         processed_files_info.append(result)
                         self.file_processed.emit(result)
                 except (
@@ -611,6 +616,16 @@ class ProcessingWorker(QThread):
 
             print(f"Original image shape: {image.shape}, dtype: {image_dtype}")
 
+            # Check if this is a folder-processing function that shouldn't save individual files
+            function_name = getattr(
+                self.processing_func, "__name__", "unknown"
+            )
+            is_folder_function = (
+                "timepoint" in function_name.lower()
+                or "merge" in function_name.lower()
+                or "folder" in function_name.lower()
+            )
+
             # Apply processing with parameters
             processed_image = self.processing_func(image, **self.param_values)
 
@@ -618,6 +633,19 @@ class ProcessingWorker(QThread):
                 f"Processed image shape before removing singletons: {processed_image.shape}, dtype: {processed_image.dtype}"
             )
 
+            # For folder functions, check if the output is the same as input (indicating no individual file should be saved)
+            if is_folder_function:
+                # If the function returns the original image unchanged, it means it handled saving internally
+                if np.array_equal(processed_image, image):
+                    print(
+                        "Folder function returned unchanged image - skipping individual file save"
+                    )
+                    return None  # Return None to indicate no file should be created
+                else:
+                    print(
+                        "Folder function returned different data - will save individual file"
+                    )
+
             # Remove ALL singleton dimensions from the processed image
             # This will keep only dimensions with size > 1
             processed_image = np.squeeze(processed_image)
@@ -629,9 +657,12 @@ class ProcessingWorker(QThread):
             # Generate new filename base
             filename = os.path.basename(filepath)
             name, ext = os.path.splitext(filename)
-            new_filename_base = (
-                name.replace(self.input_suffix, "") + self.output_suffix
-            )
+            if name.endswith(self.input_suffix):
+                new_filename_base = (
+                    name[: -len(self.input_suffix)] + self.output_suffix
+                )
+            else:
+                new_filename_base = name + self.output_suffix
 
             # Check if the first dimension should be treated as channels
             # If processed_image has more dimensions than the original image,
@@ -755,13 +786,8 @@ class ProcessingWorker(QThread):
                     "labels" in new_filename_base
                     or "semantic" in new_filename_base
                 ):
-                    # Choose appropriate integer type based on data range
-                    if data_max <= 255:
-                        save_dtype = np.uint8
-                    elif data_max <= 65535:
-                        save_dtype = np.uint16
-                    else:
-                        save_dtype = np.uint32
+
+                    save_dtype = np.uint32
 
                     print(
                         f"Saving label image as {save_dtype.__name__} with bigtiff={use_bigtiff}"
@@ -939,9 +965,49 @@ class FileResultsWidget(QWidget):
 
         # Update description
         description = function_info.get("description", "")
-        self.function_description.setText(description)
 
-        # Update parameters
+        # Check if this is a folder-processing function that needs single threading
+        is_folder_function = (
+            "folder" in function_name.lower()
+            or "timepoint" in function_name.lower()
+            or "merge" in function_name.lower()
+            or "folder" in description.lower()
+            or "cellpose" in description.lower()
+            or "careamics" in description.lower()
+            or "trackastra" in description.lower()
+        )
+
+        # Disable threading controls for folder functions
+        if is_folder_function:
+            self.thread_count.setValue(1)
+            self.thread_count.setEnabled(False)
+            self.thread_count.setToolTip(
+                "This function processes entire folders and must run with 1 thread only."
+            )
+
+            # Add warning to description if not already present
+            if (
+                "IMPORTANT:" not in description
+                and "WARNING:" not in description
+            ):
+                description += "\nThis function has to run single-threaded."
+
+            self.function_description.setText(description)
+
+            # Change the description color to make it more prominent
+            self.function_description.setStyleSheet(
+                "QLabel { color: #ff6b00; font-weight: bold; }"
+            )
+        else:
+            # Re-enable threading controls for normal functions
+            self.thread_count.setEnabled(True)
+            self.thread_count.setToolTip(
+                "Number of threads to use for parallel processing"
+            )
+            self.function_description.setStyleSheet("")  # Reset styling
+            self.function_description.setText(description)
+
+        # Get parameters
         parameters = function_info.get("parameters", {})
 
         # Remove old parameters widget if it exists
@@ -1014,6 +1080,23 @@ class FileResultsWidget(QWidget):
         self.batch_button.setEnabled(False)
         self.cancel_button.setEnabled(True)
 
+        # Set thread count based on function properties
+        worker_thread_count = self.thread_count.value()
+
+        # Check if function should run single-threaded
+        if (
+            hasattr(processing_func, "thread_safe")
+            and not processing_func.thread_safe
+        ):
+            worker_thread_count = 1
+            self.viewer.status = (
+                "Processing with a single thread (function is not thread-safe)"
+            )
+        else:
+            self.viewer.status = (
+                f"Processing with {worker_thread_count} threads"
+            )
+
         # Create and start the worker thread
         self.worker = ProcessingWorker(
             self.file_list,
@@ -1024,8 +1107,8 @@ class FileResultsWidget(QWidget):
             output_suffix,
         )
 
-        # Set the thread count from the UI
-        self.worker.thread_count = self.thread_count.value()
+        # Set the thread count from the UI or function attribute
+        self.worker.thread_count = worker_thread_count
 
         # Connect signals
         self.worker.progress_updated.connect(self.update_progress)
@@ -1037,7 +1120,7 @@ class FileResultsWidget(QWidget):
         self.worker.start()
 
         # Update status
-        self.viewer.status = f"Processing {len(self.file_list)} files with {selected_function_name} using {self.thread_count.value()} threads"
+        self.viewer.status = f"Processing {len(self.file_list)} files with {selected_function_name} using {worker_thread_count} threads"
 
     def update_progress(self, value):
         """Update the progress bar"""

napari_tmidas/_registry.py

@@ -2,6 +2,7 @@
 """
 Registry for batch processing functions.
 """
+import threading
 from typing import Any, Dict, List, Optional
 
 
@@ -11,6 +12,7 @@ class BatchProcessingRegistry:
     """
 
     _processing_functions = {}
+    _lock = threading.RLock()  # Add thread lock
 
     @classmethod
     def register(
@@ -43,26 +45,25 @@ class BatchProcessingRegistry:
             parameters = {}
 
         def decorator(func):
-            cls._processing_functions[name] = {
-                "func": func,
-                "suffix": suffix,
-                "description": description,
-                "parameters": parameters,
-            }
+            with cls._lock:  # Thread-safe registration
+                cls._processing_functions[name] = {
+                    "func": func,
+                    "suffix": suffix,
+                    "description": description,
+                    "parameters": parameters,
+                }
             return func
 
         return decorator
 
     @classmethod
     def get_function_info(cls, name: str) -> Optional[dict]:
-        """
-        Retrieve a registered processing function and its metadata
-        """
-        return cls._processing_functions.get(name)
+        """Thread-safe retrieval"""
+        with cls._lock:
+            return cls._processing_functions.get(name)
 
     @classmethod
     def list_functions(cls) -> List[str]:
-        """
-        List all registered processing function names
-        """
-        return list(cls._processing_functions.keys())
+        """Thread-safe listing"""
+        with cls._lock:
+            return list(cls._processing_functions.keys())

napari_tmidas/_tests/test_file_selector.py

@@ -0,0 +1,90 @@
+# src/napari_tmidas/_tests/test_file_selector.py
+import os
+import tempfile
+from unittest.mock import Mock
+
+import numpy as np
+
+from napari_tmidas._file_selector import ProcessingWorker, file_selector
+from napari_tmidas._registry import BatchProcessingRegistry
+
+
+class TestProcessingWorker:
+    def setup_method(self):
+        """Setup test environment"""
+        self.temp_dir = tempfile.mkdtemp()
+        BatchProcessingRegistry._processing_functions.clear()
+
+        # Register a test function
+        @BatchProcessingRegistry.register(name="Test Process", suffix="_proc")
+        def test_process(image):
+            return image * 2
+
+        self.test_func = BatchProcessingRegistry.get_function_info(
+            "Test Process"
+        )["func"]
+
+    def teardown_method(self):
+        """Cleanup"""
+        import shutil
+
+        shutil.rmtree(self.temp_dir)
+
+    def test_process_file(self):
+        """Test processing a single file"""
+        # Create test image
+        test_image = np.random.rand(100, 100)
+        input_path = os.path.join(self.temp_dir, "test.tif")
+
+        import tifffile
+
+        tifffile.imwrite(input_path, test_image)
+
+        # Create worker
+        worker = ProcessingWorker(
+            [input_path], self.test_func, {}, self.temp_dir, "", "_proc"
+        )
+
+        # Process file
+        result = worker.process_file(input_path)
+
+        assert result is not None
+        assert "original_file" in result
+        assert "processed_file" in result
+        assert os.path.exists(result["processed_file"])
+
+    def test_multi_channel_output(self):
+        """Test processing that outputs multiple channels"""
+
+        @BatchProcessingRegistry.register(
+            name="Split Channels", suffix="_split"
+        )
+        def split_channels(image):
+            return np.stack([image, image * 2, image * 3])
+
+        test_image = np.random.rand(100, 100)
+        input_path = os.path.join(self.temp_dir, "test.tif")
+
+        import tifffile
+
+        tifffile.imwrite(input_path, test_image)
+
+        func_info = BatchProcessingRegistry.get_function_info("Split Channels")
+        worker = ProcessingWorker(
+            [input_path], func_info["func"], {}, self.temp_dir, "", "_split"
+        )
+
+        result = worker.process_file(input_path)
+
+        assert "processed_files" in result
+        assert len(result["processed_files"]) == 3
+
+
+class TestFileSelector:
+    def test_file_selector_widget_creation(self):
+        """Test that file selector widget is created properly"""
+        viewer_mock = Mock()
+
+        # Test the widget can be called
+        result = file_selector(viewer_mock, "/tmp", ".tif")
+        assert isinstance(result, list)

napari_tmidas/_tests/test_registry.py

@@ -0,0 +1,67 @@
+# src/napari_tmidas/_tests/test_registry.py
+from napari_tmidas._registry import BatchProcessingRegistry
+
+
+class TestBatchProcessingRegistry:
+    def setup_method(self):
+        """Clear registry before each test"""
+        BatchProcessingRegistry._processing_functions.clear()
+
+    def test_register_function(self):
+        """Test registering a processing function"""
+
+        @BatchProcessingRegistry.register(
+            name="Test Function",
+            suffix="_test",
+            description="Test description",
+            parameters={"param1": {"type": int, "default": 5}},
+        )
+        def test_func(image, param1=5):
+            return image + param1
+
+        assert "Test Function" in BatchProcessingRegistry.list_functions()
+        info = BatchProcessingRegistry.get_function_info("Test Function")
+        assert info["suffix"] == "_test"
+        assert info["description"] == "Test description"
+        assert info["func"] == test_func
+
+    def test_list_functions(self):
+        """Test listing registered functions"""
+
+        @BatchProcessingRegistry.register(name="Func1")
+        def func1(image):
+            return image
+
+        @BatchProcessingRegistry.register(name="Func2")
+        def func2(image):
+            return image
+
+        functions = BatchProcessingRegistry.list_functions()
+        assert len(functions) == 2
+        assert "Func1" in functions
+        assert "Func2" in functions
+
+    def test_thread_safety(self):
+        """Test thread-safe registration"""
+        import threading
+
+        results = []
+
+        def register_func(i):
+            @BatchProcessingRegistry.register(name=f"ThreadFunc{i}")
+            def func(image):
+                return image
+
+            results.append(i)
+
+        threads = [
+            threading.Thread(target=register_func, args=(i,))
+            for i in range(10)
+        ]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        assert len(results) == 10
+        assert len(BatchProcessingRegistry.list_functions()) == 10

napari_tmidas/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.2'
+__version_tuple__ = version_tuple = (0, 2, 2)