bec-widgets 0.81.0__py3-none-any.whl → 0.82.1__py3-none-any.whl

tests/unit_tests/test_device_input_widgets.py

@@ -1,7 +1,7 @@
 import pytest
 
-from bec_widgets.widgets.device_inputs.device_combobox.device_combobox import DeviceComboBox
-from bec_widgets.widgets.device_inputs.device_line_edit.device_line_edit import DeviceLineEdit
+from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
+from bec_widgets.widgets.device_line_edit.device_line_edit import DeviceLineEdit
 
 from .client_mocks import mocked_client
 
@@ -67,6 +67,7 @@ def test_device_input_combobox_init(device_input_combobox):
         "bpm3a",
         "bpm3i",
         "eiger",
+        "test",
     ]
 
 
@@ -153,6 +154,7 @@ def test_device_input_line_edit_init(device_input_line_edit):
         "bpm3a",
         "bpm3i",
         "eiger",
+        "test",
     ]
 
 

tests/unit_tests/test_motor_map_widget.py

@@ -0,0 +1,196 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_settings import MotorMapSettings
+from bec_widgets.widgets.motor_map.motor_map_widget import BECMotorMapWidget
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def motor_map_widget(qtbot, mocked_client):
+    widget = BECMotorMapWidget(client=mocked_client())
+    widget.toolbar.widgets["motor_x"].device_combobox.set_device_filter("FakePositioner")
+    widget.toolbar.widgets["motor_y"].device_combobox.set_device_filter("FakePositioner")
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+@pytest.fixture
+def mock_motor_map(motor_map_widget):
+    motor_map_mock = MagicMock()
+    motor_map_widget.map = motor_map_mock
+    return motor_map_mock
+
+
+def test_motor_map_widget_init(motor_map_widget):
+    assert motor_map_widget is not None
+    assert motor_map_widget.client is not None
+    assert isinstance(motor_map_widget, BECMotorMapWidget)
+    assert motor_map_widget.config.widget_class == "BECMotorMapWidget"
+
+    # check initial state of toolbar actions
+    assert motor_map_widget.toolbar.widgets["connect"].action.isEnabled() == True
+    assert motor_map_widget.toolbar.widgets["config"].action.isEnabled() == False
+    assert motor_map_widget.toolbar.widgets["history"].action.isEnabled() == False
+    assert (
+        motor_map_widget.toolbar.widgets["motor_x"].device_combobox.config.device_filter
+        == "FakePositioner"
+    )
+    assert (
+        motor_map_widget.toolbar.widgets["motor_y"].device_combobox.config.device_filter
+        == "FakePositioner"
+    )
+    assert motor_map_widget.map.motor_x is None
+    assert motor_map_widget.map.motor_y is None
+
+
+###################################
+# Toolbar Actions
+###################################
+
+
+def test_motor_map_widget_change_motors_enable_toolbar(motor_map_widget):
+    motor_map_widget.change_motors("samx", "samy")
+    assert motor_map_widget.map.motor_x == "samx"
+    assert motor_map_widget.map.motor_y == "samy"
+    assert motor_map_widget.toolbar.widgets["motor_x"].device_combobox.currentText() == "samx"
+    assert motor_map_widget.toolbar.widgets["motor_y"].device_combobox.currentText() == "samy"
+    assert motor_map_widget.toolbar.widgets["config"].action.isEnabled() == True
+    assert motor_map_widget.toolbar.widgets["history"].action.isEnabled() == True
+
+
+###################################
+# Wrapper methods for MotorMap
+###################################
+
+
+def test_change_motors(motor_map_widget, mock_motor_map):
+    motor_map_widget.change_motors("motor_x", "motor_y", "motor_x_entry", "motor_y_entry", True)
+    mock_motor_map.change_motors.assert_called_once_with(
+        "motor_x", "motor_y", "motor_x_entry", "motor_y_entry", True
+    )
+
+
+def test_get_data(motor_map_widget, mock_motor_map):
+    motor_map_widget.get_data()
+    mock_motor_map.get_data.assert_called_once()
+
+
+def test_reset_history(motor_map_widget, mock_motor_map):
+    motor_map_widget.reset_history()
+    mock_motor_map.reset_history.assert_called_once()
+
+
+def test_set_color(motor_map_widget, mock_motor_map):
+    motor_map_widget.set_color("blue")
+    mock_motor_map.set_color.assert_called_once_with("blue")
+
+
+def test_set_max_points(motor_map_widget, mock_motor_map):
+    motor_map_widget.set_max_points(100)
+    mock_motor_map.set_max_points.assert_called_once_with(100)
+
+
+def test_set_precision(motor_map_widget, mock_motor_map):
+    motor_map_widget.set_precision(2)
+    mock_motor_map.set_precision.assert_called_once_with(2)
+
+
+def test_set_num_dim_points(motor_map_widget, mock_motor_map):
+    motor_map_widget.set_num_dim_points(50)
+    mock_motor_map.set_num_dim_points.assert_called_once_with(50)
+
+
+def test_set_background_value(motor_map_widget, mock_motor_map):
+    motor_map_widget.set_background_value(128)
+    mock_motor_map.set_background_value.assert_called_once_with(128)
+
+
+def test_set_scatter_size(motor_map_widget, mock_motor_map):
+    motor_map_widget.set_scatter_size(10)
+    mock_motor_map.set_scatter_size.assert_called_once_with(10)
+
+
+###################################
+# MotorMap Dialog
+###################################
+
+
+def test_motor_map_widget_clicked(motor_map_widget, qtbot):
+    motor_map_widget.toolbar.widgets["motor_x"].device_combobox.setCurrentText("samx")
+    motor_map_widget.toolbar.widgets["motor_y"].device_combobox.setCurrentText("samy")
+    motor_map_widget.toolbar.widgets["connect"].action.trigger()
+
+    qtbot.wait(200)
+
+    assert motor_map_widget.map.motor_x == "samx"
+    assert motor_map_widget.map.motor_y == "samy"
+    assert motor_map_widget.toolbar.widgets["config"].action.isEnabled() == True
+    assert motor_map_widget.toolbar.widgets["history"].action.isEnabled() == True
+
+
+@pytest.fixture
+def motor_map_settings(qtbot):
+    widget = MotorMapSettings()
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+def test_display_current_settings(motor_map_settings):
+    config = {
+        "max_points": 100,
+        "num_dim_points": 50,
+        "precision": 2,
+        "scatter_size": 10,
+        "background_value": 128,
+        "color": (255, 0, 0, 255),
+    }
+
+    with patch("bec_widgets.utils.widget_io.WidgetIO.set_value") as mock_set_value:
+        with patch.object(motor_map_settings.ui.color, "setColor") as mock_set_color:
+            motor_map_settings.display_current_settings(config)
+            mock_set_value.assert_any_call(motor_map_settings.ui.max_points, config["max_points"])
+            mock_set_value.assert_any_call(
+                motor_map_settings.ui.trace_dim, config["num_dim_points"]
+            )
+            mock_set_value.assert_any_call(motor_map_settings.ui.precision, config["precision"])
+            mock_set_value.assert_any_call(
+                motor_map_settings.ui.scatter_size, config["scatter_size"]
+            )
+            mock_set_value.assert_any_call(
+                motor_map_settings.ui.background_value, 50
+            )  # 128/255*100 = 50
+            mock_set_color.assert_called_once_with(config["color"])
+
+
+def test_accept_changes(motor_map_settings):
+    with patch(
+        "bec_widgets.utils.widget_io.WidgetIO.get_value", side_effect=[100, 50, 2, 10, 50]
+    ) as mock_get_value:
+        with patch.object(
+            motor_map_settings.ui.color, "get_color", return_value=(255, 0, 0, 255)
+        ) as mock_get_color:
+            mock_target_widget = MagicMock()
+            motor_map_settings.set_target_widget(mock_target_widget)
+
+            motor_map_settings.accept_changes()
+
+            mock_get_value.assert_any_call(motor_map_settings.ui.max_points)
+            mock_get_value.assert_any_call(motor_map_settings.ui.trace_dim)
+            mock_get_value.assert_any_call(motor_map_settings.ui.precision)
+            mock_get_value.assert_any_call(motor_map_settings.ui.scatter_size)
+            mock_get_value.assert_any_call(motor_map_settings.ui.background_value)
+            mock_get_color.assert_called_once()
+
+            mock_target_widget.set_max_points.assert_called_once_with(100)
+            mock_target_widget.set_num_dim_points.assert_called_once_with(50)
+            mock_target_widget.set_precision.assert_called_once_with(2)
+            mock_target_widget.set_scatter_size.assert_called_once_with(10)
+            mock_target_widget.set_background_value.assert_called_once_with(127)
+            mock_target_widget.set_color.assert_called_once_with((255, 0, 0, 255))

