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

datalab/tests/backbone/config_unit_test.py

@@ -0,0 +1,170 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Configuration test
+
+Checking .ini configuration file management.
+"""
+
+# guitest: show
+
+import os
+import os.path as osp
+
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+
+from datalab import app
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.tests import helpers
+from datalab.utils.conf import CONF
+from datalab.utils.qthelpers import datalab_app_context
+
+SEC_MAIN = Conf.main
+OPT_MAX = SEC_MAIN.window_maximized
+OPT_POS = SEC_MAIN.window_position
+OPT_SIZ = SEC_MAIN.window_size
+OPT_DIR = SEC_MAIN.base_dir
+
+SEC_CONS = Conf.console
+OPT_CON = SEC_CONS.console_enabled
+
+CONFIGS = (
+    {
+        SEC_MAIN.get_name(): {
+            OPT_MAX.option: False,
+            OPT_POS.option: (250, 250),
+            OPT_SIZ.option: (1300, 700),
+            OPT_DIR.option: "",
+        },
+        SEC_CONS.get_name(): {
+            OPT_CON.option: False,
+        },
+    },
+    {
+        SEC_MAIN.get_name(): {
+            OPT_MAX.option: False,
+            OPT_POS.option: (100, 100),
+            OPT_SIZ.option: (750, 600),
+            OPT_DIR.option: osp.dirname(__file__),
+        },
+        SEC_CONS.get_name(): {
+            OPT_CON.option: False,
+        },
+    },
+    {
+        SEC_MAIN.get_name(): {
+            OPT_MAX.option: True,
+            OPT_POS.option: (10, 10),
+            OPT_SIZ.option: (750, 600),
+            OPT_DIR.option: "",
+        },
+        SEC_CONS.get_name(): {
+            OPT_CON.option: True,
+        },
+    },
+)
+
+
+def apply_conf(conf, name):
+    """Apply configuration"""
+    execenv.print(f"  Applying configuration {name}:")
+    fname = CONF.filename()
+    try:
+        os.remove(fname)
+        execenv.print(f"    Removed configuration file {fname}")
+    except FileNotFoundError:
+        execenv.print(f"    Configuration file {fname} was not found")
+    for section, settings in conf.items():
+        for option, value in settings.items():
+            execenv.print(f"    Writing [{section}][{option}] = {value}")
+            CONF.set(section, option, value)
+    CONF.save()
+
+
+def is_wsl() -> bool:
+    """Return True if running on Windows Subsystem for Linux (WSL)"""
+    if os.name == "posix":
+        return "WSL" in os.uname().release  # pylint: disable=no-member
+    return False
+
+
+def is_offscreen() -> bool:
+    """Return True if running in offscreen mode (e.g. in CI or pytest session)"""
+    return os.environ.get("QT_QPA_PLATFORM", "") == "offscreen"
+
+
+def assert_in_interval(val1, val2, interval, context):
+    """Raise an AssertionError if val1 is in [val2-interval/2,val2+interval/2]"""
+    itv1, itv2 = val2 - 0.5 * interval, val2 + 0.5 * interval
+    try:
+        assert itv1 <= val1 <= itv2
+    except AssertionError as exc:
+        if is_wsl() or is_offscreen():
+            # Ignore this assertion error in two cases:
+            # 1. If running on WSL, as the position of windows is not reliable
+            # 2. If running in offscreen mode (e.g. in CI or pytest session),
+            #    as the position of windows may not be set correctly in offscreen mode
+            pass
+        else:
+            raise AssertionError(f"{context}: {itv1} <= {val1} <= {itv2}") from exc
+
+
+def check_conf(conf, name, win: QW.QMainWindow, h5files):
+    """Check configuration"""
+    execenv.print(f"  Checking configuration {name}: ")
+    sec_main_name = SEC_MAIN.get_name()
+    sec_cons_name = SEC_CONS.get_name()
+    sec_main = conf[sec_main_name]
+    sec_cons = conf[sec_cons_name]
+    execenv.print(f"    Checking [{sec_main_name}][{OPT_MAX.option}]: ", end="")
+    assert sec_main[OPT_MAX.option] == (
+        win.windowState() == QC.Qt.WindowState.WindowMaximized
+    )
+    execenv.print("OK")
+    execenv.print(f"    Checking [{sec_main_name}][{OPT_POS.option}]: ", end="")
+    if not sec_main[OPT_MAX.option]:  # Check position/size only when not maximized
+        #  Check position, taking into account screen offset (e.g. Linux/Gnome)
+        conf_x, conf_y = sec_main[OPT_POS.option]
+        conf_w, conf_h = sec_main[OPT_SIZ.option]
+        available_go = QW.QDesktopWidget().availableGeometry()
+        x_offset, y_offset = available_go.x(), available_go.y()
+        assert_in_interval(win.x(), conf_x - x_offset, 0, "X position")
+        assert_in_interval(win.y(), conf_y - y_offset / 2, 15 + y_offset, "Y position")
+        #  Check size
+        assert_in_interval(win.width(), conf_w, 5, "Width")
+        assert_in_interval(win.height(), conf_h, 5, "Height")
+        execenv.print(f"OK {win.x(), win.y(), win.width(), win.height()}")
+    else:
+        execenv.print("Passed (maximized)")
+    execenv.print(f"    Checking [{sec_cons_name}][{OPT_CON.option}]: ", end="")
+    assert sec_cons[OPT_CON.option] == (win.console is not None)
+    execenv.print("OK")
+    execenv.print(f"    Checking [{sec_main_name}][{OPT_DIR.option}]: ", end="")
+    if h5files is None:
+        assert conf[SEC_MAIN.get_name()][OPT_DIR.option] == OPT_DIR.get()
+        execenv.print("OK (written in conf file)")
+    else:
+        assert OPT_DIR.get() == osp.dirname(h5files[0])
+        execenv.print("OK (changed to HDF5 file path)")
+
+
+def test_config():
+    """Testing DataLab configuration file"""
+    with execenv.context(unattended=True):
+        h5files = [helpers.get_test_fnames("*.h5")[1]]
+        execenv.print("Testing DataLab configuration settings:")
+        for index, conf in enumerate(CONFIGS):
+            name = f"CONFIG{index}"
+            apply_conf(conf, name)
+            with datalab_app_context(exec_loop=True) as qapp:
+                win = app.create(splash=False, h5files=h5files)
+                qapp.processEvents()
+                check_conf(conf, name, win, h5files)
+            h5files = None
+        execenv.print("=> Everything is OK")
+
+
+if __name__ == "__main__":
+    test_config()

datalab/tests/backbone/config_versioning_unit_test.py

@@ -0,0 +1,34 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Configuration versioning test.
+
+Test that the configuration folder name is versioned correctly.
+"""
+
+import datalab
+from datalab.config import get_config_app_name
+
+
+def test_config_app_name():
+    """Test configuration app name versioning."""
+    config_name = get_config_app_name()
+    major_version = datalab.__version__.split(".", maxsplit=1)[0]
+
+    print(f"DataLab version: {datalab.__version__}")
+    print(f"Major version: {major_version}")
+    print(f"Config app name: {config_name}")
+
+    # For v0.x, the config name should be "DataLab" (no suffix)
+    if major_version == "0":
+        assert config_name == "DataLab", f"Expected 'DataLab', got '{config_name}'"
+        print("✓ v0.x uses legacy config folder name: .DataLab")
+    else:
+        # For v1.x, v2.x, etc., the config name should include version suffix
+        expected = f"DataLab_v{major_version}"
+        assert config_name == expected, f"Expected '{expected}', got '{config_name}'"
+        print(f"✓ v{major_version}.x uses versioned config folder: .{config_name}")
+
+
+if __name__ == "__main__":
+    test_config_app_name()

