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

datalab/tests/scenarios/example_app_test.py

@@ -0,0 +1,47 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Example of high-level test scenario
+
+Create an image object from Scikit-image human mitosis sample,
+then open DataLab to show it.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.objects
+import sigima.params
+from sigima.tests.data import get_test_image
+
+from datalab.control.proxy import proxy_context
+from datalab.tests import skip_if_opencv_missing
+
+
+def test_example_app() -> None:
+    """Example of high-level test scenario using proxy interface"""
+    with proxy_context("local") as proxy:
+        data = get_test_image("flower.npy").data
+        image = sigima.objects.create_image("Test image with peaks", data)
+        proxy.add_object(image)
+        proxy.calc("roberts")
+        data_size = data.shape[0]
+        n = data_size // 5
+        roi = sigima.objects.create_image_roi(
+            "rectangle", [n, n, data_size - 2 * n, data_size - 2 * n]
+        )
+        proxy.calc("compute_roi_extraction", roi)
+        param = sigima.params.BlobOpenCVParam.create(
+            min_dist_between_blobs=0.1,
+            filter_by_color=False,
+            min_area=500,
+            max_area=2000,
+            filter_by_circularity=True,
+            min_circularity=0.2,
+        )
+        with skip_if_opencv_missing():
+            proxy.calc("blob_opencv", param)
+
+
+if __name__ == "__main__":
+    test_example_app()

datalab/tests/scenarios/scenario_h5_app_test.py

@@ -0,0 +1,75 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DataLab mainwindow automation test
+----------------------------------
+
+This test scenario shows how to use the DataLab application in a test
+scenario. It also validates the HDF5 file format.
+
+This scenario executes the following steps:
+
+  - Creating two test signals
+  - Creating two test images
+  - Creating a macro
+  - Saving current project (h5 file)
+  - Removing all objects
+  - Opening another project (h5 file)
+  - Access current image metadata
+  - Checking macro code
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import os.path as osp
+
+from sigima.params import ClipParam
+from sigima.tests.data import create_noisy_gaussian_image, create_paracetamol_signal
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context, helpers
+from datalab.tests.scenarios import scenario_mac_app_test
+from datalab.utils.strings import save_html_diff
+
+
+def test_scenario_h5():
+    """Example of high-level test scenario with HDF5 file"""
+    with helpers.WorkdirRestoringTempDir() as tmpdir:
+        with datalab_test_app_context(console=False) as win:
+            # === Creating two test signals
+            panel = win.signalpanel
+            sig1 = create_paracetamol_signal()
+            panel.add_object(sig1)
+            panel.processor.run_feature("derivative")
+            # === Creating two test images
+            panel = win.imagepanel
+            ima1 = create_noisy_gaussian_image(add_annotations=True)
+            panel.add_object(ima1)
+            param = ClipParam.create(upper=ima1.data.mean())
+            panel.processor.run_feature("clip", param)
+            # === Creating a macro
+            scode = scenario_mac_app_test.add_macro_sample(win, 0).get_code()
+            scenario_mac_app_test.add_macro_sample(win, 1)
+            # === Saving project
+            fname = osp.join(tmpdir, "test.h5")
+            win.save_to_h5_file(fname)
+            # === Removing all objects
+            for panel in win.panels:
+                panel.remove_all_objects()
+            # === Reopening previously saved project
+            win.open_h5_files([fname], import_all=True, reset_all=True)
+            # === Accessing object metadata
+            obj = win.imagepanel.objmodel.get_groups()[0][0]
+            execenv.print(f"Image '{obj.title}':")
+            for key, value in obj.metadata.items():
+                execenv.print(f'  metadata["{key}"] = {value}')
+            # === Checking macro code
+            lcode = win.macropanel.get_macro(1).get_code()
+            if lcode != scode:
+                save_html_diff(scode, lcode, "Saved code", "Loaded code", "macro0.html")
+                raise AssertionError("Macro code is not the same as saved")
+
+
+if __name__ == "__main__":
+    test_scenario_h5()

datalab/tests/scenarios/scenario_ima1_app_test.py

