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

datalab/tests/backbone/procisolation2_unit.py

@@ -0,0 +1,171 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Process isolation unit test
+---------------------------
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: skip
+
+import time
+from multiprocessing import Pool
+
+import numpy as np
+import scipy.signal as sps
+from guidata.configtools import get_icon
+from guidata.qthelpers import qt_app_context
+from plotpy.plot import PlotOptions, PlotWidget
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+from sigima.objects import NewImageParam
+from sigima.tests.data import create_2d_random, create_noisy_gaussian_image
+
+from datalab.adapters_plotpy import create_adapter_from_object
+from datalab.env import execenv
+
+
+class MainWindow(QW.QMainWindow):
+    """Multiprocessing test main window"""
+
+    SIG_COMPUTATION_FINISHED = QC.Signal()
+
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle("DataLab Multiprocessing test")
+        self.setWindowIcon(get_icon("datalab.svg"))
+
+        # Setting up the layout and widgets
+        self.imagewidget = PlotWidget(options=PlotOptions(type="image"))
+        self.setCentralWidget(self.imagewidget)
+        self.layout = QW.QVBoxLayout(self.imagewidget)
+
+        self.start_button = QW.QPushButton("Start Computation", self)
+        self.start_button.clicked.connect(self.start_computation)
+        self.layout.addWidget(self.start_button)
+
+        self.cancel_button = QW.QPushButton("Cancel Computation", self)
+        self.cancel_button.clicked.connect(self.cancel_computation)
+        self.layout.addWidget(self.cancel_button)
+
+        # Create a test image and add it to the plot
+        param = NewImageParam.create(height=1000, width=1000)
+        image = create_noisy_gaussian_image(param, add_annotations=True)
+        self.imageitem = create_adapter_from_object(image).make_item()
+        self.imagewidget.plot.add_item(self.imageitem)
+
+        self.array = image.data
+        self.result = None
+        self.timer = QC.QTimer()
+        self.timer.setInterval(10)  # Check every 100 ms
+        self.timer.timeout.connect(self.check_process)
+        self.start_time = None
+
+        self.SIG_COMPUTATION_FINISHED.connect(self.update_plot)
+
+    @staticmethod
+    def long_running_task(array: np.ndarray) -> None:
+        """
+        A long running task that computes a median filter on the input array and puts
+        the result in the queue. The done_event is set when the computation is finished.
+
+        Args:
+            array (numpy.ndarray): The input data to compute the filter on.
+        """
+        start_time = time.time()
+        result = sps.medfilt(array, 1) + create_2d_random(array.shape[0], array.dtype)
+        execenv.print(f"Computation done: delta={time.time() - start_time:.3f} s")
+        return result
+
+    def print_time(self, title: str) -> None:
+        """
+        Prints the time since the last call to this method and resets the start_time.
+
+        Args:
+            title (str): The title to print before the time.
+        """
+        execenv.print(f"{title}: {time.time() - self.start_time:.3f} s")
+        self.start_time = time.time()
+
+    def start_computation(self) -> None:
+        """
+        Starts the computation in a separate process and starts the timer.
+        """
+        global POOL  # pylint: disable=global-statement,global-variable-not-assigned
+        if self.result and not self.result.ready():
+            self.print_time("Computation already running!")
+            return
+        self.start_time = time.time()
+        self.result = POOL.apply_async(self.long_running_task, (self.array,))
+        self.timer.start()
+        self.print_time("Computation started")
+
+    def cancel_computation(self) -> None:
+        """
+        Cancels the computation by terminating the process and stopping the timer.
+        """
+        global POOL  # pylint: disable=global-statement
+        # Terminate the process and stop the timer
+        POOL.terminate()
+        POOL.join()
+        self.timer.stop()
+        execenv.print("Computation cancelled!")
+        # Recreate the pool for the next computation
+        POOL = Pool(processes=1)  # pylint: disable=not-callable,consider-using-with
+
+    def check_process(self) -> None:
+        """
+        Checks if the computation is finished. If it is, stops the timer and calls
+        the method to handle the computation finishing.
+        """
+        if self.result.ready():
+            self.print_time("Computation finished")
+            self.timer.stop()
+            self.on_computation_finished()
+
+    def on_computation_finished(self) -> None:
+        """
+        Retrieves the result from the queue
+        and emits the SIG_COMPUTATION_FINISHED signal.
+        """
+        self.array = self.result.get()
+        self.SIG_COMPUTATION_FINISHED.emit()
+        self.print_time("Computation result retrieved")
+
+    def update_plot(self) -> None:
+        """
+        Updates the plot with the result of the computation.
+        """
+        self.imageitem.set_data(self.array)
+        self.imagewidget.plot.replot()
+        self.print_time("Plot updated")
+
+    def closeEvent(self, event) -> None:
+        """
+        Overrides the closeEvent to stop the timer
+        and terminate the process when the window is closed.
+
+        Args:
+            event: The close event.
+        """
+        self.timer.stop()
+        super().closeEvent(event)
+
+
+def test_multiprocessing2() -> None:
+    """
+    Creates a PyQt application context, shows the main window,
+    and starts the event loop.
+    """
+    global POOL  # pylint: disable=global-statement,global-variable-not-assigned
+    with qt_app_context(exec_loop=True):
+        window = MainWindow()
+        window.show()
+    POOL.terminate()
+    POOL.join()
+
+
+if __name__ == "__main__":
+    POOL = Pool(processes=1)  # pylint: disable=not-callable,consider-using-with
+    test_multiprocessing2()

