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

napari_tmidas/_tests/test_crop_anything.py

@@ -0,0 +1,123 @@
+# src/napari_tmidas/_tests/test_crop_anything.py
+from unittest.mock import Mock, patch
+
+from napari_tmidas._crop_anything import batch_crop_anything_widget
+
+
+class TestBatchCropAnythingWidget:
+    def test_widget_creation(self):
+        """Test that the batch crop anything widget is created properly"""
+        widget = batch_crop_anything_widget()
+        assert widget is not None
+        # Check that it has the expected attributes
+        assert hasattr(widget, "folder_path")
+        assert hasattr(widget, "data_dimensions")
+        # viewer is a parameter but may not be exposed as attribute
+        assert hasattr(widget, "call_button")  # magicgui adds this
+
+    @patch("napari_tmidas._crop_anything.batch_crop_anything")
+    def test_widget_has_browse_button(self, mock_batch_crop):
+        """Test that the widget has a browse button added"""
+        mock_widget = Mock()
+        mock_widget.folder_path = Mock()
+        mock_widget.folder_path.native = Mock()
+        mock_widget.folder_path.native.parent.return_value.layout.return_value = (
+            Mock()
+        )
+        mock_widget.folder_path.value = "/test/path"
+
+        mock_batch_crop.return_value = mock_widget
+
+        batch_crop_anything_widget()
+
+        # The browse button should be added to the layout
+        # This is hard to test directly without mocking Qt, but we can check the function exists
+        assert callable(batch_crop_anything_widget)
+
+    @patch("napari_tmidas._crop_anything.BatchCropAnything")
+    @patch("napari_tmidas._crop_anything.magicgui")
+    def test_widget_creation_safe(self, mock_magicgui, mock_batch_crop):
+        """Test widget creation with BatchCropAnything mocked to avoid any SAM2 issues"""
+        # Mock the BatchCropAnything class to avoid any SAM2 initialization
+        mock_instance = Mock()
+        mock_batch_crop.return_value = mock_instance
+
+        # Mock magicgui to return a simple widget
+        mock_widget = Mock()
+        mock_magicgui.return_value = mock_widget
+
+        # This should be completely safe since everything is mocked
+        widget = batch_crop_anything_widget()
+        assert widget is not None
+
+    def test_next_image_at_last_image(self):
+        """Test that next_image returns False when already at the last image"""
+        from napari_tmidas._crop_anything import BatchCropAnything
+
+        # Create a mock viewer
+        mock_viewer = Mock()
+        mock_viewer.layers = Mock()
+        mock_viewer.layers.clear = Mock()
+
+        # Create processor with mocked predictor to avoid SAM2 initialization
+        with patch.object(BatchCropAnything, "_initialize_sam2"):
+            processor = BatchCropAnything(mock_viewer, use_3d=False)
+            processor.predictor = (
+                None  # Ensure predictor is None to skip segmentation
+            )
+
+        # Set up test data with 3 images
+        processor.images = [
+            "/path/img1.tif",
+            "/path/img2.tif",
+            "/path/img3.tif",
+        ]
+        processor.current_index = 2  # At the last image (index 2 of 3 images)
+
+        # Try to move to next image when already at the last one
+        result = processor.next_image()
+
+        # Should return False
+        assert result is False
+
+        # Current index should not change
+        assert processor.current_index == 2
+
+        # Layers should not have been cleared (no call to _load_current_image)
+        mock_viewer.layers.clear.assert_not_called()
+
+    def test_prev_image_at_first_image(self):
+        """Test that previous_image returns False when already at the first image"""
+        from napari_tmidas._crop_anything import BatchCropAnything
+
+        # Create a mock viewer
+        mock_viewer = Mock()
+        mock_viewer.layers = Mock()
+        mock_viewer.layers.clear = Mock()
+
+        # Create processor with mocked predictor to avoid SAM2 initialization
+        with patch.object(BatchCropAnything, "_initialize_sam2"):
+            processor = BatchCropAnything(mock_viewer, use_3d=False)
+            processor.predictor = (
+                None  # Ensure predictor is None to skip segmentation
+            )
+
+        # Set up test data with 3 images
+        processor.images = [
+            "/path/img1.tif",
+            "/path/img2.tif",
+            "/path/img3.tif",
+        ]
+        processor.current_index = 0  # At the first image (index 0)
+
+        # Try to move to previous image when already at the first one
+        result = processor.previous_image()
+
+        # Should return False
+        assert result is False
+
+        # Current index should not change
+        assert processor.current_index == 0
+
+        # Layers should not have been cleared (no call to _load_current_image)
+        mock_viewer.layers.clear.assert_not_called()

