bec-widgets 0.72.0__py3-none-any.whl → 0.72.2__py3-none-any.whl

tests/unit_tests/test_bec_status_box.py

@@ -1,152 +1,121 @@
-# import re
-# from unittest import mock
-#
-# import pytest
-# from bec_lib.messages import BECStatus, ServiceMetricMessage, StatusMessage
-# from qtpy.QtCore import QMetaMethod
-#
-# from bec_widgets.widgets.bec_status_box.bec_status_box import BECServiceInfoContainer, BECStatusBox
-#
-# from .client_mocks import mocked_client
-#
-#
-# @pytest.fixture
-# def status_box(qtbot, mocked_client):
-#     with mock.patch(
-#         "bec_widgets.widgets.bec_status_box.bec_status_box.BECServiceStatusMixin"
-#     ) as mock_service_status_mixin:
-#         widget = BECStatusBox(client=mocked_client)
-#         qtbot.addWidget(widget)
-#         qtbot.waitExposed(widget)
-#         yield widget
-#
-#
-# def test_status_box_init(qtbot, mocked_client):
-#     with mock.patch(
-#         "bec_widgets.widgets.bec_status_box.bec_status_box.BECServiceStatusMixin"
-#     ) as mock_service_status_mixin:
-#         name = "my test"
-#         widget = BECStatusBox(parent=None, service_name=name, client=mocked_client)
-#         qtbot.addWidget(widget)
-#         qtbot.waitExposed(widget)
-#         assert widget.headerItem().DontShowIndicator.value == 1
-#         assert widget.children()[0].children()[0].config.service_name == name
-#
-#
-# def test_update_top_item(qtbot, mocked_client):
-#     with (
-#         mock.patch(
-#             "bec_widgets.widgets.bec_status_box.bec_status_box.BECServiceStatusMixin"
-#         ) as mock_service_status_mixin,
-#         mock.patch(
-#             "bec_widgets.widgets.bec_status_box.status_item.StatusItem.update_config"
-#         ) as mock_update,
-#     ):
-#         name = "my test"
-#         widget = BECStatusBox(parent=None, service_name=name, client=mocked_client)
-#         qtbot.addWidget(widget)
-#         qtbot.waitExposed(widget)
-#         widget.update_top_item_status(status="RUNNING")
-#         assert widget.bec_service_info_container[name].status == "RUNNING"
-#         assert mock_update.call_args == mock.call(widget.bec_service_info_container[name].dict())
-#
-#
-# 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, info=info, metrics=metrics
-#     )
-#     assert status_box.service_name in status_box.bec_service_info_container
-#     assert len(status_box.bec_service_info_container) == 1
-#     status_box._update_bec_service_container(name, status, info, metrics)
-#     assert len(status_box.bec_service_info_container) == 2
-#     assert status_box.bec_service_info_container[name] == 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.children()[0].children()) == 1
-#     status_box.add_tree_item(name, status, info, metrics)
-#     assert len(status_box.children()[0].children()) == 2
-#     assert name in status_box.tree_items
-#
-#
-# 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.tree_items
-#         status_box.update_service_status(services_status, services_metrics)
-#         assert status_box.tree_items[name][1].config.metrics == metrics
-#         assert not_connected_name not in status_box.tree_items
-#
-#
-# def test_update_core_services(qtbot, mocked_client):
-#     with (
-#         mock.patch(
-#             "bec_widgets.widgets.bec_status_box.bec_status_box.BECServiceStatusMixin"
-#         ) as mock_service_status_mixin,
-#         mock.patch(
-#             "bec_widgets.widgets.bec_status_box.bec_status_box.BECStatusBox.update_top_item_status"
-#         ) as mock_update,
-#     ):
-#         name = "my test"
-#         status_box = BECStatusBox(parent=None, service_name=name, client=mocked_client)
-#         qtbot.addWidget(status_box)
-#         qtbot.waitExposed(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 mock_update.call_args == mock.call(status.name)
-#
-#         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 mock_update.call_args == mock.call("ERROR")
-#
-#
-# 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)
-#     item, status_item = status_box.tree_items[name]
-#     with mock.patch.object(status_item, "show_popup") as mock_show_popup:
-#         status_box.itemDoubleClicked.emit(item, 0)
-#         assert mock_show_popup.call_count == 1
+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, service_name="test", 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.children()[0].children()[0].config.status == "IDLE"
+    status_box.update_top_item_status(status="RUNNING")
+    assert status_box.bec_service_info_container["test"].status == "RUNNING"
+    assert status_box.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, info=info, metrics=metrics
+    )
+    assert status_box.service_name in status_box.bec_service_info_container
+    assert len(status_box.bec_service_info_container) == 1
+    status_box._update_bec_service_container(name, status, info, metrics)
+    assert len(status_box.bec_service_info_container) == 2
+    assert status_box.bec_service_info_container[name] == 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.children()[0].children()) == 1
+    status_box.add_tree_item(name, status, info, metrics)
+    assert len(status_box.children()[0].children()) == 2
+    assert name in status_box.tree_items
+
+
+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.tree_items
+        status_box.update_service_status(services_status, services_metrics)
+        assert status_box.tree_items[name][1].config.metrics == metrics
+        assert not_connected_name not in status_box.tree_items
+
+
+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.children()[0].children()[0].config.status == "RUNNING"
+    assert status_box.tree_items[name][1].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.children()[0].children()[0].config.status == "ERROR"
+    assert status_box.tree_items[name][1].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)
+    item, status_item = status_box.tree_items[name]
+    with mock.patch.object(status_item, "show_popup") as mock_show_popup:
+        status_box.itemDoubleClicked.emit(item, 0)
+        assert mock_show_popup.call_count == 1

