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

datalab/tests/features/control/embedded1_unit_test.py

@@ -0,0 +1,304 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Application embedded test 1
+
+DataLab main window is destroyed when closing application.
+It is rebuilt from scratch when reopening application.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import abc
+
+from guidata.qthelpers import (
+    get_std_icon,
+    qt_app_context,
+    win32_fix_title_bar_background,
+)
+from guidata.widgets.codeeditor import CodeEditor
+from qtpy import QtWidgets as QW
+from sigima.objects import NewImageParam
+from sigima.tests import data as test_data
+
+from datalab.config import _
+from datalab.gui.main import DLMainWindow
+from datalab.tests.features.macro.macroeditor_unit_test import get_macro_example_path
+
+
+class HostWidget(QW.QWidget):
+    """Host widget: menu with action buttons, log viewer"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.button_layout = QW.QVBoxLayout()
+        self.logwidget = CodeEditor(self)
+        self.logwidget.setMinimumWidth(500)
+        grid_layout = QW.QGridLayout()
+        grid_layout.addLayout(self.button_layout, 0, 0)
+        grid_layout.addWidget(self.logwidget, 0, 1)
+        self.setLayout(grid_layout)
+
+    def log(self, message):
+        """Log message"""
+        self.logwidget.appendPlainText(message)
+
+    def add_spacing(self, spacing: int) -> None:
+        """Add spacing to button box"""
+        self.button_layout.addSpacing(spacing)
+
+    def add_label(self, text: str) -> None:
+        """Add label to button box"""
+        self.button_layout.addWidget(QW.QLabel(text))
+
+    def add_widget(self, obj: QW.QWidget, spacing_before: int = 0) -> None:
+        """Add widget (QWidget) to button box"""
+        if spacing_before > 0:
+            self.add_spacing(spacing_before)
+        self.button_layout.addWidget(obj)
+
+    def add_button(self, title, slot, spacing_before=0, icon=None):
+        """Add button"""
+        btn = QW.QPushButton(title)
+        if icon is not None:
+            btn.setIcon(get_std_icon(icon))
+        btn.clicked.connect(lambda _checked=False: slot())
+        self.add_widget(btn, spacing_before=spacing_before)
+        return btn
+
+    def add_stretch(self):
+        """Add stretch to button box"""
+        self.button_layout.addStretch()
+
+
+class AbstractClientWindowMeta(type(QW.QMainWindow), abc.ABCMeta):
+    """Mixed metaclass to avoid conflicts"""
+
+
+class AbstractClientWindow(QW.QMainWindow, metaclass=AbstractClientWindowMeta):
+    """Abstract client window, to embed DataLab or connect to it"""
+
+    PURPOSE = None
+    INIT_BUTTON_LABEL = None
+    SIG_TITLES = ("Oscilloscope", "Digitizer", "Radiometer", "Voltmeter", "Sensor")
+    IMA_TITLES = (
+        "Camera",
+        "Streak Camera",
+        "Image Scanner",
+        "Laser Beam Profiler",
+        "Gated Imaging Camera",
+    )
+
+    def __init__(self):
+        super().__init__()
+        win32_fix_title_bar_background(self)
+        self.setWindowTitle(_("Host application"))
+        self.setWindowIcon(get_std_icon("ComputerIcon"))
+        self.datalab: DLMainWindow = None
+        self.host = HostWidget(self)
+        self.setCentralWidget(self.host)
+        self.setup_window()
+        self.host.add_stretch()
+        self.index_sigtitle = -1
+        self.index_imatitle = -1
+
+    @property
+    def sigtitle(self):
+        """Return current signal title index"""
+        self.index_sigtitle = idx = (self.index_sigtitle + 1) % len(self.SIG_TITLES)
+        return self.SIG_TITLES[idx]
+
+    @property
+    def imatitle(self):
+        """Return current image title index"""
+        self.index_imatitle = idx = (self.index_imatitle + 1) % len(self.IMA_TITLES)
+        return self.IMA_TITLES[idx]
+
+    def setup_window(self):
+        """Setup window"""
+        self.host.add_label(self.PURPOSE)
+        add_btn = self.host.add_button
+        add_btn(self.INIT_BUTTON_LABEL, self.init_cdl, 10, "DialogApplyButton")
+        add_btn(_("Raise window"), self.raise_cdl, 0, "FileDialogToParent")
+        self.add_additional_buttons()
+        add_btn(_("Add signal objects"), self.add_signals, 10, "CommandLink")
+        add_btn(_("Add image objects"), self.add_images, 0, "CommandLink")
+        add_btn(_("Remove all objects"), self.remove_all, 5, "MessageBoxWarning")
+        add_btn(_("Run macro"), self.run_macro, 10, "CommandLink")
+        add_btn(_("Stop macro"), self.stop_macro, 0, "CommandLink")
+        add_btn(
+            _("Import macro from file (example)"), self.import_macro, 0, "CommandLink"
+        )
+        add_btn(_("Close DataLab"), self.close_datalab, 10, "DialogCloseButton")
+
+    def add_additional_buttons(self):
+        """Add additional buttons"""
+
+    @abc.abstractmethod
+    def init_cdl(self):
+        """Open DataLab test"""
+
+    def raise_cdl(self):
+        """Raise DataLab window"""
+        if self.datalab is not None:
+            self.datalab.raise_window()
+            self.host.log("=> Raised DataLab window")
+
+    @abc.abstractmethod
+    def close_datalab(self):
+        """Close DataLab window"""
+
+    def add_object(self, obj):
+        """Add object to DataLab"""
+        if self.datalab is not None:
+            self.datalab.add_object(obj)
+
+    def add_signals(self):
+        """Add signals to DataLab"""
+        if self.datalab is not None:
+            for func in (
+                test_data.create_paracetamol_signal,
+                test_data.create_noisy_signal,
+            ):
+                obj = func(title=self.sigtitle)
+                self.add_object(obj)
+                self.host.log(f"Added signal: {obj.title}")
+
+    def add_images(self):
+        """Add images to DataLab"""
+        if self.datalab is not None:
+            p = NewImageParam.create(height=2000, width=2000, title=self.imatitle)
+            for func in (
+                test_data.create_sincos_image,
+                test_data.create_noisy_gaussian_image,
+                test_data.create_multigaussian_image,
+            ):
+                obj = func(p)
+                self.add_object(obj)
+                self.host.log(f"Added image: {obj.title}")
+
+    @abc.abstractmethod
+    def remove_all(self):
+        """Remove all objects from DataLab"""
+
+    def __has_macro(self):
+        """Check if there is a macro in DataLab"""
+        return len(self.datalab.get_object_titles("macro")) > 0
+
+    def run_macro(self):
+        """Run macro in DataLab"""
+        if self.datalab is not None:
+            if self.__has_macro():
+                self.datalab.run_macro()
+                self.host.log("=> Running macro")
+            else:
+                self.host.log("No macro to run")
+
+    def stop_macro(self):
+        """Stop macro in DataLab"""
+        if self.datalab is not None:
+            if self.__has_macro():
+                self.datalab.stop_macro()
+                self.host.log("=> Stopping macro")
+            else:
+                self.host.log("No macro to stop")
+
+    def import_macro(self):
+        """Import macro in DataLab"""
+        if self.datalab is not None:
+            fname = get_macro_example_path()
+            self.datalab.import_macro_from_file(fname)
+            self.host.log(f"=> Imported macro: {fname}")
+
+
+class AbstractHostWindow(AbstractClientWindow):  # pylint: disable=abstract-method
+    """Abstract host window, embedding DataLab"""
+
+    PURPOSE = _("This the host application, which embeds DataLab.")
+    INIT_BUTTON_LABEL = _("Open DataLab")
+
+    def remove_all(self):
+        """Remove all objects from DataLab"""
+        if self.datalab is not None:
+            for panel in self.datalab.panels:
+                panel.remove_all_objects()
+                self.host.log(f"Removed objects from {panel.PANEL_STR}")
+
+    def add_additional_buttons(self):
+        """Add additional buttons"""
+        add_btn = self.host.add_button
+        add_btn(_("Import signal from DataLab"), self.import_signal, 10, "ArrowLeft")
+        add_btn(_("Import image from DataLab"), self.import_image, 0, "ArrowLeft")
+
+    def import_object(self, panel, title):
+        """Import object from DataLab"""
+        self.host.log(f"get_objects_with_dialog ({title}):")
+        objs = panel.get_objects_with_dialog(title, parent=self.host)
+        if objs is not None:
+            for obj in objs:
+                self.host.log(f"  -> {obj.title}:")
+                self.host.log(str(obj))
+        else:
+            self.host.log("  -> canceled")
+
+    def import_signal(self):
+        """Import signal from DataLab"""
+        if self.datalab is not None:
+            self.import_object(self.datalab.signalpanel, self.sender().text())
+
+    def import_image(self):
+        """Import image from DataLab"""
+        if self.datalab is not None:
+            self.import_object(self.datalab.imagepanel, self.sender().text())
+
+
+class HostWindow(AbstractHostWindow):
+    """Test main view"""
+
+    def init_cdl(self):
+        """Open DataLab test"""
+        if self.datalab is None:
+            self.datalab = DLMainWindow(console=False)
+            self.datalab.SIG_CLOSING.connect(self.datalab_was_closed)
+            self.datalab.show()
+            self.host.log("✨Initialized DataLab window")
+        else:
+            try:
+                self.datalab.show()
+                self.datalab.raise_()
+                self.host.log("=> Shown DataLab window")
+            except RuntimeError:
+                self.datalab = None
+                self.init_cdl()
+
+    def datalab_was_closed(self):
+        """DataLab was closed"""
+        self.datalab = None
+        self.host.log("✨DataLab window was closed by user")
+
+    def close_datalab(self):
+        """Close DataLab window"""
+        if self.datalab is not None:
+            self.host.log("=> Closed DataLab")
+            self.datalab.SIG_CLOSING.disconnect(self.datalab_was_closed)
+            self.datalab.close()
+            self.datalab.deleteLater()
+            self.datalab = None
+
+
+def run_host_window(klass):
+    """Running host window to test DataLab embedding feature"""
+    with qt_app_context(exec_loop=True):
+        window: HostWindow = klass()
+        window.resize(800, 800)
+        window.show()
+
+
+def test_embedded_feature():
+    """Testing embedded feature"""
+    run_host_window(HostWindow)
+
+
+if __name__ == "__main__":
+    test_embedded_feature()

datalab/tests/features/control/embedded2_unit_test.py

@@ -0,0 +1,52 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Application embedded test 2
+
+DataLab main window is simply hidden when closing application.
+It is shown and raised above other windows when reopening application.
+"""
+
+# guitest: show
+
+from datalab.gui.main import DLMainWindow
+from datalab.tests.features.control import embedded1_unit_test
+
+
+class HostWindow(embedded1_unit_test.AbstractHostWindow):
+    """Test main view"""
+
+    def init_cdl(self) -> None:
+        """Open DataLab test"""
+        if self.datalab is None:
+            self.datalab = DLMainWindow(console=False, hide_on_close=True)
+            self.host.log("✨ Initialized DataLab window")
+            self.datalab.show()
+        else:
+            self.datalab.show()
+            self.datalab.raise_window()
+        self.host.log("=> Shown DataLab window")
+
+    def close_datalab(self) -> None:
+        """Close DataLab window"""
+        if self.datalab is not None:
+            self.host.log("=> Closed DataLab")
+            self.datalab.close()
+
+    def closeEvent(self, event) -> None:  # pylint: disable=invalid-name
+        """Close event
+
+        Reimplemented from QWidget.closeEvent"""
+        if self.datalab is None or self.datalab.close_properly():
+            event.accept()
+        else:
+            event.ignore()
+
+
+def test_embedded_feature():
+    """Testing embedded feature"""
+    embedded1_unit_test.run_host_window(HostWindow)
+
+
+if __name__ == "__main__":
+    test_embedded_feature()

