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

tests/unit_tests/test_color_validation.py

@@ -1,75 +0,0 @@
-import pytest
-from pydantic import ValidationError
-
-from bec_widgets.utils import Colors
-from bec_widgets.widgets.figure.plots.waveform.waveform_curve import CurveConfig
-
-
-def test_color_validation_CSS():
-    # Test valid color
-    color = Colors.validate_color("teal")
-    assert color == "teal"
-
-    # Test invalid color
-    with pytest.raises(ValidationError) as excinfo:
-        CurveConfig(color="invalid_color")
-
-    errors = excinfo.value.errors()
-    assert len(errors) == 1
-    assert errors[0]["type"] == ("unsupported color")
-    assert "The color must be a valid HEX string or CSS Color." in str(excinfo.value)
-
-
-def test_color_validation_hex():
-    # Test valid color
-    color = Colors.validate_color("#ff0000")
-    assert color == "#ff0000"
-
-    # Test invalid color
-    with pytest.raises(ValidationError) as excinfo:
-        CurveConfig(color="#ff00000")
-
-    errors = excinfo.value.errors()
-    assert len(errors) == 1
-    assert errors[0]["type"] == ("unsupported color")
-    assert "The color must be a valid HEX string or CSS Color." in str(excinfo.value)
-
-
-def test_color_validation_RGBA():
-    # Test valid color
-    color = Colors.validate_color((255, 0, 0, 255))
-    assert color == (255, 0, 0, 255)
-
-    # Test invalid color
-    with pytest.raises(ValidationError) as excinfo:
-        CurveConfig(color=(255, 0, 0))
-
-    errors = excinfo.value.errors()
-    assert len(errors) == 1
-    assert errors[0]["type"] == ("unsupported color")
-    assert "The color must be a tuple of 4 elements (R, G, B, A)." in str(excinfo.value)
-
-    with pytest.raises(ValidationError) as excinfo:
-        CurveConfig(color=(255, 0, 0, 355))
-
-    errors = excinfo.value.errors()
-    assert len(errors) == 1
-    assert errors[0]["type"] == ("unsupported color")
-    assert "The color values must be between 0 and 255 in RGBA format (R,G,B,A)" in str(
-        excinfo.value
-    )
-
-
-def test_hex_to_rgba():
-    assert Colors.hex_to_rgba("#FF5733") == (255, 87, 51, 255)
-    assert Colors.hex_to_rgba("#FF573380") == (255, 87, 51, 128)
-    assert Colors.hex_to_rgba("#FF5733", 128) == (255, 87, 51, 128)
-
-    with pytest.raises(ValueError):
-        Colors.hex_to_rgba("#FF573")
-
-
-def test_rgba_to_hex():
-    assert Colors.rgba_to_hex(255, 87, 51, 255) == "#FF5733FF"
-    assert Colors.rgba_to_hex(255, 87, 51, 128) == "#FF573380"
-    assert Colors.rgba_to_hex(255, 87, 51) == "#FF5733FF"

tests/unit_tests/test_configs/config_device.yaml

@@ -1,33 +0,0 @@
-plot_settings:
-  background_color: "black"
-  num_columns: 1
-  colormap: "magma"
-  scan_types: false
-plot_data:
-- plot_name: "BPM4i plots vs samx"
-  x_label: "Motor X"
-  y_label: "bpm4i"
-  sources:
-    - type: "scan_segment"
-      signals:
-        x:
-          - name : "samx"
-            entry: "samx"
-        y:
-          - name : "bpm4i"
-            entry: "bpm4i"
-
-- plot_name: "Gauss plots vs samx"
-  x_label: "Motor X"
-  y_label: "Gauss"
-  sources:
-    - type: "scan_segment"
-      signals:
-        x:
-          - name: "samx"
-            entry: "samx"
-        y:
-          - name: "gauss_adc1"
-            entry: "gauss_adc1"
-          - name: "gauss_adc2"
-            entry: "gauss_adc2"

tests/unit_tests/test_configs/config_device_no_entry.yaml

@@ -1,27 +0,0 @@
-plot_settings:
-  background_color: "black"
-  num_columns: 1
-  colormap: "magma"
-  scan_types: false
-plot_data:
-- plot_name: "BPM4i plots vs samx"
-  x_label: "Motor X"
-  y_label: "bpm4i"
-  sources:
-    - type: "scan_segment"
-      signals:
-        x:
-          - name : "samx"
-        y:
-          - name : "bpm4i"
-
-- plot_name: "Gauss plots vs samx"
-  x_label: "Motor X"
-  y_label: "Gauss"
-  sources:
-    - type: "scan_segment"
-      signals:
-        x:
-          - name: "samx"
-        y:
-          - name: "gauss_bpm"

tests/unit_tests/test_configs/config_scan.yaml

