bec-widgets 0.99.8__py3-none-any.whl → 0.99.10__py3-none-any.whl

tests/unit_tests/test_bec_image_widget.py

@@ -1,217 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pyqtgraph as pg
-import pytest
-
-from bec_widgets.widgets.image.image_widget import BECImageWidget
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def image_widget(qtbot, mocked_client):
-    widget = BECImageWidget(client=mocked_client())
-    widget.toolbar.widgets["monitor"].device_combobox.set_device_filter("FakeDevice")
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-@pytest.fixture
-def mock_image(image_widget):
-    image_mock = MagicMock()
-    image_widget._image = image_mock
-    return image_mock
-
-
-def test_image_widget_init(image_widget):
-    assert image_widget is not None
-    assert image_widget.client is not None
-    assert isinstance(image_widget, BECImageWidget)
-    assert image_widget.config.widget_class == "BECImageWidget"
-    assert image_widget._image is not None
-
-    assert (
-        image_widget.toolbar.widgets["monitor"].device_combobox.config.device_filter == "FakeDevice"
-    )
-    assert image_widget.toolbar.widgets["drag_mode"].action.isChecked() == True
-    assert image_widget.toolbar.widgets["rectangle_mode"].action.isChecked() == False
-    assert image_widget.toolbar.widgets["auto_range"].action.isChecked() == False
-    assert image_widget.toolbar.widgets["auto_range_image"].action.isChecked() == True
-    assert image_widget.toolbar.widgets["FFT"].action.isChecked() == False
-    assert image_widget.toolbar.widgets["transpose"].action.isChecked() == False
-    assert image_widget.toolbar.widgets["log"].action.isChecked() == False
-
-
-###################################
-# Toolbar Actions
-###################################
-def test_toolbar_connect_action(image_widget, mock_image, qtbot):
-    combo = image_widget.toolbar.widgets["monitor"].device_combobox
-    combo.setCurrentText("eiger")
-    qtbot.wait(200)
-    assert combo.currentText() == "eiger"
-    action = image_widget.toolbar.widgets["connect"].action
-    action.trigger()
-    image_widget._image.image.assert_called_once_with(
-        monitor="eiger",
-        color_map="magma",
-        color_bar="full",
-        downsample=True,
-        opacity=1.0,
-        vrange=None,
-    )
-
-
-def test_image_toolbar_drag_mode_action_triggered(image_widget, qtbot):
-    action_drag = image_widget.toolbar.widgets["drag_mode"].action
-    action_rectangle = image_widget.toolbar.widgets["rectangle_mode"].action
-    action_drag.trigger()
-    assert action_drag.isChecked() == True
-    assert action_rectangle.isChecked() == False
-
-
-def test_image_toolbar_rectangle_mode_action_triggered(image_widget, qtbot):
-    action_drag = image_widget.toolbar.widgets["drag_mode"].action
-    action_rectangle = image_widget.toolbar.widgets["rectangle_mode"].action
-    action_rectangle.trigger()
-    assert action_drag.isChecked() == False
-    assert action_rectangle.isChecked() == True
-
-
-def test_image_toolbar_auto_range(image_widget, mock_image):
-    action = image_widget.toolbar.widgets["auto_range"].action
-    action.trigger()
-    image_widget._image.set_auto_range.assert_called_once_with(True, "xy")
-
-
-def test_image_toolbar_enable_mouse_pan_mode(qtbot, image_widget):
-    action_drag = image_widget.toolbar.widgets["drag_mode"].action
-    action_rectangle = image_widget.toolbar.widgets["rectangle_mode"].action
-
-    mock_view_box = MagicMock()
-    image_widget._image.plot_item.getViewBox = MagicMock(return_value=mock_view_box)
-
-    image_widget.enable_mouse_pan_mode()
-
-    assert action_drag.isChecked() == True
-    assert action_rectangle.isChecked() == False
-    mock_view_box.setMouseMode.assert_called_once_with(pg.ViewBox.PanMode)
-
-
-def test_image_toolbar_auto_range_image(image_widget, mock_image):
-    action = image_widget.toolbar.widgets["auto_range_image"].action
-    action.trigger()
-    assert action.isChecked() == False
-    image_widget._image.set_autorange.assert_called_once_with(False)
-
-
-def test_image_toolbar_FFT(image_widget, mock_image):
-    action = image_widget.toolbar.widgets["FFT"].action
-    action.trigger()
-    assert action.isChecked() == True
-    image_widget._image.set_fft.assert_called_once_with(True, None)
-
-
-def test_image_toolbar_log(image_widget, mock_image):
-    action = image_widget.toolbar.widgets["log"].action
-    action.trigger()
-    assert action.isChecked() == True
-    image_widget._image.set_log.assert_called_once_with(True, None)
-
-
-def test_image_toggle_transpose(image_widget, mock_image):
-    action = image_widget.toolbar.widgets["transpose"].action
-    action.trigger()
-    assert action.isChecked() == True
-    image_widget._image.set_transpose.assert_called_once_with(True, None)
-
-
-def test_image_toolbar_rotation(image_widget, mock_image):
-    action_left = image_widget.toolbar.widgets["rotate_left"].action
-    action_right = image_widget.toolbar.widgets["rotate_right"].action
-
-    action_left.trigger()
-    image_widget._image.set_rotation(1, None)
-    action_right.trigger()
-    image_widget._image.set_rotation(2, None)
-
-    action_right.trigger()
-    image_widget._image.set_rotation(1, None)
-
-
-###################################
-# Wrapper methods for ImageShow
-###################################
-
-
-def test_image_set_image(image_widget, mock_image):
-    image_widget.image(monitor="image")
-    image_widget._image.image.assert_called_once_with(
-        monitor="image",
-        color_map="magma",
-        color_bar="full",
-        downsample=True,
-        opacity=1.0,
-        vrange=None,
-    )
-
-
-def test_image_vrange(image_widget, mock_image):
-    image_widget.set_vrange(0, 1)
-    image_widget._image.set_vrange.assert_called_once_with(0, 1, None)
-
-
-def test_image_set_color_map(image_widget, mock_image):
-    image_widget.set_color_map("viridis")
-    image_widget._image.set_color_map.assert_called_once_with("viridis", None)
-
-
-def test_image_widget_set_title(image_widget, mock_image):
-    image_widget.set_title("Title Label")
-    image_widget._image.set_title.assert_called_once_with("Title Label")
-
-
-def test_image_widget_set_x_label(image_widget, mock_image):
-    image_widget.set_x_label("X Label")
-    image_widget._image.set_x_label.assert_called_once_with("X Label")
-
-
-def test_image_widget_set_y_label(image_widget, mock_image):
-    image_widget.set_y_label("Y Label")
-    image_widget._image.set_y_label.assert_called_once_with("Y Label")
-
-
-def test_image_widget_set_x_scale(image_widget, mock_image):
-    image_widget.set_x_scale("linear")
-    image_widget._image.set_x_scale.assert_called_once_with("linear")
-
-
-def test_image_widget_set_y_scale(image_widget, mock_image):
-    image_widget.set_y_scale("log")
-    image_widget._image.set_y_scale.assert_called_once_with("log")
-
-
-def test_image_widget_set_x_lim(image_widget, mock_image):
-    image_widget.set_x_lim((0, 10))
-    image_widget._image.set_x_lim.assert_called_once_with((0, 10))
-
-
-def test_image_widget_set_y_lim(image_widget, mock_image):
-    image_widget.set_y_lim((0, 10))
-    image_widget._image.set_y_lim.assert_called_once_with((0, 10))
-
-
-def test_image_widget_set_grid(image_widget, mock_image):
-    image_widget.set_grid(True, False)
-    image_widget._image.set_grid.assert_called_once_with(True, False)
-
-
-def test_image_widget_lock_aspect_ratio(image_widget, mock_image):
-    image_widget.lock_aspect_ratio(True)
-    image_widget._image.lock_aspect_ratio.assert_called_once_with(True)
-
-
-def test_image_widget_export(image_widget, mock_image):
-    image_widget.export()
-    image_widget._image.export.assert_called_once()

