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

datalab/tests/backbone/loadtest_gdi.py

@@ -0,0 +1,147 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+GDI objects loading test
+========================
+
+This test is specific to Windows. It is not relevant for other platforms.
+
+This test aims at checking that all GDI objects are released when the
+widget are closed (i.e. when the Python object is garbage collected).
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+# guitest: skip
+
+from __future__ import annotations
+
+import ctypes
+import os
+
+from sigima.objects import NewImageParam
+from sigima.tests.data import create_sincos_image, iterate_image_creation
+
+from datalab.env import execenv
+from datalab.gui.main import DLMainWindow
+from datalab.tests import datalab_test_app_context, helpers
+from datalab.tests.scenarios.common import compute_common_operations
+
+if os.name == "nt":
+    from ctypes import WinDLL
+
+    def get_gdi_count() -> int:
+        """Get the number of GDI objects for the current process.
+
+        This function uses the Windows API to get the count of GDI (Graphical
+        Device Interface) objects used by the current process.
+
+        Note: This function will only work on Windows.
+
+        Returns:
+            int: The count of GDI objects for the current process.
+        """
+        # Constants
+        GR_GDIOBJECTS: int = 0
+
+        # Load the User32 DLL
+        user32: WinDLL = ctypes.windll.user32
+
+        # Get the current process id
+        pid: int = os.getpid()
+
+        # Get handle of the process
+        handle: int = ctypes.windll.kernel32.OpenProcess(1040, 0, pid)
+
+        # Call the function and get the GDI count
+        gdi_count: int = user32.GetGuiResources(handle, GR_GDIOBJECTS)
+
+        # Close the handle
+        ctypes.windll.kernel32.CloseHandle(handle)
+
+        return gdi_count
+
+else:
+
+    def get_gdi_count() -> int:
+        """Dumb function that always returns 0."""
+        return 0
+
+
+def test_various_image_features(win: DLMainWindow):
+    """Run image related tests."""
+    win.set_current_panel("image")
+    panel = win.imagepanel
+    param = NewImageParam.create(height=150, width=150)
+    for image in iterate_image_creation(param.width, non_zero=True, verbose=False):
+        panel.add_object(create_sincos_image(param))
+        panel.add_object(image)
+        compute_common_operations(panel)
+        panel.remove_all_objects()
+        break
+
+
+def test_gdi_count(win: DLMainWindow) -> int | None:
+    """Test the GDI count.
+
+    This function will create a DataSetGroup, show the widget, and then
+    close the widget. It will then check that the GDI count has not
+    increased.
+
+    Raises:
+        AssertionError: If the GDI count has increased.
+
+    Returns:
+        int: The GDI count after creating the widget.
+    """
+    # Get the GDI count before creating the widget
+    gdi_count_before: int = get_gdi_count()
+
+    execenv.print(f"   GDI count: {gdi_count_before} --> ", end="")
+
+    # Create widgets during the test
+    test_various_image_features(win)
+
+    # Import HDF5 file using the HDF5 browser
+    win.open_h5_files(
+        helpers.get_test_fnames("*.h5")[:5], import_all=True, reset_all=False
+    )
+    for panel in (win.signalpanel, win.imagepanel):
+        panel.remove_all_objects()
+
+    # Get the GDI count after creating the widget
+    gdi_count_after: int = get_gdi_count()
+
+    execenv.print(gdi_count_after)
+
+    # # Check that the GDI count has not increased
+    # assert gdi_count_before == gdi_count_after
+    # assert gdi_count_before == gdi_count_after_close
+
+    return gdi_count_after
+
+
+def load_test():
+    """Load test."""
+    with execenv.context(unattended=True):
+        with datalab_test_app_context() as win:
+            gdi_count = []
+            for iteration in range(4):
+                execenv.print(f"Test iteration: {iteration}")
+                count = test_gdi_count(win)
+                if count is None:
+                    execenv.print("Test aborted")
+                    break
+                gdi_count.append(count)
+                if iteration > 0:
+                    increase = gdi_count[-1] - gdi_count[-2]
+                    assert increase <= 0, "GDI count should not increase (memory leak)"
+                    increase_pct = increase / gdi_count[0] * 100
+                    execenv.print(
+                        f"   GDI count increase: {increase:+d} ({increase_pct:.2f}%)"
+                    )
+
+
+if __name__ == "__main__":
+    load_test()