datalab/tests/features/control/remoteclient_app_test.py

@@ -0,0 +1,219 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Remote GUI-based client test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+# guitest: show
+
+from __future__ import annotations
+
+import functools
+from contextlib import contextmanager
+
+from guidata.qthelpers import qt_app_context, qt_wait
+from qtpy import QtWidgets as QW
+
+from datalab.config import _
+from datalab.control.proxy import RemoteProxy
+from datalab.env import execenv
+from datalab.tests import run_datalab_in_background
+from datalab.tests.features.control import embedded1_unit_test
+from datalab.tests.features.control.remoteclient_unit import multiple_commands
+from datalab.utils.qthelpers import bring_to_front
+from datalab.widgets.connection import ConnectionDialog
+
+APP_NAME = _("Remote client test")
+
+
+def try_send_command():
+    """Try and send command to DataLab application remotely"""
+
+    def try_send_command_decorator(func):
+        """Try... except... decorator"""
+
+        @functools.wraps(func)
+        def method_wrapper(*args, **kwargs):
+            """Decorator wrapper function"""
+            self: HostWindow = args[0]  # extracting 'self' from method arguments
+            output = None
+            try:
+                output = func(*args, **kwargs)
+            except ConnectionRefusedError as exc:
+                self.datalab = None
+                message = "🔥 Connection refused 🔥 (server is not ready?)"
+                self.host.log(message)
+                if execenv.unattended:
+                    raise ConnectionRefusedError(
+                        "Connection refused (server is not ready?)"
+                    ) from exc
+                QW.QMessageBox.critical(self, APP_NAME, message)
+            return output
+
+        return method_wrapper
+
+    return try_send_command_decorator
+
+
+class HostWindow(embedded1_unit_test.AbstractClientWindow):
+    """Test main view"""
+
+    PURPOSE = _("This the client application, which connects to DataLab.")
+    INIT_BUTTON_LABEL = _("Connect to DataLab")
+
+    def init_cdl(self):
+        """Open DataLab test"""
+        if self.datalab is None:
+            if execenv.unattended:
+                self.datalab = RemoteProxy()
+                ok = True
+            else:
+                self.datalab = RemoteProxy(autoconnect=False)
+                connect_dlg = ConnectionDialog(self.datalab.connect, self)
+                ok = connect_dlg.exec()
+            if ok:
+                self.host.log("✨ Initialized DataLab connection ✨")
+                self.host.log(f"  Communication port: {self.datalab.port}")
+                self.host.log("  List of exposed methods:")
+                for name in self.datalab.get_method_list():
+                    self.host.log(f"    {name}")
+            else:
+                self.datalab = None
+                error_msg = connect_dlg.get_error_message()
+                self.host.log(f"🔥 Connection refused 🔥 ({error_msg})")
+                if execenv.unattended:
+                    raise ConnectionRefusedError(
+                        "Connection refused (server is not ready?)"
+                    )
+        else:
+            self.host.log("=> Already connected to DataLab")
+
+    @try_send_command()
+    def close_datalab(self):
+        """Close DataLab window"""
+        if self.datalab is not None:
+            self.datalab.close_application()
+            self.host.log("🎬 Closed DataLab!")
+            self.datalab = None
+
+    def add_additional_buttons(self):
+        """Add additional buttons"""
+        add_btn = self.host.add_button
+        add_btn(_("Execute multiple commands"), self.exec_multiple_cmd, 10)
+        add_btn(_("Get object titles"), self.get_object_titles, 10)
+        add_btn(_("Get object uuids"), self.get_object_uuids, 10)
+        add_btn(_("Get object"), self.get_object)
+
+    @try_send_command()
+    def exec_multiple_cmd(self):
+        """Execute multiple commands in DataLab"""
+        if self.datalab is not None:
+            self.host.log("Starting command sequence...")
+            multiple_commands(self.datalab)
+            self.host.log("...end")
+
+    @try_send_command()
+    def get_object_titles(self):
+        """Get object (signal/image) titles for current panel"""
+        if self.datalab is not None:
+            self.host.log("Object titles:")
+            titles = self.datalab.get_object_titles()
+            if titles:
+                for name in titles:
+                    self.host.log(f"  {name}")
+            else:
+                self.host.log("  Empty.")
+
+    @try_send_command()
+    def get_object_uuids(self):
+        """Get object (signal/image) uuids for current panel"""
+        if self.datalab is not None:
+            self.host.log("Object uuids:")
+            uuids = self.datalab.get_object_uuids()
+            if uuids:
+                for uuid in uuids:
+                    self.host.log(f"  {uuid}")
+            else:
+                self.host.log("  Empty.")
+
+    @try_send_command()
+    def get_object(self):
+        """Get object (signal/image) at index for current panel"""
+        if self.datalab is not None:
+            titles = self.datalab.get_object_titles()
+            if titles:
+                obj = self.datalab.get_object()
+                if obj is not None:
+                    self.host.log(f"Object '{obj.title}'")
+                    self.host.log(str(obj))
+                else:
+                    self.host.log("🏴‍☠️ Object is None! (no selection)")
+            else:
+                self.host.log("🏴‍☠️ Object list is empty!")
+
+    @try_send_command()
+    def add_object(self, obj):
+        """Add object to DataLab"""
+        super().add_object(obj)
+
+    @try_send_command()
+    def remove_all(self):
+        """Remove all objects from DataLab"""
+        if self.datalab is not None:
+            self.datalab.reset_all()
+            self.host.log("Removed all objects")
+
+
+@contextmanager
+def qt_wait_print(dt: float, message: str, parent=None):
+    """Wait and print message"""
+    qt_wait(dt, show_message=True, parent=parent)
+    execenv.print(f"{message}...", end="")
+    yield
+    execenv.print("OK")
+
+
+def test_remote_client():
+    """Remote client application test"""
+    run_datalab_in_background()
+
+    with qt_app_context(exec_loop=True):
+        window = HostWindow()
+        window.resize(800, 800)
+        window.show()
+        dt = 1
+        if execenv.unattended:
+            qt_wait(8, show_message=True, parent=window)
+            window.init_cdl()
+            with qt_wait_print(dt, "Executing multiple commands"):
+                window.exec_multiple_cmd()
+            bring_to_front(window)
+            with qt_wait_print(dt, "Raising DataLab window"):
+                window.raise_cdl()
+            with qt_wait_print(dt, "Import macro"):
+                window.import_macro()
+            with qt_wait_print(dt, "Getting object titles"):
+                window.get_object_titles()
+            with qt_wait_print(dt, "Getting object uuids"):
+                window.get_object_uuids()
+            with qt_wait_print(dt, "Getting object"):
+                window.get_object()
+            with qt_wait_print(dt, "Adding signals"):
+                window.add_signals()
+            with qt_wait_print(dt, "Adding images"):
+                window.add_images()
+            with qt_wait_print(dt, "Run macro"):
+                window.run_macro()
+            with qt_wait_print(dt * 2, "Stop macro"):
+                window.stop_macro()
+            with qt_wait_print(dt, "Removing all objects"):
+                window.remove_all()
+            with qt_wait_print(dt, "Closing DataLab"):
+                window.close_datalab()
+
+
+if __name__ == "__main__":
+    test_remote_client()