tests/unit_tests/test_bec_motor_map.py

@@ -1,282 +0,0 @@
-import numpy as np
-import pytest
-from bec_lib.messages import DeviceMessage
-
-from bec_widgets.widgets.figure import BECFigure
-from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap, MotorMapConfig
-from bec_widgets.widgets.figure.plots.waveform.waveform_curve import SignalData
-
-from .client_mocks import mocked_client
-from .conftest import create_widget
-
-
-def test_motor_map_init(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    default_config = MotorMapConfig(widget_class="BECMotorMap")
-
-    mm = bec_figure.motor_map(config=default_config.model_dump())
-    default_config.gui_id = mm.gui_id
-
-    assert mm.config == default_config
-
-
-def test_motor_map_change_motors(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.motor_x == "samx"
-    assert mm.motor_y == "samy"
-    assert mm.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
-    assert mm.config.signals.y == SignalData(name="samy", entry="samy", limits=[-5, 5])
-
-    mm.change_motors("samx", "samz")
-
-    assert mm.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
-    assert mm.config.signals.y == SignalData(name="samz", entry="samz", limits=[-8, 8])
-
-
-def test_motor_map_get_limits(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    expected_limits = {"samx": [-10, 10], "samy": [-5, 5]}
-
-    for motor_name, expected_limit in expected_limits.items():
-        actual_limit = mm._get_motor_limit(motor_name)
-        assert actual_limit == expected_limit
-
-
-def test_motor_map_get_init_position(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    mm.set_precision(2)
-
-    motor_map_dev = mm.client.device_manager.devices
-
-    expected_positions = {
-        ("samx", "samx"): motor_map_dev["samx"].read()["samx"]["value"],
-        ("samy", "samy"): motor_map_dev["samy"].read()["samy"]["value"],
-    }
-
-    for (motor_name, entry), expected_position in expected_positions.items():
-        actual_position = mm._get_motor_init_position(motor_name, entry, 2)
-        assert actual_position == expected_position
-
-
-def test_motor_movement_updates_position_and_database(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    motor_map_dev = mm.client.device_manager.devices
-
-    init_positions = {
-        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
-        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
-    }
-
-    mm.change_motors("samx", "samy")
-
-    assert mm.database_buffer["x"] == init_positions["samx"]
-    assert mm.database_buffer["y"] == init_positions["samy"]
-
-    # Simulate motor movement for 'samx' only
-    new_position_samx = 4.0
-    msg = DeviceMessage(signals={"samx": {"value": new_position_samx}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-
-    init_positions["samx"].append(new_position_samx)
-    init_positions["samy"].append(init_positions["samy"][-1])
-    # Verify database update for 'samx'
-    assert mm.database_buffer["x"] == init_positions["samx"]
-
-    # Verify 'samy' retains its last known position
-    assert mm.database_buffer["y"] == init_positions["samy"]
-
-
-def test_scatter_plot_rendering(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    motor_map_dev = mm.client.device_manager.devices
-
-    init_positions = {
-        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
-        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
-    }
-
-    mm.change_motors("samx", "samy")
-
-    # Simulate motor movement for 'samx' only
-    new_position_samx = 4.0
-    msg = DeviceMessage(signals={"samx": {"value": new_position_samx}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    mm._update_plot()
-
-    # Get the scatter plot item
-    scatter_plot_item = mm.plot_components["scatter"]
-
-    # Check the scatter plot item properties
-    assert len(scatter_plot_item.data) > 0, "Scatter plot data is empty"
-    x_data = scatter_plot_item.data["x"]
-    y_data = scatter_plot_item.data["y"]
-    assert x_data[-1] == new_position_samx, "Scatter plot X data not updated correctly"
-    assert (
-        y_data[-1] == init_positions["samy"][-1]
-    ), "Scatter plot Y data should retain last known position"
-
-
-def test_plot_visualization_consistency(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    mm.change_motors("samx", "samy")
-    # Simulate updating the plot with new data
-    msg = DeviceMessage(signals={"samx": {"value": 5}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    msg = DeviceMessage(signals={"samy": {"value": 9}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    mm._update_plot()
-
-    scatter_plot_item = mm.plot_components["scatter"]
-
-    # Check if the scatter plot reflects the new data correctly
-    assert (
-        scatter_plot_item.data["x"][-1] == 5 and scatter_plot_item.data["y"][-1] == 9
-    ), "Plot not updated correctly with new data"
-
-
-def test_change_background_value(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.config.background_value == 25
-    assert np.all(mm.plot_components["limit_map"].image == 25.0)
-
-    mm.set_background_value(50)
-    qtbot.wait(200)
-
-    assert mm.config.background_value == 50
-    assert np.all(mm.plot_components["limit_map"].image == 50.0)
-
-
-def test_motor_map_init_from_config(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    config = {
-        "widget_class": "BECMotorMap",
-        "gui_id": "mm_id",
-        "parent_id": bec_figure.gui_id,
-        "row": 0,
-        "col": 0,
-        "axis": {
-            "title": "Motor position: (-0.0, 0.0)",
-            "title_size": None,
-            "x_label": "Motor X (samx)",
-            "x_label_size": None,
-            "y_label": "Motor Y (samy)",
-            "y_label_size": None,
-            "legend_label_size": None,
-            "x_scale": "linear",
-            "y_scale": "linear",
-            "x_lim": None,
-            "y_lim": None,
-            "x_grid": True,
-            "y_grid": True,
-        },
-        "signals": {
-            "source": "device_readback",
-            "x": {
-                "name": "samx",
-                "entry": "samx",
-                "unit": None,
-                "modifier": None,
-                "limits": [-10.0, 10.0],
-            },
-            "y": {
-                "name": "samy",
-                "entry": "samy",
-                "unit": None,
-                "modifier": None,
-                "limits": [-5.0, 5.0],
-            },
-            "z": None,
-            "dap": None,
-        },
-        "color": (255, 255, 255, 255),
-        "scatter_size": 5,
-        "max_points": 50,
-        "num_dim_points": 10,
-        "precision": 5,
-        "background_value": 50,
-    }
-    mm = bec_figure.motor_map(config=config)
-    config["gui_id"] = mm.gui_id
-
-    assert mm._config_dict == config
-
-
-def test_motor_map_set_scatter_size(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.config.scatter_size == 5
-    assert mm.plot_components["scatter"].opts["size"] == 5
-
-    mm.set_scatter_size(10)
-    qtbot.wait(200)
-
-    assert mm.config.scatter_size == 10
-    assert mm.plot_components["scatter"].opts["size"] == 10
-
-
-def test_motor_map_change_precision(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.config.precision == 2
-    mm.set_precision(10)
-    assert mm.config.precision == 10
-
-
-def test_motor_map_set_color(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.config.color == (255, 255, 255, 255)
-
-    mm.set_color((0, 0, 0, 255))
-    qtbot.wait(200)
-    assert mm.config.color == (0, 0, 0, 255)
-
-
-def test_motor_map_get_data_max_points(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    motor_map_dev = mm.client.device_manager.devices
-
-    init_positions = {
-        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
-        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
-    }
-    msg = DeviceMessage(signals={"samx": {"value": 5.0}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    msg = DeviceMessage(signals={"samy": {"value": 9.0}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    msg = DeviceMessage(signals={"samx": {"value": 6.0}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    msg = DeviceMessage(signals={"samy": {"value": 7.0}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-
-    expected_x = [init_positions["samx"][-1], 5.0, 5.0, 6.0, 6.0]
-    expected_y = [init_positions["samy"][-1], init_positions["samy"][-1], 9.0, 9.0, 7.0]
-    get_data = mm.get_data()
-
-    assert mm.database_buffer["x"] == expected_x
-    assert mm.database_buffer["y"] == expected_y
-    assert get_data["x"] == expected_x
-    assert get_data["y"] == expected_y
-
-    mm.set_max_points(3)
-    qtbot.wait(200)
-    get_data = mm.get_data()
-    assert len(get_data["x"]) == 3
-    assert len(get_data["y"]) == 3
-    assert get_data["x"] == expected_x[-3:]
-    assert get_data["y"] == expected_y[-3:]
-    assert mm.database_buffer["x"] == expected_x[-3:]
-    assert mm.database_buffer["y"] == expected_y[-3:]

tests/unit_tests/test_bec_queue.py

@@ -1,111 +0,0 @@
-import pytest
-from bec_lib import messages
-
-from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def bec_queue_msg_full():
-    content = {
-        "primary": {
-            "info": [
-                {
-                    "active_request_block": None,
-                    "is_scan": [True],
-                    "queue_id": "600163fc-5e56-4901-af25-14e9ee76817c",
-                    "request_blocks": [
-                        {
-                            "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
-                            "content": {
-                                "parameter": {
-                                    "args": {"samx": [-0.1, 0.1]},
-                                    "kwargs": {
-                                        "exp_time": 0.5,
-                                        "relative": True,
-                                        "steps": 20,
-                                        "system_config": {
-                                            "file_directory": None,
-                                            "file_suffix": None,
-                                        },
-                                    },
-                                },
-                                "queue": "primary",
-                                "scan_type": "line_scan",
-                            },
-                            "is_scan": True,
-                            "metadata": {
-                                "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
-                                "file_directory": None,
-                                "file_suffix": None,
-                                "user_metadata": {"sample_name": "testA"},
-                            },
-                            "msg": messages.ScanQueueMessage(
-                                metadata={
-                                    "file_suffix": None,
-                                    "file_directory": None,
-                                    "user_metadata": {"sample_name": "testA"},
-                                    "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
-                                },
-                                scan_type="line_scan",
-                                parameter={
-                                    "args": {"samx": [-0.1, 0.1]},
-                                    "kwargs": {
-                                        "steps": 20,
-                                        "exp_time": 0.5,
-                                        "relative": True,
-                                        "system_config": {
-                                            "file_suffix": None,
-                                            "file_directory": None,
-                                        },
-                                    },
-                                },
-                                queue="primary",
-                            ),
-                            "readout_priority": {
-                                "async": [],
-                                "baseline": [],
-                                "monitored": ["samx"],
-                                "on_request": [],
-                            },
-                            "report_instructions": [{"scan_progress": 20}],
-                            "scan_id": "2d704cc3-c172-404c-866d-608ce09fce40",
-                            "scan_motors": ["samx"],
-                            "scan_number": 1289,
-                        }
-                    ],
-                    "scan_id": ["2d704cc3-c172-404c-866d-608ce09fce40"],
-                    "scan_number": [1289],
-                    "status": "COMPLETED",
-                }
-            ],
-            "status": "RUNNING",
-        }
-    }
-    msg = messages.ScanQueueStatusMessage(metadata={}, queue=content)
-    return msg
-
-
-@pytest.fixture
-def bec_queue(qtbot, mocked_client):
-    widget = BECQueue(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_bec_queue(bec_queue, bec_queue_msg_full):
-    bec_queue.update_queue(bec_queue_msg_full.content, {})
-    assert bec_queue.table.rowCount() == 1
-    assert bec_queue.table.item(0, 0).text() == "1289"
-    assert bec_queue.table.item(0, 1).text() == "line_scan"
-    assert bec_queue.table.item(0, 2).text() == "COMPLETED"
-
-
-def test_bec_queue_empty(bec_queue):
-    bec_queue.update_queue({}, {})
-    assert bec_queue.table.rowCount() == 1
-    assert bec_queue.table.item(0, 0).text() == ""
-    assert bec_queue.table.item(0, 1).text() == ""
-    assert bec_queue.table.item(0, 2).text() == ""