datalab/tests/backbone/long_callback.py

@@ -0,0 +1,96 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Long callback test
+------------------
+
+This test is not meant to be executed as part of the `pytest` suite, hence the
+name of the script.
+"""
+
+# guitest: show,skip
+
+import time
+
+from guidata.qthelpers import qt_app_context
+from qtpy import QtWidgets as QW
+
+from datalab.utils.qthelpers import CallbackWorker, qt_long_callback
+
+
+def long_computation_func(delay: float) -> str:
+    """Simulate long computation
+
+    Args:
+        delay: Delay in seconds
+
+    Returns:
+        str: Result message
+    """
+    time.sleep(delay)
+    return "OK"
+
+
+def long_computation_progress_func(worker: CallbackWorker, delay: float) -> str:
+    """Simulate long computation, with progress
+
+    Args:
+        worker: Callback worker
+        delay: Delay in seconds
+
+    Returns:
+        str: Result message
+    """
+    step_delay = 2.0
+    maxiter = int(delay / step_delay)
+    for idx in range(maxiter):
+        worker.set_progress(idx / maxiter)
+        if worker.was_canceled():
+            return f"Interrupted at iteration #{idx}"
+        time.sleep(step_delay)
+    return "Done"
+
+
+class TestWindow(QW.QMainWindow):
+    """Test window"""
+
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Test window")
+        btn1 = QW.QPushButton("Run long computation")
+        btn1.clicked.connect(self.run_long_computation)
+        btn2 = QW.QPushButton("Run long computation with progress bar")
+        btn2.clicked.connect(self.run_long_computation_with_progress)
+        mainwidget = QW.QWidget()
+        layout = QW.QHBoxLayout()
+        mainwidget.setLayout(layout)
+        layout.addWidget(btn1)
+        layout.addWidget(btn2)
+        self.setCentralWidget(mainwidget)
+
+    def __execute_worker(self, worker: CallbackWorker, progress: bool) -> None:
+        """Execute worker"""
+        ret = qt_long_callback(self, "Doing stuff...", worker, progress)
+        QW.QMessageBox.information(self, "Result", f"Long computation result: {ret}")
+
+    def run_long_computation(self) -> None:
+        """Run long computation"""
+        worker = CallbackWorker(long_computation_func, delay=5.0)
+        self.__execute_worker(worker, progress=False)
+
+    def run_long_computation_with_progress(self) -> None:
+        """Run long computation with progress"""
+        worker = CallbackWorker(long_computation_progress_func, delay=10.0)
+        self.__execute_worker(worker, progress=True)
+
+
+def testing_long_callback() -> None:
+    """Test long callback function"""
+    with qt_app_context(exec_loop=True):
+        win = TestWindow()
+        win.resize(800, 600)
+        win.show()
+
+
+if __name__ == "__main__":
+    testing_long_callback()

datalab/tests/backbone/main_app_test.py

@@ -0,0 +1,137 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Application test for main window
+--------------------------------
+
+Testing the features of the main window of the application that are not
+covered by other tests.
+"""
+
+# guitest: show
+
+import os
+
+import sigima.params
+import sigima.proc.signal as sips
+from sigima.tests.data import create_paracetamol_signal
+
+from datalab.env import execenv
+from datalab.objectmodel import get_short_id, get_uuid
+from datalab.tests import datalab_test_app_context
+
+
+def test_main_app():
+    """Main window test"""
+    with datalab_test_app_context(console=False) as win:
+        # Switch from panel to panel
+        for panelname in ("macro", "image", "signal"):
+            win.set_current_panel(panelname)
+        # Switch to an unknown panel
+        try:
+            win.set_current_panel("unknown_panel")
+            raise RuntimeError("Unknown panel should have raised an exception")
+        except ValueError:
+            pass
+
+        panel = win.signalpanel
+
+        # Create new groups
+        grp1 = panel.add_group("Group 1")
+        panel.add_group("Group 2")
+        # Add group using different levels of the API
+        panel.add_group("Group 3", select=True)
+        panel.remove_object(force=True)
+        win.add_group("Group 4", select=True)
+        panel.remove_object(force=True)
+        win.add_group("Group 5", panel="signal", select=True)
+        panel.remove_object(force=True)
+        # Rename group
+        panel.objview.select_groups([2])
+        panel.rename_selected_object_or_group("Group xxx")
+        panel.remove_object(force=True)
+
+        # Add signals to signal panel
+        sig1 = create_paracetamol_signal(500)
+        panel.add_object(sig1)
+        panel.rename_selected_object_or_group("Paracetamol Signal 1")
+        panel.processor.run_feature(sips.derivative)
+        panel.processor.run_feature(sips.wiener)
+
+        # Get object titles
+        titles = win.get_object_titles()
+        execenv.print(f"Object titles:{os.linesep}{titles}")
+
+        # Get object uuids
+        uuids = win.get_object_uuids()
+        uuids2 = win.get_object_uuids(group=1)
+        uuids3 = win.get_object_uuids(group="Group 1")
+        uuids4 = win.get_object_uuids(group=get_uuid(grp1))
+        assert uuids == uuids2 == uuids3 == uuids4, "Group UUIDs should be the same"
+        execenv.print(f"Object uuids:{os.linesep}{uuids}")
+
+        # Testing `get_object`
+        execenv.print("*** Testing `get_object` ***")
+        # Get object from title
+        obj = win.get_object(titles[-1])
+        execenv.print(f"  Object (from title) '{get_short_id(obj)}':{os.linesep}{obj}")
+        # Get object
+        obj = win.get_object(1)
+        execenv.print(
+            f"  Object (from number)  '{get_short_id(obj)}':{os.linesep}{obj}"
+        )
+        # Get object by uuid
+        obj = win.get_object(uuids[-1])
+        execenv.print(f"  Object (from uuid)  '{get_short_id(obj)}':{os.linesep}{obj}")
+
+        # Testing dict-like interface of main window:
+        execenv.print("*** Testing dict-like interface of proxy ***")
+        # Get object from title
+        obj = win[titles[-1]]
+        execenv.print(f"  Object (from title) '{get_short_id(obj)}':{os.linesep}{obj}")
+        # Get object
+        obj = win[1]
+        execenv.print(
+            f"  Object (from number)  '{get_short_id(obj)}':{os.linesep}{obj}"
+        )
+        # Get object by uuid
+        obj = win[uuids[-1]]
+        execenv.print(f"  Object (from uuid)  '{get_short_id(obj)}':{os.linesep}{obj}")
+
+        # Use "calc" method with parameters
+        param = sigima.params.MovingMedianParam.create(n=5)
+        win.calc("moving_median", param)
+        # Use "calc" method without parameters
+        win.calc("integral")
+        # Use "calc" and choose an unknown computation method
+        try:
+            win.calc("unknown_method")
+            raise RuntimeError("Unknown method should have raised an exception")
+        except ValueError:
+            pass
+
+        # Force application menus to pop-up
+        for menu in (
+            win.file_menu,
+            win.create_menu,
+            win.edit_menu,
+            win.roi_menu,
+            win.operation_menu,
+            win.processing_menu,
+            win.analysis_menu,
+            win.view_menu,
+            win.help_menu,
+        ):
+            # Just access the menu to ensure it's created and initialized
+            assert menu is not None, f"Menu {menu.title()} should exist"
+            # Trigger aboutToShow to populate dynamic menus without showing the popup
+            menu.aboutToShow.emit()
+            # Verify menu has actions (optional, but good sanity check)
+            assert len(menu.actions()) > 0, f"Menu {menu.title()} should have actions"
+
+        # Open settings dialog
+        win.settings_action.trigger()
+
+
+if __name__ == "__main__":
+    test_main_app()

