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

tests/unit_tests/test_scan_control.py

@@ -1,324 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-from unittest.mock import MagicMock
-
-import pytest
-from bec_lib.messages import AvailableResourceMessage
-
-from bec_widgets.utils.widget_io import WidgetIO
-from bec_widgets.widgets.scan_control import ScanControl
-
-from .client_mocks import mocked_client
-
-available_scans_message = AvailableResourceMessage(
-    resource={
-        "line_scan": {
-            "class": "LineScan",
-            "base_class": "ScanBase",
-            "arg_input": {"device": "device", "start": "float", "stop": "float"},
-            "gui_config": {
-                "scan_class_name": "LineScan",
-                "arg_group": {
-                    "name": "Scan Arguments",
-                    "bundle": 3,
-                    "arg_inputs": {"device": "device", "start": "float", "stop": "float"},
-                    "inputs": [
-                        {
-                            "arg": True,
-                            "name": "device",
-                            "type": "device",
-                            "display_name": "Device",
-                            "tooltip": None,
-                            "default": None,
-                            "expert": False,
-                        },
-                        {
-                            "arg": True,
-                            "name": "start",
-                            "type": "float",
-                            "display_name": "Start",
-                            "tooltip": None,
-                            "default": None,
-                            "expert": False,
-                        },
-                        {
-                            "arg": True,
-                            "name": "stop",
-                            "type": "float",
-                            "display_name": "Stop",
-                            "tooltip": None,
-                            "default": None,
-                            "expert": False,
-                        },
-                    ],
-                    "min": 1,
-                    "max": None,
-                },
-                "kwarg_groups": [
-                    {
-                        "name": "Movement Parameters",
-                        "inputs": [
-                            {
-                                "arg": False,
-                                "name": "steps",
-                                "type": "int",
-                                "display_name": "Steps",
-                                "tooltip": "Number of steps",
-                                "default": None,
-                                "expert": False,
-                            },
-                            {
-                                "arg": False,
-                                "name": "relative",
-                                "type": "bool",
-                                "display_name": "Relative",
-                                "tooltip": "If True, the start and end positions are relative to the current position",
-                                "default": False,
-                                "expert": False,
-                            },
-                        ],
-                    },
-                    {
-                        "name": "Acquisition Parameters",
-                        "inputs": [
-                            {
-                                "arg": False,
-                                "name": "exp_time",
-                                "type": "float",
-                                "display_name": "Exp Time",
-                                "tooltip": "Exposure time in s",
-                                "default": 0,
-                                "expert": False,
-                            },
-                            {
-                                "arg": False,
-                                "name": "burst_at_each_point",
-                                "type": "int",
-                                "display_name": "Burst At Each Point",
-                                "tooltip": "Number of acquisition per point",
-                                "default": 1,
-                                "expert": False,
-                            },
-                        ],
-                    },
-                ],
-            },
-            "required_kwargs": ["steps", "relative"],
-            "arg_bundle_size": {"bundle": 3, "min": 1, "max": None},
-        },
-        "grid_scan": {
-            "class": "Scan",
-            "base_class": "ScanBase",
-            "arg_input": {"device": "device", "start": "float", "stop": "float", "steps": "int"},
-            "gui_config": {
-                "scan_class_name": "Scan",
-                "arg_group": {
-                    "name": "Scan Arguments",
-                    "bundle": 4,
-                    "arg_inputs": {
-                        "device": "device",
-                        "start": "float",
-                        "stop": "float",
-                        "steps": "int",
-                    },
-                    "inputs": [
-                        {
-                            "arg": True,
-                            "name": "device",
-                            "type": "device",
-                            "display_name": "Device",
-                            "tooltip": None,
-                            "default": None,
-                            "expert": False,
-                        },
-                        {
-                            "arg": True,
-                            "name": "start",
-                            "type": "float",
-                            "display_name": "Start",
-                            "tooltip": None,
-                            "default": None,
-                            "expert": False,
-                        },
-                        {
-                            "arg": True,
-                            "name": "stop",
-                            "type": "float",
-                            "display_name": "Stop",
-                            "tooltip": None,
-                            "default": None,
-                            "expert": False,
-                        },
-                        {
-                            "arg": True,
-                            "name": "steps",
-                            "type": "int",
-                            "display_name": "Steps",
-                            "tooltip": None,
-                            "default": None,
-                            "expert": False,
-                        },
-                    ],
-                    "min": 2,
-                    "max": None,
-                },
-                "kwarg_groups": [
-                    {
-                        "name": "Scan Parameters",
-                        "inputs": [
-                            {
-                                "arg": False,
-                                "name": "exp_time",
-                                "type": "float",
-                                "display_name": "Exp Time",
-                                "tooltip": "Exposure time in seconds",
-                                "default": 0,
-                                "expert": False,
-                            },
-                            {
-                                "arg": False,
-                                "name": "settling_time",
-                                "type": "float",
-                                "display_name": "Settling Time",
-                                "tooltip": "Settling time in seconds",
-                                "default": 0,
-                                "expert": False,
-                            },
-                            {
-                                "arg": False,
-                                "name": "burst_at_each_point",
-                                "type": "int",
-                                "display_name": "Burst At Each Point",
-                                "tooltip": "Number of exposures at each point",
-                                "default": 1,
-                                "expert": False,
-                            },
-                            {
-                                "arg": False,
-                                "name": "relative",
-                                "type": "bool",
-                                "display_name": "Relative",
-                                "tooltip": "If True, the motors will be moved relative to their current position",
-                                "default": False,
-                                "expert": False,
-                            },
-                        ],
-                    }
-                ],
-            },
-            "required_kwargs": ["relative"],
-            "arg_bundle_size": {"bundle": 4, "min": 2, "max": None},
-        },
-        "not_supported_scan_class": {"base_class": "NotSupportedScanClass"},
-    }
-)
-
-
-@pytest.fixture(scope="function")
-def scan_control(qtbot, mocked_client):  # , mock_dev):
-    mocked_client.connector.set("scans/available_scans", available_scans_message)
-    widget = ScanControl(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_populate_scans(scan_control, mocked_client):
-    expected_scans = ["line_scan", "grid_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() == 2
-    assert sorted(items) == sorted(expected_scans)
-
-
-@pytest.mark.parametrize("scan_name", ["line_scan", "grid_scan"])
-def test_on_scan_selected(scan_control, scan_name):
-    expected_scan_info = available_scans_message.resource[scan_name]
-    scan_control.comboBox_scan_selection.setCurrentText(scan_name)
-
-    # Check arg_box labels and widgets
-    for index, (arg_key, arg_value) in enumerate(expected_scan_info["arg_input"].items()):
-        label = scan_control.arg_box.layout.itemAtPosition(0, index).widget()
-        assert label.text().lower() == arg_key
-
-        for row in range(1, expected_scan_info["arg_bundle_size"]["min"] + 1):
-            widget = scan_control.arg_box.layout.itemAtPosition(row, index).widget()
-            assert widget is not None  # Confirm that a widget exists
-            expected_widget_type = scan_control.arg_box.WIDGET_HANDLER.get(arg_value, None)
-            assert isinstance(widget, expected_widget_type)  # Confirm the widget type matches
-
-    # Check kwargs boxes
-    kwargs_group = [param for param in expected_scan_info["gui_config"]["kwarg_groups"]]
-    print(kwargs_group)
-
-    for kwarg_box, kwarg_group in zip(scan_control.kwarg_boxes, kwargs_group):
-        assert kwarg_box.title() == kwarg_group["name"]
-        for index, kwarg_info in enumerate(kwarg_group["inputs"]):
-            label = kwarg_box.layout.itemAtPosition(0, index).widget()
-            assert label.text() == kwarg_info["display_name"]
-            widget = kwarg_box.layout.itemAtPosition(1, index).widget()
-            expected_widget_type = kwarg_box.WIDGET_HANDLER.get(kwarg_info["type"], None)
-            assert isinstance(widget, expected_widget_type)
-
-
-@pytest.mark.parametrize("scan_name", ["line_scan", "grid_scan"])
-def test_add_remove_bundle(scan_control, scan_name, qtbot):
-    expected_scan_info = available_scans_message.resource[scan_name]
-    scan_control.comboBox_scan_selection.setCurrentText(scan_name)
-
-    # Initial number of args row
-    initial_num_of_rows = scan_control.arg_box.count_arg_rows()
-
-    assert initial_num_of_rows == expected_scan_info["arg_bundle_size"]["min"]
-
-    scan_control.button_add_bundle.click()
-    scan_control.button_add_bundle.click()
-
-    if expected_scan_info["arg_bundle_size"]["max"] is None:
-        assert scan_control.arg_box.count_arg_rows() == initial_num_of_rows + 2
-
-    # Remove one bundle
-    scan_control.button_remove_bundle.click()
-    qtbot.wait(200)
-
-    assert scan_control.arg_box.count_arg_rows() == initial_num_of_rows + 1
-
-
-def test_run_line_scan_with_parameters(scan_control, mocked_client):
-    scan_name = "line_scan"
-    kwargs = {"exp_time": 0.1, "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
-
-    # Mock the scan function
-    mocked_scan_function = MagicMock()
-    setattr(mocked_client.scans, scan_name, mocked_scan_function)
-
-    # Run the scan
-    scan_control.button_run_scan.click()
-
-    # Retrieve the actual arguments passed to the mock
-    called_args, called_kwargs = mocked_scan_function.call_args
-
-    # Check if the scan function was called correctly
-    expected_device = mocked_client.device_manager.devices.samx
-    expected_args_list = [expected_device, args["start"], args["stop"]]
-    assert called_args == tuple(expected_args_list)
-    assert called_kwargs == kwargs

tests/unit_tests/test_scan_control_group_box.py

@@ -1,160 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-import pytest
-
-from bec_widgets.utils.widget_io import WidgetIO
-from bec_widgets.widgets.scan_control.scan_group_box import ScanGroupBox
-
-
-def test_kwarg_box(qtbot):
-    group_input = {
-        "name": "Kwarg Test",
-        "inputs": [
-            # Test float
-            {
-                "arg": False,
-                "name": "exp_time",
-                "type": "float",
-                "display_name": "Exp Time",
-                "tooltip": "Exposure time in seconds",
-                "default": 0,
-                "expert": False,
-            },
-            # Test int
-            {
-                "arg": False,
-                "name": "num_points",
-                "type": "int",
-                "display_name": "Num Points",
-                "tooltip": "Number of points",
-                "default": 1,
-                "expert": False,
-            },
-            # Test bool
-            {
-                "arg": False,
-                "name": "relative",
-                "type": "bool",
-                "display_name": "Relative",
-                "tooltip": "If True, the motors will be moved relative to their current position",
-                "default": False,
-                "expert": False,
-            },
-            # Test str
-            {
-                "arg": False,
-                "name": "scan_type",
-                "type": "str",
-                "display_name": "Scan Type",
-                "tooltip": "Type of scan",
-                "default": "line",
-                "expert": False,
-            },
-        ],
-    }
-
-    kwarg_box = ScanGroupBox(box_type="kwargs", config=group_input)
-    assert kwarg_box is not None
-    assert kwarg_box.box_type == "kwargs"
-    assert kwarg_box.config == group_input
-    assert kwarg_box.title() == "Kwarg Test"
-
-    # Labels
-    assert kwarg_box.layout.itemAtPosition(0, 0).widget().text() == "Exp Time"
-    assert kwarg_box.layout.itemAtPosition(0, 1).widget().text() == "Num Points"
-    assert kwarg_box.layout.itemAtPosition(0, 2).widget().text() == "Relative"
-    assert kwarg_box.layout.itemAtPosition(0, 3).widget().text() == "Scan Type"
-
-    # Widget 0
-    assert kwarg_box.widgets[0].__class__.__name__ == "ScanDoubleSpinBox"
-    assert kwarg_box.widgets[0].arg_name == "exp_time"
-    assert WidgetIO.get_value(kwarg_box.widgets[0]) == 0
-    assert kwarg_box.widgets[0].toolTip() == "Exposure time in seconds"
-
-    # Widget 1
-    assert kwarg_box.widgets[1].__class__.__name__ == "ScanSpinBox"
-    assert kwarg_box.widgets[1].arg_name == "num_points"
-    assert WidgetIO.get_value(kwarg_box.widgets[1]) == 1
-    assert kwarg_box.widgets[1].toolTip() == "Number of points"
-
-    # Widget 2
-    assert kwarg_box.widgets[2].__class__.__name__ == "ScanCheckBox"
-    assert kwarg_box.widgets[2].arg_name == "relative"
-    assert WidgetIO.get_value(kwarg_box.widgets[2]) == False
-    assert (
-        kwarg_box.widgets[2].toolTip()
-        == "If True, the motors will be moved relative to their current position"
-    )
-
-    # Widget 3
-    assert kwarg_box.widgets[3].__class__.__name__ == "ScanLineEdit"
-    assert kwarg_box.widgets[3].arg_name == "scan_type"
-    assert WidgetIO.get_value(kwarg_box.widgets[3]) == "line"
-    assert kwarg_box.widgets[3].toolTip() == "Type of scan"
-
-    parameters = kwarg_box.get_parameters()
-    assert parameters == {"exp_time": 0, "num_points": 1, "relative": False, "scan_type": "line"}
-
-
-def test_arg_box(qtbot):
-    group_input = {
-        "name": "Arg Test",
-        "inputs": [
-            # Test device
-            {
-                "arg": True,
-                "name": "device",
-                "type": "str",
-                "display_name": "Device",
-                "tooltip": "Device to scan",
-                "default": "samx",
-                "expert": False,
-            },
-            # Test float
-            {
-                "arg": True,
-                "name": "start",
-                "type": "float",
-                "display_name": "Start",
-                "tooltip": "Start position",
-                "default": 0,
-                "expert": False,
-            },
-            # Test int
-            {
-                "arg": True,
-                "name": "stop",
-                "type": "int",
-                "display_name": "Stop",
-                "tooltip": "Stop position",
-                "default": 1,
-                "expert": False,
-            },
-        ],
-    }
-
-    arg_box = ScanGroupBox(box_type="args", config=group_input)
-    assert arg_box is not None
-    assert arg_box.box_type == "args"
-    assert arg_box.config == group_input
-    assert arg_box.title() == "Arg Test"
-
-    # Labels
-    assert arg_box.layout.itemAtPosition(0, 0).widget().text() == "Device"
-    assert arg_box.layout.itemAtPosition(0, 1).widget().text() == "Start"
-    assert arg_box.layout.itemAtPosition(0, 2).widget().text() == "Stop"
-
-    # Widget 0
-    assert arg_box.widgets[0].__class__.__name__ == "ScanLineEdit"
-    assert arg_box.widgets[0].arg_name == "device"
-    assert WidgetIO.get_value(arg_box.widgets[0]) == "samx"
-    assert arg_box.widgets[0].toolTip() == "Device to scan"
-
-    # Widget 1
-    assert arg_box.widgets[1].__class__.__name__ == "ScanDoubleSpinBox"
-    assert arg_box.widgets[1].arg_name == "start"
-    assert WidgetIO.get_value(arg_box.widgets[1]) == 0
-    assert arg_box.widgets[1].toolTip() == "Start position"
-
-    # Widget 2
-    assert arg_box.widgets[2].__class__.__name__ == "ScanSpinBox"
-    assert arg_box.widgets[2].arg_name

tests/unit_tests/test_setting_dialog.py

@@ -1,96 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-from qtpy.QtWidgets import QWidget
-
-from bec_widgets.qt_utils.settings_dialog import SettingsDialog, SettingWidget
-
-###################################
-# SettingWidget base class tests
-###################################
-
-
-@pytest.fixture
-def setting_widget(qtbot):
-    widget = SettingWidget()
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_setting_widget_initialization(setting_widget):
-    assert setting_widget.target_widget is None
-
-
-def test_setting_widget_set_target_widget(setting_widget):
-    mock_target = MagicMock(spec=QWidget)
-    setting_widget.set_target_widget(mock_target)
-    assert setting_widget.target_widget == mock_target
-
-
-def test_setting_widget_accept_changes(setting_widget):
-    with patch.object(setting_widget, "accept_changes") as mock_accept_changes:
-        setting_widget.accept_changes()
-        mock_accept_changes.assert_called_once()
-
-
-def test_setting_widget_display_current_settings(setting_widget):
-    config_dict = {"setting1": "value1", "setting2": "value2"}
-    with patch.object(setting_widget, "display_current_settings") as mock_display_current_settings:
-        setting_widget.display_current_settings(config_dict)
-        mock_display_current_settings.assert_called_once_with(config_dict)
-
-
-###################################
-# SettingsDialog tests
-###################################
-@pytest.fixture
-def settings_dialog(qtbot, setting_widget):
-    parent_widget = QWidget()
-    setting_widget.set_target_widget = MagicMock()
-    setting_widget.display_current_settings = MagicMock()
-    setting_widget.accept_changes = MagicMock()
-
-    dialog = SettingsDialog(
-        parent=parent_widget,
-        settings_widget=setting_widget,
-        window_title="Test Settings",
-        config={"setting1": "value1", "setting2": "value2"},
-    )
-    qtbot.addWidget(dialog)
-    qtbot.waitExposed(dialog)
-    yield dialog, parent_widget, setting_widget
-    parent_widget.close()
-    parent_widget.deleteLater()
-
-
-def test_settings_dialog_initialization(settings_dialog):
-    dialog, parent_widget, settings_widget = settings_dialog
-
-    assert dialog.windowTitle() == "Test Settings"
-    settings_widget.set_target_widget.assert_called_once_with(parent_widget)
-    settings_widget.display_current_settings.assert_called_once_with(
-        {"setting1": "value1", "setting2": "value2"}
-    )
-
-
-def test_settings_dialog_accept(settings_dialog, qtbot):
-    dialog, _, settings_widget = settings_dialog
-
-    dialog.button_box.buttons()[0].click()  # OK Button
-    settings_widget.accept_changes.assert_called_once()
-
-
-def test_settings_dialog_reject(settings_dialog, qtbot):
-    dialog, _, _ = settings_dialog
-
-    with patch.object(dialog, "reject", wraps=dialog.reject) as mock_reject:
-        dialog.button_box.buttons()[1].click()  # Cancel Button
-        mock_reject.assert_called_once()
-
-
-def test_settings_dialog_apply_changes(settings_dialog, qtbot):
-    dialog, _, settings_widget = settings_dialog
-
-    dialog.apply_button.click()
-    settings_widget.accept_changes.assert_called_once()

tests/unit_tests/test_spinner.py

@@ -1,31 +0,0 @@
-import pytest
-
-from bec_widgets.utils.colors import apply_theme
-from bec_widgets.utils.reference_utils import snap_and_compare
-from bec_widgets.widgets.spinner.spinner import SpinnerWidget
-
-
-@pytest.fixture
-def spinner_widget(qtbot):
-    apply_theme("light")
-    spinner = SpinnerWidget()
-    qtbot.addWidget(spinner)
-    qtbot.waitExposed(spinner)
-    yield spinner
-    spinner.close()
-
-
-def test_spinner_widget_paint_event(spinner_widget, qtbot):
-    spinner_widget.paintEvent(None)
-
-
-def test_spinner_widget_rendered(spinner_widget, qtbot, tmpdir):
-    spinner_widget.update()
-    qtbot.wait(200)
-    snap_and_compare(spinner_widget, str(tmpdir), suffix="")
-
-    spinner_widget._started = True
-    spinner_widget.update()
-    qtbot.wait(200)
-
-    snap_and_compare(spinner_widget, str(tmpdir), suffix="started")

tests/unit_tests/test_stop_button.py

@@ -1,27 +0,0 @@
-# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
-
-import pytest
-
-from bec_widgets.widgets.stop_button.stop_button import StopButton
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def stop_button(qtbot, mocked_client):
-    widget = StopButton(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_stop_button(stop_button):
-    assert stop_button.text() == "Stop"
-    assert (
-        stop_button.styleSheet()
-        == "background-color:  #cc181e; color: white; font-weight: bold; font-size: 12px;"
-    )
-    stop_button.click()
-    assert stop_button.queue.request_scan_abortion.called
-    assert stop_button.queue.request_queue_reset.called
-    stop_button.close()