datalab-platform 0.0.1.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

datalab/tests/features/common/add_metadata_app_test.py

@@ -0,0 +1,134 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Add metadata application test for screenshots:
+
+  - Create signals and images
+  - Open Add metadata dialog
+  - Take screenshots for documentation
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING
+
+import guidata.dataset as gds
+
+from datalab.env import execenv
+from datalab.gui.panel.base import AddMetadataParam
+from datalab.tests import datalab_test_app_context
+from datalab.tests.features.common.add_metadata_unit_test import (
+    create_test_images,
+    create_test_signals,
+)
+
+if TYPE_CHECKING:
+    from datalab.gui.main import DLMainWindow
+
+
+def __add_metadata_to_signals(win: DLMainWindow, screenshot: bool = False) -> None:
+    """Add metadata to signals helper function."""
+    execenv.print("Add metadata signal application test:")
+    panel = win.signalpanel
+
+    # Add test signals to the panel
+    for sig in create_test_signals():
+        panel.add_object(sig)
+
+    # Select all signals
+    panel.objview.select_objects([1, 2, 3])
+
+    # Create and configure the Add metadata dialog
+    objs = panel.objview.get_sel_objects(include_groups=True)
+    param = AddMetadataParam(objs)
+
+    # Configure example metadata
+    param.metadata_key = "experiment_id"
+    param.value_pattern = "EXP_{index:03d}"
+    param.conversion = "string"
+    param.update_preview()
+    execenv.print(f"  Preview: {param.preview}")
+    assert "experiment_id" in param.preview
+    execenv.print("  ✓ Add metadata parameter configured correctly")
+
+    # Edit the parameter to show the dialog
+    execenv.print("  Opening Add metadata dialog...")
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=gds.DataItemValidationWarning)
+        with execenv.context(screenshot=screenshot):
+            param.edit(parent=win, wordwrap=False, object_name="s_add_metadata")
+
+    # Run DataLab's metadata addition functionality:
+    panel.add_metadata(param)
+
+    execenv.print("==> Signal application test OK")
+
+
+def __add_metadata_to_images(win: DLMainWindow, screenshot: bool = False) -> None:
+    """Add metadata to images helper function."""
+    execenv.print("Add metadata image test:")
+    panel = win.imagepanel
+
+    # Add test images to the panel
+    for img in create_test_images():
+        panel.add_object(img)
+
+    # Select all images
+    panel.objview.select_objects([1, 2, 3])
+
+    # Create and configure the Add metadata dialog
+    objs = panel.objview.get_sel_objects(include_groups=True)
+    param = AddMetadataParam(objs)
+
+    # Configure example metadata
+    param.metadata_key = "sample_id"
+    param.value_pattern = "SAMPLE_{index:04d}_{title:upper}"
+    param.conversion = "string"
+    param.update_preview()
+    execenv.print(f"  Preview: {param.preview}")
+    assert "sample_id" in param.preview
+    execenv.print("  ✓ Add metadata parameter configured correctly")
+
+    # Edit the parameter to show the dialog
+    execenv.print("  Opening Add metadata dialog...")
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=gds.DataItemValidationWarning)
+        with execenv.context(screenshot=screenshot):
+            param.edit(parent=win, wordwrap=False, object_name="i_add_metadata")
+
+    # Run DataLab's metadata addition functionality:
+    panel.add_metadata(param)
+
+    execenv.print("==> Image application test OK")
+
+
+def test_add_metadata_to_signals() -> None:
+    """Test Add metadata feature for signals."""
+    with datalab_test_app_context() as win:
+        __add_metadata_to_signals(win)
+
+
+def test_add_metadata_to_images() -> None:
+    """Test Add metadata feature for images."""
+    with datalab_test_app_context() as win:
+        __add_metadata_to_images(win)
+
+
+def add_metadata_screenshots():
+    """Generate add metadata screenshots."""
+    with execenv.context(unattended=True):
+        with datalab_test_app_context() as win:
+            execenv.print("Add metadata screenshots test:")
+            __add_metadata_to_signals(win, screenshot=True)
+            __add_metadata_to_images(win, screenshot=True)
+            execenv.print("==> All screenshot tests completed")
+
+
+if __name__ == "__main__":
+    # test_add_metadata_to_signals()
+    # test_add_metadata_to_images()
+    add_metadata_screenshots()

datalab/tests/features/common/add_metadata_unit_test.py