tests/unit_tests/test_ring_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.ring_progress_bar import RingProgressBar
+from bec_widgets.widgets.ring_progress_bar.ring import ProgressbarConnections, RingConfig
+from bec_widgets.widgets.ring_progress_bar.ring_progress_bar import RingProgressBarConfig
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def ring_progress_bar(qtbot, mocked_client):
+    widget = RingProgressBar(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+def test_bar_init(ring_progress_bar):
+    assert ring_progress_bar is not None
+    assert ring_progress_bar.client is not None
+    assert isinstance(ring_progress_bar, RingProgressBar)
+    assert ring_progress_bar.config.widget_class == "RingProgressBar"
+    assert ring_progress_bar.config.gui_id is not None
+    assert ring_progress_bar.gui_id == ring_progress_bar.config.gui_id
+
+
+def test_config_validation_num_of_bars():
+    config = RingProgressBarConfig(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:
+        RingProgressBarConfig(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:
+        RingProgressBarConfig(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:
+        RingProgressBarConfig(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:
+        RingProgressBarConfig(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:
+        ProgressbarConnections(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:
+        ProgressbarConnections(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(ring_progress_bar):
+    assert ring_progress_bar.config.num_bars == 1
+
+    ring_progress_bar.set_number_of_bars(5)
+    assert ring_progress_bar.config.num_bars == 5
+
+    ring_progress_bar.set_number_of_bars(2)
+    assert ring_progress_bar.config.num_bars == 2
+
+
+def test_add_remove_bars_individually(ring_progress_bar):
+    ring_progress_bar.add_ring()
+    ring_progress_bar.add_ring()
+
+    assert ring_progress_bar.config.num_bars == 3
+    assert len(ring_progress_bar.config.rings) == 3
+
+    ring_progress_bar.remove_ring(1)
+    assert ring_progress_bar.config.num_bars == 2
+    assert len(ring_progress_bar.config.rings) == 2
+    assert ring_progress_bar.rings[0].config.index == 0
+    assert ring_progress_bar.rings[1].config.index == 1
+
+
+def test_bar_set_value(ring_progress_bar):
+    ring_progress_bar.set_number_of_bars(5)
+
+    assert ring_progress_bar.config.num_bars == 5
+    assert len(ring_progress_bar.config.rings) == 5
+    assert len(ring_progress_bar.rings) == 5
+
+    ring_progress_bar.set_value([10, 20, 30, 40, 50])
+    ring_values = [ring.config.value for ring in ring_progress_bar.rings]
+    assert ring_values == [10, 20, 30, 40, 50]
+
+    # update just one bar
+    ring_progress_bar.set_value(90, 1)
+    ring_values = [ring.config.value for ring in ring_progress_bar.rings]
+    assert ring_values == [10, 90, 30, 40, 50]
+
+
+def test_bar_set_precision(ring_progress_bar):
+    ring_progress_bar.set_number_of_bars(3)
+
+    assert ring_progress_bar.config.num_bars == 3
+    assert len(ring_progress_bar.config.rings) == 3
+    assert len(ring_progress_bar.rings) == 3
+
+    ring_progress_bar.set_precision(2)
+    ring_precision = [ring.config.precision for ring in ring_progress_bar.rings]
+    assert ring_precision == [2, 2, 2]
+
+    ring_progress_bar.set_value([10.1234, 20.1234, 30.1234])
+    ring_values = [ring.config.value for ring in ring_progress_bar.rings]
+    assert ring_values == [10.12, 20.12, 30.12]
+
+    ring_progress_bar.set_precision(4, 1)
+    ring_precision = [ring.config.precision for ring in ring_progress_bar.rings]
+    assert ring_precision == [2, 4, 2]
+
+    ring_progress_bar.set_value([10.1234, 20.1234, 30.1234])
+    ring_values = [ring.config.value for ring in ring_progress_bar.rings]
+    assert ring_values == [10.12, 20.1234, 30.12]
+
+
+def test_set_min_max_value(ring_progress_bar):
+    ring_progress_bar.set_number_of_bars(2)
+
+    ring_progress_bar.set_min_max_values(0, 10)
+    ring_min_values = [ring.config.min_value for ring in ring_progress_bar.rings]
+    ring_max_values = [ring.config.max_value for ring in ring_progress_bar.rings]
+
+    assert ring_min_values == [0, 0]
+    assert ring_max_values == [10, 10]
+
+    ring_progress_bar.set_value([5, 15])
+    ring_values = [ring.config.value for ring in ring_progress_bar.rings]
+    assert ring_values == [5, 10]
+
+
+def test_setup_colors_from_colormap(ring_progress_bar):
+    ring_progress_bar.set_number_of_bars(5)
+    ring_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 ring_progress_bar.rings]
+    ring_config_colors = [ring.config.color for ring in ring_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(ring_progress_bar):
+    ring_progress_bar.set_number_of_bars(2)
+    ring_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(ring_progress_bar.rings)
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+    # increase the number of bars to 6
+    ring_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(ring_progress_bar.rings)
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+    # decrease the number of bars to 3
+    ring_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(ring_progress_bar.rings)
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+
+def test_set_colors_directly(ring_progress_bar):
+    ring_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)]
+    ring_progress_bar.set_colors_directly(colors)
+    converted_colors = get_colors_from_rings(ring_progress_bar.rings)[0]
+
+    assert colors == converted_colors
+
+    ring_progress_bar.set_colors_directly((255, 0, 0, 255), 1)
+    converted_colors = get_colors_from_rings(ring_progress_bar.rings)[0]
+
+    assert converted_colors == [(255, 0, 0, 255), (255, 0, 0, 255), (0, 0, 255, 255)]
+
+
+def test_set_line_width(ring_progress_bar):
+    ring_progress_bar.set_number_of_bars(3)
+
+    ring_progress_bar.set_line_widths(5)
+    line_widths = [ring.config.line_width for ring in ring_progress_bar.rings]
+
+    assert line_widths == [5, 5, 5]
+
+    ring_progress_bar.set_line_widths([10, 20, 30])
+    line_widths = [ring.config.line_width for ring in ring_progress_bar.rings]
+
+    assert line_widths == [10, 20, 30]
+
+    ring_progress_bar.set_line_widths(15, 1)
+    line_widths = [ring.config.line_width for ring in ring_progress_bar.rings]
+
+    assert line_widths == [10, 15, 30]
+
+
+def test_set_gap(ring_progress_bar):
+    ring_progress_bar.set_number_of_bars(3)
+    ring_progress_bar.set_gap(20)
+
+    assert ring_progress_bar.config.gap == 20
+
+
+def test_auto_update(ring_progress_bar):
+    ring_progress_bar.enable_auto_updates(True)
+
+    scan_queue_status_scan_progress = {
+        "queue": {
+            "primary": {
+                "info": [{"active_request_block": {"report_instructions": [{"scan_progress": 10}]}}]
+            }
+        }
+    }
+    meta = {}
+
+    ring_progress_bar.on_scan_queue_status(scan_queue_status_scan_progress, meta)
+
+    assert ring_progress_bar._auto_updates is True
+    assert len(ring_progress_bar._rings) == 1
+    assert ring_progress_bar._rings[0].config.connections == ProgressbarConnections(
+        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],
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+    }
+    ring_progress_bar.on_scan_queue_status(scan_queue_status_device_readback, meta)
+
+    assert ring_progress_bar._auto_updates is True
+    assert len(ring_progress_bar._rings) == 2
+    assert ring_progress_bar._rings[0].config.connections == ProgressbarConnections(
+        slot="on_device_readback", endpoint=MessageEndpoints.device_readback("samx")
+    )
+    assert ring_progress_bar._rings[1].config.connections == ProgressbarConnections(
+        slot="on_device_readback", endpoint=MessageEndpoints.device_readback("samy")
+    )
+
+    assert ring_progress_bar._rings[0].config.min_value == 1
+    assert ring_progress_bar._rings[0].config.max_value == 10
+    assert ring_progress_bar._rings[1].config.min_value == 2
+    assert ring_progress_bar._rings[1].config.max_value == 20

tests/unit_tests/test_rpc_widget_handler.py

@@ -4,4 +4,4 @@ from bec_widgets.cli.rpc_wigdet_handler import RPCWidgetHandler
 def test_rpc_widget_handler():
     handler = RPCWidgetHandler()
     assert "BECFigure" in handler.widget_classes
-    assert "SpiralProgressBar" in handler.widget_classes
+    assert "RingProgressBar" in handler.widget_classes

bec_widgets/widgets/spiral_progress_bar/__init__.py

@@ -1 +0,0 @@
-from .spiral_progress_bar import SpiralProgressBar