@@ -0,0 +1,34 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image processing test scenario
+------------------------------
+
+Testing all the image processing features, without process isolation.
+"""
+
+# pylint: disable=duplicate-code
+# guitest: show
+
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+from datalab.tests.scenarios import common
+
+
+def test_scenario_image() -> None:
+    """Run image unit test scenario 1 (no process isolation)"""
+    assert Conf.main.process_isolation_enabled.get(), (
+        "Process isolation must be enabled"
+    )
+    with datalab_test_app_context(save=True) as win:
+        with win.context_no_refresh():
+            execenv.print("Testing image features without process isolation...")
+            win.set_process_isolation_enabled(False)
+            common.run_image_computations(win)
+        win.imagepanel.remove_all_objects()
+        execenv.print("==> OK")
+
+
+if __name__ == "__main__":
+    test_scenario_image()

datalab/tests/scenarios/scenario_ima2_app_test.py

@@ -0,0 +1,34 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image processing test scenario
+------------------------------
+
+Testing all the image processing features, with process isolation.
+"""
+
+# pylint: disable=duplicate-code
+# guitest: show
+
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+from datalab.tests.scenarios import common
+
+
+def test_scenario_image2() -> None:
+    """Run image unit test scenario 2 (process isolation)"""
+    assert Conf.main.process_isolation_enabled.get(), (
+        "Process isolation must be enabled"
+    )
+
+    with datalab_test_app_context(save=True) as win:
+        execenv.print("Testing image features *with* process isolation...")
+        common.run_image_computations(win, all_types=False)
+        oids = win.imagepanel.objmodel.get_object_ids()
+        win.imagepanel.open_separate_view(oids[:4])
+        execenv.print("==> OK")
+
+
+if __name__ == "__main__":
+    test_scenario_image2()

datalab/tests/scenarios/scenario_mac_app_test.py

@@ -0,0 +1,58 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Macro-commands test scenario
+----------------------------
+
+Testing all the macro-commands features.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import os.path as osp
+import time
+
+from datalab.gui.macroeditor import Macro
+from datalab.gui.main import DLMainWindow
+from datalab.tests import datalab_test_app_context, helpers
+
+
+def add_macro_sample(win: DLMainWindow, index: int) -> Macro:
+    """Add a macro sample to the macro panel
+
+    Args:
+        win: DLMainWindow
+        index: index of the macro sample to add
+    """
+    macro = win.macropanel.add_macro()
+    macro.title = f"Test macro {index}"
+    samples = [
+        "import time; [print(f'{i}:{time.sleep(.1)}') for i in range(50)]",
+        "print('Hello world')",
+    ]
+    assert index < len(samples), f"index={index} is out of range"
+    macro.set_code(samples[index])
+    return macro
+
+
+def test_scenario_macro() -> None:
+    """Example of high-level test scenario with HDF5 file"""
+    with helpers.WorkdirRestoringTempDir() as tmpdir:
+        with datalab_test_app_context(console=False) as win:
+            win.set_current_panel("macro")
+            add_macro_sample(win, 0)
+            win.macropanel.run_macro()
+            time.sleep(1)
+            win.macropanel.stop_macro()
+            code2 = add_macro_sample(win, 1).get_code()
+            fname = osp.join(tmpdir, "test.macro")
+            win.macropanel.export_macro_to_file(2, fname)
+            win.macropanel.remove_macro()
+            macro_nb = win.macropanel.import_macro_from_file(fname)
+            macro2 = win.macropanel.get_macro(macro_nb)
+            assert macro2.get_code() == code2, "Macro code is not the same"
+
+
+if __name__ == "__main__":
+    test_scenario_macro()

datalab/tests/scenarios/scenario_sig1_app_test.py

@@ -0,0 +1,36 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Signal processing test scenario
+-------------------------------
+
+Testing all the signal processing features, without process isolation.
+"""
+
+# pylint: disable=duplicate-code
+# guitest: show
+
+from __future__ import annotations
+
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+from datalab.tests.scenarios import common
+
+
+def test_scenario_signal1() -> None:
+    """Run signal unit test scenario 1 (no process isolation)"""
+    assert Conf.main.process_isolation_enabled.get(), (
+        "Process isolation must be enabled"
+    )
+    with datalab_test_app_context(save=True) as win:
+        with win.context_no_refresh():
+            execenv.print("Testing signal features (process isolation: off)...")
+            win.set_process_isolation_enabled(False)
+            common.run_signal_computations(win, all_types=True)
+        win.signalpanel.remove_all_objects()
+        execenv.print("==> OK")
+
+
+if __name__ == "__main__":
+    test_scenario_signal1()

datalab/tests/scenarios/scenario_sig2_app_test.py

@@ -0,0 +1,35 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Signal processing test scenario
+-------------------------------
+
+Testing all the signal processing features, with process isolation.
+"""
+
+# pylint: disable=duplicate-code
+# guitest: show
+
+from __future__ import annotations
+
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+from datalab.tests.scenarios import common
+
+
+def test_scenario_signal2() -> None:
+    """Run signal unit test scenario 2 (process isolation)"""
+    assert Conf.main.process_isolation_enabled.get(), (
+        "Process isolation must be enabled"
+    )
+    with datalab_test_app_context(save=True) as win:
+        execenv.print("Testing signal features (process isolation: on)...")
+        common.run_signal_computations(win, all_types=False)
+        oids = win.signalpanel.objmodel.get_object_ids()
+        win.signalpanel.open_separate_view(oids[:3])
+        execenv.print("==> OK")
+
+
+if __name__ == "__main__":
+    test_scenario_signal2()

