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

napari_tmidas/_tests/test_spotiflow.py

@@ -0,0 +1,87 @@
+"""
+Test module for Spotiflow processing functions.
+"""
+
+import subprocess
+
+import numpy as np
+import pytest
+
+from napari_tmidas.processing_functions.spotiflow_env_manager import (
+    SpotiflowEnvironmentManager,
+    is_env_created,
+    is_spotiflow_installed,
+)
+
+
+def test_spotiflow_env_manager_init():
+    """Test SpotiflowEnvironmentManager initialization."""
+    manager = SpotiflowEnvironmentManager()
+    assert manager.env_name == "spotiflow"
+    assert "spotiflow" in manager.env_dir
+
+
+def test_is_spotiflow_installed():
+    """Test spotiflow installation check."""
+    # This will likely be False in most test environments
+    result = is_spotiflow_installed()
+    assert isinstance(result, bool)
+
+
+def test_is_env_created():
+    """Test environment creation check."""
+    result = is_env_created()
+    assert isinstance(result, bool)
+
+
+@pytest.mark.slow
+def test_spotiflow_detection_import():
+    """Test importing the spotiflow detection module."""
+    try:
+        from napari_tmidas.processing_functions import spotiflow_detection
+
+        assert hasattr(spotiflow_detection, "spotiflow_detect_spots")
+    except ImportError:
+        pytest.skip("Spotiflow detection module not available")
+
+
+@pytest.mark.slow
+def test_spotiflow_detection_with_synthetic_data():
+    """Test spot detection with synthetic data."""
+    try:
+        from napari_tmidas.processing_functions.spotiflow_detection import (
+            spotiflow_detect_spots,
+        )
+
+        # Create synthetic 2D image with some bright spots
+        image = np.zeros((100, 100), dtype=np.uint16)
+        # Add some bright spots
+        image[25:27, 25:27] = 1000
+        image[75:77, 75:77] = 1200
+        image[50:52, 25:27] = 800
+
+        # Add some noise
+        image = image + np.random.normal(0, 50, image.shape).astype(np.uint16)
+
+        # Test detection (this will likely use the dedicated environment)
+        points = spotiflow_detect_spots(
+            image, pretrained_model="general", force_dedicated_env=True
+        )
+
+        # Should return an array of points
+        assert isinstance(points, np.ndarray)
+        assert points.ndim == 2
+        assert points.shape[1] == 2  # 2D coordinates
+
+    except ImportError:
+        pytest.skip("Spotiflow not available for testing")
+    except (RuntimeError, subprocess.CalledProcessError) as e:
+        pytest.skip(f"Spotiflow test failed: {e}")
+
+
+if __name__ == "__main__":
+    # Run basic tests
+    test_spotiflow_env_manager_init()
+    test_is_spotiflow_installed()
+    test_is_env_created()
+    print("Basic Spotiflow tests passed!")

napari_tmidas/_tests/test_tyx_display_fix.py