datalab/tests/backbone/dictlistserial_app_test.py

@@ -0,0 +1,38 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Testing (de)serialization of Dictionnary/List inside object metadata
+"""
+
+# guitest: show
+
+import os.path as osp
+
+from sigima.tests.data import create_test_image_with_metadata
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context, helpers
+
+
+def test_dict_serialization():
+    """Dictionnary/List in metadata (de)serialization test"""
+    with execenv.context(unattended=True):
+        with helpers.WorkdirRestoringTempDir() as tmpdir:
+            with datalab_test_app_context(console=False) as win:
+                panel = win.imagepanel
+                image = create_test_image_with_metadata()
+                panel.add_object(image)
+                fname = osp.join(tmpdir, "test.h5")
+                win.save_to_h5_file(fname)
+                win.reset_all()
+                win.open_h5_files([fname], import_all=True)
+                execenv.print("Dictionary/List (de)serialization:")
+                oids = panel.objmodel.get_object_ids()
+                first_image = panel.objmodel[oids[0]]
+                helpers.compare_metadata(
+                    image.metadata, first_image.metadata.copy(), raise_on_diff=True
+                )
+
+
+if __name__ == "__main__":
+    test_dict_serialization()

datalab/tests/backbone/errorcatcher_unit_test.py

@@ -0,0 +1,69 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Catch error and warning test (during computation)
+
+Unit test for BaseProcessor.handle_output method: catching error and warning
+during computation. This test runs a computation function that raises an
+error and/or a warning, and checks that the error and/or warning are/is correctly
+caught and displayed in the GUI.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+# guitest: show
+
+import warnings
+
+from sigima.objects import SignalObj
+from sigima.tests import data as test_data
+
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+
+
+def comp_error(src: SignalObj) -> SignalObj:  # pylint: disable=unused-argument
+    """Computation function that raises an error"""
+    raise ValueError("This is a test error")
+
+
+def comp_warning(src: SignalObj) -> SignalObj:  # pylint: disable=unused-argument
+    """Computation function that raises a warning"""
+    warnings.warn("This is a test warning")
+    return src.copy()
+
+
+def comp_warning_error(src: SignalObj) -> SignalObj:  # pylint: disable=unused-argument
+    """Computation function that raises a warning and an error"""
+    warnings.warn("This is a test warning")
+    raise ValueError("This is a test error")
+
+
+def comp_no_error(src: SignalObj) -> SignalObj:  # pylint: disable=unused-argument
+    """Computation function that does not raise an error"""
+    return src.copy()
+
+
+def test_catcher():
+    """Catch error and warning test"""
+    with execenv.context(catcher_test=True):
+        with datalab_test_app_context() as win:
+            panel = win.signalpanel
+            sig = test_data.create_paracetamol_signal()
+            panel.add_object(sig)
+            panel.processor.compute_1_to_1(comp_no_error, title="Test no error")
+            panel.processor.compute_1_to_1(comp_error, title="Test error")
+            Conf.proc.ignore_warnings.set(True)
+            panel.processor.compute_1_to_1(comp_warning, title="Test warning (ignored)")
+            Conf.proc.ignore_warnings.set(False)
+            panel.processor.compute_1_to_1(
+                comp_warning, title="Test warning (not ignored)"
+            )
+            panel.processor.compute_1_to_1(
+                comp_warning_error, title="Test warning + error"
+            )
+
+
+if __name__ == "__main__":
+    test_catcher()

datalab/tests/backbone/errormsgbox_unit_test.py

@@ -0,0 +1,50 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Error message box test
+"""
+
+# guitest: show
+
+from guidata.qthelpers import exec_dialog, qt_app_context
+from qtpy import QtWidgets as QW
+
+from datalab.widgets.warningerror import WarningErrorMessageBox
+
+
+def error_message_box(category: str):
+    """Test error message box
+
+    Args:
+        category (str): Error category
+            Valid values are: "error", "warning"
+    """
+    with qt_app_context():
+        win = QW.QMainWindow()
+        win.setWindowTitle(f"DataLab {category.capitalize()} Message Box test")
+        win.show()
+        if category == "error":
+            try:
+                raise ValueError("Test error message box")
+            except ValueError:
+                context = "Test_error_message_box." * 5
+                tip = "This error may occured when testing the error message box. " * 10
+                dlg = WarningErrorMessageBox(win, "error", context, tip=tip)
+                exec_dialog(dlg)
+        elif category == "warning":
+            context = "Test_warning_message_box." * 5
+            message = "Test warning message box" * 10
+            dlg = WarningErrorMessageBox(win, "warning", context, message)
+            exec_dialog(dlg)
+        else:
+            raise ValueError(f"Invalid category: {category}")
+
+
+def test_error_message_box():
+    """Test error message box"""
+    error_message_box("error")
+    error_message_box("warning")
+
+
+if __name__ == "__main__":
+    test_error_message_box()

