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

tests/unit_tests/test_device_browser.py

@@ -1,83 +0,0 @@
-from typing import TYPE_CHECKING
-from unittest import mock
-
-import pytest
-from qtpy.QtCore import Qt
-
-from bec_widgets.widgets.device_browser.device_browser import DeviceBrowser
-
-from .client_mocks import mocked_client
-
-if TYPE_CHECKING:
-    from qtpy.QtWidgets import QListWidgetItem
-
-    from bec_widgets.widgets.device_browser.device_item.device_item import DeviceItem
-
-
-@pytest.fixture
-def device_browser(qtbot, mocked_client):
-    dev_browser = DeviceBrowser(client=mocked_client)
-    qtbot.addWidget(dev_browser)
-    qtbot.waitExposed(dev_browser)
-    yield dev_browser
-
-
-def test_device_browser_init_with_devices(device_browser):
-    """
-    Test that the device browser is initialized with the correct number of devices.
-    """
-    device_list = device_browser.ui.device_list
-    assert device_list.count() == len(device_browser.dev)
-
-
-def test_device_browser_filtering(qtbot, device_browser):
-    """
-    Test that the device browser is able to filter the device list.
-    """
-    device_list = device_browser.ui.device_list
-    device_browser.ui.filter_input.setText("sam")
-    qtbot.wait(1000)
-    assert device_list.count() == 3
-
-    device_browser.ui.filter_input.setText("nonexistent")
-    qtbot.wait(1000)
-    assert device_list.count() == 0
-
-    device_browser.ui.filter_input.setText("")
-    qtbot.wait(1000)
-    assert device_list.count() == len(device_browser.dev)
-
-
-def test_device_item_mouse_press_event(device_browser, qtbot):
-    """
-    Test that the mousePressEvent is triggered correctly.
-    """
-    # Simulate a left mouse press event on the device item
-    device_item: QListWidgetItem = device_browser.ui.device_list.itemAt(0, 0)
-    widget: DeviceItem = device_browser.ui.device_list.itemWidget(device_item)
-    qtbot.mousePress(widget.label, Qt.MouseButton.LeftButton)
-
-
-def test_device_item_mouse_press_event_creates_drag(device_browser, qtbot):
-    """
-    Test that the mousePressEvent is triggered correctly and initiates a drag.
-    """
-    device_item: QListWidgetItem = device_browser.ui.device_list.itemAt(0, 0)
-    widget: DeviceItem = device_browser.ui.device_list.itemWidget(device_item)
-    device_name = widget.device
-    with mock.patch("qtpy.QtGui.QDrag.exec_") as mock_exec:
-        with mock.patch("qtpy.QtGui.QDrag.setMimeData") as mock_set_mimedata:
-            qtbot.mousePress(widget.label, Qt.MouseButton.LeftButton)
-            mock_set_mimedata.assert_called_once()
-            mock_exec.assert_called_once()
-            assert mock_set_mimedata.call_args[0][0].text() == device_name
-
-
-def test_device_item_double_click_event(device_browser, qtbot):
-    """
-    Test that the mouseDoubleClickEvent is triggered correctly.
-    """
-    # Simulate a left mouse press event on the device item
-    device_item: QListWidgetItem = device_browser.ui.device_list.itemAt(0, 0)
-    widget: DeviceItem = device_browser.ui.device_list.itemWidget(device_item)
-    qtbot.mouseDClick(widget, Qt.LeftButton)

tests/unit_tests/test_device_input_base.py

