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

datalab/tests/features/common/io_app_test.py

@@ -0,0 +1,75 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+I/O application test:
+
+  - Testing signals I/O
+  - Testing images I/O
+"""
+
+# guitest: show
+
+from __future__ import annotations
+
+import os.path as osp
+
+from sigima.io.base import IOAction
+from sigima.io.image import ImageIORegistry
+from sigima.io.signal import SignalIORegistry
+
+from datalab.env import execenv
+from datalab.gui.panel.base import BaseDataPanel
+from datalab.tests import datalab_test_app_context, helpers
+
+
+def __testfunc(
+    title: str,
+    panel: BaseDataPanel,
+    registry: SignalIORegistry | ImageIORegistry,
+    pattern: str,
+    in_folder: str,
+) -> None:
+    """Test I/O features"""
+    execenv.print(f"  {title}:")
+    with helpers.WorkdirRestoringTempDir() as tmpdir:
+        # os.startfile(tmpdir)
+        fnames = helpers.get_test_fnames(pattern, in_folder)
+        execenv.print("    Opening:")
+        # TODO: [P3] This test does not support formats that return multiple objects
+        # (e.g. SIF files with multiple images). As a consequence, it will not test
+        # thoroughly the I/O functionalities for these formats (it will keep only the
+        # first object in the list of returned objects)
+        objs = []
+        for fname in fnames:
+            execenv.print(f"      {fname}: ", end="")
+            try:
+                registry.get_format(fname, IOAction.LOAD)
+            except NotImplementedError:
+                execenv.print("Skipped (not supported)")
+                continue
+            objs.append(panel.load_from_files([fname])[0])
+            execenv.print("OK")
+        execenv.print("    Saving:")
+        for fname, obj in zip(fnames, objs):
+            panel.objview.set_current_object(obj)
+            path = osp.join(tmpdir, osp.basename(fname))
+            execenv.print(f"      {path}: ", end="")
+            try:
+                registry.get_format(fname, IOAction.SAVE)
+            except NotImplementedError:
+                execenv.print("Skipped (not supported)")
+                continue
+            panel.save_to_files([path])
+            execenv.print("OK")
+
+
+def test_io_app() -> None:
+    """Run image tools test scenario"""
+    with datalab_test_app_context() as win:
+        execenv.print("I/O application test:")
+        __testfunc("Signals", win.signalpanel, SignalIORegistry, "*.*", "curve_formats")
+        __testfunc("Images", win.imagepanel, ImageIORegistry, "*.*", "image_formats")
+
+
+if __name__ == "__main__":
+    test_io_app()

datalab/tests/features/common/large_results_app_test.py

@@ -0,0 +1,187 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Large Results Application Test Module
+
+This module contains tests for verifying that DataLab handles large result datasets
+efficiently and correctly.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show,skip
+
+import time
+
+import numpy as np
+import sigima.enums
+import sigima.objects
+import sigima.params as sigima_param
+from sigima.tests.data import get_test_image
+
+from datalab.adapters_metadata.geometry_adapter import GeometryAdapter
+from datalab.config import Conf
+from datalab.tests import datalab_test_app_context
+
+
+def create_polygon_vertices(
+    x0: float, y0: float, nb_points: int, radius_mean: float, radius_variation: float
+) -> list[tuple[float, float]]:
+    """Generate points for a polygon around (x0, y0)
+
+    Args:
+        x0: x coordinate of the polygon center
+        y0: y coordinate of the polygon center
+        nb_points: number of points to generate
+        radius_mean: mean radius of the polygon
+        radius_variation: variation in radius
+
+    Returns:
+        List of (x, y) points representing the polygon vertices
+    """
+    points = []
+    # Calculate number of NaNs to append (random numbers between 0 and nb_points-10):
+    num_nans = np.random.randint(0, nb_points - 10)
+    for j in range(nb_points - num_nans):
+        angle = j * (2 * np.pi / (nb_points - num_nans))
+        radius = radius_mean + radius_variation * np.random.rand()
+        x = x0 + radius * np.cos(angle)
+        y = y0 + radius * np.sin(angle)
+        points.append((x, y))
+    for _ in range(num_nans):
+        points.append((np.nan, np.nan))
+    return points
+
+
+def create_random_polygons(
+    size: int, nb_polygons: int, nb_points_per_polygon: int
+) -> np.ndarray:
+    """Create random polygons
+
+    Args:
+        size: size of the area in which to create polygons
+        nb_polygons: number of polygons to create
+        nb_points_per_polygon: number of points per polygon
+
+    Returns:
+        Array of shape (nb_polygons, nb_points_per_polygon, 2)
+    """
+    polygons = []
+    for _ in range(nb_polygons):
+        x0 = size * np.random.rand()
+        y0 = size * np.random.rand()
+        points = create_polygon_vertices(
+            x0, y0, nb_points_per_polygon, radius_mean=20, radius_variation=30
+        )
+        # Append the flattened points:
+        polygons.append(points)
+    return np.array(polygons)
+
+
+def test_large_results_scenario(measure_execution_time: bool = False) -> None:
+    """Test scenario to verify result truncation limits work correctly
+
+    Args:
+        measure_execution_time: if True, measure and print the execution time, then
+         quit immediately
+
+    This scenario tests:
+    - Contour detection on flower.npy (generates many contours)
+    - Shape drawing truncation at max_shapes_to_draw limit
+    - Label display truncation at max_cells_in_label limit
+    - Performance with large polygons (many points per polygon)
+
+    Performance benchmark (15 polygons × 5000 points):
+    - Pure PlotPy: ~473ms (baseline for drawing shapes only)
+    - DataLab: ~254ms (includes shape drawing + HTML label generation)
+    - Note: DataLab is faster due to optimized HTML truncation before formatting
+    """
+    nb_polygons = 15
+    nb_points_per_polygon = 5000
+
+    with datalab_test_app_context(
+        console=False, exec_loop=not measure_execution_time
+    ) as win:
+        # Create an image panel
+        panel = win.imagepanel
+
+        # Load the flower test image
+        ima = get_test_image("flower.npy")
+        ima.title = "Test image 'flower.npy' - Contour Detection Limit Test"
+        panel.add_object(ima)
+
+        # Apply Roberts filter for edge detection
+        panel.processor.run_feature("roberts")
+
+        # Run contour detection which should produce a large set of results
+        param = sigima_param.ContourShapeParam()
+        param.shape = sigima.enums.ContourShape.POLYGON
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("contour_shape", param)
+
+        # Create geometry results manually using many polygons (we generate results
+        # in a manner that should be similar to what contour detection would typically
+        # produce but in a way that we can control precisely here)
+        vertices = create_random_polygons(
+            size=ima.data.shape[0],
+            nb_polygons=nb_polygons,
+            nb_points_per_polygon=nb_points_per_polygon,
+        )
+        geom_result = sigima.objects.GeometryResult(
+            title="Polygon",
+            kind=sigima.objects.KindShape.POLYGON,
+            coords=vertices.reshape(-1, nb_points_per_polygon * 2),
+            func_name="contour_detection_test",
+        )
+        geom_adapter = GeometryAdapter(geom_result)
+
+        ima2 = ima.copy()
+        geom_adapter.add_to(ima2)
+        panel.add_object(ima2)
+
+        if measure_execution_time:
+            # Now measure the execution time of switching selection between
+            # the 3 images:
+            # Image #1: flower.npy, as loaded
+            # Image #2: Image #1 after Roberts filter + contour detection
+            # Image #3: Image #1 with manually added large polygon result
+            print("\nMeasuring image switch timings...")
+            image_switch_times = {}
+            for _j in range(2):  # Doing multiple iterations to stabilize timings
+                panel.objview.select_objects([1])
+                for i in range(2, 4):
+                    start_time = time.perf_counter()
+                    panel.objview.select_objects([i])
+                    elapsed_time = (time.perf_counter() - start_time) * 1000  # in ms
+                    image_switch_times.setdefault(i, []).append(elapsed_time)
+                    print(f"  - Switch to image #{i}: {elapsed_time:.1f} ms")
+            print("\nImage switch timings (ms):")
+            for i in range(2, 4):
+                times = image_switch_times[i]
+                avg_time = sum(times) / len(times)
+                print(
+                    f" - Switching to image #{i}: avg {avg_time:.1f} ms "
+                    f"over {len(times)} runs"
+                )
+
+            # Measure execution time of manual refresh of the image view:
+            print("\nMeasuring image view refresh timings...")
+            image_refresh_times = {}
+            for i in range(3, 4):
+                panel.objview.select_objects([i])
+                for _j in range(5):  # Doing multiple iterations to stabilize timings
+                    start_time = time.perf_counter()
+                    panel.manual_refresh()
+                    elapsed_time = (time.perf_counter() - start_time) * 1000  # in ms
+                    image_refresh_times.setdefault(i, []).append(elapsed_time)
+                    print(f"  - Manual refresh: {elapsed_time:.1f} ms")
+            print("\nImage view refresh timings (ms):")
+            for i in range(3, 4):
+                times = image_refresh_times[i]
+                avg_time = sum(times) / len(times)
+                print(
+                    f" - Manual refresh: avg {avg_time:.1f} ms over {len(times)} runs"
+                )
+
+
+if __name__ == "__main__":
+    test_large_results_scenario(measure_execution_time=False)

datalab/tests/features/common/metadata_all_patterns_test.py

@@ -0,0 +1,103 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Processing metadata storage tests
+
+Tests that ALL processing patterns (1-to-1, 2-to-1, n-to-1) correctly
+store metadata in object metadata options, regardless of whether they
+support interactive re-processing.
+
+This is an integration test that verifies the metadata storage infrastructure
+works correctly across all computation patterns.
+
+Note: interactive_processing_test.py tests the interactive re-processing UI feature.
+"""
+
+# guitest: show
+
+import guidata.dataset as gds
+from guidata.qthelpers import qt_app_context
+from sigima.proc.signal.filtering import GaussianParam
+
+from datalab.gui.processor.base import PROCESSING_PARAMETERS_OPTION
+from datalab.objectmodel import get_uuid
+from datalab.tests import datalab_test_app_context
+
+
+def test_metadata_all_patterns():
+    """Test that metadata is stored for all processing patterns."""
+    with qt_app_context():
+        with datalab_test_app_context() as win:
+            # Get panels
+            sig_panel = win.signalpanel
+            img_panel = win.imagepanel
+
+            # === Test 1: 1-to-1 pattern (with parameters) ===
+            sig_panel.new_object()
+            sig1 = sig_panel.objmodel.get_all_objects()[-1]
+
+            param = GaussianParam.create(sigma=2.0)
+            sig_panel.processor.compute_1_to_1(
+                sig_panel.processor.get_feature("gaussian_filter").function,
+                param=param,
+                title="Gaussian filter",
+            )
+            filtered_sig = sig_panel.objmodel.get_all_objects()[-1]
+
+            # Check metadata contains all keys including pattern type
+            assert PROCESSING_PARAMETERS_OPTION in filtered_sig.get_metadata_options()
+            option_dict = filtered_sig.get_metadata_option(PROCESSING_PARAMETERS_OPTION)
+            assert option_dict["func_name"] == "gaussian_filter"
+            assert option_dict["pattern"] == "1-to-1"
+            assert option_dict["source_uuid"] == get_uuid(sig1)
+            assert option_dict["param_json"] == gds.dataset_to_json(param)
+
+            # === Test 2: 2-to-1 pattern (single operand) ===
+            sig_panel.new_object()
+            sig2 = sig_panel.objmodel.get_all_objects()[-1]
+            sig_panel.objview.select_objects([sig1])  # Select only sig1
+            sig_panel.processor.compute_2_to_1(
+                obj2=sig2,
+                obj2_name="signal to subtract",
+                func=sig_panel.processor.get_feature("difference").function,
+                title="Difference",
+            )
+            subtracted_sig = sig_panel.objmodel.get_all_objects()[-1]
+
+            # Check lightweight metadata (no params, but has pattern and sources)
+            assert PROCESSING_PARAMETERS_OPTION in subtracted_sig.get_metadata_options()
+            option_dict = subtracted_sig.get_metadata_option(
+                PROCESSING_PARAMETERS_OPTION
+            )
+            assert option_dict["pattern"] == "2-to-1"
+            assert option_dict["source_uuids"] == [get_uuid(sig1), get_uuid(sig2)]
+            assert len(option_dict["source_uuids"]) == 2
+            # Should NOT have full parameters stored
+            assert "param" not in option_dict
+
+            # === Test 3: n-to-1 pattern (single operand mode) ===
+            img_panel.new_object()
+            img1 = img_panel.objmodel.get_all_objects()[-1]
+            img_panel.new_object()
+            img2 = img_panel.objmodel.get_all_objects()[-1]
+            img_panel.objview.select_objects([img1, img2])
+            img_panel.processor.compute_n_to_1(
+                func=img_panel.processor.get_feature("addition").function,
+                title="Addition",
+            )
+            sum_img = img_panel.objmodel.get_all_objects()[-1]
+
+            # Check lightweight metadata
+            assert PROCESSING_PARAMETERS_OPTION in sum_img.get_metadata_options()
+            option_dict = sum_img.get_metadata_option(PROCESSING_PARAMETERS_OPTION)
+            assert option_dict["pattern"] == "n-to-1"
+            assert "source_uuids" in option_dict
+            assert len(option_dict["source_uuids"]) == 2
+            # Should NOT have full parameters stored
+            assert "param" not in option_dict
+
+            print("✓ All processing patterns store appropriate metadata")
+
+
+if __name__ == "__main__":
+    test_metadata_all_patterns()

