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

datalab/tests/features/signal/xarray_compat_app_test.py

@@ -0,0 +1,128 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+X-array compatibility application test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import numpy as np
+from sigima.objects import GaussParam, SignalObj, create_signal_from_param
+
+from datalab.config import Conf
+from datalab.tests import datalab_test_app_context
+
+
+def __check_addition_result(
+    result: SignalObj, s_ref: SignalObj, context: str, coeff: float
+) -> None:
+    """Check that the Y data of the result is the same as the reference signal
+    multiplied by coeff."""
+    assert len(result.x) == len(s_ref.x), f"[{context}] Addition result length mismatch"
+    assert np.allclose(result.y, coeff * s_ref.y, atol=1e-4), (
+        f"[{context}] Addition result value mismatch"
+    )
+
+
+def __check_difference_result(
+    result: SignalObj, s_ref: SignalObj, context: str
+) -> None:
+    """Check that the Y data of the result is zero."""
+    assert len(result.x) == len(s_ref.x), (
+        f"[{context}] Difference result length mismatch"
+    )
+    assert np.allclose(result.y, 0.0, atol=1e-4), (
+        f"[{context}] Difference result value mismatch"
+    )
+
+
+def test_xarray_compatibility_app():
+    """X-array compatibility application test.
+
+    This test aims at verifying that the X-array compatibility feature works as expected
+    in the application context.
+    """
+    with datalab_test_app_context() as win:
+        panel = win.signalpanel
+
+        # Reference parameters:
+        p_ref = GaussParam.create(size=500, xmin=-10, xmax=10)
+
+        # Parameters with the same number of points but different X ranges:
+        p_same_nbp = GaussParam.create(size=500, xmin=-5, xmax=5)
+
+        # Parameters with different number of points but same X ranges:
+        p_same_range = GaussParam.create(size=1000, xmin=-10, xmax=10)
+
+        # Parameters with different number of points and different X ranges:
+        p_different = GaussParam.create(size=1000, xmin=-5, xmax=5)
+
+        panel.add_object(s_ref := create_signal_from_param(p_ref))
+        panel.add_object(s_same_nbp := create_signal_from_param(p_same_nbp))
+        panel.add_object(s_same_range := create_signal_from_param(p_same_range))
+        panel.add_object(s_different := create_signal_from_param(p_different))
+
+        # Test with addition operation:
+        with Conf.proc.xarray_compat_behavior.temp("interpolate"):
+            # Select signals with the same number of points but different X ranges:
+            panel.objview.select_objects([s_ref, s_same_nbp])
+            panel.processor.run_feature("addition")
+            __check_addition_result(
+                panel.objview.get_sel_objects()[0], s_ref, "same_nbp", 2.0
+            )
+
+            # Select signals with different number of points but same X ranges:
+            panel.objview.select_objects([s_ref, s_same_range])
+            panel.processor.run_feature("addition")
+            __check_addition_result(
+                panel.objview.get_sel_objects()[0], s_ref, "same_range", 2.0
+            )
+
+            # Select signals with different number of points and different X ranges:
+            panel.objview.select_objects([s_ref, s_different])
+            panel.processor.run_feature("addition")
+            __check_addition_result(
+                panel.objview.get_sel_objects()[0], s_ref, "different", 2.0
+            )
+
+            # Select all signals and add them:
+            panel.objview.select_objects([s_ref, s_same_nbp, s_same_range, s_different])
+            panel.processor.run_feature("addition")
+            __check_addition_result(
+                panel.objview.get_sel_objects()[0], s_ref, "all", 4.0
+            )
+
+            # Select all signals and average them:
+            panel.objview.select_objects([s_ref, s_same_nbp, s_same_range, s_different])
+            panel.processor.run_feature("average")
+            __check_addition_result(
+                panel.objview.get_sel_objects()[0], s_ref, "all", 1.0
+            )
+
+        # Test with subtraction operation:
+        with Conf.proc.xarray_compat_behavior.temp("interpolate"):
+            # Select signals with the same number of points but different X ranges:
+            panel.objview.select_objects([s_ref])
+            panel.processor.run_feature("difference", obj2=s_same_nbp)
+            __check_difference_result(
+                panel.objview.get_sel_objects()[0], s_ref, "same_nbp"
+            )
+
+            # Select signals with different number of points but same X ranges:
+            panel.objview.select_objects([s_ref])
+            panel.processor.run_feature("difference", obj2=s_same_range)
+            __check_difference_result(
+                panel.objview.get_sel_objects()[0], s_ref, "same_range"
+            )
+
+            # Select signals with different number of points and different X ranges:
+            panel.objview.select_objects([s_ref])
+            panel.processor.run_feature("difference", obj2=s_different)
+            __check_difference_result(
+                panel.objview.get_sel_objects()[0], s_ref, "different"
+            )
+
+
+if __name__ == "__main__":
+    test_xarray_compatibility_app()

