datalab-platform 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

datalab/objectmodel.py

@@ -189,7 +189,7 @@ class ObjectGroup:
 
     def get_object_ids(self) -> list[str]:
         """Return object ids in group"""
-        return self.__objects
+        return self.__objects.copy()
 
 
 class ObjectModel:

datalab/tests/features/common/auto_analysis_recompute_unit_test.py

@@ -235,6 +235,87 @@ def test_analysis_recompute_after_recompute_1_to_1():
         print("\n✓ Recompute_1_to_1 auto-analysis test passed!")
 
 
+def test_analysis_recompute_avoids_redundant_calculations():
+    """Test that auto-recompute doesn't cause O(n²) redundant calculations.
+
+    This test verifies that when multiple objects have ROIs modified simultaneously,
+    the analysis is recomputed only once per object, not once per object × number
+    of selected objects.
+
+    Regression test for bug: When N images were selected with statistics computed,
+    adding a ROI would trigger N × N = N² calculations instead of N.
+    """
+    with datalab_test_app_context(console=False) as win:
+        panel = win.imagepanel
+
+        # Create multiple images (N = 5 for this test)
+        n_images = 5
+        size = 100
+        images = []
+        for i in range(n_images):
+            param = Gauss2DParam.create(height=size, width=size, sigma=15)
+            img = create_image_from_param(param)
+            img.title = f"Test image {i + 1}"
+            panel.add_object(img)
+            images.append(img)
+
+        # Select all images
+        panel.objview.select_objects(images)
+        selected = panel.objview.get_sel_objects()
+        assert len(selected) == n_images, f"Should have {n_images} selected objects"
+
+        # Compute statistics on all selected images
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("centroid")
+
+        # Verify all images have centroid results
+        for img in images:
+            centroid = get_centroid_coords(img)
+            assert centroid is not None, f"Image '{img.title}' should have centroid"
+
+        print(f"\nInitial statistics computed for {n_images} images")
+
+        # Track how many times compute_1_to_0 is called during auto-recompute
+        # by counting the calls via a wrapper
+        call_count = [0]  # Use list to allow modification in closure
+        original_compute_1_to_0 = panel.processor.compute_1_to_0
+
+        def counting_compute_1_to_0(*args, **kwargs):
+            call_count[0] += 1
+            return original_compute_1_to_0(*args, **kwargs)
+
+        panel.processor.compute_1_to_0 = counting_compute_1_to_0
+
+        try:
+            # Add ROI to all selected images via edit_roi_graphically flow
+            # Simulating what happens when user adds ROI in the editor
+            roi = create_image_roi("rectangle", [25, 25, 50, 50])
+            for img in images:
+                img.roi = roi
+                # Simulate the auto-recompute that happens after ROI modification
+                panel.processor.auto_recompute_analysis(img)
+
+            # With the fix, compute_1_to_0 should be called exactly N times
+            # (once per object), not N² times
+            print(f"compute_1_to_0 was called {call_count[0]} times")
+            assert call_count[0] == n_images, (
+                f"compute_1_to_0 should be called exactly {n_images} times "
+                f"(once per object), but was called {call_count[0]} times. "
+                f"This suggests O(n²) redundant calculations."
+            )
+
+            # Verify the target_objs parameter is being used correctly:
+            # Each call should process only 1 object, not all selected objects
+            # This is verified by checking that the call count matches n_images
+
+        finally:
+            # Restore the original method
+            panel.processor.compute_1_to_0 = original_compute_1_to_0
+
+        print(f"\n✓ Auto-recompute correctly called {n_images} times (no O(n²) issue)")
+
+
 if __name__ == "__main__":
     test_analysis_recompute_after_roi_change()
     test_analysis_recompute_after_recompute_1_to_1()
+    test_analysis_recompute_avoids_redundant_calculations()

datalab/tests/features/common/coordutils_unit_test.py

