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

tests/unit_tests/test_bec_status_box.py

@@ -1,123 +0,0 @@
-# pylint: skip-file
-from unittest import mock
-
-import pytest
-from bec_lib.messages import BECStatus, ServiceMetricMessage, StatusMessage
-
-from bec_widgets.widgets.bec_status_box.bec_status_box import BECServiceInfoContainer, BECStatusBox
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def service_status_fixture():
-    yield mock.MagicMock()
-
-
-@pytest.fixture
-def status_box(qtbot, mocked_client, service_status_fixture):
-    widget = BECStatusBox(client=mocked_client, bec_service_status_mixin=service_status_fixture)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_update_top_item(status_box):
-    assert status_box.tree.children()[0].children()[0].config.status == "IDLE"
-    name = status_box.box_name
-    status_box.update_top_item_status(status="RUNNING")
-    assert status_box.status_container[name]["info"].status == "RUNNING"
-    assert status_box.tree.children()[0].children()[0].config.status == "RUNNING"
-
-
-def test_create_status_widget(status_box):
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    item = status_box._create_status_widget(name, status, info, metrics)
-    assert item.config.service_name == name
-    assert item.config.status == status.name
-    assert item.config.info == info
-    assert item.config.metrics == metrics
-
-
-def test_bec_service_container(status_box):
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    expected_return = BECServiceInfoContainer(
-        service_name=name, status=status.name, info=info, metrics=metrics
-    )
-    assert status_box.box_name in status_box.status_container
-    assert len(status_box.status_container) == 1
-    status_box._update_status_container(name, status, info, metrics)
-    assert len(status_box.status_container) == 2
-    assert status_box.status_container[name]["info"] == expected_return
-
-
-def test_add_tree_item(status_box):
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    assert len(status_box.tree.children()[0].children()) == 1
-    status_box.add_tree_item(name, status, info, metrics)
-    assert len(status_box.tree.children()[0].children()) == 2
-    assert name in status_box.status_container
-
-
-def test_update_service_status(status_box):
-    """Also checks check redundant tree items"""
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    status_box.add_tree_item(name, status, info, {})
-    not_connected_name = "invalid_service"
-    status_box.add_tree_item(not_connected_name, status, info, metrics)
-
-    services_status = {name: StatusMessage(name=name, status=status, info=info)}
-    services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
-
-    with mock.patch.object(status_box, "update_core_services", return_value=services_status):
-        assert not_connected_name in status_box.status_container
-        status_box.update_service_status(services_status, services_metrics)
-        assert status_box.status_container[name]["widget"].config.metrics == metrics
-        assert not_connected_name not in status_box.status_container
-
-
-def test_update_core_services(status_box):
-    status_box.CORE_SERVICES = ["test_service"]
-    name = "test_service"
-    status = BECStatus.RUNNING
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    services_status = {name: StatusMessage(name=name, status=status, info=info)}
-    services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
-
-    status_box.update_core_services(services_status, services_metrics)
-    assert status_box.tree.children()[0].children()[0].config.status == "RUNNING"
-    assert status_box.status_container[name]["widget"].config.metrics == metrics
-
-    status = BECStatus.IDLE
-    services_status = {name: StatusMessage(name=name, status=status, info=info)}
-    services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
-    status_box.update_core_services(services_status, services_metrics)
-    assert status_box.tree.children()[0].children()[0].config.status == status.name
-    assert status_box.status_container[name]["widget"].config.metrics == metrics
-
-
-def test_double_click_item(status_box):
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"MyData": "This should be shown nicely"}
-    status_box.add_tree_item(name, status, info, metrics)
-    container = status_box.status_container[name]
-    item = container["item"]
-    status_item = container["widget"]
-    with mock.patch.object(status_item, "show_popup") as mock_show_popup:
-        status_box.tree.itemDoubleClicked.emit(item, 0)
-        assert mock_show_popup.call_count == 1

tests/unit_tests/test_client_utils.py