@@ -1,82 +0,0 @@
-plot_settings:
-  background_color: "white"
-  num_columns: 3
-  colormap: "magma"
-  scan_types: true
-plot_data:
-  grid_scan:
-  - plot_name: "Grid plot 1"
-    x_label: "Motor X"
-    y_label: "BPM"
-    sources:
-      - type: "scan_segment"
-        signals:
-          x:
-            - name: "samx"
-              entry: "samx"
-          y:
-            - name: "gauss_bpm"
-              entry: "gauss_bpm"
-  - plot_name: "Grid plot 2"
-    x_label: "Motor X"
-    y_label: "BPM"
-    sources:
-      - type: "scan_segment"
-        signals:
-          x:
-            - name: "samx"
-              entry: "samx"
-          y:
-            - name: "gauss_adc1"
-              entry: "gauss_adc1"
-  - plot_name: "Grid plot 3"
-    x_label: "Motor X"
-    y_label: "BPM"
-    sources:
-      - type: "scan_segment"
-        signals:
-          x:
-            - name: "samx"
-              entry: "samx"
-          y:
-            - name: "gauss_adc2"
-              entry: "gauss_adc2"
-  - plot_name: "Grid plot 4"
-    x_label: "Motor X"
-    y_label: "BPM"
-    sources:
-      - type: "scan_segment"
-        signals:
-          x:
-            - name: "samx"
-              entry: "samx"
-          y:
-            - name: "bpm4i"
-              entry: "bpm4i"
-  line_scan:
-    - plot_name: "Multiple Gauss Plot"
-      x_label: "Motor X"
-      y_label: "BPM"
-      sources:
-        - type: "scan_segment"
-          signals:
-            x:
-              - name: "samx"
-            y:
-              - name: "gauss_bpm"
-                entry: "gauss_bpm"
-              - name: "gauss_adc1"
-                entry: "gauss_adc1"
-              - name: "gauss_adc2"
-                entry: "gauss_adc2"
-    - plot_name: "BPM Plot"
-      x_label: "Motor X"
-      y_label: "BPM"
-      sources:
-        - type: "scan_segment"
-          signals:
-            x:
-              - name: "samx"
-            y:
-              - name: "bpm4i"
-                entry: "bpm4i"

tests/unit_tests/test_crosshair.py

@@ -1,143 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-import numpy as np
-import pytest
-from qtpy.QtCore import QPointF
-
-from bec_widgets.widgets.image.image_widget import BECImageWidget
-from bec_widgets.widgets.waveform.waveform_widget import BECWaveformWidget
-
-from .client_mocks import mocked_client
-
-# pylint: disable = redefined-outer-name
-
-
-@pytest.fixture
-def plot_widget_with_crosshair(qtbot, mocked_client):
-    widget = BECWaveformWidget(client=mocked_client())
-    widget.plot(x=[1, 2, 3], y=[4, 5, 6])
-    widget.waveform.hook_crosshair()
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-
-    yield widget.waveform.crosshair, widget.waveform.plot_item
-
-
-@pytest.fixture
-def image_widget_with_crosshair(qtbot, mocked_client):
-    widget = BECImageWidget(client=mocked_client())
-    widget._image.add_custom_image(name="test", data=np.random.random((100, 200)))
-    widget._image.hook_crosshair()
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-
-    yield widget._image.crosshair, widget._image.plot_item
-
-
-def test_mouse_moved_lines(plot_widget_with_crosshair):
-    crosshair, plot_item = plot_widget_with_crosshair
-
-    # Connect the signals to slots that will store the emitted values
-    emitted_values_1D = []
-    crosshair.coordinatesChanged1D.connect(emitted_values_1D.append)
-
-    # Simulate a mouse moved event at a specific position
-    pos_in_view = QPointF(2, 5)
-    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
-    event_mock = [pos_in_scene]
-
-    # Call the mouse_moved method
-    crosshair.mouse_moved(event_mock)
-
-    # Assert the expected behavior
-    assert np.isclose(crosshair.v_line.pos().x(), 2)
-    assert np.isclose(crosshair.h_line.pos().y(), 5)
-
-
-def test_mouse_moved_signals(plot_widget_with_crosshair):
-    crosshair, plot_item = plot_widget_with_crosshair
-
-    # Create a slot that will store the emitted values as tuples
-    emitted_values_1D = []
-
-    def slot(coordinates):
-        emitted_values_1D.append(coordinates)
-
-    # Connect the signal to the custom slot
-    crosshair.coordinatesChanged1D.connect(slot)
-
-    # Simulate a mouse moved event at a specific position
-    pos_in_view = QPointF(2, 5)
-    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
-    event_mock = [pos_in_scene]
-
-    # Call the mouse_moved method
-    crosshair.mouse_moved(event_mock)
-
-    # Assert the expected behavior
-    assert emitted_values_1D == [("Curve 1", 2, 5)]
-
-
-def test_mouse_moved_signals_outside(plot_widget_with_crosshair):
-    crosshair, plot_item = plot_widget_with_crosshair
-
-    # Create a slot that will store the emitted values as tuples
-    emitted_values_1D = []
-
-    def slot(x, y_values):
-        emitted_values_1D.append((x, y_values))
-
-    # Connect the signal to the custom slot
-    crosshair.coordinatesChanged1D.connect(slot)
-
-    # Simulate a mouse moved event at a specific position
-    pos_in_view = QPointF(22, 55)
-    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
-    event_mock = [pos_in_scene]
-
-    # Call the mouse_moved method
-    crosshair.mouse_moved(event_mock)
-
-    # Assert the expected behavior
-    assert emitted_values_1D == []
-
-
-def test_mouse_moved_signals_2D(image_widget_with_crosshair):
-    crosshair, plot_item = image_widget_with_crosshair
-
-    # Create a slot that will store the emitted values as tuples
-    emitted_values_2D = []
-
-    def slot(coordinates):
-        emitted_values_2D.append(coordinates)
-
-    # Connect the signal to the custom slot
-    crosshair.coordinatesChanged2D.connect(slot)
-    # Simulate a mouse moved event at a specific position
-    pos_in_view = QPointF(22.0, 55.0)
-    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
-    event_mock = [pos_in_scene]
-    # Call the mouse_moved method
-    crosshair.mouse_moved(event_mock)
-    # Assert the expected behavior
-    assert emitted_values_2D == [("test", 22.0, 55.0)]
-
-
-def test_mouse_moved_signals_2D_outside(image_widget_with_crosshair):
-    crosshair, plot_item = image_widget_with_crosshair
-
-    # Create a slot that will store the emitted values as tuples
-    emitted_values_2D = []
-
-    def slot(x, y):
-        emitted_values_2D.append((x, y))
-
-    # Connect the signal to the custom slot
-    crosshair.coordinatesChanged2D.connect(slot)
-    # Simulate a mouse moved event at a specific position
-    pos_in_view = QPointF(220.0, 555.0)
-    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
-    event_mock = [pos_in_scene]
-    # Call the mouse_moved method
-    crosshair.mouse_moved(event_mock)
-    # Assert the expected behavior
-    assert emitted_values_2D == []