@@ -1,76 +0,0 @@
-import pytest
-from qtpy.QtWidgets import QWidget
-
-from bec_widgets.widgets.base_classes.device_input_base import DeviceInputBase
-
-from .client_mocks import mocked_client
-
-
-# DeviceInputBase is meant to be mixed in a QWidget
-class DeviceInputWidget(DeviceInputBase, QWidget):
-    def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QWidget.__init__(self, parent=parent)
-
-
-@pytest.fixture
-def device_input_base(qtbot, mocked_client):
-    widget = DeviceInputWidget(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_device_input_base_init(device_input_base):
-    assert device_input_base is not None
-    assert device_input_base.client is not None
-    assert isinstance(device_input_base, DeviceInputBase)
-    assert device_input_base.config.widget_class == "DeviceInputWidget"
-    assert device_input_base.config.device_filter is None
-    assert device_input_base.config.default is None
-    assert device_input_base.devices == []
-
-
-def test_device_input_base_init_with_config(mocked_client):
-    config = {
-        "widget_class": "DeviceInputWidget",
-        "gui_id": "test_gui_id",
-        "device_filter": "FakePositioner",
-        "default": "samx",
-    }
-    widget = DeviceInputWidget(client=mocked_client, config=config)
-    assert widget.config.gui_id == "test_gui_id"
-    assert widget.config.device_filter == "FakePositioner"
-    assert widget.config.default == "samx"
-
-
-def test_device_input_base_set_device_filter(device_input_base):
-    device_input_base.set_device_filter("FakePositioner")
-    assert device_input_base.config.device_filter == "FakePositioner"
-
-
-def test_device_input_base_set_device_filter_error(device_input_base):
-    with pytest.raises(ValueError) as excinfo:
-        device_input_base.set_device_filter("NonExistingClass")
-        assert "Device filter NonExistingClass is not in the device list." in str(excinfo.value)
-
-
-def test_device_input_base_set_default_device(device_input_base):
-    device_input_base.set_default_device("samx")
-    assert device_input_base.config.default == "samx"
-
-
-def test_device_input_base_set_default_device_error(device_input_base):
-    with pytest.raises(ValueError) as excinfo:
-        device_input_base.set_default_device("NonExistingDevice")
-        assert "Default device NonExistingDevice is not in the device list." in str(excinfo.value)
-
-
-def test_device_input_base_get_device_list(device_input_base):
-    devices = device_input_base.get_device_list("FakePositioner")
-    assert devices == ["samx", "samy", "samz", "aptrx", "aptry"]
-
-
-def test_device_input_base_get_filters(device_input_base):
-    filters = device_input_base.get_available_filters()
-    assert filters == {"FakePositioner", "FakeDevice", "Positioner", "Device"}

tests/unit_tests/test_device_input_widgets.py

@@ -1,178 +0,0 @@
-import pytest
-
-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
-
-
-@pytest.fixture
-def device_input_combobox(qtbot, mocked_client):
-    widget = DeviceComboBox(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-@pytest.fixture
-def device_input_combobox_with_config(qtbot, mocked_client):
-    config = {
-        "widget_class": "DeviceComboBox",
-        "gui_id": "test_gui_id",
-        "device_filter": "FakePositioner",
-        "default": "samx",
-        "arg_name": "test_arg_name",
-    }
-    widget = DeviceComboBox(client=mocked_client, config=config)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-@pytest.fixture
-def device_input_combobox_with_kwargs(qtbot, mocked_client):
-    widget = DeviceComboBox(
-        client=mocked_client,
-        gui_id="test_gui_id",
-        device_filter="FakePositioner",
-        default="samx",
-        arg_name="test_arg_name",
-    )
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_device_input_combobox_init(device_input_combobox):
-    assert device_input_combobox is not None
-    assert device_input_combobox.client is not None
-    assert isinstance(device_input_combobox, DeviceComboBox)
-    assert device_input_combobox.config.widget_class == "DeviceComboBox"
-    assert device_input_combobox.config.device_filter is None
-    assert device_input_combobox.config.default is None
-    assert device_input_combobox.devices == [
-        "samx",
-        "samy",
-        "samz",
-        "aptrx",
-        "aptry",
-        "gauss_bpm",
-        "gauss_adc1",
-        "gauss_adc2",
-        "gauss_adc3",
-        "bpm4i",
-        "bpm3a",
-        "bpm3i",
-        "eiger",
-        "async_device",
-        "test",
-        "test_device",
-    ]
-
-
-def test_device_input_combobox_init_with_config(device_input_combobox_with_config):
-    assert device_input_combobox_with_config.config.gui_id == "test_gui_id"
-    assert device_input_combobox_with_config.config.device_filter == "FakePositioner"
-    assert device_input_combobox_with_config.config.default == "samx"
-    assert device_input_combobox_with_config.config.arg_name == "test_arg_name"
-
-
-def test_device_input_combobox_init_with_kwargs(device_input_combobox_with_kwargs):
-    assert device_input_combobox_with_kwargs.config.gui_id == "test_gui_id"
-    assert device_input_combobox_with_kwargs.config.device_filter == "FakePositioner"
-    assert device_input_combobox_with_kwargs.config.default == "samx"
-    assert device_input_combobox_with_kwargs.config.arg_name == "test_arg_name"
-
-
-def test_get_device_from_input_combobox_init(device_input_combobox):
-    device_input_combobox.setCurrentIndex(0)
-    device_text = device_input_combobox.currentText()
-    current_device = device_input_combobox.get_device()
-
-    assert current_device.name == device_text
-
-
-@pytest.fixture
-def device_input_line_edit(qtbot, mocked_client):
-    widget = DeviceLineEdit(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-@pytest.fixture
-def device_input_line_edit_with_config(qtbot, mocked_client):
-    config = {
-        "widget_class": "DeviceLineEdit",
-        "gui_id": "test_gui_id",
-        "device_filter": "FakePositioner",
-        "default": "samx",
-        "arg_name": "test_arg_name",
-    }
-    widget = DeviceLineEdit(client=mocked_client, config=config)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-@pytest.fixture
-def device_input_line_edit_with_kwargs(qtbot, mocked_client):
-    widget = DeviceLineEdit(
-        client=mocked_client,
-        gui_id="test_gui_id",
-        device_filter="FakePositioner",
-        default="samx",
-        arg_name="test_arg_name",
-    )
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_device_input_line_edit_init(device_input_line_edit):
-    assert device_input_line_edit is not None
-    assert device_input_line_edit.client is not None
-    assert isinstance(device_input_line_edit, DeviceLineEdit)
-    assert device_input_line_edit.config.widget_class == "DeviceLineEdit"
-    assert device_input_line_edit.config.device_filter is None
-    assert device_input_line_edit.config.default is None
-    assert device_input_line_edit.devices == [
-        "samx",
-        "samy",
-        "samz",
-        "aptrx",
-        "aptry",
-        "gauss_bpm",
-        "gauss_adc1",
-        "gauss_adc2",
-        "gauss_adc3",
-        "bpm4i",
-        "bpm3a",
-        "bpm3i",
-        "eiger",
-        "async_device",
-        "test",
-        "test_device",
-    ]
-
-
-def test_device_input_line_edit_init_with_config(device_input_line_edit_with_config):
-    assert device_input_line_edit_with_config.config.gui_id == "test_gui_id"
-    assert device_input_line_edit_with_config.config.device_filter == "FakePositioner"
-    assert device_input_line_edit_with_config.config.default == "samx"
-    assert device_input_line_edit_with_config.config.arg_name == "test_arg_name"
-
-
-def test_device_input_line_edit_init_with_kwargs(device_input_line_edit_with_kwargs):
-    assert device_input_line_edit_with_kwargs.config.gui_id == "test_gui_id"
-    assert device_input_line_edit_with_kwargs.config.device_filter == "FakePositioner"
-    assert device_input_line_edit_with_kwargs.config.default == "samx"
-    assert device_input_line_edit_with_kwargs.config.arg_name == "test_arg_name"
-
-
-def test_get_device_from_input_line_edit_init(device_input_line_edit):
-    device_input_line_edit.setText("samx")
-    device_text = device_input_line_edit.text()
-    current_device = device_input_line_edit.get_device()
-
-    assert current_device.name == device_text

tests/unit_tests/test_error_utils.py

@@ -1,63 +0,0 @@
-from unittest.mock import patch
-
-import pytest
-import pytestqt
-from qtpy.QtWidgets import QMessageBox
-
-from bec_widgets.qt_utils.error_popups import ErrorPopupUtility, ExampleWidget
-
-
-@pytest.fixture
-def widget(qtbot):
-    test_widget = ExampleWidget()
-    qtbot.addWidget(test_widget)
-    qtbot.waitExposed(test_widget)
-    yield test_widget
-    test_widget.close()
-
-
-@patch.object(QMessageBox, "exec_", return_value=QMessageBox.Ok)
-def test_show_error_message_global(mock_exec, widget, qtbot):
-    error_utility = ErrorPopupUtility()
-    error_utility.enable_global_error_popups(True)
-
-    with qtbot.waitSignal(error_utility.error_occurred, timeout=1000) as blocker:
-        error_utility.error_occurred.emit("Test Error", "This is a test error message.", widget)
-
-    assert mock_exec.called
-    assert blocker.signal_triggered
-
-
-@pytest.mark.parametrize("global_pop", [False, True])
-@patch.object(QMessageBox, "exec_", return_value=QMessageBox.Ok)
-def test_slot_with_popup_on_error(mock_exec, widget, qtbot, global_pop):
-    error_utility = ErrorPopupUtility()
-    error_utility.enable_global_error_popups(global_pop)
-
-    with qtbot.waitSignal(error_utility.error_occurred, timeout=200) as blocker:
-        widget.method_with_error_handling()
-
-    assert blocker.signal_triggered
-    assert mock_exec.called
-
-
-@pytest.mark.parametrize("global_pop", [False, True])
-@patch.object(QMessageBox, "exec_", return_value=QMessageBox.Ok)
-def test_slot_no_popup_by_default_on_error(mock_exec, widget, qtbot, capsys, global_pop):
-    error_utility = ErrorPopupUtility()
-    error_utility.enable_global_error_popups(global_pop)
-
-    try:
-        with qtbot.waitSignal(error_utility.error_occurred, timeout=200) as blocker:
-            widget.method_without_error_handling()
-    except pytestqt.exceptions.TimeoutError:
-        assert not global_pop
-
-    if global_pop:
-        assert blocker.signal_triggered
-        assert mock_exec.called
-    else:
-        assert not blocker.signal_triggered
-        assert not mock_exec.called
-        stdout, stderr = capsys.readouterr()
-        assert "ValueError" in stderr

tests/unit_tests/test_generate_cli_client.py

@@ -1,123 +0,0 @@
-from textwrap import dedent
-
-import black
-import isort
-
-from bec_widgets.cli.generate_cli import ClientGenerator
-from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
-
-# pylint: disable=missing-function-docstring
-
-
-# Mock classes to test the generator
-class MockBECWaveform1D:
-    USER_ACCESS = ["set_frequency", "set_amplitude"]
-
-    def set_frequency(self, frequency: float) -> list:
-        """Set the frequency of the waveform."""
-        return [frequency]
-
-    def set_amplitude(self, amplitude: float) -> tuple[float, float]:
-        """Set the amplitude of the waveform."""
-        return amplitude, amplitude
-
-
-class MockBECFigure:
-    USER_ACCESS = ["add_plot", "remove_plot"]
-
-    def add_plot(self, plot_id: str):
-        """Add a plot to the figure."""
-
-    def remove_plot(self, plot_id: str):
-        """Remove a plot from the figure."""
-
-
-def test_client_generator_with_black_formatting():
-    generator = ClientGenerator()
-    container = BECClassContainer()
-    container.add_class(
-        BECClassInfo(
-            name="MockBECWaveform1D",
-            module="test_module",
-            file="test_file",
-            obj=MockBECWaveform1D,
-            is_connector=True,
-            is_widget=True,
-            is_top_level=False,
-        )
-    )
-    container.add_class(
-        BECClassInfo(
-            name="MockBECFigure",
-            module="test_module",
-            file="test_file",
-            obj=MockBECFigure,
-            is_connector=True,
-            is_widget=True,
-            is_top_level=True,
-        )
-    )
-
-    generator.generate_client(container)
-
-    # Format the expected output with black to ensure it matches the generator output
-    expected_output = dedent(
-        '''\
-        # This file was automatically generated by generate_cli.py
-
-        import enum
-        from typing import Literal, Optional, overload
-
-        from bec_widgets.cli.client_utils import BECGuiClientMixin, RPCBase, rpc_call
-
-        # pylint: skip-file
-
-
-        class Widgets(str, enum.Enum):
-            """
-            Enum for the available widgets.
-            """
-
-            MockBECFigure = "MockBECFigure"
-
-
-        class MockBECFigure(RPCBase):
-            @rpc_call
-            def add_plot(self, plot_id: str):
-                """
-                Add a plot to the figure.
-                """
-
-            @rpc_call
-            def remove_plot(self, plot_id: str):
-                """
-                Remove a plot from the figure.
-                """
-
-
-        class MockBECWaveform1D(RPCBase):
-            @rpc_call
-            def set_frequency(self, frequency: float) -> list:
-                """
-                Set the frequency of the waveform.
-                """
-
-            @rpc_call
-            def set_amplitude(self, amplitude: float) -> tuple[float, float]:
-                """
-                Set the amplitude of the waveform.
-                """
-    '''
-    )
-
-    expected_output_formatted = black.format_str(
-        expected_output, mode=black.FileMode(line_length=100)
-    ).lstrip()
-
-    generated_output_formatted = black.format_str(
-        generator.header + "\n" + generator.content, mode=black.FileMode(line_length=100)
-    )
-
-    generated_output_formatted = isort.code(generated_output_formatted)
-
-    assert expected_output_formatted == generated_output_formatted

tests/unit_tests/test_generate_plugin.py

@@ -1,155 +0,0 @@
-import importlib
-import inspect
-import os
-import sys
-
-import pytest
-
-from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator
-
-
-def load_plugin(dir_path, content, plugin_name="MyWidget"):
-    plugin_path = dir_path.mkdir("plugin").join("plugin.py")
-    plugin_path.write(content)
-    sys.path.append(str(dir_path))
-    plugin = importlib.import_module("plugin.plugin")
-    importlib.reload(plugin)
-    yield getattr(plugin, plugin_name)
-    sys.path.pop()
-
-
-@pytest.fixture(
-    params=[
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, parent=None):
-        QWidget.__init__(self, parent)
-""",
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, parent=None):
-        QWidget.__init__(self, parent=parent)
-""",
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-""",
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, parent=None):
-        super().__init__(parent=parent)
-""",
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, parent=None):
-        super(QWidget, self).__init__(parent)"""
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, parent=None):
-        super(QWidget, self).__init__(parent=parent)
-""",
-    ]
-)
-def plugin_with_correct_parent(tmpdir, request):
-    yield from load_plugin(tmpdir, request.param)
-
-
-@pytest.fixture(
-    params=[
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, parent=None):
-        QWidget.__init__(self)
-""",
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, parent=None):
-        super().__init__()
-""",
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, parent=None):
-        super(QWidget, self).__init__()
-        """,
-    ]
-)
-def plugin_with_missing_parent(tmpdir, request):
-    yield from load_plugin(tmpdir, request.param)
-
-
-def test_generate_plugin(plugin_with_correct_parent):
-    generator = DesignerPluginGenerator(plugin_with_correct_parent)
-    generator.run()
-    assert os.path.exists(f"{generator.info.base_path}/register_my_widget.py")
-    assert os.path.exists(f"{generator.info.base_path}/my_widget_plugin.py")
-    assert os.path.exists(f"{generator.info.base_path}/my_widget.pyproject")
-
-
-def test_generate_plugin_with_missing_parent(plugin_with_missing_parent):
-    with pytest.raises(ValueError) as excinfo:
-        generator = DesignerPluginGenerator(plugin_with_missing_parent)
-        generator.run()
-    assert "Widget class MyWidget must call the super constructor with parent." in str(
-        excinfo.value
-    )
-
-
-@pytest.fixture()
-def plugin_with_excluded_widget(tmpdir):
-    content = """
-from qtpy.QtWidgets import QWidget
-class BECDock(QWidget):
-    def __init__(self, parent=None):
-        QWidget.__init__(self, parent)
-"""
-    yield from load_plugin(tmpdir, content, plugin_name="BECDock")
-
-
-def test_generate_plugin_with_excluded_widget(plugin_with_excluded_widget, capsys):
-    generator = DesignerPluginGenerator(plugin_with_excluded_widget)
-    generator.run()
-    captured = capsys.readouterr()
-
-    assert "Plugin BECDock is excluded from generation." in captured.out
-    assert not os.path.exists(f"{generator.info.base_path}/register_bec_dock.py")
-    assert not os.path.exists(f"{generator.info.base_path}/bec_dock_plugin.py")
-    assert not os.path.exists(f"{generator.info.base_path}/bec_dock.pyproject")
-
-
-@pytest.fixture(
-    params=[
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self):
-        QWidget.__init__(self)
-""",
-        """
-from qtpy.QtWidgets import QWidget
-class MyWidget(QWidget):
-    def __init__(self, config, parent=None):
-        super().__init__()
-""",
-    ]
-)
-def plugin_with_no_parent_as_first_arg(tmpdir, request):
-    yield from load_plugin(tmpdir, request.param)
-
-
-def test_generate_plugin_raises_exception_when_first_argument_is_not_parent(
-    plugin_with_no_parent_as_first_arg,
-):
-    with pytest.raises(ValueError) as excinfo:
-        generator = DesignerPluginGenerator(plugin_with_no_parent_as_first_arg)
-        generator.run()
-    assert "Widget class MyWidget must have parent as the first argument." in str(excinfo.value)