@@ -0,0 +1,267 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for Add Metadata feature.
+
+This module tests the `AddMetadataParam` class and the `add_metadata` method
+from `datalab.gui.panel.base`.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import guidata.config as gcfg
+import numpy as np
+import pytest
+from sigima.objects import create_image, create_signal
+
+from datalab.env import execenv
+from datalab.gui.panel.base import AddMetadataParam
+
+if TYPE_CHECKING:
+    from sigima.objects import ImageObj, SignalObj
+
+
+def create_test_signals() -> list[SignalObj]:
+    """Create a list of test signals for testing."""
+    # Signal 1: Sine wave
+    x = np.linspace(0, 10, 100)
+    signal1 = create_signal(
+        title="Sine Wave",
+        x=x,
+        y=np.sin(x),
+        metadata={"type": "sine", "frequency": "1 Hz"},
+    )
+
+    # Signal 2: Cosine wave
+    signal2 = create_signal(
+        title="Cosine Wave",
+        x=x,
+        y=np.cos(x * 2),
+        metadata={"type": "cosine", "frequency": "2 Hz"},
+    )
+
+    # Signal 3: Exponential decay
+    signal3 = create_signal(
+        title="Exponential Decay",
+        x=x,
+        y=np.exp(-x / 3),
+        metadata={"type": "exponential", "time_constant": "3 s"},
+    )
+
+    return [signal1, signal2, signal3]
+
+
+def create_test_images() -> list[ImageObj]:
+    """Create a list of test images for testing."""
+    # Image 1: Random noise
+    image1 = create_image(
+        title="Random Noise",
+        data=np.random.rand(100, 100),
+        metadata={"type": "noise", "distribution": "uniform"},
+    )
+
+    # Image 2: Gaussian pattern
+    x = np.linspace(-3, 3, 50)
+    y = np.linspace(-3, 3, 50)
+    X, Y = np.meshgrid(x, y)
+    image2 = create_image(
+        title="Gaussian Pattern",
+        data=np.exp(-(X**2 + Y**2)),
+        metadata={"type": "gaussian", "sigma": "1.0"},
+    )
+
+    # Image 3: Checkerboard pattern
+    data3 = np.zeros((100, 100))
+    data3[::10, ::10] = 1
+    data3[5::10, 5::10] = 1
+    image3 = create_image(
+        title="Checkerboard",
+        data=data3,
+        metadata={"type": "pattern", "period": "10 px"},
+    )
+
+    return [image1, image2, image3]
+
+
+class TestAddMetadata:
+    """Test class for AddMetadataParam with proper setup/teardown."""
+
+    @pytest.fixture(autouse=True)
+    def setup_validation(self):
+        """Disable guidata validation during tests."""
+        old_mode = gcfg.get_validation_mode()
+        gcfg.set_validation_mode(gcfg.ValidationMode.DISABLED)
+        yield
+        gcfg.set_validation_mode(old_mode)
+
+    def test_string_values(self) -> None:
+        """Test adding string metadata values."""
+        execenv.print(f"{self.test_string_values.__doc__}:")
+
+        # Create test signals
+        signals = create_test_signals()
+
+        # Create parameter
+        p = AddMetadataParam(signals)
+        p.metadata_key = "test_string"
+        p.value_pattern = "{title}"
+        p.conversion = "string"
+
+        # Build values
+        values = p.build_values(signals)
+
+        expected_values = ["Sine Wave", "Cosine Wave", "Exponential Decay"]
+        assert values == expected_values, f"Expected {expected_values}, got {values}"
+        execenv.print(f"  ✓ String values: {values}")
+
+        # Check preview
+        p.update_preview()
+        assert "test_string" in p.preview, "Preview should contain metadata key"
+        execenv.print("  ✓ Preview generated successfully")
+
+        execenv.print(f"{self.test_string_values.__doc__}: OK")
+
+    def test_numeric_values(self) -> None:
+        """Test adding numeric metadata values."""
+        execenv.print(f"{self.test_numeric_values.__doc__}:")
+
+        # Create test signals
+        signals = create_test_signals()
+
+        # Test integer conversion
+        p = AddMetadataParam(signals)
+        p.metadata_key = "index"
+        p.value_pattern = "{index}"
+        p.conversion = "int"
+
+        values = p.build_values(signals)
+        expected_values = [1, 2, 3]
+        assert values == expected_values, f"Expected {expected_values}, got {values}"
+        execenv.print(f"  ✓ Integer values: {values}")
+
+        # Test float conversion
+        p.conversion = "float"
+        values = p.build_values(signals)
+        expected_values = [1.0, 2.0, 3.0]
+        assert values == expected_values, f"Expected {expected_values}, got {values}"
+        execenv.print(f"  ✓ Float values: {values}")
+
+        execenv.print(f"{self.test_numeric_values.__doc__}: OK")
+
+    def test_boolean_values(self) -> None:
+        """Test adding boolean metadata values."""
+        execenv.print(f"{self.test_boolean_values.__doc__}:")
+
+        # Create test signals
+        signals = create_test_signals()
+
+        # Test boolean conversion with "true" pattern
+        p = AddMetadataParam(signals)
+        p.metadata_key = "is_valid"
+        p.value_pattern = "true"
+        p.conversion = "bool"
+
+        values = p.build_values(signals)
+        expected_values = [True, True, True]
+        assert values == expected_values, f"Expected {expected_values}, got {values}"
+        execenv.print(f"  ✓ Boolean (true) values: {values}")
+
+        # Test boolean conversion with "false" pattern
+        p.value_pattern = "false"
+        values = p.build_values(signals)
+        expected_values = [False, False, False]
+        assert values == expected_values, f"Expected {expected_values}, got {values}"
+        execenv.print(f"  ✓ Boolean (false) values: {values}")
+
+        execenv.print(f"{self.test_boolean_values.__doc__}: OK")
+
+    def test_pattern_formatting(self) -> None:
+        """Test various pattern formatting options."""
+        execenv.print(f"{self.test_pattern_formatting.__doc__}:")
+
+        # Create test signals
+        signals = create_test_signals()
+
+        # Test index with zero padding
+        p = AddMetadataParam(signals)
+        p.metadata_key = "file_id"
+        p.value_pattern = "file_{index:03d}"
+        p.conversion = "string"
+
+        values = p.build_values(signals)
+        expected_values = ["file_001", "file_002", "file_003"]
+        assert values == expected_values, f"Expected {expected_values}, got {values}"
+        execenv.print(f"  ✓ Padded index pattern: {values}")
+
+        # Test uppercase modifier
+        p.value_pattern = "{title:upper}"
+        values = p.build_values(signals)
+        expected_values = ["SINE WAVE", "COSINE WAVE", "EXPONENTIAL DECAY"]
+        assert values == expected_values, f"Expected {expected_values}, got {values}"
+        execenv.print(f"  ✓ Uppercase pattern: {values}")
+
+        # Test lowercase modifier
+        p.value_pattern = "{title:lower}"
+        values = p.build_values(signals)
+        expected_values = ["sine wave", "cosine wave", "exponential decay"]
+        assert values == expected_values, f"Expected {expected_values}, got {values}"
+        execenv.print(f"  ✓ Lowercase pattern: {values}")
+
+        execenv.print(f"{self.test_pattern_formatting.__doc__}: OK")
+
+    def test_with_images(self) -> None:
+        """Test AddMetadataParam with image objects."""
+        execenv.print(f"{self.test_with_images.__doc__}:")
+
+        # Create test images
+        images = create_test_images()
+
+        # Create parameter
+        p = AddMetadataParam(images)
+        p.metadata_key = "category"
+        p.value_pattern = "{title:lower}"
+        p.conversion = "string"
+
+        # Build values
+        values = p.build_values(images)
+        expected_values = ["random noise", "gaussian pattern", "checkerboard"]
+        assert values == expected_values, f"Expected {expected_values}, got {values}"
+        execenv.print(f"  ✓ Image metadata values: {values}")
+
+        # Check preview
+        p.update_preview()
+        assert "category" in p.preview, "Preview should contain metadata key"
+        # Check that all values are in the preview
+        for expected_val in expected_values:
+            assert expected_val in p.preview, f"Preview should contain {expected_val}"
+        execenv.print("  ✓ Preview contains all values")
+
+        execenv.print(f"{self.test_with_images.__doc__}: OK")
+
+    def test_error_handling(self) -> None:
+        """Test error handling for invalid patterns."""
+        execenv.print(f"{self.test_error_handling.__doc__}:")
+
+        # Create test signals
+        signals = create_test_signals()
+
+        # Test with invalid pattern
+        p = AddMetadataParam(signals)
+        p.metadata_key = "test"
+        p.value_pattern = "{invalid_key}"  # This key doesn't exist
+        p.conversion = "string"
+
+        # Update preview should handle the error gracefully
+        p.update_preview()
+        assert "Invalid" in p.preview, "Preview should show invalid pattern error"
+        execenv.print("  ✓ Invalid pattern error handled")
+
+        execenv.print(f"{self.test_error_handling.__doc__}: OK")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