tests/unit_tests/test_dark_mode_button.py

@@ -1,70 +0,0 @@
-from unittest import mock
-
-import pytest
-from qtpy.QtCore import Qt
-
-from bec_widgets.widgets.dark_mode_button.dark_mode_button import DarkModeButton
-
-# pylint: disable=unused-import
-from .client_mocks import mocked_client
-
-# pylint: disable=redefined-outer-name
-
-
-@pytest.fixture
-def dark_mode_button(qtbot, mocked_client):
-    """
-    Fixture for the dark mode button.
-    """
-    button = DarkModeButton(client=mocked_client)
-    qtbot.addWidget(button)
-    qtbot.waitExposed(button)
-    yield button
-
-
-def test_dark_mode_button_init(dark_mode_button):
-    """
-    Test that the dark mode button is initialized correctly.
-    """
-    assert dark_mode_button.dark_mode_enabled is False
-    assert dark_mode_button.mode_button.toolTip() == "Set Dark Mode"
-
-
-def test_dark_mode_button_toggle(dark_mode_button):
-    """
-    Test that the dark mode button toggles correctly.
-    """
-    dark_mode_button.toggle_dark_mode()
-    assert dark_mode_button.dark_mode_enabled is True
-    assert dark_mode_button.mode_button.toolTip() == "Set Light Mode"
-
-    dark_mode_button.toggle_dark_mode()
-    assert dark_mode_button.dark_mode_enabled == False
-    assert dark_mode_button.mode_button.toolTip() == "Set Dark Mode"
-
-
-def test_dark_mode_button_toggles_on_click(dark_mode_button, qtbot):
-    """
-    Test that the dark mode button toggles correctly when clicked.
-    """
-    qtbot.mouseClick(dark_mode_button.mode_button, Qt.MouseButton.LeftButton)
-    assert dark_mode_button.dark_mode_enabled is True
-    assert dark_mode_button.mode_button.toolTip() == "Set Light Mode"
-
-    qtbot.mouseClick(dark_mode_button.mode_button, Qt.MouseButton.LeftButton)
-    assert dark_mode_button.dark_mode_enabled is False
-    assert dark_mode_button.mode_button.toolTip() == "Set Dark Mode"
-
-
-def test_dark_mode_button_changes_theme(dark_mode_button):
-    """
-    Test that the dark mode button changes the theme correctly.
-    """
-    with mock.patch(
-        "bec_widgets.widgets.dark_mode_button.dark_mode_button.set_theme"
-    ) as mocked_set_theme:
-        dark_mode_button.toggle_dark_mode()
-        mocked_set_theme.assert_called_with("dark")
-
-        dark_mode_button.toggle_dark_mode()
-        mocked_set_theme.assert_called_with("light")

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"}