datalab/tests/features/tour_unit_test.py

@@ -0,0 +1,22 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Tour test
+"""
+
+# guitest: show
+
+from datalab.gui.tour import start
+from datalab.tests import datalab_test_app_context
+
+
+def test_tour() -> None:
+    """
+    Test the tour of DataLab features.
+    """
+    with datalab_test_app_context() as win:
+        start(win)
+
+
+if __name__ == "__main__":
+    test_tour()

datalab/tests/features/utilities/__init__.py

@@ -0,0 +1 @@
+#

datalab/tests/features/utilities/installconf_unit_test.py

@@ -0,0 +1,21 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Dependencies viewer test
+"""
+
+# guitest: show
+
+from guidata.qthelpers import qt_app_context
+
+from datalab.widgets.instconfviewer import exec_datalab_installconfig_dialog
+
+
+def test_dep_viewer():
+    """Test dep viewer window"""
+    with qt_app_context():
+        exec_datalab_installconfig_dialog()
+
+
+if __name__ == "__main__":
+    test_dep_viewer()

datalab/tests/features/utilities/logview_app_test.py

@@ -0,0 +1,21 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Log viewer test
+"""
+
+# guitest: show
+
+from datalab.app import run
+from datalab.tests import helpers
+from datalab.tests.features.utilities import logview_error
+
+
+def test_logviewer_app():
+    """Test log viewer"""
+    helpers.exec_script(logview_error.__file__)
+    run()
+
+
+if __name__ == "__main__":
+    test_logviewer_app()

datalab/tests/features/utilities/logview_error.py

@@ -0,0 +1,24 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Log viewer test: raise an exception and create a seg fault in DataLab
+"""
+
+# guitest: skip
+
+from guidata.qthelpers import qt_app_context
+
+from datalab.env import execenv
+from datalab.gui.main import DLMainWindow
+
+
+def error():
+    """Raise an exception and create a seg fault in DataLab"""
+    with execenv.context(unattended=True):
+        with qt_app_context(exec_loop=True):
+            win = DLMainWindow()
+            win.test_segfault_error()
+
+
+if __name__ == "__main__":
+    error()

datalab/tests/features/utilities/logview_unit_test.py

@@ -0,0 +1,21 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Log viewer test
+"""
+
+# guitest: show
+
+from guidata.qthelpers import qt_app_context
+
+from datalab.widgets.logviewer import exec_datalab_logviewer_dialog
+
+
+def test_logviewer_dialog():
+    """Test log viewer window"""
+    with qt_app_context():
+        exec_datalab_logviewer_dialog()
+
+
+if __name__ == "__main__":
+    test_logviewer_dialog()

datalab/tests/features/utilities/memstatus_app_test.py

@@ -0,0 +1,42 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Memory status widget application test
+"""
+
+# guitest: show
+
+import numpy as np
+import psutil
+from sigima.objects import Gauss2DParam
+
+from datalab import config
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+
+
+def memory_alarm(threshold):
+    """Memory alarm test"""
+    config.Conf.main.available_memory_threshold.set(threshold)
+    rng = np.random.default_rng()
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        win.memorystatus.update_status()  # Force memory status update
+        param = Gauss2DParam.create(
+            x0=rng.integers(-9, 9), y0=rng.integers(-9, 9), sigma=rng.integers(1, 20)
+        )
+        panel.new_object(param, edit=False)
+
+
+def test_mem_status():
+    """Memory alarm test"""
+    mem_available = psutil.virtual_memory().available // (1024**2)
+    execenv.print(f"Memory status widget test (memory available: {mem_available} MB):")
+    for index, threshold in enumerate((mem_available * 2, mem_available - 100)):
+        execenv.print(f"    Threshold {index}: {threshold} MB")
+        memory_alarm(threshold)
+    config.reset()
+
+
+if __name__ == "__main__":
+    test_mem_status()