datalab/tests/backbone/procisolation_unit_test.py

@@ -0,0 +1,22 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Process isolation unit test
+---------------------------
+
+Just test if it's possible to run the process isolation test from another module. This
+may be an issue with the Pool object being global.
+"""
+
+# guitest: show
+
+from datalab.tests.backbone import procisolation1_unit
+
+
+def test_procisolation():
+    """Test process isolation"""
+    procisolation1_unit.test_multiprocessing1()
+
+
+if __name__ == "__main__":
+    test_procisolation()

datalab/tests/backbone/profiling_app.py

@@ -0,0 +1,27 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Profiling
+"""
+
+# guitest: skip
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+
+
+def test_profiling():
+    """Profiling test"""
+    with execenv.context(unattended=True):
+        with datalab_test_app_context() as win:
+            win.open_h5_files(
+                [
+                    "C:/Dev/Projets/X-GRID_data/Projets_Oasis/XGRID5/"
+                    "VS000001-blobs_doh_profiling.h5"
+                ],
+                import_all=True,
+            )
+
+
+if __name__ == "__main__":
+    test_profiling()

datalab/tests/backbone/strings_unit_test.py

@@ -0,0 +1,65 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+String utilities unit tests for DataLab
+
+Testing the string utility functions in datalab.utils.strings module,
+particularly the save_html_diff function which is useful for debugging
+and comparing text differences.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from datalab.utils.strings import save_html_diff
+
+
+@pytest.fixture
+def temp_html_file():
+    """Fixture providing a temporary file path for HTML diff output."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        yield os.path.join(tmpdir, "test_diff.html")
+
+
+def test_save_html_diff_basic(temp_html_file):  # pylint: disable=W0621
+    """Test that save_html_diff creates a valid HTML file with diff content."""
+    text1 = "Line 1\nLine 2\nLine 3"
+    text2 = "Line 1\nModified Line 2\nLine 3"
+
+    with patch("webbrowser.open"):
+        save_html_diff(text1, text2, "Before", "After", temp_html_file)
+
+    # Verify file creation and basic structure
+    assert Path(temp_html_file).exists()
+    content = Path(temp_html_file).read_text(encoding="utf-8")
+    assert "<!DOCTYPE html" in content or "<html" in content
+    assert "Before" in content
+    assert "After" in content
+
+
+def test_save_html_diff_edge_cases(temp_html_file):  # pylint: disable=W0621
+    """Test save_html_diff with edge cases: empty strings and Unicode."""
+    # Test with empty string
+    with patch("webbrowser.open"):
+        save_html_diff("", "New content", "Empty", "Added", temp_html_file)
+
+    assert Path(temp_html_file).exists()
+
+    # Test with Unicode
+    with patch("webbrowser.open"):
+        save_html_diff(
+            "Hello 世界", "Bonjour monde", "中文", "Français", temp_html_file
+        )
+
+    content = Path(temp_html_file).read_text(encoding="utf-8")
+    assert "中文" in content or "Fran" in content  # Descriptions should be present
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

datalab/tests/backbone/title_formatting_unit_test.py

@@ -0,0 +1,82 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DataLab-specific title formatting configuration tests
+
+This module verifies that DataLab correctly configures the Sigima title formatting
+system. The actual functionality of the title formatting system is comprehensively
+tested in Sigima's test suite (sigima.tests.common.title_formatting_unit_test).
+
+This test suite only verifies:
+  - DataLab uses PlaceholderTitleFormatter by default (required for DataLab)
+  - DataLab-specific complex parameter patterns work correctly
+
+For comprehensive tests of the title formatting system itself, see:
+  sigima/tests/common/title_formatting_unit_test.py
+"""
+
+from __future__ import annotations
+
+import pytest
+from sigima import create_signal
+from sigima.proc.base import dst_1_to_1
+from sigima.proc.title_formatting import (
+    PlaceholderTitleFormatter,
+    get_default_title_formatter,
+    set_default_title_formatter,
+)
+
+
+class TestDataLabTitleFormattingConfiguration:
+    """Test suite verifying DataLab's title formatting configuration.
+
+    Note: Comprehensive tests of the title formatting system itself are in
+    sigima/tests/common/title_formatting_unit_test.py. These tests only verify
+    DataLab-specific configuration and usage patterns.
+    """
+
+    def test_datalab_uses_placeholder_formatter_by_default(self):
+        """Verify DataLab is configured with PlaceholderTitleFormatter by default.
+
+        This is critical for DataLab's workflow, as placeholder titles like
+        "wiener({0})" are later resolved by DataLab's patch_title_with_ids()
+        function to create titles like "wiener(s001)".
+        """
+        current_formatter = get_default_title_formatter()
+        assert isinstance(current_formatter, PlaceholderTitleFormatter), (
+            "DataLab must use PlaceholderTitleFormatter for proper title resolution"
+        )
+
+    def test_complex_datalab_parameter_patterns(self):
+        """Test complex parameter strings typical in DataLab.
+
+        DataLab often uses complex, multi-valued parameter strings in operation
+        titles. This test verifies these patterns work correctly.
+        """
+        original_formatter = get_default_title_formatter()
+        try:
+            set_default_title_formatter(PlaceholderTitleFormatter())
+
+            signal = create_signal("Test", x=[1, 2, 3], y=[4, 5, 6])
+
+            # Test DataLab's typical complex parameter patterns
+            complex_params = [
+                "sigma=1.5,mode=constant",
+                "window=hamming,nperseg=256,noverlap=128",
+                "method=butterworth,order=4,critical_freq=0.1",
+                "roi=[10,20,30,40],background=auto",
+            ]
+
+            for params in complex_params:
+                result = dst_1_to_1(signal, "filter", params)
+                expected = f"filter({{0}})|{params}"
+                assert result.title == expected, (
+                    f"Complex parameter '{params}' not preserved in title"
+                )
+
+        finally:
+            set_default_title_formatter(original_formatter)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