@@ -0,0 +1,212 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Coordinate utilities unit tests
+"""
+
+import numpy as np
+import pytest
+from sigima.objects import (
+    CircularROI,
+    PolygonalROI,
+    RectangularROI,
+    SegmentROI,
+    create_image,
+    create_signal,
+)
+
+from datalab.adapters_plotpy.coordutils import (
+    round_image_coords,
+    round_image_roi_param,
+    round_signal_coords,
+    round_signal_roi_param,
+)
+
+
+def test_round_signal_coords():
+    """Test signal coordinate rounding"""
+    # Create a signal with sampling period of 0.1
+    x = np.arange(0, 10, 0.1)
+    y = np.sin(x)
+    sig = create_signal("test", x, y)
+
+    # Test basic rounding
+    coords = [1.23456789, 5.87654321]
+    rounded = round_signal_coords(sig, coords)
+    # With sampling period 0.1 and precision_factor 0.1, precision = 0.01
+    # Should round to 2 decimal places
+    assert rounded == [1.23, 5.88]
+
+    # Test with custom precision factor
+    rounded = round_signal_coords(sig, coords, precision_factor=1.0)
+    # precision = 0.1, should round to 1 decimal place
+    assert rounded == [1.2, 5.9]
+
+    # Test with signal that has too few points
+    sig_short = create_signal("test", np.array([1.0]), np.array([2.0]))
+    coords = [1.23456789]
+    rounded = round_signal_coords(sig_short, coords)
+    # Should return coords as-is
+    assert rounded == coords
+
+    # Test with constant x (zero sampling period)
+    sig_const = create_signal("test", np.ones(10), np.ones(10))
+    rounded = round_signal_coords(sig_const, coords)
+    # Should return coords as-is
+    assert rounded == coords
+
+
+def test_round_image_coords():
+    """Test image coordinate rounding"""
+    # Create an image with dx=dy=1.0 (uniform)
+    data = np.ones((100, 100))
+    img = create_image("test", data)
+
+    # Test basic rounding
+    coords = [10.123456, 20.987654, 30.555555, 40.444444]
+    rounded = round_image_coords(img, coords)
+    # With pixel spacing 1.0 and precision_factor 0.1, precision = 0.1
+    # Should round to 1 decimal place
+    assert rounded == [10.1, 21.0, 30.6, 40.4]
+
+    # Test with custom precision factor
+    rounded = round_image_coords(img, coords, precision_factor=1.0)
+    # precision = 1.0, should round to 0 decimal places
+    assert rounded == [10.0, 21.0, 31.0, 40.0]
+
+    # Test with empty coords
+    assert not round_image_coords(img, [])
+
+    # Test error for odd number of coordinates
+    with pytest.raises(ValueError, match="even number of elements"):
+        round_image_coords(img, [1.0, 2.0, 3.0])
+
+
+def test_round_signal_roi_param():
+    """Test signal ROI parameter rounding"""
+    # Create a signal with sampling period of 0.1
+    x = np.arange(0, 10, 0.1)
+    y = np.sin(x)
+    sig = create_signal("test", x, y)
+
+    # Create a segment ROI
+    roi = SegmentROI([1.23456789, 5.87654321], False)
+    param = roi.to_param(sig, 0)
+
+    # Round the parameter
+    round_signal_roi_param(sig, param)
+
+    # Check that coordinates are rounded
+    assert param.xmin == 1.23
+    assert param.xmax == 5.88
+
+
+def test_round_image_roi_param_rectangle():
+    """Test image ROI parameter rounding for rectangular ROI"""
+    # Create an image with dx=dy=1.0
+    data = np.ones((100, 100))
+    img = create_image("test", data)
+
+    # Create a rectangular ROI with floating-point errors
+    roi = RectangularROI([10.0, 20.0, 50.29999999999995, 75.19999999999999], False)
+    param = roi.to_param(img, 0)
+
+    # Verify we have the floating-point errors before rounding
+    assert param.dx == 50.29999999999995
+    assert param.dy == 75.19999999999999
+
+    # Round the parameter
+    round_image_roi_param(img, param)
+
+    # Check that coordinates are rounded
+    assert param.x0 == 10.0
+    assert param.y0 == 20.0
+    assert param.dx == 50.3
+    assert param.dy == 75.2
+
+
+def test_round_image_roi_param_circle():
+    """Test image ROI parameter rounding for circular ROI"""
+    # Create an image with dx=dy=1.0
+    data = np.ones((100, 100))
+    img = create_image("test", data)
+
+    # Create a circular ROI with floating-point errors
+    roi = CircularROI([50.123456, 50.987654, 25.555555], False)
+    param = roi.to_param(img, 0)
+
+    # Round the parameter
+    round_image_roi_param(img, param)
+
+    # Check that coordinates are rounded
+    assert param.xc == 50.1
+    assert param.yc == 51.0
+    assert param.r == 25.6
+
+
+def test_round_image_roi_param_polygon():
+    """Test image ROI parameter rounding for polygonal ROI"""
+    # Create an image with dx=dy=1.0
+    data = np.ones((100, 100))
+    img = create_image("test", data)
+
+    # Create a polygonal ROI with floating-point errors
+    coords = [10.123456, 20.987654, 30.555555, 40.444444, 50.111111, 60.999999]
+    roi = PolygonalROI(coords, False)
+    param = roi.to_param(img, 0)
+
+    # Round the parameter
+    round_image_roi_param(img, param)
+
+    # Check that coordinates are rounded
+    expected = np.array([10.1, 21.0, 30.6, 40.4, 50.1, 61.0])
+    np.testing.assert_array_equal(param.points, expected)
+
+
+def test_round_coords_non_uniform_image():
+    """Test coordinate rounding for non-uniform image coordinates"""
+    # Create an image with non-uniform coordinates
+    data = np.ones((10, 10))
+    img = create_image("test", data)
+    # Set non-uniform coordinates
+    img.xcoords = np.array([0, 1, 3, 6, 10, 15, 21, 28, 36, 45])  # varying spacing
+    img.ycoords = np.array([0, 2, 4, 6, 8, 10, 12, 14, 16, 18])  # uniform spacing of 2
+
+    # Test rounding - should use average spacing
+    coords = [5.123456, 7.987654, 25.555555, 13.444444]
+    rounded = round_image_coords(img, coords)
+
+    # Average dx ≈ 5.0, average dy = 2.0
+    # With precision_factor=0.1: precision_x=0.5, precision_y=0.2
+    # Should round to 1 decimal place for both
+    assert rounded == [5.1, 8.0, 25.6, 13.4]
+
+
+def test_round_coords_preserves_structure():
+    """Test that coordinate rounding preserves the structure of coordinates"""
+    # Create an image
+    data = np.ones((100, 100))
+    img = create_image("test", data)
+
+    # Test with multiple coordinate pairs
+    coords = [
+        10.111,
+        20.222,
+        30.333,
+        40.444,
+        50.555,
+        60.666,
+        70.777,
+        80.888,
+    ]
+    rounded = round_image_coords(img, coords)
+
+    # Should have same length
+    assert len(rounded) == len(coords)
+
+    # Each coordinate should be rounded independently
+    assert all(isinstance(c, (int, float)) for c in rounded)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

datalab/tests/features/common/result_deletion_unit_test.py

@@ -12,12 +12,13 @@ Test the deletion of analysis results from objects.
 
 from __future__ import annotations
 
-from sigima.objects import Gauss2DParam, create_image_from_param
+from sigima.objects import Gauss2DParam, create_image_from_param, create_image_roi
 from sigima.tests.data import create_paracetamol_signal
 
 from datalab.adapters_metadata import GeometryAdapter, TableAdapter
 from datalab.config import Conf
 from datalab.env import execenv
+from datalab.gui.processor.base import extract_analysis_parameters
 from datalab.objectmodel import get_uuid
 from datalab.tests import datalab_test_app_context
 
@@ -91,6 +92,125 @@ def test_delete_results_signal():
         execenv.print("  ✓ Stats result deleted")
 
 
+def test_delete_results_clears_analysis_parameters():
+    """Test that deleting results also clears analysis parameters.
+
+    This prevents auto_recompute_analysis from attempting to recompute
+    deleted analyses when ROI changes.
+    """
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Test delete_results clears analysis parameters:")
+        panel = win.imagepanel
+
+        # Create a test image
+        param = Gauss2DParam.create(height=200, width=200, sigma=20)
+        img = create_image_from_param(param)
+        panel.add_object(img)
+
+        # Run centroid analysis to create results and store analysis parameters
+        execenv.print("  Running centroid analysis...")
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("centroid")
+
+        # Verify that analysis parameters exist
+        img_refreshed = panel.objmodel[get_uuid(img)]
+        analysis_params = extract_analysis_parameters(img_refreshed)
+        assert analysis_params is not None, (
+            "Analysis parameters should exist after running centroid"
+        )
+        assert analysis_params.func_name == "centroid", (
+            "Analysis parameters should store the centroid function name"
+        )
+        execenv.print("  ✓ Analysis parameters stored")
+
+        # Delete all results
+        execenv.print("  Deleting all results...")
+        panel.objview.select_objects([get_uuid(img)])
+        panel.delete_results()
+
+        # Verify that analysis parameters were also cleared
+        img_after = panel.objmodel[get_uuid(img)]
+        analysis_params_after = extract_analysis_parameters(img_after)
+        assert analysis_params_after is None, (
+            "Analysis parameters should be cleared after deleting results"
+        )
+        execenv.print("  ✓ Analysis parameters cleared")
+
+        # Now add a ROI and verify no auto-recompute happens (no new results)
+        execenv.print("  Adding ROI to verify no auto-recompute...")
+        roi = create_image_roi("rectangle", [25, 25, 100, 100])
+        img_after.roi = roi
+        panel.processor.auto_recompute_analysis(img_after)
+
+        # Verify that no new results were created
+        adapter_after_roi = GeometryAdapter.from_obj(img_after, "centroid")
+        assert adapter_after_roi is None, (
+            "No centroid result should be created after ROI change "
+            "because analysis parameters were cleared"
+        )
+        execenv.print(
+            "  ✓ No auto-recompute after ROI change (analysis params cleared)"
+        )
+        execenv.print("\n✓ All tests passed!")
+
+
+def test_delete_results_after_roi_removed():
+    """Test that deleting results works when ROI was removed from object.
+
+    This tests the fix for the bug where deleting results fails with
+    AttributeError when results contain ROI information but the ROI
+    was subsequently removed from the object.
+    """
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Test delete_results after ROI removed:")
+        panel = win.imagepanel
+
+        # Create a test image with ROI
+        param = Gauss2DParam.create(height=200, width=200, sigma=20)
+        img = create_image_from_param(param)
+        roi = create_image_roi("rectangle", [25, 25, 100, 100])
+        img.roi = roi
+        panel.add_object(img)
+        execenv.print("  ✓ Created image with ROI")
+
+        # Run centroid analysis - this stores ROI index in results
+        execenv.print("  Running centroid analysis with ROI...")
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("centroid")
+
+        # Verify that results exist and contain ROI information
+        img_refreshed = panel.objmodel[get_uuid(img)]
+        adapter_before = GeometryAdapter.from_obj(img_refreshed, "centroid")
+        assert adapter_before is not None, "Centroid result should exist"
+        df = adapter_before.to_dataframe()
+        assert "roi_index" in df.columns, "Results should contain roi_index"
+        execenv.print("  ✓ Centroid result created with ROI information")
+
+        # Now remove the ROI from the object (simulating user action)
+        img_refreshed.roi = None
+        execenv.print("  ✓ Removed ROI from object")
+
+        # Try to delete all results - this should NOT raise an error
+        execenv.print("  Deleting all results (with ROI removed)...")
+        panel.objview.select_objects([get_uuid(img)])
+        try:
+            panel.delete_results()
+            execenv.print("  ✓ Delete results succeeded (no AttributeError)")
+        except AttributeError as e:
+            raise AssertionError(
+                f"delete_results should not raise AttributeError when ROI is None: {e}"
+            ) from e
+
+        # Verify that results were deleted
+        img_after = panel.objmodel[get_uuid(img)]
+        adapter_after = GeometryAdapter.from_obj(img_after, "centroid")
+        assert adapter_after is None, "Centroid result should be deleted"
+        execenv.print("  ✓ Centroid result deleted successfully")
+        execenv.print("\n✓ Test passed!")
+
+
 if __name__ == "__main__":
     test_delete_results_image()
     test_delete_results_signal()
+    test_delete_results_clears_analysis_parameters()
+    test_delete_results_after_roi_removed()

datalab/tests/features/common/roi_plotitem_unit_test.py

@@ -32,11 +32,13 @@ def __conversion_methods(
     single_roi = roi.get_single_roi(0)
     with qt_app_context(exec_loop=False):
         plot_item = create_adapter_from_object(single_roi).to_plot_item(obj)
-        sroi_new = plotitem_to_singleroi(plot_item)
+        sroi_new = plotitem_to_singleroi(plot_item, obj)
         orig_coords = [float(val) for val in single_roi.get_physical_coords(obj)]
         new_coords = [float(val) for val in sroi_new.get_physical_coords(obj)]
         execenv.print(f"{orig_coords} --> {new_coords}")
-        assert np.array_equal(orig_coords, new_coords)
+        # Check that coordinates are close
+        # (allowing for rounding applied during conversion)
+        assert np.allclose(orig_coords, new_coords, rtol=1e-5, atol=1e-10)
 
 
 def test_signal_roi_plotitem_conversion() -> None:

datalab/tests/features/common/update_tree_robustness_test.py

@@ -0,0 +1,65 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Update tree robustness test
+---------------------------
+
+This test verifies that the object tree view handles edge cases gracefully,
+specifically when the tree becomes out of sync with the model.
+
+This is a regression test for a bug where update_tree() crashed with
+AttributeError: 'NoneType' object has no attribute 'setText' when an
+object existed in the model but had no corresponding tree item.
+
+The fix makes update_tree() defensive by calling populate_tree() if
+an item is not found.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import numpy as np
+import sigima.objects
+
+from datalab.tests import datalab_test_app_context
+
+
+def test_update_tree_with_model_tree_desync():
+    """Test that update_tree handles model/tree desynchronization gracefully.
+
+    This test simulates a scenario where an object exists in the model
+    but doesn't have a corresponding tree item, which previously caused
+    an AttributeError in update_tree().
+
+    The fix ensures update_tree() detects this and calls populate_tree()
+    to restore consistency.
+    """
+    with datalab_test_app_context(console=False) as win:
+        win.set_current_panel("image")
+
+        # Create and add a base image
+        data = np.random.rand(100, 100).astype(np.float64)
+        img1 = sigima.objects.create_image("Base Image", data)
+        win.imagepanel.add_object(img1)
+
+        # Create a second image and add it to the MODEL only (not to the tree)
+        # This simulates a desync between model and tree
+        data2 = np.random.rand(100, 100).astype(np.float64)
+        img2 = sigima.objects.create_image("Second Image", data2)
+
+        # Get current group ID
+        group_id = win.imagepanel.objview.get_current_group_id()
+
+        # Add to model ONLY (bypassing add_object_item which adds to tree)
+        win.imagepanel.objmodel.add_object(img2, group_id)
+
+        # Now the model has 2 objects but the tree only shows 1
+        # Calling update_tree() should NOT crash
+        # With the fix, it should call populate_tree() to resync
+
+        # This is the call that previously caused:
+        # AttributeError: 'NoneType' object has no attribute 'setText'
+        win.imagepanel.objview.update_tree()
+
+        # Verify objects are now in sync
+        assert len(win.imagepanel) == 2

datalab/tests/features/control/remoteclient_unit.py

@@ -48,6 +48,16 @@ def multiple_commands(remote: RemoteProxy):
         remote.reset_all()
         remote.open_h5_files([fname], True, False)
         remote.import_h5_file(fname, True)
+
+        # Test new headless workspace API methods (Issue #275)
+        fname_workspace = osp.join(tmpdir, "workspace_test.h5")
+        remote.save_h5_workspace(fname_workspace)
+        assert osp.exists(fname_workspace), "Workspace file was not created"
+        remote.reset_all()
+        remote.load_h5_workspace([fname_workspace], reset_all=True)
+        # Verify objects were restored
+        assert len(remote.get_object_titles()) > 0, "No objects after load_h5_workspace"
+
         remote.set_current_panel("signal")
         assert remote.get_current_panel() == "signal"
         remote.calc("log10")

datalab/tests/features/hdf5/h5workspace_unit_test.py

@@ -0,0 +1,133 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+HDF5 workspace API unit tests
+-----------------------------
+
+Tests for the headless HDF5 workspace API methods:
+- load_h5_workspace: Load native DataLab HDF5 files without GUI elements
+- save_h5_workspace: Save workspace to native DataLab HDF5 file without GUI elements
+
+These methods are designed for use from the internal console where Qt GUI elements
+would cause thread-safety issues.
+"""
+
+# guitest: show
+
+import os.path as osp
+
+import h5py
+import pytest
+from sigima.tests.data import create_noisy_gaussian_image, create_paracetamol_signal
+
+from datalab.tests import datalab_test_app_context, helpers
+
+
+def test_save_and_load_h5_workspace():
+    """Test save_h5_workspace and load_h5_workspace methods"""
+    with helpers.WorkdirRestoringTempDir() as tmpdir:
+        with datalab_test_app_context(console=False) as win:
+            # === Create test objects
+            sig1 = create_paracetamol_signal()
+            win.signalpanel.add_object(sig1)
+
+            ima1 = create_noisy_gaussian_image()
+            win.imagepanel.add_object(ima1)
+
+            # Store object counts and titles for verification
+            sig_count_before = len(win.signalpanel.objmodel)
+            ima_count_before = len(win.imagepanel.objmodel)
+            sig_title = sig1.title
+            ima_title = ima1.title
+
+            # === Test save_h5_workspace
+            fname = osp.join(tmpdir, "test_workspace.h5")
+            win.save_h5_workspace(fname)
+            assert osp.exists(fname), "HDF5 file was not created"
+
+            # === Clear workspace
+            for panel in win.panels:
+                panel.remove_all_objects()
+
+            assert len(win.signalpanel.objmodel) == 0
+            assert len(win.imagepanel.objmodel) == 0
+
+            # === Test load_h5_workspace
+            win.load_h5_workspace([fname], reset_all=True)
+
+            # Verify objects were restored
+            assert len(win.signalpanel.objmodel) == sig_count_before
+            assert len(win.imagepanel.objmodel) == ima_count_before
+
+            # Verify titles (get objects in order from groups)
+            loaded_sig = win.signalpanel.objmodel.get_all_objects()[0]
+            loaded_ima = win.imagepanel.objmodel.get_all_objects()[0]
+            assert loaded_sig.title == sig_title
+            assert loaded_ima.title == ima_title
+
+
+def test_load_h5_workspace_invalid_file():
+    """Test load_h5_workspace raises ValueError for non-native HDF5 files"""
+    with helpers.WorkdirRestoringTempDir() as tmpdir:
+        with datalab_test_app_context(console=False) as win:
+            # Create a non-native HDF5 file (just an empty HDF5)
+            fname = osp.join(tmpdir, "not_native.h5")
+            with h5py.File(fname, "w") as f:
+                f.create_dataset("dummy", data=[1, 2, 3])
+
+            # Should raise ValueError for non-native file
+            with pytest.raises(ValueError, match="not a native DataLab HDF5 file"):
+                win.load_h5_workspace([fname])
+
+
+def test_load_h5_workspace_append():
+    """Test load_h5_workspace with reset_all=False (append mode)"""
+    with helpers.WorkdirRestoringTempDir() as tmpdir:
+        with datalab_test_app_context(console=False) as win:
+            # Create and save first signal
+            sig1 = create_paracetamol_signal()
+            sig1.title = "Signal 1"
+            win.signalpanel.add_object(sig1)
+
+            fname = osp.join(tmpdir, "workspace1.h5")
+            win.save_h5_workspace(fname)
+
+            # Clear and create second signal
+            win.signalpanel.remove_all_objects()
+            sig2 = create_paracetamol_signal()
+            sig2.title = "Signal 2"
+            win.signalpanel.add_object(sig2)
+
+            assert len(win.signalpanel.objmodel) == 1
+
+            # Load first workspace with reset_all=False (append)
+            win.load_h5_workspace([fname], reset_all=False)
+
+            # Should now have both signals (appended)
+            assert len(win.signalpanel.objmodel) == 2
+
+
+def test_save_h5_workspace_modified_flag():
+    """Test that save_h5_workspace clears the modified flag"""
+    with helpers.WorkdirRestoringTempDir() as tmpdir:
+        with datalab_test_app_context(console=False) as win:
+            # Create an object (this sets modified flag)
+            sig1 = create_paracetamol_signal()
+            win.signalpanel.add_object(sig1)
+
+            # Workspace should be modified
+            assert win.is_modified()
+
+            # Save workspace
+            fname = osp.join(tmpdir, "test.h5")
+            win.save_h5_workspace(fname)
+
+            # Modified flag should be cleared
+            assert not win.is_modified()
+
+
+if __name__ == "__main__":
+    test_save_and_load_h5_workspace()
+    test_load_h5_workspace_invalid_file()
+    test_load_h5_workspace_append()
+    test_save_h5_workspace_modified_flag()