datalab/tests/features/utilities/settings_unit_test.py

@@ -0,0 +1,88 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DataLab settings test
+"""
+
+# guitest: show
+
+import guidata.dataset as gds
+from guidata.dataset.qtwidgets import DataSetGroupEditDialog
+from guidata.qthelpers import qt_app_context
+from qtpy import QtWidgets as QW
+
+from datalab.config import _
+from datalab.env import execenv
+from datalab.gui.settings import create_dataset_dict, edit_settings
+from datalab.utils import qthelpers as qth
+
+
+def test_edit_settings():
+    """Test edit settings"""
+    with qt_app_context():
+        changed = edit_settings(None)
+        execenv.print(changed)
+
+
+def capture_settings_screenshots():
+    """Capture screenshots of each settings tab
+
+    Note: Screenshot filenames are language-independent (use English names)
+    to ensure consistency across different language builds.
+    """
+    with qt_app_context(exec_loop=False):
+        paramdict = create_dataset_dict()
+        params = gds.DataSetGroup(paramdict.values(), title=_("Settings"))
+        names = list(paramdict.keys())
+
+        # Define fixed sub-tab names for View settings (language-independent)
+        # These correspond to the order of BeginGroup items in ViewSettings
+        view_subtab_names = ["common", "signals", "images", "results"]
+
+        # Create the dialog manually so we can access the tab widget
+        dialog = DataSetGroupEditDialog(
+            instance=params, icon="", parent=None, apply=None, wordwrap=True, size=None
+        )
+
+        # Find the main QTabWidget in the dialog
+        main_tab_widget = dialog.findChild(QW.QTabWidget)
+
+        if main_tab_widget is not None:
+            # Take a screenshot of each main tab
+            for i in range(main_tab_widget.count()):
+                main_tab_widget.setCurrentIndex(i)
+                dialog.show()
+                tab_name = names[i]
+
+                # Check if this tab contains a nested tab widget (like View settings)
+                current_widget = main_tab_widget.currentWidget()
+                nested_tab_widgets = current_widget.findChildren(QW.QTabWidget)
+
+                if nested_tab_widgets:
+                    # Handle nested tabs (e.g., Common, Signals, Images, Results)
+                    nested_tab_widget = nested_tab_widgets[0]
+                    for j in range(nested_tab_widget.count()):
+                        nested_tab_widget.setCurrentIndex(j)
+                        # Use predefined names instead of translated tab text
+                        if tab_name == "view" and j < len(view_subtab_names):
+                            nested_tab_name = view_subtab_names[j]
+                        else:
+                            # Fallback for any other potential nested tabs
+                            nested_tab_name = f"tab{j}"
+                        qth.grab_save_window(
+                            dialog,
+                            f"settings_{tab_name}_{nested_tab_name}",
+                            add_timestamp=False,
+                        )
+                else:
+                    # No nested tabs, just take a screenshot of the main tab
+                    qth.grab_save_window(
+                        dialog, f"settings_{tab_name}", add_timestamp=False
+                    )
+
+        # Don't execute the dialog, just close it
+        dialog.close()
+
+
+if __name__ == "__main__":
+    capture_settings_screenshots()

datalab/tests/scenarios/__init__.py

@@ -0,0 +1 @@
+#

datalab/tests/scenarios/beautiful_app.py

@@ -0,0 +1,121 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+beautiful_app
+-------------
+
+A high-level test scenario producing beautiful screenshots.
+
+.. note::
+
+    This scenario is used to produce screenshots for the documentation.
+    Thus, it is not run by default when running all tests.
+
+.. warning::
+
+    When modifying this scenario, please update the script "update_screenshots.py"
+    in the "doc" folder.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show,skip
+
+import sigima.objects
+import sigima.params
+from sigima.tests.data import get_test_image
+
+from datalab.config import Conf
+from datalab.tests import datalab_test_app_context
+
+
+def run_beautiful_scenario(screenshots: bool = False) -> None:
+    """High-level test scenario producing beautiful screenshots"""
+    data_size = 500
+    with datalab_test_app_context(console=False, exec_loop=not screenshots) as win:
+        # Beautiful screenshot of a signal
+        panel = win.signalpanel
+        sig = sigima.objects.create_signal_from_param(sigima.objects.LorentzParam())
+        panel.add_object(sig)
+        panel.processor.run_feature("fft")
+        panel.processor.run_feature("wiener")
+        panel.processor.run_feature("derivative")
+        panel.processor.run_feature("integral")
+        panel.processor.run_feature("gaussian_filter", sigima.params.GaussianParam())
+        panel.processor.run_feature("fft")
+        panel.processor.run_feature("derivative")
+        # Beautiful screenshot of an image
+        panel = win.imagepanel
+        param = sigima.objects.Gauss2DParam.create(height=data_size, width=data_size)
+        ima = sigima.objects.create_image_from_param(param)
+        ima.set_metadata_option("colormap", "jet")
+        panel.add_object(ima)
+        panel.processor.run_feature("equalize_hist", sigima.params.EqualizeHistParam())
+        panel.processor.run_feature(
+            "equalize_adapthist", sigima.params.EqualizeAdaptHistParam()
+        )
+        panel.processor.run_feature("denoise_tv", sigima.params.DenoiseTVParam())
+        panel.processor.run_feature(
+            "denoise_wavelet", sigima.params.DenoiseWaveletParam()
+        )
+        panel.processor.run_feature("white_tophat", sigima.params.MorphologyParam())
+        panel.processor.run_feature("denoise_tv", sigima.params.DenoiseTVParam())
+        n = data_size // 3
+        roi = sigima.objects.create_image_roi(
+            "rectangle", [n, n, data_size - 2 * n, data_size - 2 * n]
+        )
+        panel.processor.compute_roi_extraction(roi)
+        if screenshots:
+            win.statusBar().hide()
+            win.take_screenshot("i_beautiful")
+            win.take_menu_screenshots()
+            win.set_current_panel(win.signalpanel)
+            win.take_screenshot("s_beautiful")
+
+
+def run_blob_detection_on_flower_image(screenshots: bool = False) -> None:
+    """High-level test scenario for flower image with ROI extraction
+
+    This scenario creates:
+    - A flower test image
+    - Roberts edge detection filter applied
+    - A rectangular ROI extraction
+    - A closing morphological filter to clean up the result
+    - Blob detection using OpenCV algorithm
+    """
+    with datalab_test_app_context(console=False, exec_loop=not screenshots) 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'"
+        panel.add_object(ima)
+
+        # Apply Roberts filter for edge detection
+        panel.processor.run_feature("roberts")
+
+        # Extract a rectangular ROI
+        roi = sigima.objects.create_image_roi("rectangle", [32, 64, 448, 384])
+        panel.processor.compute_roi_extraction(roi)
+
+        # Apply a closing morphological filter to clean up the result
+        closing_param = sigima.params.MorphologyParam.create(radius=10)
+        panel.processor.run_feature("closing", closing_param)
+
+        # Detect blobs using OpenCV algorithm
+        param = sigima.params.BlobOpenCVParam()
+        param.filter_by_color = False
+        param.min_area = 400
+        param.max_area = 1000
+        param.filter_by_circularity = True
+        param.min_circularity = 0.7
+        with Conf.proc.show_result_dialog.temp(False):
+            with Conf.view.show_result_label.temp(False):
+                panel.processor.run_feature("blob_opencv", param)
+                if screenshots:
+                    win.statusBar().hide()
+                    win.take_screenshot("i_blob_detection_flower")
+
+
+if __name__ == "__main__":
+    run_blob_detection_on_flower_image(screenshots=False)