@@ -0,0 +1,142 @@
+"""Test TYX image display bug fix"""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+
+class TestTYXDisplayFix:
+    """Test the fix for TYX images being incorrectly displayed"""
+
+    def test_channel_detection_rgb(self):
+        """RGB images (3 channels) should be detected as multi-channel"""
+        shape = (3, 100, 100)
+        # Simulate the detection logic
+        is_multi_channel = len(shape) > 2 and shape[0] <= 4 and shape[0] > 1
+        assert (
+            is_multi_channel
+        ), "RGB image should be detected as multi-channel"
+
+    def test_channel_detection_rgba(self):
+        """RGBA images (4 channels) should be detected as multi-channel"""
+        shape = (4, 100, 100)
+        is_multi_channel = len(shape) > 2 and shape[0] <= 4 and shape[0] > 1
+        assert (
+            is_multi_channel
+        ), "RGBA image should be detected as multi-channel"
+
+    def test_channel_detection_tyx(self):
+        """TYX time series (5+ timepoints) should NOT be detected as multi-channel"""
+        shape = (5, 100, 100)
+        is_multi_channel = len(shape) > 2 and shape[0] <= 4 and shape[0] > 1
+        assert (
+            not is_multi_channel
+        ), "TYX time series should NOT be detected as multi-channel"
+
+    def test_channel_detection_zyx(self):
+        """ZYX z-stacks (10+ slices) should NOT be detected as multi-channel"""
+        shape = (10, 100, 100)
+        is_multi_channel = len(shape) > 2 and shape[0] <= 4 and shape[0] > 1
+        assert (
+            not is_multi_channel
+        ), "ZYX z-stack should NOT be detected as multi-channel"
+
+    def test_channel_detection_dual_channel(self):
+        """2-channel images should be detected as multi-channel"""
+        shape = (2, 100, 100)
+        is_multi_channel = len(shape) > 2 and shape[0] <= 4 and shape[0] > 1
+        assert (
+            is_multi_channel
+        ), "2-channel image should be detected as multi-channel"
+
+    def test_3d_view_not_enabled_for_tyx(self):
+        """TYX time series should use 2D view, not 3D view"""
+        shape = (5, 100, 100)
+
+        # Simulate the 3D view detection logic
+        if shape[0] >= 2 and shape[0] <= 4:
+            meaningful_dims = shape[1:]
+        else:
+            meaningful_dims = shape
+
+        # Check if 3D view would be enabled
+        enable_3d = False
+        if len(meaningful_dims) >= 4:
+            z_dim = meaningful_dims[1]
+            enable_3d = z_dim > 1
+        elif len(meaningful_dims) == 3:
+            first_dim = meaningful_dims[0]
+            enable_3d = first_dim > 10
+
+        assert not enable_3d, "TYX with 5 timepoints should NOT enable 3D view"
+
+    def test_3d_view_enabled_for_large_zyx(self):
+        """Large ZYX z-stacks should enable 3D view"""
+        shape = (20, 100, 100)
+
+        # Simulate the 3D view detection logic
+        if shape[0] >= 2 and shape[0] <= 4:
+            meaningful_dims = shape[1:]
+        else:
+            meaningful_dims = shape
+
+        enable_3d = False
+        if len(meaningful_dims) >= 4:
+            z_dim = meaningful_dims[1]
+            enable_3d = z_dim > 1
+        elif len(meaningful_dims) == 3:
+            first_dim = meaningful_dims[0]
+            enable_3d = first_dim > 10
+
+        assert enable_3d, "ZYX with 20 slices should enable 3D view"
+
+    def test_3d_view_enabled_for_tzyx(self):
+        """TZYX data should enable 3D view"""
+        shape = (10, 50, 100, 100)
+
+        # Simulate the 3D view detection logic
+        if shape[0] >= 2 and shape[0] <= 4:
+            meaningful_dims = shape[1:]
+        else:
+            meaningful_dims = shape
+
+        enable_3d = False
+        if len(meaningful_dims) >= 4:
+            z_dim = meaningful_dims[1]
+            enable_3d = z_dim > 1
+        elif len(meaningful_dims) == 3:
+            first_dim = meaningful_dims[0]
+            enable_3d = first_dim > 10
+
+        assert enable_3d, "TZYX data should enable 3D view"
+
+    def test_3d_view_not_enabled_for_rgb_channels(self):
+        """After splitting RGB, individual channels should use 2D view"""
+        shape = (
+            3,
+            100,
+            100,
+        )  # This would be seen after channel splitting doesn't occur
+
+        # Simulate the 3D view detection logic
+        if shape[0] >= 2 and shape[0] <= 4:
+            meaningful_dims = shape[1:]
+        else:
+            meaningful_dims = shape
+
+        enable_3d = False
+        if len(meaningful_dims) >= 4:
+            z_dim = meaningful_dims[1]
+            enable_3d = z_dim > 1
+        elif len(meaningful_dims) == 3:
+            first_dim = meaningful_dims[0]
+            enable_3d = first_dim > 10
+
+        assert not enable_3d, "RGB channels should use 2D view"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

napari_tmidas/_tests/test_ui_utils.py

@@ -0,0 +1,68 @@
+# src/napari_tmidas/_tests/test_ui_utils.py
+from unittest.mock import Mock
+
+from napari_tmidas._ui_utils import add_browse_button_to_folder_field
+
+
+class TestUIUtils:
+    def test_add_browse_button_to_folder_field(self):
+        """Test adding browse button to a folder field"""
+        # Create mock widget
+        mock_widget = Mock()
+        mock_folder_field = Mock()
+        mock_folder_field.value = "/test/path"
+        mock_folder_field.native = Mock()
+        mock_parent = Mock()
+        mock_layout = Mock()
+        mock_parent.layout.return_value = mock_layout
+        mock_folder_field.native.parent.return_value = mock_parent
+
+        mock_widget.folder_path = mock_folder_field
+
+        # Call the function
+        result = add_browse_button_to_folder_field(mock_widget, "folder_path")
+        assert result == mock_widget
+
+    def test_add_browse_button_with_existing_value(self):
+        """Test adding browse button when folder field has existing value"""
+        # Create mock widget
+        mock_widget = Mock()
+        mock_folder_field = Mock()
+        mock_folder_field.value = "/existing/path"
+        mock_folder_field.native = Mock()
+        mock_parent = Mock()
+        mock_layout = Mock()
+        mock_parent.layout.return_value = mock_layout
+        mock_folder_field.native.parent.return_value = mock_parent
+
+        mock_widget.existing_path = mock_folder_field
+
+        # Call the function
+        result = add_browse_button_to_folder_field(
+            mock_widget, "existing_path"
+        )
+
+        # Check that the button was added to the layout
+        mock_layout.addWidget.assert_called_once()
+        assert result == mock_widget
+
+    def test_add_browse_button_with_empty_value(self):
+        """Test adding browse button when folder field is empty"""
+        # Create mock widget
+        mock_widget = Mock()
+        mock_folder_field = Mock()
+        mock_folder_field.value = ""  # Empty value
+        mock_folder_field.native = Mock()
+        mock_parent = Mock()
+        mock_layout = Mock()
+        mock_parent.layout.return_value = mock_layout
+        mock_folder_field.native.parent.return_value = mock_parent
+
+        mock_widget.empty_path = mock_folder_field
+
+        # Call the function
+        result = add_browse_button_to_folder_field(mock_widget, "empty_path")
+
+        # Check that the button was added to the layout
+        mock_layout.addWidget.assert_called_once()
+        assert result == mock_widget