datalab/tests/features/control/remoteclient_unit.py

@@ -0,0 +1,75 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Remote client test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+# guitest: skip
+
+import os
+import os.path as osp
+import time
+
+import numpy as np
+from guidata.qthelpers import qt_app_context
+from plotpy.builder import make
+from sigima.params import XYCalibrateParam
+from sigima.tests.data import create_2d_gaussian, create_paracetamol_signal
+
+from datalab import app
+from datalab.control.proxy import RemoteProxy
+from datalab.env import execenv
+from datalab.tests import helpers
+
+
+def multiple_commands(remote: RemoteProxy):
+    """Execute multiple XML-RPC commands"""
+    with helpers.WorkdirRestoringTempDir() as tmpdir:
+        x, y = create_paracetamol_signal().get_data()
+        remote.add_signal("tutu", x, y)
+
+        z = create_2d_gaussian(2000, np.uint16)
+        remote.add_image("toto", z)
+        rect = make.annotated_rectangle(100, 100, 200, 200, title="Test")
+        area = rect.get_rect()
+        remote.add_annotations_from_items([rect])
+        uuid = remote.get_sel_object_uuids()[0]
+        items = remote.get_object_shapes()
+        assert len(items) == 1 and items[0].get_rect() == area
+        remote.add_label_with_title(f"Image uuid: {uuid}")
+        remote.select_groups([1])
+        remote.select_objects([uuid])
+        remote.delete_metadata()
+
+        fname = osp.join(tmpdir, osp.basename("remote_test.h5"))
+        remote.save_to_h5_file(fname)
+        remote.reset_all()
+        remote.open_h5_files([fname], True, False)
+        remote.import_h5_file(fname, True)
+        remote.set_current_panel("signal")
+        assert remote.get_current_panel() == "signal"
+        remote.calc("log10")
+
+        param = XYCalibrateParam.create(a=1.2, b=0.1)
+        remote.calc("calibration", param)
+
+        time.sleep(2)  # Avoid permission error when trying to clean-up temporary files
+
+
+def test_remoteclient_unit():
+    """Remote client test"""
+    env = os.environ.copy()
+    env[execenv.DO_NOT_QUIT_ENV] = "1"
+    execenv.print("Launching DataLab in a separate process")
+    helpers.exec_script(app.__file__, wait=False, env=env)
+    remote = RemoteProxy()
+    execenv.print("Executing multiple commands...", end="")
+    with qt_app_context():  # needed for building plot items
+        multiple_commands(remote)
+    execenv.print("OK")
+
+
+if __name__ == "__main__":
+    test_remoteclient_unit()