datalab/utils/__init__.py

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

datalab/utils/conf.py

@@ -0,0 +1,304 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DataLab Configuration utilities
+"""
+
+from __future__ import annotations
+
+import os
+import os.path as osp
+import warnings
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any
+
+import guidata.dataset as gds
+from guidata.configtools import MONOSPACE, get_family
+from guidata.userconfig import NoDefault, UserConfig
+
+if TYPE_CHECKING:
+    import qtpy.QtGui as QG
+
+
+class AppUserConfig(UserConfig):
+    """Application user configuration"""
+
+    def to_dict(self) -> dict:
+        """Return configuration as a dictionary"""
+        confdict = {}
+        for section in self.sections():
+            secdict = {}
+            for option, value in self.items(section, raw=self.raw):
+                secdict[option] = value
+            confdict[section] = secdict
+        return confdict
+
+
+CONF = AppUserConfig({})
+
+
+class Configuration:
+    """Configuration file"""
+
+    @classmethod
+    def initialize(cls, name: str, version: str, load: bool) -> None:
+        """Initialize configuration"""
+        CONF.set_application(name, version, load=load)
+
+    @classmethod
+    def reset(cls) -> None:
+        """Reset configuration"""
+        global CONF  # pylint: disable=global-statement
+        CONF.cleanup()  # Remove configuration file
+        CONF = AppUserConfig({})
+
+    @classmethod
+    def get_filename(cls) -> str:
+        """Return configuration file name"""
+        return CONF.filename()
+
+    @classmethod
+    def get_path(cls, basename: str) -> str:
+        """Return filename path inside configuration directory"""
+        return CONF.get_path(basename)
+
+    @classmethod
+    def to_dict(cls) -> dict:
+        """Return configuration as a dictionary"""
+        return CONF.to_dict()
+
+
+class Section:
+    """Configuration section"""
+
+    @classmethod
+    def set_name(cls, section: str) -> None:
+        """Set section name"""
+        cls._name = section
+
+    @classmethod
+    def get_name(cls) -> str:
+        """Return section name"""
+        return cls._name
+
+
+class Option:
+    """Configuration option handler"""
+
+    def __init__(self) -> None:
+        self.section = None
+        self.option = None
+
+    def get(self, default=NoDefault) -> Any:
+        """Get configuration option value"""
+        return CONF.get(self.section, self.option, default)
+
+    def set(self, value: Any) -> None:
+        """Set configuration option value"""
+        CONF.set(self.section, self.option, value)
+
+    def remove(self) -> None:
+        """Remove configuration option"""
+        # No use case for this method yet (quite dangerous!)
+        CONF.remove_option(self.section, self.option)
+
+    @contextmanager
+    def temp(self, value: Any) -> Generator[None, None, None]:
+        """Temporarily set configuration option value
+
+        Args:
+            value: new value
+        """
+        old_value = self.get()
+        self.set(value)
+        yield
+        self.set(old_value)
+
+
+class FontOption(Option):
+    """Font configuration option handler"""
+
+    def get(self, default=NoDefault) -> str:
+        """Get font name from configuration"""
+        if default is NoDefault:
+            default = (MONOSPACE, 9, False)
+        family = CONF.get(self.section, self.option + "_family", default[0])
+        size = CONF.get(self.section, self.option + "_size", default[1])
+        bold = CONF.get(self.section, self.option + "_bold", default[2])
+        return family, size, bold
+
+    def set(self, value: tuple[str | list[str], int, bool]) -> None:
+        """Set font name in configuration"""
+        assert isinstance(value, tuple), (
+            "Font value must be a tuple (family, size, bold)"
+        )
+        CONF.set(self.section, self.option + "_family", value[0])
+        CONF.set(self.section, self.option + "_size", value[1])
+        CONF.set(self.section, self.option + "_bold", value[2])
+
+    def get_font(self) -> QG.QFont:
+        """Get QFont from configuration"""
+        # Import here to avoid having to create a Qt application when
+        # just manipulating configuration files
+        from qtpy import QtGui as QG  # pylint: disable=import-outside-toplevel
+
+        family, size, bold = self.get()
+        if isinstance(family, (list, tuple)):
+            family = get_family(family)
+        return QG.QFont(family, size, QG.QFont.Bold if bold else QG.QFont.Normal)
+
+
+class ConfigPathOption(Option):
+    """Configuration file path configuration option handler"""
+
+    def get(self, default=NoDefault) -> str:
+        """Get configuration file path from configuration"""
+        if default is NoDefault:
+            default = ""
+        fname = super().get(default)
+        if osp.basename(fname) != fname:
+            raise ValueError(f"Invalid configuration file name {fname}")
+        return CONF.get_path(osp.basename(fname))
+
+
+class WorkingDirOption(Option):
+    """Working directory configuration option handler"""
+
+    def get(self, default=NoDefault) -> str:
+        """Get working directory from configuration"""
+        if default is NoDefault:
+            default = ""
+        path = super().get(default)
+        if osp.isdir(path):
+            return path
+        return ""
+
+    def set(self, value: str) -> None:
+        """Set working directory in configuration"""
+        if not osp.isdir(value):
+            value = osp.dirname(value)
+            if not osp.isdir(value):
+                raise FileNotFoundError(f"Invalid working directory name {value}")
+        os.chdir(value)
+        super().set(value)
+
+
+class EnumOption(Option):
+    """Enumeration option handler"""
+
+    def __init__(self, values: list[Any], default: Any = NoDefault) -> None:
+        super().__init__()
+        if default is NoDefault:
+            default = values[0]
+        self.values = values
+        self.default = default
+
+    def get(self, default: Any = NoDefault) -> Any:
+        """Get configuration option value"""
+        value = super().get(default)
+        if value not in self.values:
+            # Only show a warning here, as the configuration file may be edited manually
+            warnings.warn(
+                f"Invalid value {value} for option {self.option}, "
+                f"expected {self.values}"
+            )
+            return self.default
+        return value
+
+    def set(self, value: Any) -> None:
+        """Set configuration option value"""
+        if value not in self.values:
+            raise ValueError(
+                f"Invalid value {value} for option {self.option}, "
+                f"expected {self.values}"
+            )
+        super().set(value)
+
+
+class DataSetOption(Option):
+    """DataSet option handler"""
+
+    def __init__(self, default_instance: gds.DataSet | None = None) -> None:
+        super().__init__()
+        self.default_instance = default_instance
+
+    def set_default_instance(self, default_instance: gds.DataSet) -> None:
+        """Set the default instance (for lazy initialization)"""
+        self.default_instance = default_instance
+
+    def get(self, default: Any = NoDefault) -> gds.DataSet:
+        """Get configuration option value"""
+        # Use provided default or fall back to default_instance
+        effective_default = (
+            default if default is not NoDefault else self.default_instance
+        )
+        try:
+            json_str = super().get(default)
+        except RuntimeError as exc:
+            # Option not yet registered in CONF - register it with default
+            if effective_default is None:
+                raise ValueError(
+                    f"No default instance set for option '{self.option}' "
+                    f"in section '{self.section}'"
+                ) from exc
+            # Register the default value in CONF (writes to config file)
+            self.set(effective_default)
+            return effective_default
+        # If the option doesn't exist, super().get() returns the default parameter
+        if not isinstance(json_str, str):
+            return json_str
+        if json_str is NoDefault or not json_str:
+            if effective_default is None:
+                raise ValueError(
+                    f"No default instance set for option '{self.option}' "
+                    f"in section '{self.section}'"
+                )
+            return effective_default
+        # Unescape percent signs that were escaped for ConfigParser
+        json_str = json_str.replace("%%", "%")
+        try:
+            return gds.json_to_dataset(json_str)
+        except Exception as exc:  # pylint: disable=broad-except
+            # Corrupted JSON: remove the option and return default
+            self.remove()
+            if effective_default is None:
+                raise ValueError(
+                    f"No default instance set for option '{self.option}' "
+                    f"in section '{self.section}'"
+                ) from exc
+            return effective_default
+
+    def set(self, value: gds.DataSet) -> None:
+        """Set configuration option value"""
+        json_str = gds.dataset_to_json(value)
+        # Escape percent signs for ConfigParser (which uses % for interpolation)
+        json_str = json_str.replace("%", "%%")
+        super().set(json_str)
+
+
+class SectionMeta(type):
+    """Configuration metaclass"""
+
+    #  pylint: disable=bad-mcs-classmethod-argument
+    def __new__(cls, name, bases, dct):
+        optlist = []
+        for attrname, obj in list(dct.items()):
+            if isinstance(obj, Option):
+                obj.option = attrname
+                optlist.append(obj)
+        dct["_options"] = optlist
+        return type.__new__(cls, name, bases, dct)
+
+
+class ConfMeta(type):
+    """Configuration metaclass"""
+
+    #  pylint: disable=bad-mcs-classmethod-argument
+    def __new__(cls, name, bases, dct):
+        for attrname, obj in list(dct.items()):
+            if isinstance(obj, Section):
+                obj.set_name(attrname)
+                for option in obj._options:
+                    option.section = attrname
+        return type.__new__(cls, name, bases, dct)