napari_tmidas/_tests/test_env_manager.py

@@ -0,0 +1,89 @@
+# src/napari_tmidas/_tests/test_env_manager.py
+import tempfile
+from unittest.mock import Mock, patch
+
+from napari_tmidas._env_manager import BaseEnvironmentManager
+
+
+class MockEnvironmentManager(BaseEnvironmentManager):
+    """Test implementation of BaseEnvironmentManager."""
+
+    def __init__(self):
+        super().__init__("test-env")
+
+    def _install_dependencies(self, env_python: str) -> None:
+        """Mock installation."""
+
+    def is_package_installed(self) -> bool:
+        """Mock package check."""
+        return True
+
+
+class TestBaseEnvironmentManager:
+    def setup_method(self):
+        """Setup test environment"""
+        self.temp_dir = tempfile.mkdtemp()
+        self.manager = MockEnvironmentManager()
+
+    def teardown_method(self):
+        """Cleanup"""
+        import shutil
+
+        shutil.rmtree(self.temp_dir)
+
+    def test_initialization(self):
+        """Test manager initialization"""
+        assert self.manager.env_name == "test-env"
+        assert "test-env" in self.manager.env_dir
+
+    def test_is_env_created_false(self):
+        """Test is_env_created returns False when env doesn't exist"""
+        assert not self.manager.is_env_created()
+
+    @patch("napari_tmidas._env_manager.venv.create")
+    @patch("napari_tmidas._env_manager.subprocess.check_call")
+    def test_create_env(self, mock_subprocess, mock_venv):
+        """Test environment creation"""
+        env_python = self.manager.create_env()
+
+        # Check that venv.create was called
+        mock_venv.assert_called_once()
+
+        # Check that pip upgrade was called
+        mock_subprocess.assert_called()
+
+        # Check that the returned path is correct
+        assert env_python == self.manager.get_env_python_path()
+
+    def test_get_env_python_path_linux(self):
+        """Test getting Python path on Linux"""
+        with patch(
+            "napari_tmidas._env_manager.platform.system", return_value="Linux"
+        ):
+            path = self.manager.get_env_python_path()
+            import os
+
+            norm = os.path.normpath(path)
+            assert os.path.join("bin", "python") in norm
+
+    def test_get_env_python_path_windows(self):
+        """Test getting Python path on Windows"""
+        with patch(
+            "napari_tmidas._env_manager.platform.system",
+            return_value="Windows",
+        ):
+            path = self.manager.get_env_python_path()
+            assert "Scripts" in path and "python.exe" in path
+
+    def test_is_package_installed(self):
+        """Test package installation check"""
+        assert self.manager.is_package_installed()
+
+    @patch("napari_tmidas._env_manager.subprocess.run")
+    def test_run_in_env(self, mock_subprocess):
+        """Test running command in environment"""
+        mock_subprocess.return_value = Mock()
+        result = self.manager.run_in_env("print('test')")
+
+        mock_subprocess.assert_called_once()
+        assert result is not None

napari_tmidas/_tests/test_grid_view_overlay.py