datalab/tests/features/common/metadata_app_test.py

@@ -0,0 +1,139 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Metadata application test:
+
+  - Create signal/image, with ROI
+  - Compute things (adds metadata)
+  - Test metadata delete, copy, paste
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.objects
+import sigima.params
+import sigima.proc.image as sipi
+import sigima.proc.signal as sips
+from sigima.tests.data import create_paracetamol_signal
+
+from datalab.adapters_metadata.geometry_adapter import GeometryAdapter
+from datalab.env import execenv
+from datalab.gui.panel.base import BaseDataPanel, PasteMetadataParam
+from datalab.gui.panel.image import ImagePanel
+from datalab.gui.panel.signal import SignalPanel
+from datalab.tests import datalab_test_app_context
+from datalab.tests.features.image.roi_app_test import create_test_image_with_roi
+
+
+def __run_signal_computations(panel: SignalPanel):
+    """Test all signal features related to ROI"""
+    execenv.print("  Signal features")
+    panel.processor.run_feature(sips.fwhm, sigima.params.FWHMParam())
+    panel.processor.run_feature(sips.fw1e2)
+
+
+def __run_image_computations(panel: ImagePanel):
+    """Test all image features related to ROI"""
+    execenv.print("  Image features")
+    panel.processor.run_feature(sipi.centroid)
+    panel.processor.run_feature(sipi.enclosing_circle)
+    panel.processor.run_feature(
+        sipi.peak_detection, sigima.params.Peak2DDetectionParam()
+    )
+
+
+def __test_metadata_features(panel: BaseDataPanel):
+    """Test all metadata features"""
+    # Duplicate the first object
+    panel.duplicate_object()
+
+    # Delete metadata of the first object
+    for keep_roi in (True, False):  # Test both cases (coverage test)
+        panel.delete_metadata(keep_roi=keep_roi)
+
+    # Select and copy metadata of the second object
+    panel.objview.select_objects([2])
+    source_obj = panel.objview.get_sel_objects()[0]
+    source_metadata = source_obj.metadata.copy()
+
+    # Verify source object has geometry results
+    geometry_keys = [
+        k for k, v in source_metadata.items() if GeometryAdapter.match(k, v)
+    ]
+    execenv.print(f"  Source object has {len(geometry_keys)} geometry metadata keys")
+    assert len(geometry_keys) > 0, "Source object should have geometry results"
+
+    # Copy metadata
+    panel.copy_metadata()
+
+    # Select and paste metadata to the first object
+    panel.objview.select_objects([1])
+    target_obj = panel.objview.get_sel_objects()[0]
+
+    # Verify target has no geometry metadata before paste
+    target_geo_keys_before = [
+        k for k, v in target_obj.metadata.items() if GeometryAdapter.match(k, v)
+    ]
+    execenv.print(
+        f"  Target object has {len(target_geo_keys_before)} geometry keys before paste"
+    )
+
+    # Paste metadata (with default parameters - keep everything)
+    param = PasteMetadataParam("Test paste")
+    param.keep_geometry = True
+    param.keep_tables = True
+    param.keep_other = True
+    param.keep_roi = True
+    panel.paste_metadata(param)
+
+    # Verify the paste worked
+    target_metadata_after = target_obj.metadata.copy()
+    target_geo_keys_after = [
+        k for k, v in target_metadata_after.items() if GeometryAdapter.match(k, v)
+    ]
+    execenv.print(
+        f"  Target object has {len(target_geo_keys_after)} geometry keys after paste"
+    )
+
+    # Check that geometry metadata was actually pasted
+    assert len(target_geo_keys_after) > 0, (
+        "Target object should have geometry results after paste"
+    )
+
+    # Verify that all geometry metadata uses the new unified format (_dict)
+    for key in target_geo_keys_after:
+        # Verify the geometry data is valid
+        geometry_data = target_metadata_after[key]
+        assert isinstance(geometry_data, dict), f"Geometry data should be dict: {key}"
+        assert "title" in geometry_data, f"Missing title in geometry data: {key}"
+        assert "coords" in geometry_data, f"Missing coords in geometry data: {key}"
+        execenv.print(f"  ✓ Valid geometry entry: {key}")
+
+    execenv.print("  ✓ Metadata copy/paste verification passed")
+
+
+def test_metadata_app():
+    """Run metadata application test scenario"""
+    size = 200
+    with datalab_test_app_context() as win:
+        execenv.print("Metadata application test:")
+        # === Signal metadata features test ===
+        panel = win.signalpanel
+        sig = create_paracetamol_signal(size)
+        sig.roi = sigima.objects.create_signal_roi([[26, 41], [125, 146]], indices=True)
+        panel.add_object(sig)
+        __run_signal_computations(panel)
+        __test_metadata_features(panel)
+        # === Image metadata features test ===
+        panel = win.imagepanel
+        param = sigima.objects.NewImageParam.create(height=size, width=size)
+        ima = create_test_image_with_roi(param)
+        panel.add_object(ima)
+        __run_image_computations(panel)
+        __test_metadata_features(panel)
+        execenv.print("==> OK")
+
+
+if __name__ == "__main__":
+    test_metadata_app()

