bec-widgets 0.99.1__py3-none-any.whl → 0.99.9__py3-none-any.whl

tests/end-2-end/test_bec_figure_rpc_e2e.py

@@ -1,212 +0,0 @@
-import time
-
-import numpy as np
-import pytest
-from bec_lib.endpoints import MessageEndpoints
-
-from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
-
-
-def test_rpc_waveform1d_custom_curve(rpc_server_figure):
-    fig = BECFigure(rpc_server_figure)
-
-    ax = fig.plot()
-    curve = ax.plot(x=[1, 2, 3], y=[1, 2, 3])
-    curve.set_color("red")
-    curve = ax.curves[0]
-    curve.set_color("blue")
-
-    assert len(fig.widgets) == 1
-    assert len(fig.widgets[ax._rpc_id].curves) == 1
-
-
-def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
-    fig = BECFigure(rpc_server_figure)
-
-    plt = fig.plot(x_name="samx", y_name="bpm4i")
-    im = fig.image("eiger")
-    motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.plot(x_name="samx", y_name="samy", z_name="bpm4i", new=True)
-
-    # Checking if classes are correctly initialised
-    assert len(fig.widgets) == 4
-    assert plt.__class__.__name__ == "BECWaveform"
-    assert plt.__class__ == BECWaveform
-    assert im.__class__.__name__ == "BECImageShow"
-    assert im.__class__ == BECImageShow
-    assert motor_map.__class__.__name__ == "BECMotorMap"
-    assert motor_map.__class__ == BECMotorMap
-
-    # check if the correct devices are set
-    # plot
-    assert plt._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
-        "dap": None,
-        "source": "scan_segment",
-        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
-        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
-        "z": None,
-    }
-    # image
-    assert im._config_dict["images"]["eiger"]["monitor"] == "eiger"
-    # motor map
-    assert motor_map._config_dict["signals"] == {
-        "dap": None,
-        "source": "device_readback",
-        "x": {
-            "name": "samx",
-            "entry": "samx",
-            "unit": None,
-            "modifier": None,
-            "limits": [-50.0, 50.0],
-        },
-        "y": {
-            "name": "samy",
-            "entry": "samy",
-            "unit": None,
-            "modifier": None,
-            "limits": [-50.0, 50.0],
-        },
-        "z": None,
-    }
-    # plot with z scatter
-    assert plt_z._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
-        "dap": None,
-        "source": "scan_segment",
-        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
-        "y": {"name": "samy", "entry": "samy", "unit": None, "modifier": None, "limits": None},
-        "z": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
-    }
-
-
-def test_rpc_waveform_scan(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
-
-    # add 3 different curves to track
-    plt = fig.plot(x_name="samx", y_name="bpm4i")
-    fig.plot(x_name="samx", y_name="bpm3a")
-    fig.plot(x_name="samx", y_name="bpm4d")
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-    queue = client.queue
-
-    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-    status.wait()
-
-    last_scan_data = queue.scan_storage.storage[-1].data
-
-    # get data from curves
-    plt_data = plt.get_all_data()
-
-    # check plotted data
-    assert plt_data["bpm4i-bpm4i"]["x"] == last_scan_data["samx"]["samx"].val
-    assert plt_data["bpm4i-bpm4i"]["y"] == last_scan_data["bpm4i"]["bpm4i"].val
-    assert plt_data["bpm3a-bpm3a"]["x"] == last_scan_data["samx"]["samx"].val
-    assert plt_data["bpm3a-bpm3a"]["y"] == last_scan_data["bpm3a"]["bpm3a"].val
-    assert plt_data["bpm4d-bpm4d"]["x"] == last_scan_data["samx"]["samx"].val
-    assert plt_data["bpm4d-bpm4d"]["y"] == last_scan_data["bpm4d"]["bpm4d"].val
-
-
-def test_rpc_image(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
-
-    im = fig.image("eiger")
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-
-    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-    status.wait()
-
-    last_image_device = client.connector.get_last(MessageEndpoints.device_monitor_2d("eiger"))[
-        "data"
-    ].data
-    last_image_plot = im.images[0].get_data()
-
-    # check plotted data
-    np.testing.assert_equal(last_image_device, last_image_plot)
-
-
-def test_rpc_motor_map(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
-
-    motor_map = fig.motor_map("samx", "samy")
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-
-    initial_pos_x = dev.samx.read()["samx"]["value"]
-    initial_pos_y = dev.samy.read()["samy"]["value"]
-
-    status = scans.mv(dev.samx, 1, dev.samy, 2, relative=True)
-    status.wait()
-
-    final_pos_x = dev.samx.read()["samx"]["value"]
-    final_pos_y = dev.samy.read()["samy"]["value"]
-
-    # check plotted data
-    motor_map_data = motor_map.get_data()
-
-    np.testing.assert_equal(
-        [motor_map_data["x"][0], motor_map_data["y"][0]], [initial_pos_x, initial_pos_y]
-    )
-    np.testing.assert_equal(
-        [motor_map_data["x"][-1], motor_map_data["y"][-1]], [final_pos_x, final_pos_y]
-    )
-
-
-def test_dap_rpc(rpc_server_figure, bec_client_lib, qtbot):
-
-    fig = BECFigure(rpc_server_figure)
-    plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
-
-    client = bec_client_lib
-    dev = client.device_manager.devices
-    scans = client.scans
-
-    dev.bpm4i.sim.sim_select_model("GaussianModel")
-    params = dev.bpm4i.sim.sim_params
-    params.update(
-        {"noise": "uniform", "noise_multiplier": 10, "center": 5, "sigma": 1, "amplitude": 200}
-    )
-    dev.bpm4i.sim.sim_params = params
-    time.sleep(1)
-
-    res = scans.line_scan(dev.samx, 0, 8, steps=50, relative=False)
-    res.wait()
-
-    # especially on slow machines, the fit might not be done yet
-    # so we wait until the fit reaches the expected value
-    def wait_for_fit():
-        dap_curve = plt.get_curve("bpm4i-bpm4i-GaussianModel")
-        fit_params = dap_curve.dap_params
-        print(fit_params)
-        return np.isclose(fit_params["center"], 5, atol=0.5)
-
-    qtbot.waitUntil(wait_for_fit, timeout=10000)
-
-
-def test_removing_subplots(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
-    plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
-    im = fig.image(monitor="eiger")
-    mm = fig.motor_map(motor_x="samx", motor_y="samy")
-
-    assert len(fig.widget_list) == 3
-
-    # removing curves
-    assert len(plt.curves) == 2
-    plt.curves[0].remove()
-    assert len(plt.curves) == 1
-    plt.remove_curve("bpm4i-bpm4i")
-    assert len(plt.curves) == 0
-
-    # removing all subplots from figure
-    plt.remove()
-    im.remove()
-    mm.remove()
-
-    assert len(fig.widget_list) == 0

tests/end-2-end/test_rpc_register_e2e.py

@@ -1,40 +0,0 @@
-import pytest
-
-from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
-
-
-def test_rpc_register_list_connections(rpc_server_figure):
-    fig = BECFigure(rpc_server_figure)
-
-    plt = fig.plot(x_name="samx", y_name="bpm4i")
-    im = fig.image("eiger")
-    motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.plot(x_name="samx", y_name="samy", z_name="bpm4i", new=True)
-
-    # keep only class names from objects, since objects on server and client are different
-    # so the best we can do is to compare types (rpc register is unit-tested elsewhere)
-    all_connections = {obj_id: type(obj).__name__ for obj_id, obj in fig._get_all_rpc().items()}
-
-    all_subwidgets_expected = {wid: type(widget).__name__ for wid, widget in fig.widgets.items()}
-    curve_1D = fig.widgets[plt._rpc_id]
-    curve_2D = fig.widgets[plt_z._rpc_id]
-    curves_expected = {
-        curve_1D._rpc_id: type(curve_1D).__name__,
-        curve_2D._rpc_id: type(curve_2D).__name__,
-    }
-    curves_expected.update({curve._gui_id: type(curve).__name__ for curve in curve_1D.curves})
-    curves_expected.update({curve._gui_id: type(curve).__name__ for curve in curve_2D.curves})
-    fig_expected = {fig._rpc_id: type(fig).__name__}
-    image_item_expected = {
-        fig.widgets[im._rpc_id].images[0]._rpc_id: type(fig.widgets[im._rpc_id].images[0]).__name__
-    }
-
-    all_connections_expected = {
-        **all_subwidgets_expected,
-        **curves_expected,
-        **fig_expected,
-        **image_item_expected,
-    }
-
-    assert len(all_connections) == 8
-    assert all_connections == all_connections_expected

tests/end-2-end/test_scan_control_e2e.py

@@ -1,71 +0,0 @@
-import time
-
-import pytest
-
-from bec_widgets.utils.widget_io import WidgetIO
-from bec_widgets.widgets.scan_control import ScanControl
-
-
-@pytest.fixture(scope="function")
-def scan_control(qtbot, bec_client_lib):  # , mock_dev):
-    widget = ScanControl(client=bec_client_lib)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_scan_control_populate_scans_e2e(scan_control):
-    expected_scans = [
-        "grid_scan",
-        "fermat_scan",
-        "round_scan",
-        "cont_line_scan",
-        "cont_line_fly_scan",
-        "round_scan_fly",
-        "round_roi_scan",
-        "time_scan",
-        "monitor_scan",
-        "acquire",
-        "line_scan",
-    ]
-    items = [
-        scan_control.comboBox_scan_selection.itemText(i)
-        for i in range(scan_control.comboBox_scan_selection.count())
-    ]
-    assert scan_control.comboBox_scan_selection.count() == len(expected_scans)
-    assert sorted(items) == sorted(expected_scans)
-
-
-def test_run_line_scan_with_parameters_e2e(scan_control, bec_client_lib, qtbot):
-    client = bec_client_lib
-    queue = client.queue
-
-    scan_name = "line_scan"
-    kwargs = {"exp_time": 0.01, "steps": 10, "relative": True, "burst_at_each_point": 1}
-    args = {"device": "samx", "start": -5, "stop": 5}
-
-    scan_control.comboBox_scan_selection.setCurrentText(scan_name)
-
-    # Set kwargs in the UI
-    for kwarg_box in scan_control.kwarg_boxes:
-        for widget in kwarg_box.widgets:
-            for key, value in kwargs.items():
-                if widget.arg_name == key:
-                    WidgetIO.set_value(widget, value)
-                    break
-    # Set args in the UI
-    for widget in scan_control.arg_box.widgets:
-        for key, value in args.items():
-            if widget.arg_name == key:
-                WidgetIO.set_value(widget, value)
-                break
-
-    # Run the scan
-    scan_control.button_run_scan.click()
-    time.sleep(2)
-
-    last_scan = queue.scan_storage.storage[-1]
-    assert last_scan.status_message.info["scan_name"] == scan_name
-    assert last_scan.status_message.info["exp_time"] == kwargs["exp_time"]
-    assert last_scan.status_message.info["scan_motors"] == [args["device"]]
-    assert last_scan.status_message.info["num_points"] == kwargs["steps"]

tests/unit_tests/client_mocks.py

@@ -1,189 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-from unittest.mock import MagicMock, patch
-
-import fakeredis
-import pytest
-from bec_lib.client import BECClient
-from bec_lib.device import Positioner, ReadoutPriority
-from bec_lib.devicemanager import DeviceContainer
-from bec_lib.redis_connector import RedisConnector
-
-
-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True, readout_priority=ReadoutPriority.MONITORED):
-        self.name = name
-        self.enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
-        self.readout_priority = readout_priority
-        self._config = {
-            "readoutPriority": "baseline",
-            "deviceClass": "ophyd_devices.SimPositioner",
-            "deviceConfig": {
-                "delay": 1,
-                "limits": [-50, 50],
-                "tolerance": 0.01,
-                "update_frequency": 400,
-            },
-            "deviceTags": ["user motors"],
-            "enabled": enabled,
-            "readOnly": False,
-            "name": self.name,
-        }
-
-    def __contains__(self, item):
-        return item == self.name
-
-    @property
-    def _hints(self):
-        return [self.name]
-
-    def set_value(self, fake_value: float = 1.0) -> None:
-        """
-        Setup fake value for device readout
-        Args:
-            fake_value(float): Desired fake value
-        """
-        self.signals[self.name]["value"] = fake_value
-
-    def describe(self) -> dict:
-        """
-        Get the description of the device
-        Returns:
-            dict: Description of the device
-        """
-        return self.description
-
-
-class FakePositioner(FakeDevice):
-    def __init__(
-        self,
-        name,
-        enabled=True,
-        limits=None,
-        read_value=1.0,
-        readout_priority=ReadoutPriority.MONITORED,
-    ):
-        super().__init__(name, enabled, readout_priority)
-        self.limits = limits if limits is not None else [0, 0]
-        self.read_value = read_value
-        self.name = name
-
-    @property
-    def precision(self):
-        return 3
-
-    def set_read_value(self, value):
-        self.read_value = value
-
-    def read(self):
-        return {
-            self.name: {"value": self.read_value},
-            f"{self.name}_setpoint": {"value": self.read_value},
-            f"{self.name}_motor_is_moving": {"value": 0},
-        }
-
-    def set_limits(self, limits):
-        self.limits = limits
-
-    def move(self, value, relative=False):
-        """Simulates moving the device to a new position."""
-        if relative:
-            self.read_value += value
-        else:
-            self.read_value = value
-        # Respect the limits
-        self.read_value = max(min(self.read_value, self.limits[1]), self.limits[0])
-
-    @property
-    def readback(self):
-        return MagicMock(get=MagicMock(return_value=self.read_value))
-
-
-class Positioner(FakePositioner):
-    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
-
-    def __init__(self, name="test", limits=None, read_value=1.0):
-        super().__init__(name, limits, read_value)
-
-
-class Device(FakeDevice):
-    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
-
-    def __init__(self, name, enabled=True):
-        super().__init__(name, enabled)
-
-
-class DMMock:
-    def __init__(self):
-        self.devices = DeviceContainer()
-
-    def add_devives(self, devices: list):
-        for device in devices:
-            self.devices[device.name] = device
-
-
-DEVICES = [
-    FakePositioner("samx", limits=[-10, 10], read_value=2.0),
-    FakePositioner("samy", limits=[-5, 5], read_value=3.0),
-    FakePositioner("samz", limits=[-8, 8], read_value=4.0),
-    FakePositioner("aptrx", limits=None, read_value=4.0),
-    FakePositioner("aptry", limits=None, read_value=5.0),
-    FakeDevice("gauss_bpm"),
-    FakeDevice("gauss_adc1"),
-    FakeDevice("gauss_adc2"),
-    FakeDevice("gauss_adc3"),
-    FakeDevice("bpm4i"),
-    FakeDevice("bpm3a"),
-    FakeDevice("bpm3i"),
-    FakeDevice("eiger"),
-    FakeDevice("async_device", readout_priority=ReadoutPriority.ASYNC),
-    Positioner("test", limits=[-10, 10], read_value=2.0),
-    Device("test_device"),
-]
-
-
-def fake_redis_server(host, port):
-    redis = fakeredis.FakeRedis()
-    return redis
-
-
-@pytest.fixture(scope="function")
-def mocked_client(bec_dispatcher):
-    connector = RedisConnector("localhost:1", redis_cls=fake_redis_server)
-    # Create a MagicMock object
-    client = MagicMock()  # TODO change to real BECClient
-
-    # Shutdown the original client
-    bec_dispatcher.client.shutdown()
-    # Mock the connector attribute
-    bec_dispatcher.client = client
-
-    # Mock the device_manager.devices attribute
-    client.connector = connector
-    client.device_manager = DMMock()
-    client.device_manager.add_devives(DEVICES)
-
-    def mock_mv(*args, relative=False):
-        # Extracting motor and value pairs
-        for i in range(0, len(args), 2):
-            motor = args[i]
-            value = args[i + 1]
-            motor.move(value, relative=relative)
-        return MagicMock(wait=MagicMock())
-
-    client.scans = MagicMock(mv=mock_mv)
-
-    # Ensure isinstance check for Positioner passes
-    original_isinstance = isinstance
-
-    def isinstance_mock(obj, class_info):
-        if class_info == Positioner and isinstance(obj, FakePositioner):
-            return True
-        return original_isinstance(obj, class_info)
-
-    with patch("builtins.isinstance", new=isinstance_mock):
-        yield client
-    connector.shutdown()  # TODO change to real BECClient

tests/unit_tests/conftest.py

@@ -1,64 +0,0 @@
-import pytest
-from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
-from qtpy.QtWidgets import QApplication
-
-from bec_widgets.cli.rpc_register import RPCRegister
-from bec_widgets.qt_utils import error_popups
-from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
-
-
-@pytest.fixture(autouse=True)
-def qapplication(qtbot):  # pylint: disable=unused-argument
-    yield
-
-    qapp = QApplication.instance()
-    # qapp.quit()
-    qapp.processEvents()
-    try:
-        qtbot.waitUntil(lambda: qapp.topLevelWidgets() == [])
-    except QtBotTimeoutError as exc:
-        raise TimeoutError(f"Failed to close all widgets: {qapp.topLevelWidgets()}") from exc
-
-
-@pytest.fixture(autouse=True)
-def rpc_register():
-    yield RPCRegister()
-    RPCRegister.reset_singleton()
-
-
-@pytest.fixture(autouse=True)
-def bec_dispatcher(threads_check):  # pylint: disable=unused-argument
-    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
-    yield bec_dispatcher
-    bec_dispatcher.disconnect_all()
-    # clean BEC client
-    bec_dispatcher.client.shutdown()
-    # reinitialize singleton for next test
-    bec_dispatcher_module.BECDispatcher.reset_singleton()
-
-
-@pytest.fixture(autouse=True)
-def clean_singleton():
-    error_popups._popup_utility_instance = None
-
-
-def create_widget(qtbot, widget, *args, **kwargs):
-    """
-    Create a widget and add it to the qtbot for testing. This is a helper function that
-    should be used in all tests that require a widget to be created.
-    DO NOT CREATE WIDGETS DIRECTLY IN A FIXTURE!
-
-    Args:
-        qtbot (fixture): pytest-qt fixture
-        widget (QWidget): widget class to be created
-        *args: positional arguments for the widget
-        **kwargs: keyword arguments for the widget
-
-    Returns:
-        QWidget: the created widget
-
-    """
-    widget = widget(*args, **kwargs)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    return widget

tests/unit_tests/test_bec_connector.py

@@ -1,80 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-import time
-
-import pytest
-from qtpy.QtWidgets import QApplication
-
-from bec_widgets.qt_utils.error_popups import SafeSlot as Slot
-from bec_widgets.utils import BECConnector, ConnectionConfig
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def bec_connector(mocked_client):
-    connector = BECConnector(client=mocked_client)
-    return connector
-
-
-def test_bec_connector_init(bec_connector):
-    assert bec_connector is not None
-    assert bec_connector.client is not None
-    assert isinstance(bec_connector, BECConnector)
-    assert bec_connector.config.widget_class == "BECConnector"
-
-
-def test_bec_connector_init_with_gui_id(mocked_client):
-    bc = BECConnector(client=mocked_client, gui_id="test_gui_id")
-    assert bc.config.gui_id == "test_gui_id"
-    assert bc.gui_id == "test_gui_id"
-
-
-def test_bec_connector_set_gui_id(bec_connector):
-    bec_connector.set_gui_id("test_gui_id")
-    assert bec_connector.config.gui_id == "test_gui_id"
-
-
-def test_bec_connector_change_config(bec_connector):
-    bec_connector.on_config_update({"gui_id": "test_gui_id"})
-    assert bec_connector.config.gui_id == "test_gui_id"
-
-
-def test_bec_connector_get_obj_by_id(bec_connector):
-    bec_connector.set_gui_id("test_gui_id")
-    assert bec_connector.get_obj_by_id("test_gui_id") == bec_connector
-    assert bec_connector.get_obj_by_id("test_gui_id_2") is None
-
-
-def test_bec_connector_update_client(bec_connector, mocked_client):
-    client_new = mocked_client
-    bec_connector.update_client(client_new)
-    assert bec_connector.client == client_new
-    assert bec_connector.dev is not None
-    assert bec_connector.scans is not None
-    assert bec_connector.queue is not None
-    assert bec_connector.scan_storage is not None
-    assert bec_connector.dap is not None
-
-
-def test_bec_connector_get_config(bec_connector):
-    assert bec_connector.get_config(dict_output=False) == bec_connector.config
-    assert bec_connector.get_config() == bec_connector.config.model_dump()
-
-
-def test_bec_connector_submit_task(bec_connector):
-    def test_func():
-        time.sleep(2)
-        print("done")
-
-    completed = False
-
-    @Slot()
-    def complete_func():
-        nonlocal completed
-        completed = True
-
-    bec_connector.submit_task(test_func, on_complete=complete_func)
-    assert not completed
-    while not completed:
-        QApplication.processEvents()
-        time.sleep(0.1)