@@ -0,0 +1,193 @@
+"""Tests for grid view overlay processing function."""
+
+import numpy as np
+import pytest
+
+try:
+    from napari_tmidas.processing_functions.grid_view_overlay import (
+        _create_grid,
+        _create_overlay,
+        _get_intensity_filename,
+    )
+
+    GRID_OVERLAY_AVAILABLE = True
+except ImportError:
+    GRID_OVERLAY_AVAILABLE = False
+
+
+@pytest.mark.skipif(
+    not GRID_OVERLAY_AVAILABLE, reason="Grid overlay function not available"
+)
+def test_get_intensity_filename():
+    """Test intensity filename extraction from label filenames."""
+    assert (
+        _get_intensity_filename("test_convpaint_labels_filtered.tif")
+        == "test.tif"
+    )
+    assert _get_intensity_filename("test_labels.tif") == "test.tif"
+    assert _get_intensity_filename("test_labels_filtered.tif") == "test.tif"
+    assert _get_intensity_filename("test_intensity_filtered.tif") == "test.tif"
+    assert _get_intensity_filename("unknown.tif") == "unknown.tif"
+
+
+@pytest.mark.skipif(
+    not GRID_OVERLAY_AVAILABLE, reason="Grid overlay function not available"
+)
+def test_create_overlay():
+    """Test overlay creation with intensity and labels."""
+    # Create simple test images
+    intensity = np.random.randint(0, 255, (100, 100), dtype=np.uint8)
+    labels = np.zeros((100, 100), dtype=np.uint16)
+    labels[20:40, 20:40] = 1
+    labels[60:80, 60:80] = 2
+
+    # Create overlay without downsampling (with overlay enabled)
+    overlay = _create_overlay(intensity, labels, show_overlay=True)
+
+    # Check output
+    assert overlay.shape == (100, 100, 3)
+    assert overlay.dtype == np.uint8
+    assert overlay.min() >= 0
+    assert overlay.max() <= 255
+
+
+@pytest.mark.skipif(
+    not GRID_OVERLAY_AVAILABLE, reason="Grid overlay function not available"
+)
+def test_create_overlay_with_downsampling():
+    """Test overlay creation with downsampling."""
+    # Create larger test images
+    intensity = np.random.randint(0, 255, (1000, 1000), dtype=np.uint8)
+    labels = np.zeros((1000, 1000), dtype=np.uint16)
+    labels[200:400, 200:400] = 1
+    labels[600:800, 600:800] = 2
+
+    # Create overlay with downsampling to 300px
+    overlay = _create_overlay(
+        intensity, labels, target_size=300, show_overlay=True
+    )
+
+    # Check output is downsampled
+    assert overlay.shape[0] <= 300
+    assert overlay.shape[1] <= 300
+    assert overlay.shape[2] == 3
+    assert overlay.dtype == np.uint8
+    assert overlay.min() >= 0
+    assert overlay.max() <= 255
+
+
+@pytest.mark.skipif(
+    not GRID_OVERLAY_AVAILABLE, reason="Grid overlay function not available"
+)
+def test_create_grid():
+    """Test grid creation from multiple images."""
+    # Create test images
+    images = [
+        np.random.randint(0, 255, (50, 50, 3), dtype=np.uint8)
+        for _ in range(6)
+    ]
+
+    # Create grid with 3 columns (should be 2 rows)
+    grid = _create_grid(images, grid_cols=3)
+
+    # Check output
+    assert grid.shape == (
+        100,
+        150,
+        3,
+    )  # 2 rows * 50px, 3 cols * 50px, 3 channels
+    assert grid.dtype == np.uint8
+
+
+@pytest.mark.skipif(
+    not GRID_OVERLAY_AVAILABLE, reason="Grid overlay function not available"
+)
+def test_create_grid_grayscale():
+    """Test grid creation with grayscale images."""
+    # Create grayscale test images
+    images = [
+        np.random.randint(0, 255, (50, 50), dtype=np.uint8) for _ in range(4)
+    ]
+
+    # Create grid with 2 columns
+    grid = _create_grid(images, grid_cols=2)
+
+    # Check output
+    assert grid.shape == (100, 100)  # 2 rows * 50px, 2 cols * 50px
+    assert grid.dtype == np.uint8
+
+
+@pytest.mark.skipif(
+    not GRID_OVERLAY_AVAILABLE, reason="Grid overlay function not available"
+)
+def test_create_grid_empty():
+    """Test grid creation with empty list."""
+    grid = _create_grid([], grid_cols=4)
+    assert grid is None
+
+
+@pytest.mark.skipif(
+    not GRID_OVERLAY_AVAILABLE, reason="Grid overlay function not available"
+)
+def test_create_overlay_intensity_only():
+    """Test overlay creation with intensity only (no label overlay)."""
+    # Create simple test images
+    intensity = np.random.randint(0, 255, (100, 100), dtype=np.uint8)
+    labels = np.zeros((100, 100), dtype=np.uint16)
+    labels[20:40, 20:40] = 1
+    labels[60:80, 60:80] = 2
+
+    # Create overlay with overlay disabled (intensity only)
+    overlay = _create_overlay(intensity, labels, show_overlay=False)
+
+    # Check output - should be grayscale RGB (all channels equal)
+    assert overlay.shape == (100, 100, 3)
+    assert overlay.dtype == np.uint8
+    assert overlay.min() >= 0
+    assert overlay.max() <= 255
+
+    # Check that all channels are equal (grayscale)
+    assert np.array_equal(overlay[:, :, 0], overlay[:, :, 1])
+    assert np.array_equal(overlay[:, :, 1], overlay[:, :, 2])
+
+
+@pytest.mark.skipif(
+    not GRID_OVERLAY_AVAILABLE, reason="Grid overlay function not available"
+)
+def test_create_overlay_with_and_without_labels():
+    """Test that overlay mode creates different outputs with labels."""
+    # Create test images with labels
+    intensity = np.random.randint(0, 255, (100, 100), dtype=np.uint8)
+    labels = np.zeros((100, 100), dtype=np.uint16)
+    labels[20:40, 20:40] = 1
+    labels[60:80, 60:80] = 2
+
+    # Create overlay with labels
+    overlay_with_labels = _create_overlay(intensity, labels, show_overlay=True)
+
+    # Create overlay without labels (intensity only)
+    overlay_intensity_only = _create_overlay(
+        intensity, labels, show_overlay=False
+    )
+
+    # Both should have same shape
+    assert overlay_with_labels.shape == overlay_intensity_only.shape
+
+    # But different content (overlay should have colored regions)
+    # In the intensity-only version, all channels should be equal
+    assert np.array_equal(
+        overlay_intensity_only[:, :, 0], overlay_intensity_only[:, :, 1]
+    )
+
+    # In the overlay version, channels should differ in labeled regions
+    # Check the labeled region [20:40, 20:40]
+    labeled_region_r = overlay_with_labels[20:40, 20:40, 0]
+    labeled_region_g = overlay_with_labels[20:40, 20:40, 1]
+    labeled_region_b = overlay_with_labels[20:40, 20:40, 2]
+
+    # At least one channel pair should differ in the labeled region
+    assert (
+        not np.array_equal(labeled_region_r, labeled_region_g)
+        or not np.array_equal(labeled_region_g, labeled_region_b)
+        or not np.array_equal(labeled_region_r, labeled_region_b)
+    )