datalab/tests/backbone/execenv_unit.py

@@ -0,0 +1,262 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DLExecEnv test
+---------------
+
+Checking DataLab execution environment management.
+"""
+
+# guitest: skip (only needed for regression tests)
+
+from __future__ import annotations
+
+import os
+import sys
+
+import datalab
+from datalab.env import VerbosityLevels, execenv
+from datalab.tests import helpers
+
+ARGV_TEST = "--execenvtest"
+
+
+def print_execenv() -> None:
+    """Print DL execution environment"""
+    sys.argv.remove(ARGV_TEST)
+    print(str(execenv.to_dict()))
+
+
+def get_subprocess_execenv_dict(args: list[str], env: dict | None = None) -> dict:
+    """Get DL execution environment dict from subprocess
+
+    Args:
+        args (list[str]): command-line arguments
+        env (dict | None): environment variables to pass to subprocess
+
+    Returns:
+        dict[str, str | int | bool | None]: DL execution environment dict
+    """
+    output = helpers.get_script_output(__file__, args=args + [ARGV_TEST], env=env)
+    return eval(output)  # pylint: disable=eval-used
+
+
+def assert_two_dicts_are_equal(
+    dict1: dict, dict2: dict, exceptions: tuple[str] | None = None
+) -> None:
+    """Assert two dicts are equal
+
+    Args:
+        dict1 (dict): first dict
+        dict2 (dict): second dict
+        exceptions (tuple[str] | None): keys to ignore
+    """
+    diff_keys = []
+    for key in dict1:
+        if key in exceptions:
+            continue
+        if dict1[key] != dict2[key]:
+            diff_keys.append(key)
+    if diff_keys:
+        assert False, f"Dictionaries differ on keys: {diff_keys}"
+
+
+def test_cli():
+    """Test DL execution environment from command-line"""
+    remove_all_datalab_envvars()
+
+    # Test default values
+    execenv.print("Testing command-line arguments:")
+    execenv.print("  Default values: ", end="")
+    execenvdict = get_subprocess_execenv_dict([])
+    execenv.print("OK")
+    assert execenvdict == execenv.to_dict()
+    # Testing boolean arguments
+    execenv.print("  Testing boolean arguments:")
+    for argname in ("unattended", "accept_dialogs", "screenshot"):
+        execenv.print(f"    {argname}:", end="")
+        for val in (True, False):
+            execenv.print(f" {val}", end="")
+            if val:
+                args = [f"--{argname}"]
+            else:
+                args = []  # Default value is False
+            execenvdict = get_subprocess_execenv_dict(args)
+            assert_two_dicts_are_equal(execenvdict, execenv.to_dict(), (argname,))
+            assert execenvdict[argname] is val, (
+                f"execenvdict[{argname}] = {execenvdict[argname]} != {val}"
+            )
+        execenv.print()
+    # Testing integer arguments
+    execenv.print("  Testing integer arguments:")
+    for argname in ("delay", "xmlrpcport"):
+        execenv.print(f"    {argname}:", end="")
+        for val in (None, 0, 1, 2):
+            if val is None:
+                args = []
+            else:
+                args = [f"--{argname}", str(val)]
+            execenv.print(f" {val}", end="")
+            execenvdict = get_subprocess_execenv_dict(args)
+            assert_two_dicts_are_equal(execenvdict, execenv.to_dict(), (argname,))
+            if val is None:
+                if argname == "delay":
+                    # Default value is 0 for delay
+                    assert execenvdict[argname] == 0
+                else:
+                    # Default value is None for xmlrpcport
+                    assert execenvdict[argname] is None
+            else:
+                assert execenvdict[argname] == val
+        execenv.print()
+    # Testing choice arguments
+    execenv.print("  Testing choice arguments:")
+    for argname in ("verbose",):
+        execenv.print(f"    {argname}:", end="")
+        choices = {"verbose": [verb.value for verb in VerbosityLevels]}
+        defaultval = {"verbose": VerbosityLevels.NORMAL.value}[argname]
+        for val in [None] + choices[argname]:
+            if val is None:
+                args = []
+            else:
+                args = [f"--{argname}", val]
+            execenv.print(f" {val}", end="")
+            execenvdict = get_subprocess_execenv_dict(args)
+            assert_two_dicts_are_equal(execenvdict, execenv.to_dict(), (argname,))
+            if val is None:
+                assert execenvdict[argname] == defaultval
+            else:
+                assert execenvdict[argname] == val
+        execenv.print()
+    # Testing special arguments
+    execenv.print("  Testing special arguments:")
+    execenv.print("    version: ", end="")
+    args = ["--version"]
+    output = helpers.get_script_output(__file__, args=args + [ARGV_TEST])
+    execenv.print(output)
+    assert datalab.__version__ in output
+    execenv.print("    h5 positionnal argument: ", end="")
+    for h5files in (None, ["test.h5"], ["toto.h5", "tata.h5"]):
+        if h5files is None:
+            args = []
+        else:
+            args = [";".join(h5files)]
+        execenv.print(f" {h5files}", end="")
+        execenvdict = get_subprocess_execenv_dict(args)
+        assert execenvdict["h5files"] == h5files
+    execenv.print()
+    execenv.print("    h5browser argument:")
+    for argname in ("-b", "--h5browser"):
+        execenv.print(f"      {argname}", end="")
+        for val in (None, "test.h5"):
+            if val is None:
+                args = []
+            else:
+                args = [argname, val]
+            execenv.print(f" {val}", end="")
+            execenvdict = get_subprocess_execenv_dict(args)
+            assert execenvdict["h5browser_file"] == val
+        execenv.print()
+    execenv.print("=> Everything is OK")
+
+
+def remove_all_datalab_envvars():
+    """Remove all DL environment variables"""
+    for _attrname, envvar in execenv.iterate_over_attrs_envvars():
+        os.environ.pop(envvar, None)
+
+
+def get_attr_to_envvar(
+    vartype: type,
+    default: int | str | None | bool,
+    values: list[int | str | None | bool] | None = None,
+) -> tuple:
+    """Get ATTR_TO_ENVVAR tuple for a given type"""
+    if vartype is bool:
+        if default is False:
+            ate = ((True, ("1", "true")), (False, (None, "", "0", "false")))
+        else:
+            ate = ((True, (None, "", "1", "true")), (False, ("0", "false")))
+    elif vartype is int:
+        ate = []
+        for val in values:
+            if val == default:
+                ate.append((val, (None, "", str(val))))
+            else:
+                ate.append((val, (str(val),)))
+        ate = tuple(ate)
+        if default is None:
+            ate = ((None, (None, "")),) + ate
+    elif vartype is str:
+        ate = ((None, (None, "")),)
+    elif vartype is list:
+        ate = []
+        for choice in values:
+            if choice == default:
+                ate.append((choice, (None, "", choice)))
+            else:
+                ate.append((choice, (choice,)))
+        ate = tuple(ate)
+    else:
+        raise ValueError(f"Unknown type {vartype}")
+    return ate
+
+
+ATTR_TO_ENVVAR = {
+    "unattended": get_attr_to_envvar(bool, False),
+    "accept_dialogs": get_attr_to_envvar(bool, False),
+    "screenshot": get_attr_to_envvar(bool, False),
+    "do_not_quit": get_attr_to_envvar(bool, False),
+    "catcher_test": get_attr_to_envvar(bool, False),
+    "delay": get_attr_to_envvar(int, 0, [0, 10, 20]),
+    "xmlrpcport": get_attr_to_envvar(int, None, [9854, 1020, 213]),
+    "verbose": get_attr_to_envvar(
+        list, VerbosityLevels.NORMAL.value, [verb.value for verb in VerbosityLevels]
+    ),
+}
+
+
+def test_envvar():
+    """Testing DataLab configuration file"""
+    assert execenv.unattended is False, "This test must be run with unattended=False"
+    print("Testing DataLab execution environment:")
+    for attrname, envvar in execenv.iterate_over_attrs_envvars():
+        attr_to_envvar = ATTR_TO_ENVVAR[attrname]
+        print(f"  Testing {attrname}:")
+        for value, envvals in attr_to_envvar:
+            print(f"    {value}: [attr->env]", end="")
+            remove_all_datalab_envvars()
+            if value is not None:
+                setattr(execenv, attrname, value)
+            assert os.environ.get(envvar) in envvals, (
+                f"os.environ[{envvar}] = {os.environ.get(envvar)} != {envvals}"
+            )
+            print(" [env->attr]", end="")
+            remove_all_datalab_envvars()
+            for envval in envvals:
+                if envval is not None:
+                    os.environ[envvar] = envval
+                assert getattr(execenv, attrname) == value, (
+                    f"execenv.{attrname} = {getattr(execenv, attrname)}"
+                    f" != {value} (envval = {repr(envval)})"
+                )
+            print(" [env->subprocess->attr]", end="")
+            remove_all_datalab_envvars()
+            for envval in envvals:
+                if envval is not None:
+                    os.environ[envvar] = envval
+                execenvdict = get_subprocess_execenv_dict([])
+                assert execenvdict[attrname] == value, (
+                    f"execenvdict[{attrname}] = {execenvdict[attrname]}"
+                    f" != {value} (envval = {repr(envval)})"
+                )
+            print()
+    print("=> Everything is OK")
+
+
+if __name__ == "__main__":
+    if ARGV_TEST in sys.argv:
+        print_execenv()
+    else:
+        test_envvar()
+        test_cli()