datalab-platform 1.0.2__py3-none-any.whl → 1.0.4__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

@@ -75,7 +75,7 @@ def test_round_image_coords():
     assert rounded == [10.0, 21.0, 31.0, 40.0]
 
     # Test with empty coords
-    assert round_image_coords(img, []) == []
+    assert not round_image_coords(img, [])
 
     # Test error for odd number of coordinates
     with pytest.raises(ValueError, match="even number of elements"):

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/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()

datalab/tests/features/image/roigrid_unit_test.py

@@ -55,6 +55,81 @@ def test_roi_grid_geometry_headless() -> None:
         assert dy == img.height / 2 * 0.5
 
 
+def test_roi_grid_custom_step() -> None:
+    """Test ROI grid with custom xstep/ystep parameters.
+
+    This test verifies the bug fix for Issue #XXX where grid ROI extraction
+    was not working correctly for images with non-uniformly distributed features
+    (e.g., laser spot arrays with gaps between spots).
+
+    The bug was that xstep and ystep parameters were missing, so users couldn't
+    adjust the spacing between ROIs when spots don't fill the entire image.
+    """
+    img = create_grid_of_gaussian_images()
+
+    # Test Case 1: Custom step to simulate tighter spacing (e.g., laser spots)
+    gp = ROIGridParam()
+    gp.nx, gp.ny = 3, 3
+    gp.xsize = gp.ysize = 20  # Small ROI size (20% of cell)
+    gp.xtranslation = gp.ytranslation = 50  # Centered
+    gp.xstep = gp.ystep = 75  # Tighter spacing (75% instead of 100%)
+    gp.xdirection = gp.ydirection = Direction.INCREASING
+
+    with qt_app_context():
+        dlg = ImageGridROIEditor(parent=None, obj=img, gridparam=gp)
+        dlg.update_obj(update_item=False)
+        roi = dlg.get_roi()
+        assert roi is not None
+        # 9 ROIs for 3x3 grid
+        assert len(list(roi)) == 9
+
+        # Verify spacing is correctly applied
+        r11 = next(r for r in roi if r.title == "ROI(1,1)")
+        r12 = next(r for r in roi if r.title == "ROI(1,2)")
+        x0_r11, _, _, _ = r11.get_physical_coords(img)
+        x0_r12, _, _, _ = r12.get_physical_coords(img)
+
+        # Expected spacing: (width / nx) * (xstep / 100)
+        expected_spacing = (img.width / gp.nx) * (gp.xstep / 100.0)
+        actual_spacing = x0_r12 - x0_r11
+
+        # Allow 1% tolerance for numerical precision
+        assert abs(actual_spacing - expected_spacing) / expected_spacing < 0.01
+
+    # Test Case 2: Different X and Y steps
+    gp2 = ROIGridParam()
+    gp2.nx, gp2.ny = 2, 2
+    gp2.xsize = gp2.ysize = 30
+    gp2.xtranslation = gp2.ytranslation = 50
+    gp2.xstep = 80  # Tighter X spacing
+    gp2.ystep = 120  # Wider Y spacing
+    gp2.xdirection = gp2.ydirection = Direction.INCREASING
+
+    with qt_app_context():
+        dlg2 = ImageGridROIEditor(parent=None, obj=img, gridparam=gp2)
+        dlg2.update_obj(update_item=False)
+        roi2 = dlg2.get_roi()
+        assert roi2 is not None
+        assert len(list(roi2)) == 4
+
+        # Verify X spacing (80%)
+        r11 = next(r for r in roi2 if r.title == "ROI(1,1)")
+        r12 = next(r for r in roi2 if r.title == "ROI(1,2)")
+        x0_r11, y0_r11, _, _ = r11.get_physical_coords(img)
+        x0_r12, _, _, _ = r12.get_physical_coords(img)
+        expected_x_spacing = (img.width / gp2.nx) * 0.8
+        actual_x_spacing = x0_r12 - x0_r11
+        assert abs(actual_x_spacing - expected_x_spacing) / expected_x_spacing < 0.01
+
+        # Verify Y spacing (120%)
+        r21 = next(r for r in roi2 if r.title == "ROI(2,1)")
+        _, y0_r21, _, _ = r21.get_physical_coords(img)
+        expected_y_spacing = (img.height / gp2.ny) * 1.2
+        actual_y_spacing = y0_r21 - y0_r11
+        assert abs(actual_y_spacing - expected_y_spacing) / expected_y_spacing < 0.01
+
+
 if __name__ == "__main__":
     test_roi_grid_geometry_headless()
+    test_roi_grid_custom_step()
     test_roi_grid(screenshots=True)

datalab/tests/features/macro/macroeditor_unit_test.py

@@ -25,7 +25,7 @@ from qtpy import QtWidgets as QW
 
 from datalab.env import execenv
 from datalab.gui.macroeditor import Macro