napari_tmidas/_tests/test_init.py

@@ -0,0 +1,98 @@
+# src/napari_tmidas/_tests/test_init.py
+import os
+import sys
+
+import pytest
+
+from napari_tmidas import (
+    __version__,
+    batch_crop_anything_widget,
+    file_selector,
+    label_inspector_widget,
+    make_sample_data,
+    napari_get_reader,
+    roi_colocalization_analyzer,
+    write_multiple,
+    write_single_image,
+)
+
+
+class TestInit:
+    @pytest.mark.skipif(
+        sys.platform == "win32" and os.environ.get("CI") == "true",
+        reason="Version is 'unknown' on Windows CI when skip_install=true",
+    )
+    def test_version_import(self):
+        """Test that version is imported correctly"""
+        # Version should be a string
+        assert isinstance(__version__, str)
+        # Should not be "unknown" in normal operation
+        assert __version__ != "unknown"
+
+    def test_core_exports_available(self):
+        """Test that core exports are always available"""
+        # These should always be importable
+        assert napari_get_reader is not None
+        assert write_single_image is not None
+        assert write_multiple is not None
+        assert make_sample_data is not None
+        assert file_selector is not None
+
+    def test_optional_exports(self):
+        """Test optional exports (may be None on some platforms)"""
+        # These might be None if dependencies fail to load on Windows
+        # but we should at least be able to import them
+        assert (
+            label_inspector_widget is not None
+            or label_inspector_widget is None
+        )
+        assert (
+            roi_colocalization_analyzer is not None
+            or roi_colocalization_analyzer is None
+        )
+        assert (
+            batch_crop_anything_widget is not None
+            or batch_crop_anything_widget is None
+        )
+
+    def test_imports_dont_crash(self):
+        """Test that imports don't cause crashes on any platform"""
+        # This test will pass as long as the imports above didn't crash
+        # which is the main issue we're trying to solve on Windows
+        assert True
+        assert make_sample_data is not None
+        assert file_selector is not None
+        assert label_inspector_widget is not None
+        assert batch_crop_anything_widget is not None
+        assert roi_colocalization_analyzer is not None
+
+    def test_functions_are_callable(self):
+        """Test that exported functions are callable"""
+        # These should be callable objects
+        assert callable(napari_get_reader)
+        assert callable(write_single_image)
+        assert callable(write_multiple)
+        assert callable(make_sample_data)
+        assert callable(file_selector)
+        assert callable(label_inspector_widget)
+        assert callable(batch_crop_anything_widget)
+
+    def test_version_fallback(self):
+        """Test version fallback when _version import fails"""
+        import sys
+        from unittest.mock import patch
+
+        # Mock import failure
+        with patch.dict("sys.modules", {"napari_tmidas._version": None}):
+            # Force reimport
+            if "napari_tmidas" in sys.modules:
+                del sys.modules["napari_tmidas"]
+
+            # This should trigger the fallback
+            try:
+                import napari_tmidas
+
+                # Version should be "unknown" when import fails
+                assert napari_tmidas.__version__ == "unknown"
+            except ImportError:
+                pass  # Expected if other imports fail