tests/unit_tests/test_setting_dialog.py

@@ -0,0 +1,97 @@
+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
+    widget.close()
+
+
+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):
+    parent_widget = QWidget()
+    settings_widget = SettingWidget()
+    settings_widget.set_target_widget = MagicMock()
+    settings_widget.display_current_settings = MagicMock()
+    settings_widget.accept_changes = MagicMock()
+
+    dialog = SettingsDialog(
+        parent=parent_widget,
+        settings_widget=settings_widget,
+        window_title="Test Settings",
+        config={"setting1": "value1", "setting2": "value2"},
+    )
+    qtbot.addWidget(dialog)
+    qtbot.waitExposed(dialog)
+    yield dialog, parent_widget, settings_widget
+    dialog.close()
+
+
+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_stop_button.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from bec_widgets.widgets.buttons import StopButton
+from bec_widgets.widgets.stop_button.stop_button import StopButton
 
 from .client_mocks import mocked_client
 
@@ -18,7 +18,10 @@ def stop_button(qtbot, mocked_client):
 
 def test_stop_button(stop_button):
     assert stop_button.text() == "Stop"
-    assert stop_button.styleSheet() == "background-color:  #cc181e; color: white"
+    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

tests/unit_tests/test_toggle.py

@@ -0,0 +1,38 @@
+import pytest
+from qtpy.QtCore import QPointF, Qt
+
+from bec_widgets.widgets.toggle.toggle import ToggleSwitch
+
+
+@pytest.fixture
+def toggle(qtbot):
+    widget = ToggleSwitch()
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_toggle(toggle):
+    toggle.checked = False
+    assert toggle.checked is False
+
+    assert toggle.thumb_pos == QPointF(3, 2)
+
+    toggle.checked = True
+    assert toggle.checked is True
+
+    assert toggle.thumb_pos == QPointF(22, 2)
+
+
+def test_toggle_click(qtbot, toggle):
+    init_state = toggle.checked
+
+    qtbot.mouseClick(toggle, Qt.LeftButton)
+    toggle.paintEvent(None)
+    assert toggle.checked is not init_state
+
+    init_state = toggle.checked
+
+    qtbot.mouseClick(toggle, Qt.LeftButton)
+    toggle.paintEvent(None)
+    assert toggle.checked is not init_state