@@ -1,76 +0,0 @@
-from unittest import mock
-
-import pytest
-
-from bec_widgets.cli.client import BECFigure
-from bec_widgets.cli.client_utils import BECGuiClientMixin, _start_plot_process
-
-from .client_mocks import FakeDevice
-
-
-@pytest.fixture
-def cli_figure():
-    fig = BECFigure(gui_id="test")
-    with mock.patch.object(fig, "_run_rpc") as mock_rpc_call:
-        with mock.patch.object(fig, "gui_is_alive", return_value=True):
-            yield fig, mock_rpc_call
-
-
-def test_rpc_call_plot(cli_figure):
-    fig, mock_rpc_call = cli_figure
-    fig.plot(x_name="samx", y_name="bpm4i")
-    mock_rpc_call.assert_called_with("plot", x_name="samx", y_name="bpm4i")
-
-
-def test_rpc_call_accepts_device_as_input(cli_figure):
-    dev1 = FakeDevice("samx")
-    dev2 = FakeDevice("bpm4i")
-    fig, mock_rpc_call = cli_figure
-    fig.plot(x_name=dev1, y_name=dev2)
-    mock_rpc_call.assert_called_with("plot", x_name="samx", y_name="bpm4i")
-
-
-@pytest.mark.parametrize(
-    "config, call_config",
-    [
-        (None, None),
-        ("/path/to/config.yml", "/path/to/config.yml"),
-        ({"key": "value"}, '{"key": "value"}'),
-    ],
-)
-def test_client_utils_start_plot_process(config, call_config):
-    with mock.patch("bec_widgets.cli.client_utils.subprocess.Popen") as mock_popen:
-        _start_plot_process("gui_id", BECFigure, config)
-        command = ["bec-gui-server", "--id", "gui_id", "--gui_class", "BECFigure"]
-        if call_config:
-            command.extend(["--config", call_config])
-        mock_popen.assert_called_once_with(
-            command,
-            text=True,
-            start_new_session=True,
-            stdout=mock.ANY,
-            stderr=mock.ANY,
-            env=mock.ANY,
-        )
-
-
-def test_client_utils_passes_client_config_to_server(bec_dispatcher):
-    """
-    Test that the client config is passed to the server. This ensures that
-    changes to the client config (either through config files or plugins) are
-    reflected in the server.
-    """
-    mixin = BECGuiClientMixin()
-    mixin._client = bec_dispatcher.client
-    mixin._gui_id = "gui_id"
-    mixin.gui_is_alive = mock.MagicMock()
-    mixin.gui_is_alive.side_effect = [True]
-
-    with mock.patch("bec_widgets.cli.client_utils._start_plot_process") as mock_start_plot:
-        with mock.patch.object(mixin, "_start_update_script") as mock_start_update:
-            mock_start_plot.return_value = [mock.MagicMock(), mock.MagicMock()]
-            mixin.show()
-            mock_start_plot.assert_called_once_with(
-                "gui_id", BECGuiClientMixin, mixin._client._service_config.config
-            )
-            mock_start_update.assert_called_once()

tests/unit_tests/test_color_map_selector.py

@@ -1,42 +0,0 @@
-import pyqtgraph as pg
-import pytest
-
-from bec_widgets.widgets.colormap_selector.colormap_selector import ColormapSelector
-
-
-@pytest.fixture
-def color_map_selector(qtbot):
-    widget = ColormapSelector()
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_color_map_selector_init(color_map_selector):
-    assert color_map_selector is not None
-    assert isinstance(color_map_selector, ColormapSelector)
-
-    all_maps = pg.colormap.listMaps()
-    loaded_maps = [
-        color_map_selector.combo.itemText(i) for i in range(color_map_selector.combo.count())
-    ]
-    assert len(loaded_maps) > 0
-    assert all_maps == loaded_maps
-
-
-def test_color_map_selector_add_color_maps(color_map_selector):
-    color_map_selector.add_color_maps(["cividis", "viridis"])
-    assert color_map_selector.combo.count() == 2
-    assert color_map_selector.combo.itemText(0) == "cividis"
-    assert color_map_selector.combo.itemText(1) == "viridis"
-    assert color_map_selector.combo.itemText(2) != "cividis"
-    assert color_map_selector.combo.itemText(2) != "viridis"
-
-
-def test_colormap_add_maps_by_property(color_map_selector):
-    color_map_selector.colormaps = ["cividis", "viridis"]
-    assert color_map_selector.combo.count() == 2
-    assert color_map_selector.combo.itemText(0) == "cividis"
-    assert color_map_selector.combo.itemText(1) == "viridis"
-    assert color_map_selector.combo.itemText(2) != "cividis"
-    assert color_map_selector.combo.itemText(2) != "viridis"

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