napari_tmidas/_tests/test_widget.py

@@ -1,4 +1,8 @@
+import os
+import sys
+
 import numpy as np
+import pytest
 
 from napari_tmidas._widget import (
     ExampleQWidget,
@@ -7,6 +11,14 @@ from napari_tmidas._widget import (
     threshold_magic_widget,
 )
 
+# Check if pytest-qt is available
+try:
+    import pytest_qt  # noqa: F401
+
+    PYTEST_QT_AVAILABLE = True
+except ImportError:
+    PYTEST_QT_AVAILABLE = False
+
 
 def test_threshold_autogenerate_widget():
     # because our "widget" is a pure function, we can call it and
@@ -20,6 +32,12 @@ def test_threshold_autogenerate_widget():
 # make_napari_viewer is a pytest fixture that returns a napari viewer object
 # you don't need to import it, as long as napari is installed
 # in your testing environment
+@pytest.mark.skipif(
+    not PYTEST_QT_AVAILABLE
+    or (os.environ.get("DISPLAY", "") == "" and os.name != "nt")
+    or (sys.platform == "win32" and os.environ.get("CI") == "true"),
+    reason="Requires pytest-qt, X11 display in headless *nix CI or full napari install on Windows CI",
+)
 def test_threshold_magic_widget(make_napari_viewer):
     viewer = make_napari_viewer()
     layer = viewer.add_image(np.random.random((100, 100)))
@@ -33,6 +51,12 @@ def test_threshold_magic_widget(make_napari_viewer):
     # etc.
 
 
+@pytest.mark.skipif(
+    not PYTEST_QT_AVAILABLE
+    or (os.environ.get("DISPLAY", "") == "" and os.name != "nt")
+    or (sys.platform == "win32" and os.environ.get("CI") == "true"),
+    reason="Requires pytest-qt, X11 display in headless *nix CI or full napari install on Windows CI",
+)
 def test_image_threshold_widget(make_napari_viewer):
     viewer = make_napari_viewer()
     layer = viewer.add_image(np.random.random((100, 100)))
@@ -50,6 +74,12 @@ def test_image_threshold_widget(make_napari_viewer):
 
 
 # capsys is a pytest fixture that captures stdout and stderr output streams
+@pytest.mark.skipif(
+    not PYTEST_QT_AVAILABLE
+    or (os.environ.get("DISPLAY", "") == "" and os.name != "nt")
+    or (sys.platform == "win32" and os.environ.get("CI") == "true"),
+    reason="Requires pytest-qt, X11 display in headless *nix CI or full napari install on Windows CI",
+)
 def test_example_q_widget(make_napari_viewer, capsys):
     # make viewer and add an image layer using our fixture
     viewer = make_napari_viewer()

napari_tmidas/_tests/test_windows_basic.py

@@ -0,0 +1,66 @@
+# src/napari_tmidas/_tests/test_windows_basic.py
+"""
+Basic Windows tests that don't require heavy dependencies.
+This ensures the package structure is correct without testing full functionality.
+"""
+import os
+import platform
+import sys
+
+
+class TestWindowsBasic:
+    def test_python_version(self):
+        """Test that Python version is supported"""
+        assert sys.version_info >= (3, 9)
+
+    def test_platform_detection(self):
+        """Test that we can detect Windows platform"""
+        if platform.system() == "Windows":
+            assert True  # We're on Windows, basic test passes
+        else:
+            assert True  # Not on Windows, still pass
+
+    def test_basic_imports(self):
+        """Test that basic Python modules can be imported"""
+        import json
+        import pathlib
+        import tempfile
+
+        # Create a simple test
+        with tempfile.TemporaryDirectory() as temp_dir:
+            test_file = pathlib.Path(temp_dir) / "test.json"
+            test_data = {"test": "data"}
+
+            # Write and read JSON
+            with open(test_file, "w") as f:
+                json.dump(test_data, f)
+
+            with open(test_file) as f:
+                loaded_data = json.load(f)
+
+            assert loaded_data == test_data
+
+    def test_package_structure_exists(self):
+        """Test that the package structure exists"""
+        # Test that we can find the package directory
+        import napari_tmidas
+
+        package_dir = os.path.dirname(napari_tmidas.__file__)
+        assert os.path.exists(package_dir)
+        assert os.path.isdir(package_dir)
+
+        # Test that __version__ is available
+        assert hasattr(napari_tmidas, "__version__")
+        assert isinstance(napari_tmidas.__version__, str)
+
+        # On Windows CI with skip_install=true, version may be "unknown"
+        # This is expected and acceptable
+        if platform.system() == "Windows" and os.environ.get("CI") == "true":
+            assert (
+                napari_tmidas.__version__ in ["unknown", "0.0.0"]
+                or "+" in napari_tmidas.__version__
+                or napari_tmidas.__version__.startswith("0.")
+            )
+        else:
+            # On other platforms or local development, version should be meaningful
+            assert napari_tmidas.__version__ != "unknown"

napari_tmidas/_ui_utils.py

@@ -0,0 +1,57 @@
+"""
+Common UI utilities for napari widgets.
+"""
+
+import os
+
+# Lazy imports for optional heavy dependencies
+try:
+    from qtpy.QtWidgets import QFileDialog, QPushButton
+
+    _HAS_QTPY = True
+except ImportError:
+    QFileDialog = QPushButton = None
+    _HAS_QTPY = False
+
+
+def add_browse_button_to_folder_field(widget, folder_field_name: str):
+    """
+    Add a browse button next to a folder path field in a magicgui widget.
+
+    Parameters
+    ----------
+    widget : magicgui widget
+        The widget containing the folder field
+    folder_field_name : str
+        The name of the folder field attribute
+
+    Returns
+    -------
+    QWidget
+        The modified widget with browse button
+    """
+    folder_field = getattr(widget, folder_field_name)
+
+    # Create browse button
+    browse_button = QPushButton("Browse...")
+
+    def on_browse_clicked():
+        current_value = folder_field.value
+        start_dir = current_value if current_value else os.path.expanduser("~")
+        folder = QFileDialog.getExistingDirectory(
+            None,
+            "Select Folder",
+            start_dir,
+            QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks,
+        )
+        if folder:
+            folder_field.value = folder
+
+    browse_button.clicked.connect(on_browse_clicked)
+
+    # Insert the browse button next to the folder_path field
+    field_layout = folder_field.native.parent().layout()
+    if field_layout:
+        field_layout.addWidget(browse_button)
+
+    return widget

napari_tmidas/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.2'
-__version_tuple__ = version_tuple = (0, 2, 2)
+__version__ = version = '0.2.4'
+__version_tuple__ = version_tuple = (0, 2, 4)
+
+__commit_id__ = commit_id = None

napari_tmidas/_widget.py

@@ -31,10 +31,47 @@ Replace code below according to your needs.
 
 from typing import TYPE_CHECKING
 
-from magicgui import magic_factory
-from magicgui.widgets import CheckBox, Container, create_widget
-from qtpy.QtWidgets import QHBoxLayout, QPushButton, QWidget
-from skimage.util import img_as_float
+# Lazy imports for optional heavy dependencies
+try:
+    from magicgui import magic_factory
+    from magicgui.widgets import CheckBox, Container, create_widget
+
+    _HAS_MAGICGUI = True
+except ImportError:
+    # Create stub decorator and stubs
+    def magic_factory(*args, **kwargs):
+        def decorator(func):
+            return func
+
+        if len(args) == 1 and callable(args[0]) and not kwargs:
+            return args[0]
+        return decorator
+
+    class Container:
+        pass
+
+    CheckBox = create_widget = None
+    _HAS_MAGICGUI = False
+
+try:
+    from qtpy.QtWidgets import QHBoxLayout, QPushButton, QWidget
+
+    _HAS_QTPY = True
+except ImportError:
+
+    class QWidget:
+        pass
+
+    QHBoxLayout = QPushButton = None
+    _HAS_QTPY = False
+
+try:
+    from skimage.util import img_as_float
+
+    _HAS_SKIMAGE = True
+except ImportError:
+    img_as_float = None
+    _HAS_SKIMAGE = False
 
 if TYPE_CHECKING:
     import napari