bec_widgets/examples/motor_movement/__init__.py

@@ -1,9 +0,0 @@
-from .motor_control_compilations import (
-    MotorControlApp,
-    MotorControlMap,
-    MotorControlPanel,
-    MotorControlPanelAbsolute,
-    MotorControlPanelRelative,
-    MotorCoordinateTable,
-    MotorThread,
-)

bec_widgets/examples/motor_movement/motor_control_compilations.py

@@ -1,250 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-
-import qdarktheme
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import QApplication, QSplitter, QVBoxLayout, QWidget
-
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-from bec_widgets.widgets.motor_control.motor_control import MotorThread
-from bec_widgets.widgets.motor_control.motor_table.motor_table import MotorCoordinateTable
-from bec_widgets.widgets.motor_control.movement_absolute.movement_absolute import (
-    MotorControlAbsolute,
-)
-from bec_widgets.widgets.motor_control.movement_relative.movement_relative import (
-    MotorControlRelative,
-)
-from bec_widgets.widgets.motor_control.selection.selection import MotorControlSelection
-
-CONFIG_DEFAULT = {
-    "motor_control": {
-        "motor_x": "samx",
-        "motor_y": "samy",
-        "step_size_x": 3,
-        "step_size_y": 3,
-        "precision": 4,
-        "step_x_y_same": False,
-        "move_with_arrows": False,
-    },
-    "plot_settings": {
-        "colormap": "Greys",
-        "scatter_size": 5,
-        "max_points": 1000,
-        "num_dim_points": 100,
-        "precision": 2,
-        "num_columns": 1,
-        "background_value": 25,
-    },
-    "motors": [
-        {
-            "plot_name": "Motor Map",
-            "x_label": "Motor X",
-            "y_label": "Motor Y",
-            "signals": {
-                "x": [{"name": "samx", "entry": "samx"}],
-                "y": [{"name": "samy", "entry": "samy"}],
-            },
-        }
-    ],
-}
-
-
-class MotorControlApp(QWidget):
-    def __init__(self, parent=None, client=None, config=None):
-        super().__init__(parent)
-
-        bec_dispatcher = BECDispatcher()
-        self.client = bec_dispatcher.client if client is None else client
-        self.config = config
-
-        # Widgets
-        self.motor_control_panel = MotorControlPanel(client=self.client, config=self.config)
-        # Create MotorMap
-        # self.motion_map = MotorMap(client=self.client, config=self.config)
-        # Create MotorCoordinateTable
-        self.motor_table = MotorCoordinateTable(client=self.client, config=self.config)
-
-        # Create the splitter and add MotorMap and MotorControlPanel
-        splitter = QSplitter(Qt.Horizontal)
-        # splitter.addWidget(self.motion_map)
-        splitter.addWidget(self.motor_control_panel)
-        splitter.addWidget(self.motor_table)
-
-        # Set the main layout
-        layout = QVBoxLayout(self)
-        layout.addWidget(splitter)
-        self.setLayout(layout)
-
-        # Connecting signals and slots
-        # self.motor_control_panel.selection_widget.selected_motors_signal.connect(
-        #     lambda x, y: self.motion_map.change_motors(x, y, 0)
-        # )
-        self.motor_control_panel.absolute_widget.coordinates_signal.connect(
-            self.motor_table.add_coordinate
-        )
-        self.motor_control_panel.relative_widget.precision_signal.connect(
-            self.motor_table.set_precision
-        )
-        self.motor_control_panel.relative_widget.precision_signal.connect(
-            self.motor_control_panel.absolute_widget.set_precision
-        )
-
-        # self.motor_table.plot_coordinates_signal.connect(self.motion_map.plot_saved_coordinates)
-
-
-class MotorControlMap(QWidget):
-    def __init__(self, parent=None, client=None, config=None):
-        super().__init__(parent)
-
-        bec_dispatcher = BECDispatcher()
-        self.client = bec_dispatcher.client if client is None else client
-        self.config = config
-
-        # Widgets
-        self.motor_control_panel = MotorControlPanel(client=self.client, config=self.config)
-        # Create MotorMap
-        # self.motion_map = MotorMap(client=self.client, config=self.config)
-
-        # Create the splitter and add MotorMap and MotorControlPanel
-        splitter = QSplitter(Qt.Horizontal)
-        # splitter.addWidget(self.motion_map)
-        splitter.addWidget(self.motor_control_panel)
-
-        # Set the main layout
-        layout = QVBoxLayout(self)
-        layout.addWidget(splitter)
-        self.setLayout(layout)
-
-        # Connecting signals and slots
-        # self.motor_control_panel.selection_widget.selected_motors_signal.connect(
-        #     lambda x, y: self.motion_map.change_motors(x, y, 0)
-        # )
-
-
-class MotorControlPanel(QWidget):
-    def __init__(self, parent=None, client=None, config=None):
-        super().__init__(parent)
-
-        bec_dispatcher = BECDispatcher()
-        self.client = bec_dispatcher.client if client is None else client
-        self.config = config
-
-        self.motor_thread = MotorThread(client=self.client)
-
-        self.selection_widget = MotorControlSelection(
-            client=self.client, config=self.config, motor_thread=self.motor_thread
-        )
-        self.relative_widget = MotorControlRelative(
-            client=self.client, config=self.config, motor_thread=self.motor_thread
-        )
-        self.absolute_widget = MotorControlAbsolute(
-            client=self.client, config=self.config, motor_thread=self.motor_thread
-        )
-
-        layout = QVBoxLayout(self)
-
-        layout.addWidget(self.selection_widget)
-        layout.addWidget(self.relative_widget)
-        layout.addWidget(self.absolute_widget)
-
-        # Connecting signals and slots
-        self.selection_widget.selected_motors_signal.connect(self.relative_widget.change_motors)
-        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)
-
-        # Set the window to a fixed size based on its contents
-        # self.layout().setSizeConstraint(layout.SetFixedSize)
-
-
-class MotorControlPanelAbsolute(QWidget):
-    def __init__(self, parent=None, client=None, config=None):
-        super().__init__(parent)
-
-        bec_dispatcher = BECDispatcher()
-        self.client = bec_dispatcher.client if client is None else client
-        self.config = config
-
-        self.motor_thread = MotorThread(client=self.client)
-
-        self.selection_widget = MotorControlSelection(
-            client=client, config=config, motor_thread=self.motor_thread
-        )
-        self.absolute_widget = MotorControlAbsolute(
-            client=client, config=config, motor_thread=self.motor_thread
-        )
-
-        layout = QVBoxLayout(self)
-        layout.addWidget(self.selection_widget)
-        layout.addWidget(self.absolute_widget)
-
-        # Connecting signals and slots
-        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)
-
-
-class MotorControlPanelRelative(QWidget):
-    def __init__(self, parent=None, client=None, config=None):
-        super().__init__(parent)
-
-        bec_dispatcher = BECDispatcher()
-        self.client = bec_dispatcher.client if client is None else client
-        self.config = config
-
-        self.motor_thread = MotorThread(client=self.client)
-
-        self.selection_widget = MotorControlSelection(
-            client=client, config=config, motor_thread=self.motor_thread
-        )
-        self.relative_widget = MotorControlRelative(
-            client=client, config=config, motor_thread=self.motor_thread
-        )
-
-        layout = QVBoxLayout(self)
-        layout.addWidget(self.selection_widget)
-        layout.addWidget(self.relative_widget)
-
-        # Connecting signals and slots
-        self.selection_widget.selected_motors_signal.connect(self.relative_widget.change_motors)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import argparse
-    import sys
-
-    parser = argparse.ArgumentParser(description="Run various Motor Control Widgets compositions.")
-    parser.add_argument(
-        "-v",
-        "--variant",
-        type=str,
-        choices=["app", "map", "panel", "panel_abs", "panel_rel"],
-        help="Select the variant of the motor control to run. "
-        "'app' for the full application, "
-        "'map' for MotorMap, "
-        "'panel' for the MotorControlPanel, "
-        "'panel_abs' for MotorControlPanel with absolute control, "
-        "'panel_rel' for MotorControlPanel with relative control.",
-    )
-
-    args = parser.parse_args()
-
-    bec_dispatcher = BECDispatcher()
-    client = bec_dispatcher.client
-    client.start()
-
-    app = QApplication([])
-    qdarktheme.setup_theme("auto")
-
-    if args.variant == "app":
-        window = MotorControlApp(client=client)  # , config=CONFIG_DEFAULT)
-    elif args.variant == "map":
-        window = MotorControlMap(client=client)  # , config=CONFIG_DEFAULT)
-    elif args.variant == "panel":
-        window = MotorControlPanel(client=client)  # , config=CONFIG_DEFAULT)
-    elif args.variant == "panel_abs":
-        window = MotorControlPanelAbsolute(client=client)  # , config=CONFIG_DEFAULT)
-    elif args.variant == "panel_rel":
-        window = MotorControlPanelRelative(client=client)  # , config=CONFIG_DEFAULT)
-    else:
-        print("Please specify a valid variant to run. Use -h for help.")
-        print("Running the full application by default.")
-        window = MotorControlApp(client=client)  # , config=CONFIG_DEFAULT)
-
-    window.show()
-    sys.exit(app.exec())