-from datalab.gui.panel import macro
+from datalab.gui.panel.macro import MacroPanel
 from datalab.tests import datalab_test_app_context, helpers
 
 
@@ -56,7 +56,7 @@ print("All done! :)")
 def test_macro_editor():
     """Test dep viewer window"""
     with qt_app_context(exec_loop=True):
-        widget = macro.MacroPanel(None)
+        widget = MacroPanel(None)
         widget.resize(800, 600)
         widget.show()
 

datalab/widgets/imagebackground.py

@@ -6,12 +6,12 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 from guidata.configtools import get_icon
 from plotpy.builder import make
-from plotpy.plot import PlotDialog
+from plotpy.plot import PlotDialog, PlotOptions
 
 from datalab.adapters_plotpy import create_adapter_from_object
 from datalab.config import _
@@ -29,16 +29,25 @@ class ImageBackgroundDialog(PlotDialog):
     Args:
         image: image object
         parent: parent widget. Defaults to None.
+        options: plot options. Defaults to None.
     """
 
-    def __init__(self, image: ImageObj, parent: QWidget | None = None) -> None:
+    def __init__(
+        self,
+        image: ImageObj,
+        parent: QWidget | None = None,
+        options: PlotOptions | dict[str, Any] | None = None,
+    ) -> None:
         self.__background: float | None = None
         self.__rect_coords: tuple[float, float, float, float] | None = None
         self.imageitem: MaskedXYImageItem | None = None
         self.rectarea: RectangleShape | None = None
         self.comput2d: RangeComputation2d | None = None
         super().__init__(
-            title=_("Image background selection"), edit=True, parent=parent
+            title=_("Image background selection"),
+            edit=True,
+            parent=parent,
+            options=options,
         )
         self.setObjectName("backgroundselection")
         if parent is None:

datalab/widgets/instconfviewer.py

@@ -89,8 +89,8 @@ def get_manifest_package_info(manifest_path: Path) -> str:
             result_lines.append(f"{name:{name_width}}   {version:{version_width}}")
 
         return os.linesep.join(result_lines)
-    except Exception as e:
-        return f"Error reading manifest file: {e}"
+    except Exception as exc:  # pylint: disable=broad-except
+        return f"Error reading manifest file: {exc}"
 
 
 def get_install_info() -> str:

datalab/widgets/signalcursor.py

@@ -12,6 +12,7 @@ import numpy as np
 from guidata.configtools import get_icon
 from plotpy.builder import make
 from plotpy.plot import PlotDialog
+from qtpy import QtCore as QC
 from qtpy import QtGui as QG
 from qtpy import QtWidgets as QW
 from sigima.tools.signal.features import find_x_values_at_y
@@ -76,10 +77,14 @@ class SignalCursorDialog(PlotDialog):
         ylabel = QW.QLabel("Y=")
         self.xlineedit = QW.QLineEdit()
         self.xlineedit.editingFinished.connect(self.xlineedit_editing_finished)
-        self.xlineedit.setValidator(QG.QDoubleValidator())
+        x_validator = QG.QDoubleValidator()
+        x_validator.setLocale(QC.QLocale("C"))
+        self.xlineedit.setValidator(x_validator)
         self.ylineedit = QW.QLineEdit()
         self.ylineedit.editingFinished.connect(self.ylineedit_editing_finished)
-        self.ylineedit.setValidator(QG.QDoubleValidator())
+        y_validator = QG.QDoubleValidator()
+        y_validator.setLocale(QC.QLocale("C"))
+        self.ylineedit.setValidator(y_validator)
         self.xlineedit.setReadOnly(self.__cursor_orientation == "horizontal")
         self.xlineedit.setDisabled(self.__cursor_orientation == "horizontal")
         self.ylineedit.setReadOnly(self.__cursor_orientation == "vertical")

datalab/widgets/signaldeltax.py

@@ -15,6 +15,7 @@ import numpy as np
 from guidata.configtools import get_icon
 from plotpy.builder import make
 from plotpy.plot import PlotDialog
+from qtpy import QtCore as QC
 from qtpy import QtGui as QG
 from qtpy import QtWidgets as QW
 from sigima.tools.signal.pulse import full_width_at_y
@@ -68,7 +69,9 @@ class SignalDeltaXDialog(PlotDialog):
         self.deltaxlineedit.setDisabled(True)
         self.ylineedit = QW.QLineEdit()
         self.ylineedit.editingFinished.connect(self.ylineedit_editing_finished)
-        self.ylineedit.setValidator(QG.QDoubleValidator())
+        y_validator = QG.QDoubleValidator()
+        y_validator.setLocale(QC.QLocale("C"))
+        self.ylineedit.setValidator(y_validator)
         xygroup = QW.QGroupBox(_("Cursor position"))
         xylayout = QW.QHBoxLayout()
         xylayout.addWidget(xlabel)