datalab/tests/backbone/memory_leak.py

@@ -0,0 +1,43 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Memory leak test
+
+DataLab application memory leak test.
+"""
+
+# guitest: skip
+
+import os
+
+import numpy as np
+import psutil
+from guidata.qthelpers import qt_app_context
+from sigima.tests.vistools import view_curves
+
+from datalab.env import execenv
+from datalab.tests.features.control.embedded1_unit_test import HostWindow
+
+
+def memory_leak_test(iterations=100):
+    """Test for memory leak"""
+    with qt_app_context():
+        proc = psutil.Process(os.getpid())
+        mainview = HostWindow()
+        mainview.show()
+        memlist = []
+        for i in range(iterations):
+            mainview.init_cdl()
+            mainview.close_datalab()
+            memdata = proc.memory_info().vms / 1024**2
+            memlist.append(memdata)
+            execenv.print(i + 1, ":", memdata, "MB")
+        view_curves(
+            np.array(memlist),
+            title="Memory leak test for DataLab application",
+            ylabel="Memory (MB)",
+        )
+
+
+if __name__ == "__main__":
+    memory_leak_test()

datalab/tests/backbone/procisolation1_unit.py

@@ -0,0 +1,128 @@
+# 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, ...
+# pylint: disable=duplicate-code
+# guitest: skip
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from multiprocessing.pool import AsyncResult, Pool
+from typing import Any
+
+import numpy as np
+import scipy.signal as sps
+from guidata.qthelpers import qt_app_context
+from plotpy.plot import PlotWindow
+from qtpy import QtWidgets as QW
+from sigima.objects import ImageDatatypes, 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
+from datalab.utils.qthelpers import create_progress_bar
+
+POOL: Pool | None = None
+
+
+class Worker:
+    """Multiprocessing worker, to run long-running tasks in a separate process"""
+
+    def __init__(self) -> None:
+        self.asyncresult: AsyncResult = None
+        self.result: Any = None
+
+    @staticmethod
+    def create_pool() -> None:
+        """Create multiprocessing pool"""
+        global POOL  # pylint: disable=global-statement
+        # Create a pool with one process
+        POOL = Pool(processes=1)  # pylint: disable=not-callable,consider-using-with
+
+    @staticmethod
+    def terminate_pool() -> None:
+        """Terminate multiprocessing pool"""
+        global POOL  # pylint: disable=global-statement
+        if POOL is not None:
+            POOL.terminate()
+            POOL.join()
+            POOL = None
+
+    def run(self, func: Callable, args: tuple[Any]) -> None:
+        """Run computation"""
+        global POOL  # pylint: disable=global-statement,global-variable-not-assigned
+        assert POOL is not None
+        self.asyncresult = POOL.apply_async(func, args)
+
+    def terminate(self) -> None:
+        """Terminate worker"""
+        # Terminate the process and stop the timer
+        self.terminate_pool()
+        execenv.print("Computation cancelled!")
+        # Recreate the pool for the next computation
+        self.create_pool()
+
+    def is_computation_finished(self) -> bool:
+        """Return True if computation is finished"""
+        return self.asyncresult.ready()
+
+    def get_result(self) -> Any:
+        """Return computation result"""
+        self.result = self.asyncresult.get()
+        self.asyncresult = None
+        return self.result
+
+
+def testfunc(data: np.ndarray, size: int, error: bool) -> np.ndarray:
+    """Test function"""
+    if error:
+        raise ValueError("Test error")
+    return sps.medfilt(data, size) + create_2d_random(data.shape[0], data.dtype)
+
+
+def test_multiprocessing1(iterations: int = 4) -> None:
+    """Multiprocessing test"""
+    Worker.create_pool()
+    with qt_app_context(exec_loop=True):
+        win = PlotWindow(title="Multiprocessing test", icon="datalab.svg", toolbar=True)
+        win.resize(800, 600)
+        win.show()
+        param = NewImageParam.create(
+            height=1000, width=1000, dtype=ImageDatatypes.UINT16
+        )
+        image = create_noisy_gaussian_image(param, add_annotations=True)
+        win.get_plot().add_item(create_adapter_from_object(image).make_item())
+        worker = Worker()
+        with create_progress_bar(win, "Computing", max_=iterations) as progress:
+            for index in range(iterations):
+                progress.setValue(index)
+                progress.setLabelText(f"Computing {index}")
+                test_error = index == 2
+                worker.run(testfunc, (image.data, 3, test_error))
+                while not worker.is_computation_finished():
+                    QW.QApplication.processEvents()
+                    time.sleep(0.1)
+                    if progress.wasCanceled():
+                        worker.terminate()
+                        break
+                if worker.is_computation_finished():
+                    try:
+                        image.data = worker.get_result()
+                    except Exception as exc:  # pylint: disable=broad-except
+                        execenv.print(f"Intercepted exception: {exc}")
+                    win.get_plot().add_item(
+                        create_adapter_from_object(image).make_item()
+                    )
+                else:
+                    break
+        worker.terminate_pool()
+
+
+if __name__ == "__main__":
+    test_multiprocessing1()