datalab/tests/conftest.py

@@ -0,0 +1,131 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DataLab pytest configuration
+----------------------------
+
+This file contains the configuration for running pytest in DataLab. It is
+executed before running any tests.
+"""
+
+import os
+import os.path as osp
+
+import guidata
+import h5py
+import numpy
+import plotpy
+import pytest
+import qtpy
+import qwt
+import scipy
+import sigima
+import skimage
+from guidata.config import ValidationMode, set_validation_mode
+from guidata.utils.gitreport import format_git_info_for_pytest, get_git_info_for_modules
+from sigima.tests import helpers
+
+import datalab
+from datalab.env import execenv
+from datalab.plugins import PluginRegistry, get_available_plugins
+
+# Set validation mode to STRICT for all tests
+set_validation_mode(ValidationMode.STRICT)
+
+# Turn on unattended mode for executing tests without user interaction
+execenv.unattended = True
+execenv.verbose = "quiet"
+
+INITIAL_CWD = os.getcwd()
+
+
+def pytest_addoption(parser):
+    """Add custom command line options to pytest."""
+    parser.addoption(
+        "--show-windows",
+        action="store_true",
+        default=False,
+        help="Display Qt windows during tests (disables QT_QPA_PLATFORM=offscreen)",
+    )
+
+
+def pytest_report_header(config):  # pylint: disable=unused-argument
+    """Add additional information to the pytest report header."""
+    nfstr = ", ".join(
+        f"{plugin.info.name} {plugin.info.version}"
+        for plugin in get_available_plugins()
+    )
+    qtbindings_version = qtpy.PYSIDE_VERSION
+    if qtbindings_version is None:
+        qtbindings_version = qtpy.PYQT_VERSION
+    infolist = [
+        f"DataLab {datalab.__version__} [Plugins: {nfstr if nfstr else 'None'}]",
+        f"  sigima {sigima.__version__},",
+        f"  guidata {guidata.__version__}, PlotPy {plotpy.__version__}",
+        f"  PythonQwt {qwt.__version__}, "
+        f"{qtpy.API_NAME} {qtbindings_version} [Qt version: {qtpy.QT_VERSION}]",
+        f"  NumPy {numpy.__version__}, SciPy {scipy.__version__}, "
+        f"h5py {h5py.__version__}, scikit-image {skimage.__version__}",
+    ]
+    try:
+        import cv2  # pylint: disable=import-outside-toplevel
+
+        infolist[-1] += f", OpenCV {cv2.__version__}"
+    except ImportError:
+        pass
+    envlist = []
+    for vname in ("DATALAB_DATA", "PYTHONPATH", "DEBUG", "QT_API", "QT_QPA_PLATFORM"):
+        value = os.environ.get(vname, "")
+        if value:
+            if vname == "PYTHONPATH":
+                pathlist = value.split(os.pathsep)
+                envlist.append(f"  {vname}:")
+                envlist.extend(f"    {p}" for p in pathlist if p)
+            else:
+                envlist.append(f"  {vname}: {value}")
+    if envlist:
+        infolist.append("Environment variables:")
+        infolist.extend(envlist)
+    infolist.append("Test paths:")
+    for test_path in helpers.get_test_paths():
+        test_path = osp.abspath(test_path)
+        infolist.append(f"  {test_path}")
+
+    # Git information for all modules using the new gitreport module
+    modules_config = [
+        ("DataLab", datalab, "."),  # DataLab uses current directory
+        ("guidata", guidata, None),
+        ("PlotPy", plotpy, None),
+        ("Sigima", sigima, None),
+    ]
+    git_repos = get_git_info_for_modules(modules_config)
+    git_info_lines = format_git_info_for_pytest(git_repos, "DataLab")
+    if git_info_lines:
+        infolist.extend(git_info_lines)
+
+    return infolist
+
+
+def pytest_configure(config):
+    """Add custom markers to pytest."""
+    if config.option.durations is None:
+        config.option.durations = 20  # Default to showing 20 slowest tests
+    config.addinivalue_line(
+        "markers",
+        "validation: mark a test as a validation test (ground truth or analytical)",
+    )
+    if not config.getoption("--show-windows"):
+        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+
+@pytest.fixture(autouse=True)
+def reset_cwd(request):  # pylint: disable=unused-argument
+    """Reset the current working directory to the initial one after each test."""
+    yield
+    os.chdir(INITIAL_CWD)
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_runtest_teardown(item, nextitem):  # pylint: disable=unused-argument
+    """Run teardown after each test."""
+    PluginRegistry.unregister_all_plugins()

datalab/tests/features/__init__.py

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

datalab/tests/features/applauncher/__init__.py

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

datalab/tests/features/applauncher/launcher1_app_test.py

@@ -0,0 +1,28 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Basic application launcher test 1
+
+Running application a few times in a row with different entry parameters.
+"""
+
+# guitest: show
+
+from datalab import app
+from datalab.env import execenv
+from datalab.utils.qthelpers import datalab_app_context
+
+
+def test_launcher1(screenshots: bool = False):
+    """Testing DataLab app launcher"""
+    with datalab_app_context(exec_loop=not screenshots):
+        execenv.print("Opening DataLab with no argument")
+        win = app.create()
+        if screenshots:
+            win.statusBar().hide()
+            win.take_screenshot("s_app_at_startup")
+            win.close()
+
+
+if __name__ == "__main__":
+    test_launcher1()

datalab/tests/features/applauncher/launcher2_app_test.py

@@ -0,0 +1,30 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Basic application launcher test 2
+
+Create signal and image objects (with circles, rectangles, segments and markers),
+then open DataLab to show them.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from sigima.objects import NewImageParam
+from sigima.tests import data as test_data
+
+from datalab.app import run
+
+
+def test_launcher2():
+    """Simple test"""
+    sig1 = test_data.create_paracetamol_signal()
+    sig2 = test_data.create_noisy_signal()
+    param = NewImageParam.create(height=2000, width=2000)
+    ima1 = test_data.create_sincos_image(param)
+    ima2 = test_data.create_noisy_gaussian_image(param, add_annotations=True)
+    run(objects=(sig1, sig2, ima1, ima2), size=(1200, 550))
+
+
+if __name__ == "__main__":
+    test_launcher2()

datalab/tests/features/common/__init__.py

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