bec-widgets 0.53.3__py3-none-any.whl → 0.55.0__py3-none-any.whl

tests/unit_tests/test_spiral_progress_bar.py

@@ -0,0 +1,338 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+
+import pytest
+from bec_lib.endpoints import MessageEndpoints
+from pydantic import ValidationError
+
+from bec_widgets.utils import Colors
+from bec_widgets.widgets import SpiralProgressBar
+from bec_widgets.widgets.spiral_progress_bar.ring import RingConfig, RingConnections
+from bec_widgets.widgets.spiral_progress_bar.spiral_progress_bar import SpiralProgressBarConfig
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def spiral_progress_bar(qtbot, mocked_client):
+    widget = SpiralProgressBar(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+def test_bar_init(spiral_progress_bar):
+    assert spiral_progress_bar is not None
+    assert spiral_progress_bar.client is not None
+    assert isinstance(spiral_progress_bar, SpiralProgressBar)
+    assert spiral_progress_bar.config.widget_class == "SpiralProgressBar"
+    assert spiral_progress_bar.config.gui_id is not None
+    assert spiral_progress_bar.gui_id == spiral_progress_bar.config.gui_id
+
+
+def test_config_validation_num_of_bars():
+    config = SpiralProgressBarConfig(num_bars=100, min_num_bars=1, max_num_bars=10)
+
+    assert config.num_bars == 10
+
+
+def test_config_validation_num_of_ring_error():
+    ring_config_0 = RingConfig(index=0)
+    ring_config_1 = RingConfig(index=1)
+
+    with pytest.raises(ValidationError) as excinfo:
+        SpiralProgressBarConfig(rings=[ring_config_0, ring_config_1], num_bars=1)
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "different number of configs"
+    assert "Length of rings configuration (2) does not match the number of bars (1)." in str(
+        excinfo.value
+    )
+
+
+def test_config_validation_ring_indices_wrong_order():
+    ring_config_0 = RingConfig(index=2)
+    ring_config_1 = RingConfig(index=5)
+
+    with pytest.raises(ValidationError) as excinfo:
+        SpiralProgressBarConfig(rings=[ring_config_0, ring_config_1], num_bars=2)
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "wrong indices"
+    assert (
+        "Indices of ring configurations must be unique and in order from 0 to num_bars 2."
+        in str(excinfo.value)
+    )
+
+
+def test_config_validation_ring_same_indices():
+    ring_config_0 = RingConfig(index=0)
+    ring_config_1 = RingConfig(index=0)
+
+    with pytest.raises(ValidationError) as excinfo:
+        SpiralProgressBarConfig(rings=[ring_config_0, ring_config_1], num_bars=2)
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "wrong indices"
+    assert (
+        "Indices of ring configurations must be unique and in order from 0 to num_bars 2."
+        in str(excinfo.value)
+    )
+
+
+def test_config_validation_invalid_colormap():
+    with pytest.raises(ValueError) as excinfo:
+        SpiralProgressBarConfig(color_map="crazy_colors")
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "unsupported colormap"
+    assert "Colormap 'crazy_colors' not found in the current installation of pyqtgraph" in str(
+        excinfo.value
+    )
+
+
+def test_ring_connection_endpoint_validation():
+    with pytest.raises(ValueError) as excinfo:
+        RingConnections(slot="on_scan_progress", endpoint="non_existing")
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "unsupported endpoint"
+    assert (
+        "For slot 'on_scan_progress', endpoint must be MessageEndpoint.scan_progress or 'scans/scan_progress'."
+        in str(excinfo.value)
+    )
+
+    with pytest.raises(ValueError) as excinfo:
+        RingConnections(slot="on_device_readback", endpoint="non_existing")
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "unsupported endpoint"
+    assert (
+        "For slot 'on_device_readback', endpoint must be MessageEndpoint.device_readback(device) or 'internal/devices/readback/{device}'."
+        in str(excinfo.value)
+    )
+
+
+def test_bar_add_number_of_bars(spiral_progress_bar):
+    assert spiral_progress_bar.config.num_bars == 1
+
+    spiral_progress_bar.set_number_of_bars(5)
+    assert spiral_progress_bar.config.num_bars == 5
+
+    spiral_progress_bar.set_number_of_bars(2)
+    assert spiral_progress_bar.config.num_bars == 2
+
+
+def test_add_remove_bars_individually(spiral_progress_bar):
+    spiral_progress_bar.add_ring()
+    spiral_progress_bar.add_ring()
+
+    assert spiral_progress_bar.config.num_bars == 3
+    assert len(spiral_progress_bar.config.rings) == 3
+
+    spiral_progress_bar.remove_ring(1)
+    assert spiral_progress_bar.config.num_bars == 2
+    assert len(spiral_progress_bar.config.rings) == 2
+    assert spiral_progress_bar.rings[0].config.index == 0
+    assert spiral_progress_bar.rings[1].config.index == 1
+
+
+def test_bar_set_value(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(5)
+
+    assert spiral_progress_bar.config.num_bars == 5
+    assert len(spiral_progress_bar.config.rings) == 5
+    assert len(spiral_progress_bar.rings) == 5
+
+    spiral_progress_bar.set_value([10, 20, 30, 40, 50])
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [10, 20, 30, 40, 50]
+
+    # update just one bar
+    spiral_progress_bar.set_value(90, 1)
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [10, 90, 30, 40, 50]
+
+
+def test_bar_set_precision(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(3)
+
+    assert spiral_progress_bar.config.num_bars == 3
+    assert len(spiral_progress_bar.config.rings) == 3
+    assert len(spiral_progress_bar.rings) == 3
+
+    spiral_progress_bar.set_precision(2)
+    ring_precision = [ring.config.precision for ring in spiral_progress_bar.rings]
+    assert ring_precision == [2, 2, 2]
+
+    spiral_progress_bar.set_value([10.1234, 20.1234, 30.1234])
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [10.12, 20.12, 30.12]
+
+    spiral_progress_bar.set_precision(4, 1)
+    ring_precision = [ring.config.precision for ring in spiral_progress_bar.rings]
+    assert ring_precision == [2, 4, 2]
+
+    spiral_progress_bar.set_value([10.1234, 20.1234, 30.1234])
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [10.12, 20.1234, 30.12]
+
+
+def test_set_min_max_value(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(2)
+
+    spiral_progress_bar.set_min_max_values(0, 10)
+    ring_min_values = [ring.config.min_value for ring in spiral_progress_bar.rings]
+    ring_max_values = [ring.config.max_value for ring in spiral_progress_bar.rings]
+
+    assert ring_min_values == [0, 0]
+    assert ring_max_values == [10, 10]
+
+    spiral_progress_bar.set_value([5, 15])
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [5, 10]
+
+
+def test_setup_colors_from_colormap(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(5)
+    spiral_progress_bar.set_colors_from_map("viridis", "RGB")
+
+    expected_colors = Colors.golden_angle_color("viridis", 5, "RGB")
+    converted_colors = [ring.color.getRgb() for ring in spiral_progress_bar.rings]
+    ring_config_colors = [ring.config.color for ring in spiral_progress_bar.rings]
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+
+def get_colors_from_rings(rings):
+    converted_colors = [ring.color.getRgb() for ring in rings]
+    ring_config_colors = [ring.config.color for ring in rings]
+    return converted_colors, ring_config_colors
+
+
+def test_set_colors_from_colormap_and_change_num_of_bars(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(2)
+    spiral_progress_bar.set_colors_from_map("viridis", "RGB")
+
+    expected_colors = Colors.golden_angle_color("viridis", 2, "RGB")
+    converted_colors, ring_config_colors = get_colors_from_rings(spiral_progress_bar.rings)
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+    # increase the number of bars to 6
+    spiral_progress_bar.set_number_of_bars(6)
+    expected_colors = Colors.golden_angle_color("viridis", 6, "RGB")
+    converted_colors, ring_config_colors = get_colors_from_rings(spiral_progress_bar.rings)
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+    # decrease the number of bars to 3
+    spiral_progress_bar.set_number_of_bars(3)
+    expected_colors = Colors.golden_angle_color("viridis", 3, "RGB")
+    converted_colors, ring_config_colors = get_colors_from_rings(spiral_progress_bar.rings)
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+
+def test_set_colors_directly(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(3)
+
+    # setting as a list of rgb tuples
+    colors = [(255, 0, 0, 255), (0, 255, 0, 255), (0, 0, 255, 255)]
+    spiral_progress_bar.set_colors_directly(colors)
+    converted_colors = get_colors_from_rings(spiral_progress_bar.rings)[0]
+
+    assert colors == converted_colors
+
+    spiral_progress_bar.set_colors_directly((255, 0, 0, 255), 1)
+    converted_colors = get_colors_from_rings(spiral_progress_bar.rings)[0]
+
+    assert converted_colors == [(255, 0, 0, 255), (255, 0, 0, 255), (0, 0, 255, 255)]
+
+
+def test_set_line_width(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(3)
+
+    spiral_progress_bar.set_line_widths(5)
+    line_widths = [ring.config.line_width for ring in spiral_progress_bar.rings]
+
+    assert line_widths == [5, 5, 5]
+
+    spiral_progress_bar.set_line_widths([10, 20, 30])
+    line_widths = [ring.config.line_width for ring in spiral_progress_bar.rings]
+
+    assert line_widths == [10, 20, 30]
+
+    spiral_progress_bar.set_line_widths(15, 1)
+    line_widths = [ring.config.line_width for ring in spiral_progress_bar.rings]
+
+    assert line_widths == [10, 15, 30]
+
+
+def test_set_gap(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(3)
+    spiral_progress_bar.set_gap(20)
+
+    assert spiral_progress_bar.config.gap == 20
+
+
+def test_auto_update(spiral_progress_bar):
+    spiral_progress_bar.enable_auto_updates(True)
+
+    scan_queue_status_scan_progress = {
+        "queue": {
+            "primary": {
+                "info": [{"active_request_block": {"report_instructions": [{"scan_progress": 10}]}}]
+            }
+        }
+    }
+    meta = {}
+
+    spiral_progress_bar.on_scan_queue_status(scan_queue_status_scan_progress, meta)
+
+    assert spiral_progress_bar._auto_updates is True
+    assert len(spiral_progress_bar._rings) == 1
+    assert spiral_progress_bar._rings[0].config.connections == RingConnections(
+        slot="on_scan_progress", endpoint=MessageEndpoints.scan_progress()
+    )
+
+    scan_queue_status_device_readback = {
+        "queue": {
+            "primary": {
+                "info": [
+                    {
+                        "active_request_block": {
+                            "report_instructions": [
+                                {
+                                    "readback": {
+                                        "devices": ["samx", "samy"],
+                                        "start": [1, 2],
+                                        "end": [10, 20],
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+    }
+    spiral_progress_bar.on_scan_queue_status(scan_queue_status_device_readback, meta)
+
+    assert spiral_progress_bar._auto_updates is True
+    assert len(spiral_progress_bar._rings) == 2
+    assert spiral_progress_bar._rings[0].config.connections == RingConnections(
+        slot="on_device_readback", endpoint=MessageEndpoints.device_readback("samx")
+    )
+    assert spiral_progress_bar._rings[1].config.connections == RingConnections(
+        slot="on_device_readback", endpoint=MessageEndpoints.device_readback("samy")
+    )
+
+    assert spiral_progress_bar._rings[0].config.min_value == 1
+    assert spiral_progress_bar._rings[0].config.max_value == 10
+    assert spiral_progress_bar._rings[1].config.min_value == 2
+    assert spiral_progress_bar._rings[1].config.max_value == 20

tests/unit_tests/test_waveform1d.py

@@ -4,7 +4,7 @@ from unittest.mock import MagicMock
 import numpy as np
 import pytest
 
-from bec_widgets.widgets.plots.waveform import CurveConfig, Signal, SignalData
+from bec_widgets.widgets.figure.plots.waveform.waveform_curve import CurveConfig, Signal, SignalData
 
 from .client_mocks import mocked_client
 from .test_bec_figure import bec_figure
@@ -304,6 +304,18 @@ def test_set_custom_curve_data(bec_figure, qtbot):
     assert np.array_equal(y_new, [7, 8, 9])
 
 
+def test_custom_data_2D_array(bec_figure, qtbot):
+
+    data = np.random.rand(10, 2)
+
+    plt = bec_figure.plot(data)
+
+    x, y = plt.curves[0].get_data()
+
+    assert np.array_equal(x, data[:, 0])
+    assert np.array_equal(y, data[:, 1])
+
+
 def test_get_all_data(bec_figure):
     w1 = bec_figure.add_plot()
 

bec_widgets/validation/__init__.py

@@ -1,2 +0,0 @@
-# from .monitor_config import validate_monitor_config, ValidationError
-from .monitor_config_validator import MonitorConfigValidator

bec_widgets/validation/monitor_config_validator.py

@@ -1,258 +0,0 @@
-from typing import Literal, Optional, Union
-
-from pydantic import BaseModel, Field, ValidationError, field_validator, model_validator
-from pydantic_core import PydanticCustomError
-
-
-class Signal(BaseModel):
-    """
-    Represents a signal in a plot configuration.
-
-    Args:
-        name (str): The name of the signal.
-        entry (Optional[str]): The entry point of the signal, optional.
-    """
-
-    name: str
-    entry: Optional[str] = Field(None, validate_default=True)
-
-    @model_validator(mode="before")
-    @classmethod
-    def validate_fields(cls, values):
-        """Validate the fields of the model.
-        First validate the 'name' field, then validate the 'entry' field.
-
-        Args:
-            values (dict): The values to be validated."""
-        devices = MonitorConfigValidator.devices
-
-        # Validate 'name'
-        name = values.get("name")
-
-        # Check if device name provided
-        if name is None:
-            raise PydanticCustomError(
-                "no_device_name", "Device name must be provided", {"wrong_value": name}
-            )
-        # Check if device exists in BEC
-        if name not in devices:
-            raise PydanticCustomError(
-                "no_device_bec",
-                'Device "{wrong_value}" not found in current BEC session',
-                {"wrong_value": name},
-            )
-
-        device = devices[name]  # get the device to check if it has signals
-
-        # Get device description
-        description = device.describe()
-
-        # Validate 'entry'
-        entry = values.get("entry")
-
-        # Set entry based on hints if not provided
-        if entry is None:
-            entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
-        if entry not in description:
-            raise PydanticCustomError(
-                "no_entry_for_device",
-                'Entry "{wrong_value}" not found in device "{device_name}" signals',
-                {"wrong_value": entry, "device_name": name},
-            )
-
-        values["entry"] = entry
-        return values
-
-
-class AxisSignal(BaseModel):
-    """
-    Configuration signal axis for a single plot.
-    Attributes:
-        x (list): Signal for the X axis.
-        y (list): Signals for the Y axis.
-    """
-
-    x: list[Signal] = Field(default_factory=list)
-    y: list[Signal] = Field(default_factory=list)
-
-    @field_validator("x")
-    @classmethod
-    def validate_x_signals(cls, v):
-        """Ensure that there is only one signal for x-axis."""
-        if len(v) != 1:
-            raise PydanticCustomError(
-                "x_axis_multiple_signals",
-                'There must be exactly one signal for x axis. Number of x signals: "{wrong_value}"',
-                {"wrong_value": v},
-            )
-
-        return v
-
-
-class SourceHistoryValidator(BaseModel):
-    """History source validator
-    Attributes:
-        type (str): type of source - history
-        scan_id (str): Scan ID for history source.
-        signals (list): Signal for the source.
-    """
-
-    type: Literal["history"]
-    scan_id: str  # TODO can be validated if it is a valid scan_id
-    signals: AxisSignal
-
-
-class SourceSegmentValidator(BaseModel):
-    """Scan Segment source validator
-    Attributes:
-        type (str): type of source - scan_segment
-        signals (AxisSignal): Signal for the source.
-    """
-
-    type: Literal["scan_segment"]
-    signals: AxisSignal
-
-
-class SourceRedisValidator(BaseModel):
-    """Scan Segment source validator
-    Attributes:
-        type (str): type of source - scan_segment
-        endpoint (str): Endpoint reference in redis.
-        update (str): Update type.
-    """
-
-    type: Literal["redis"]
-    endpoint: str
-    update: str
-    signals: dict
-
-
-class Source(BaseModel):  # TODO decide if it should stay for general Source validation
-    """
-    General source validation, includes all Optional arguments of all other sources.
-    Attributes:
-        type (list): type of source (scan_segment, history)
-        scan_id (Optional[str]): Scan ID for history source.
-        signals (Optional[AxisSignal]): Signal for the source.
-    """
-
-    type: Literal["scan_segment", "history", "redis"]
-    scan_id: Optional[str] = None
-    signals: Optional[dict] = None
-
-
-class PlotConfig(BaseModel):
-    """
-    Configuration for a single plot.
-
-    Attributes:
-        plot_name (Optional[str]): Name of the plot.
-        x_label (Optional[str]): The label for the x-axis.
-        y_label (Optional[str]): The label for the y-axis.
-        sources (list): A list of sources to be plotted on this axis.
-    """
-
-    plot_name: Optional[str] = None
-    x_label: Optional[str] = None
-    y_label: Optional[str] = None
-    sources: list = Field(default_factory=list)
-
-    @field_validator("sources")
-    @classmethod
-    def validate_sources(cls, values):
-        """Validate the sources of the plot configuration, based on the type of source."""
-        validated_sources = []
-        for source in values:
-            # Check if source type is supported
-            Source(**source)
-            source_type = source.get("type", None)
-
-            # Validate source based on type
-            if source_type == "scan_segment":
-                validated_sources.append(SourceSegmentValidator(**source))
-            elif source_type == "history":
-                validated_sources.append(SourceHistoryValidator(**source))
-            elif source_type == "redis":
-                validated_sources.append(SourceRedisValidator(**source))
-        return validated_sources
-
-
-class PlotSettings(BaseModel):
-    """
-    Global settings for plotting affecting mostly visuals.
-
-    Attributes:
-        background_color (str): Color of the plot background. Default is black.
-        axis_width (Optional[int]): Width of the plot axes. Default is 2.
-        axis_color (Optional[str]): Color of the plot axes. Default is None.
-        num_columns (int): Number of columns in the plot layout. Default is 1.
-        colormap (str): Colormap to be used. Default is magma.
-        scan_types (bool): Indicates if the configuration is for different scan types. Default is False.
-    """
-
-    background_color: Literal["black", "white"] = "black"
-    axis_width: Optional[int] = 2
-    axis_color: Optional[str] = None
-    num_columns: Optional[int] = 1
-    colormap: Optional[str] = "magma"
-    scan_types: Optional[bool] = False
-
-
-class DeviceMonitorConfig(BaseModel):
-    """
-    Configuration model for the device monitor mode.
-
-    Attributes:
-        plot_settings (PlotSettings): Global settings for plotting.
-        plot_data (list[PlotConfig]): List of plot configurations.
-    """
-
-    plot_settings: PlotSettings
-    plot_data: list[PlotConfig]
-
-
-class ScanModeConfig(BaseModel):
-    """
-    Configuration model for scan mode.
-
-    Attributes:
-        plot_settings (PlotSettings): Global settings for plotting.
-        plot_data (dict[str, list[PlotConfig]]): Dictionary of plot configurations,
-                                                 keyed by scan type.
-    """
-
-    plot_settings: PlotSettings
-    plot_data: dict[str, list[PlotConfig]]
-
-
-class MonitorConfigValidator:
-    """Validates the configuration data for the BECMonitor."""
-
-    devices = None
-
-    def __init__(self, devices):
-        # self.device_manager = device_manager
-        MonitorConfigValidator.devices = devices
-
-    def validate_monitor_config(
-        self, config_data: dict
-    ) -> Union[DeviceMonitorConfig, ScanModeConfig]:
-        """
-        Validates the configuration data based on the provided schema.
-
-        Args:
-            config_data (dict): Configuration data to be validated.
-
-        Returns:
-            Union[DeviceMonitorConfig, ScanModeConfig]: Validated configuration object.
-
-        Raises:
-            ValidationError: If the configuration data does not conform to the schema.
-        """
-        config_type = config_data.get("plot_settings", {}).get("scan_types", False)
-        if config_type:
-            validated_config = ScanModeConfig(**config_data)
-        else:
-            validated_config = DeviceMonitorConfig(**config_data)
-
-        return validated_config

bec_widgets/widgets/monitor/__init__.py

@@ -1 +0,0 @@
-from .monitor import BECMonitor