datalab/tests/features/common/annotations_management_unit_test.py

@@ -0,0 +1,152 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Unit tests for annotation copy/paste functionality."""
+
+import os.path as osp
+
+from sigima.tests import data as test_data
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context, helpers
+
+
+def test_annotations_copy_paste():
+    """Test copying and pasting annotations between objects."""
+    with execenv.context(unattended=True):
+        with datalab_test_app_context() as win:
+            panel = win.signalpanel
+
+            # Create two signals
+            sig1 = test_data.create_paracetamol_signal()
+            sig2 = test_data.create_paracetamol_signal()
+
+            # Add annotations to first signal
+            orig_annotations = [
+                {"type": "label", "text": "Peak 1"},
+                {"type": "label", "text": "Peak 2"},
+            ]
+            sig1.set_annotations(orig_annotations)
+
+            # Add objects to panel - sig1 will be selected after this
+            panel.add_object(sig1)
+
+            # Copy from first signal (which is currently selected)
+            panel.copy_annotations()
+
+            # Add second signal - sig2 will be selected after this
+            panel.add_object(sig2)
+
+            # Paste to second signal (which is now selected)
+            panel.paste_annotations()
+
+            # Verify annotations were copied
+            assert sig2.get_annotations() == orig_annotations
+
+
+def test_annotations_import_export():
+    """Test importing and exporting annotations to file."""
+    with execenv.context(unattended=True):
+        with helpers.WorkdirRestoringTempDir() as tmpdir:
+            fname = osp.join(tmpdir, "test.dlabann")
+            with datalab_test_app_context() as win:
+                panel = win.signalpanel
+
+                # Create signal with annotations
+                sig = test_data.create_paracetamol_signal()
+                orig_annotations = [{"type": "label", "text": "Test annotation"}]
+                sig.set_annotations(orig_annotations)
+
+                panel.add_object(sig)
+
+                # Export annotations
+                panel.export_annotations_from_file(fname)
+
+                # Clear annotations to test import
+                sig.clear_annotations()
+                assert len(sig.get_annotations()) == 0
+
+                # Import annotations
+                panel.import_annotations_from_file(fname)
+
+                # Verify annotations were imported
+                assert sig.get_annotations() == orig_annotations
+
+
+def test_annotations_delete():
+    """Test deleting annotations from objects."""
+    with execenv.context(unattended=True):
+        with datalab_test_app_context() as win:
+            panel = win.signalpanel
+
+            # Create signal with annotations
+            sig = test_data.create_paracetamol_signal()
+            sig.set_annotations(
+                [
+                    {"type": "label", "text": "To be deleted"},
+                ]
+            )
+
+            panel.add_object(sig)
+
+            # Verify annotations exist
+            assert len(sig.get_annotations()) == 1
+
+            # Delete annotations
+            panel.delete_annotations()
+
+            # Verify annotations were deleted
+            assert len(sig.get_annotations()) == 0
+
+
+def test_annotations_action_states():
+    """Test that action states are updated after annotation operations.
+
+    This test verifies the fix for the issue where action enable states
+    were not updated after operations like delete_annotations, requiring
+    the user to select another object for the actions to update.
+
+    Note: We can't easily test the UI action states in automated tests,
+    but we verify that the underlying state update mechanism is called.
+    """
+    with execenv.context(unattended=True):
+        with datalab_test_app_context() as win:
+            panel = win.signalpanel
+
+            # Create signal with annotations
+            sig = test_data.create_paracetamol_signal()
+            orig_annotations = [{"type": "label", "text": "Test"}]
+            sig.set_annotations(orig_annotations)
+
+            panel.add_object(sig)
+
+            # Verify object has annotations
+            assert len(sig.get_annotations()) == 1
+
+            # Delete annotations - this should update action states
+            panel.delete_annotations()
+
+            # Verify annotations were deleted
+            assert len(sig.get_annotations()) == 0
+
+            # Verify clipboard is empty
+            assert len(panel.annotations_clipboard) == 0
+
+            # Re-add annotations and copy - this should update action states
+            sig.set_annotations(orig_annotations)
+            panel.selection_changed()  # Refresh states
+            panel.copy_annotations()
+
+            # Verify clipboard now has annotations
+            assert len(panel.annotations_clipboard) == 1
+
+            # Clear annotations, paste, and verify
+            sig.clear_annotations()
+            panel.paste_annotations()
+            assert len(sig.get_annotations()) == 1
+
+
+if __name__ == "__main__":
+    test_annotations_copy_paste()
+    test_annotations_import_export()
+    test_annotations_delete()
+    test_annotations_action_states()