datalab/tests/features/common/metadata_io_unit_test.py

@@ -0,0 +1,60 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Metadata import/export unit test:
+
+  - Create an image with annotations, geometry result and table results
+  - Add the image to DataLab
+  - Export image metadata to file (JSON)
+  - Delete image metadata
+  - Import image metadata from previous file
+  - Check if image metadata is the same as the original image
+"""
+
+# guitest: show
+
+import os.path as osp
+
+from sigima.tests import data as test_data
+
+from datalab.adapters_metadata import GeometryAdapter, TableAdapter
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context, helpers
+
+
+def test_metadata_io_unit():
+    """Run image tools test scenario"""
+    with execenv.context(unattended=True):
+        with helpers.WorkdirRestoringTempDir() as tmpdir:
+            fname = osp.join(tmpdir, "test.dlabmeta")
+            with datalab_test_app_context() as win:
+                panel = win.imagepanel
+
+                # Create a test image with annotations
+                ima = test_data.create_annotated_image()
+
+                # Add geometry results to test their serialization
+                for geometry in test_data.generate_geometry_results():
+                    GeometryAdapter(geometry).add_to(ima)
+
+                # Add table results to test their serialization
+                for table in test_data.generate_table_results():
+                    TableAdapter(table).add_to(ima)
+
+                panel.add_object(ima)
+                orig_metadata = ima.metadata.copy()
+                panel.export_metadata_from_file(fname)
+                panel.delete_metadata()
+
+                # The +1 is for the "number" metadata option which has no default:
+                assert len(ima.metadata) == len(ima.get_metadata_options_defaults()) + 1
+
+                panel.import_metadata_from_file(fname)
+                execenv.print("Check metadata export <--> import features:")
+                helpers.compare_metadata(
+                    orig_metadata, ima.metadata, raise_on_diff=True
+                )
+
+
+if __name__ == "__main__":
+    test_metadata_io_unit()