feat(figure): added support for async device readbacks as curve data

Automatically generated by python-semantic-release

.gitlab-ci.yml

@@ -154,7 +154,6 @@ test-matrix:
           - "3.12"
         QT_PCKG:
           - "pyside6"
-          - "pyqt5"
           - "pyqt6"
 
   stage: AdditionalTests

.pylintrc

@@ -3,7 +3,7 @@
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
 # run arbitrary code.
-extension-pkg-allow-list=PyQt5, pyqtgraph
+extension-pkg-allow-list=PyQt6, PySide6, pyqtgraph
 
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may

CHANGELOG.md

@@ -1,5 +1,73 @@
 # CHANGELOG
 
+## v0.81.0 (2024-07-06)
+
+### Feature
+
+* feat(color_button): can get colors in RGBA or HEX ([`9594be2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9594be260680d11c8550ff74ffb8d679e5a5b8f6))
+
+## v0.80.1 (2024-07-06)
+
+### Fix
+
+* fix(entry_validator): check for entry == "" ([`61de7e9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/61de7e9e221c766b9fb3ec23246da6a11c96a986))
+
+## v0.80.0 (2024-07-06)
+
+### Feature
+
+* feat(qt5): dropped support for qt5; pyside2 and pyqt5 ([`fadbf77`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fadbf77866903beff6580802bc203d53367fc7e7))
+
+* feat(plugins): moved plugin dict to dataclass and container ([`03819a3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/03819a3d902b4a51f3e882d52aedd971b2a8e127))
+
+* feat(plugins): added support for pyqt6 ui files ([`d6d0777`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d6d07771135335cb78dc648508ce573b8970261a))
+
+* feat(plugins): added bec widgets base class ([`1aa83e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1aa83e0ef1ffe45b01677b0b4590535cb0ca1cff))
+
+## v0.79.3 (2024-07-05)
+
+### Fix
+
+* fix: changed inheritance to adress qt designer bug in rendering ([`e403870`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e403870874bd5e45840a034d6f1b3dd576d9c846))
+
+* fix: add designer plugin classes ([`1586ce2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1586ce2d6cba2bb086b2ef596e724bb9e40ab4f2))
+
+### Refactor
+
+* refactor: simplify logic in bec_status_box ([`576353c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/576353cfe8c6fd64db561f0b6e2bc951300643d3))
+
+## v0.79.2 (2024-07-04)
+
+### Fix
+
+* fix: overwrite closeEvent and call super class ([`bc0ef78`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/bc0ef7893ef100b71b62101c459655509b534a56))
+
+## v0.79.1 (2024-07-03)
+
+### Fix
+
+* fix: use libdir env var to preload Python library, also for Linux platform ([`d7718d4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d7718d4dcb9728c050b6421388af4d484f3741f2))
+
+## v0.79.0 (2024-07-03)
+
+### Feature
+
+* feat(motor_map_widget): standalone MotorMap Widget with toolbar + plugin ([`6e75642`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6e756420907d7093557e945bc92bc4cfc0138d07))
+
+* feat(motor_map): method to reset history trace ([`5960918`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5960918137dd41cdeb94e50f8abc4f169cf45c11))
+
+### Fix
+
+* fix(toolbar): change default color to black to match BECFigure theme ([`b8774e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b8774e0b0bc43dcd00f94f42539a778e507ca27d))
+
+* fix(motor_map): fixed bug with residual trace after changing motors ([`aaa0d10`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/aaa0d1003d2e94b45bafe4f700852c2c05288aea))
+
+* fix(widget_io): widget handler adjusted for spinboxes and comboboxes ([`3dc0532`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3dc0532df05b6ec0a2522107fa0b1e210ce7d91b))
+
+### Refactor
+
+* refactor(toolbar): cleanup and adjusted colors ([`96863ad`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/96863adf53c15112645d20eb6200733617801c6d))
+
 ## v0.78.1 (2024-07-02)
 
 ### Fix
@@ -73,79 +141,3 @@
 ### Feature
 
 * feat(widgets): added simple bec queue widget ([`3faee98`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3faee98ec80041a27e4c1f1156178de6f9dcdc63))
-
-### Refactor
-
-* refactor(dispatcher): cleanup ([`ca02132`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ca02132c8d18535b37e9192e00459d2aca6ba5cf))
-
-## v0.74.1 (2024-06-26)
-
-### Build
-
-* build: added missing pytest-bec-e2e dependency; closes #219 ([`56fdae4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/56fdae42757bdb9fa301c1e425a77e98b6eaf92b))
-
-* build: fixed dependency ranges; closes #135 ([`e6a06c9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e6a06c9f43e0ad6bbfcfa550a2f580d2a27aff66))
-
-### Chore
-
-* chore: sorted dependencies alphabetically ([`21c807f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/21c807f35831fdd1ef2e488ab90edae4719f0cb7))
-
-### Documentation
-
-* docs: fixed doc string ([`f979a63`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f979a63d3d1a008f80e500510909750878ff4303))
-
-### Fix
-
-* fix(rings): rings properties updated right after setting ([`c8b7367`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c8b7367815b095f8e4aa8b819481efb701f2e542))
-
-* fix(motor_map): motor map can be removed from BECFigure with .remove() ([`6b25abf`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6b25abff70280271e2eeb70450553c05d4b7c99c))
-
-### Test
-
-* test(bec_figure): tests for removing widgets with rpc e2e ([`a268caa`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a268caaa30711fcc7ece542d24578d74cbf65c77))
-
-## v0.74.0 (2024-06-25)
-
-### Documentation
-
-* docs(becfigure): docs added ([`a51b15d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a51b15da3f5e83e0c897a0342bdb05b9c677a179))
-
-### Feature
-
-* feat(waveform1d): dap LMFit model can be added to plot ([`1866ba6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1866ba66c8e3526661beb13fff3e13af6a0ae562))
-
-### Test
-
-* test(waveform1d): dap e2e test added ([`7271b42`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7271b422f98ef9264970d708811c414b69a644db))
-
-## v0.73.2 (2024-06-25)
-
-### Fix
-
-* fix(vscode): only run terminate if the process is still alive ([`7120f3e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7120f3e93b054b788f15e2d5bcd688e3c140c1ce))
-
-* fix(rpc): trigger shutdown of server when gui is terminated ([`acc1318`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/acc13183e28030e3ca9af21bb081e1eed081622b))
-
-* fix(rpc): remove of calling "close" and waiting for gui_is_alive ([`f75fc19`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f75fc19c5b10022763252917ca473f404a25165a))
-
-## v0.73.1 (2024-06-25)
-
-### Fix
-
-* fix(ringprogressbar): removed hard-coded endpoint strings ([`1de3cbf`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1de3cbf65a1832150917a7549a1bf3efdee6371a))
-
-## v0.73.0 (2024-06-25)
-
-### Feature
-
-* feat: add new default scaling of image_item ([`df812ea`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/df812eaad5989f2930dde41d87491868505af946))
-
-### Test
-
-* test: add test for imageitem ([`88ecd05`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/88ecd05b95974938ef1efff40e81854baf004cb4))
-
-## v0.72.2 (2024-06-25)
-
-### Fix
-
-* fix(designer): fixed designer for pyenv and venv; closes #237 ([`e631fc1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e631fc15d8707b73d58cb64316e115a7e43961ea))

README.md

@@ -17,7 +17,7 @@ cd bec_widgets
 pip install -e .[dev,pyqt6]
 ```
 
-BEC Widgets currently supports both PyQt5 and PyQt6, however, no default distribution is specified. As a result, users must install one of the supported
+BEC Widgets currently supports both Pyside6 and PyQt6, however, no default distribution is specified. As a result, users must install one of the supported
 Python Qt distributions manually.
 
 To select a specific Python Qt distribution, install the package with an additional tag:
@@ -28,7 +28,7 @@ pip install bec_widgets[pyqt6]
 or 
 
 ```bash
-pip install bec_widgets[pyqt5]
+pip install bec_widgets[pyside6]
 ```
 ## Documentation
 

bec_widgets/cli/client.py

@@ -13,11 +13,12 @@ class Widgets(str, enum.Enum):
     Enum for the available widgets.
     """
 
-    BECQueue = "BECQueue"
-    BECStatusBox = "BECStatusBox"
     BECDock = "BECDock"
     BECDockArea = "BECDockArea"
     BECFigure = "BECFigure"
+    BECMotorMapWidget = "BECMotorMapWidget"
+    BECQueue = "BECQueue"
+    BECStatusBox = "BECStatusBox"
     RingProgressBar = "RingProgressBar"
     ScanControl = "ScanControl"
     TextBox = "TextBox"
@@ -1192,6 +1193,7 @@ class BECMotorMap(RPCBase):
     def get_data(self) -> "dict":
         """
         Get the data of the motor map.
+
         Returns:
             dict: Data of the motor map.
         """
@@ -1202,6 +1204,94 @@ class BECMotorMap(RPCBase):
         Remove the plot widget from the figure.
         """
 
+    @rpc_call
+    def reset_history(self):
+        """
+        Reset the history of the motor map.
+        """
+
+
+class BECMotorMapWidget(RPCBase):
+    @rpc_call
+    def change_motors(
+        self,
+        motor_x: "str",
+        motor_y: "str",
+        motor_x_entry: "str" = None,
+        motor_y_entry: "str" = None,
+        validate_bec: "bool" = True,
+    ) -> "None":
+        """
+        Change the active motors for the plot.
+
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            motor_x_entry(str): Motor entry for the X axis.
+            motor_y_entry(str): Motor entry for the Y axis.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        """
+
+    @rpc_call
+    def set_max_points(self, max_points: "int") -> "None":
+        """
+        Set the maximum number of points to display on the motor map.
+
+        Args:
+            max_points(int): Maximum number of points to display.
+        """
+
+    @rpc_call
+    def set_precision(self, precision: "int") -> "None":
+        """
+        Set the precision of the motor map.
+
+        Args:
+            precision(int): Precision to set.
+        """
+
+    @rpc_call
+    def set_num_dim_points(self, num_dim_points: "int") -> "None":
+        """
+        Set the number of points to display on the motor map.
+
+        Args:
+            num_dim_points(int): Number of points to display.
+        """
+
+    @rpc_call
+    def set_background_value(self, background_value: "int") -> "None":
+        """
+        Set the background value of the motor map.
+
+        Args:
+            background_value(int): Background value of the motor map.
+        """
+
+    @rpc_call
+    def set_scatter_size(self, scatter_size: "int") -> "None":
+        """
+        Set the scatter size of the motor map.
+
+        Args:
+            scatter_size(int): Scatter size of the motor map.
+        """
+
+    @rpc_call
+    def get_data(self) -> "dict":
+        """
+        Get the data of the motor map.
+
+        Returns:
+            dict: Data of the motor map.
+        """
+
+    @rpc_call
+    def reset_history(self) -> "None":
+        """
+        Reset the history of the motor map.
+        """
+
 
 class BECPlotBase(RPCBase):
     @property

bec_widgets/cli/generate_cli.py

@@ -5,13 +5,12 @@ import argparse
 import inspect
 import os
 import sys
-from typing import Literal
 
 import black
 import isort
 
 from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator
-from bec_widgets.utils.plugin_utils import get_rpc_classes
+from bec_widgets.utils.plugin_utils import BECClassContainer, get_rpc_classes
 
 if sys.version_info >= (3, 11):
     from typing import get_overloads
@@ -40,17 +39,20 @@ from bec_widgets.cli.client_utils import RPCBase, rpc_call, BECGuiClientMixin
 
         self.content = ""
 
-    def generate_client(
-        self, published_classes: dict[Literal["connector_classes", "top_level_classes"], list[type]]
-    ):
+    def generate_client(self, class_container: BECClassContainer):
         """
         Generate the client for the published classes.
 
         Args:
-            published_classes(dict): A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
+            class_container: The class container with the classes to generate the client for.
         """
-        self.write_client_enum(published_classes["top_level_classes"])
-        for cls in published_classes["connector_classes"]:
+        rpc_top_level_classes = class_container.rpc_top_level_classes
+        rpc_top_level_classes.sort(key=lambda x: x.__name__)
+        connector_classes = class_container.connector_classes
+        connector_classes.sort(key=lambda x: x.__name__)
+
+        self.write_client_enum(rpc_top_level_classes)
+        for cls in connector_classes:
             self.content += "\n\n"
             self.generate_content_for_class(cls)
 
@@ -156,13 +158,12 @@ def main():
         client_path = os.path.join(current_path, "client.py")
 
         rpc_classes = get_rpc_classes("bec_widgets")
-        rpc_classes["connector_classes"].sort(key=lambda x: x.__name__)
 
         generator = ClientGenerator()
         generator.generate_client(rpc_classes)
         generator.write(client_path)
 
-        for cls in rpc_classes["top_level_classes"]:
+        for cls in rpc_classes.plugins:
             plugin = DesignerPluginGenerator(cls)
             if not hasattr(plugin, "info"):
                 continue

bec_widgets/cli/rpc_wigdet_handler.py

@@ -29,7 +29,7 @@ class RPCWidgetHandler:
         from bec_widgets.utils.plugin_utils import get_rpc_classes
 
         clss = get_rpc_classes("bec_widgets")
-        self._widget_classes = {cls.__name__: cls for cls in clss["top_level_classes"]}
+        self._widget_classes = {cls.__name__: cls for cls in clss.top_level_classes}
 
     def create_widget(self, widget_type, **kwargs) -> BECConnector:
         """

bec_widgets/utils/bec_connector.py

@@ -13,6 +13,7 @@ from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
 from qtpy.QtCore import Slot as pyqtSlot
 
 from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui
 
 BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
@@ -63,7 +64,7 @@ class Worker(QRunnable):
         self.signals.completed.emit()
 
 
-class BECConnector:
+class BECConnector(BECWidget):
     """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
 
     USER_ACCESS = ["_config_dict", "_get_all_rpc"]

bec_widgets/utils/bec_designer.py

@@ -73,26 +73,28 @@ def patch_designer():  # pragma: no cover
     os.environ["PY_MAJOR_VERSION"] = str(major_version)
     os.environ["PY_MINOR_VERSION"] = str(minor_version)
 
-    if sys.platform == "linux":
+    if sys.platform == "win32":
+        if is_virtual_env():
+            _extend_path_var("PATH", os.fspath(Path(sys._base_executable).parent), True)
+    else:
+        if sys.platform == "linux":
+            suffix = f"{sys.abiflags}.so"
+            env_var = "LD_PRELOAD"
+        elif sys.platform == "darwin":
+            suffix = ".dylib"
+            env_var = "DYLD_INSERT_LIBRARIES"
+        else:
+            raise RuntimeError(f"Unsupported platform: {sys.platform}")
         version = f"{major_version}.{minor_version}"
-        library_name = f"libpython{version}{sys.abiflags}.so"
-        if is_pyenv_python():
-            library_name = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
-        os.environ["LD_PRELOAD"] = library_name
-    elif sys.platform == "darwin":
-        library_name = f"libpython{major_version}.{minor_version}.dylib"
+        library_name = f"libpython{version}{suffix}"
         lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
-        os.environ["DYLD_INSERT_LIBRARIES"] = lib_path
+        os.environ[env_var] = lib_path
 
         if is_pyenv_python() or is_virtual_env():
             # append all editable packages to the PYTHONPATH
             editable_packages = list_editable_packages()
             for pckg in editable_packages:
                 _extend_path_var("PYTHONPATH", pckg, True)
-    elif sys.platform == "win32":
-        if is_virtual_env():
-            _extend_path_var("PATH", os.fspath(Path(sys._base_executable).parent), True)
-
     qt_tool_wrapper(ui_tool_binary("designer"), sys.argv[1:])
 
 

bec_widgets/utils/bec_dispatcher.py

@@ -8,7 +8,7 @@ import redis
 from bec_lib.client import BECClient
 from bec_lib.redis_connector import MessageObject, RedisConnector
 from bec_lib.service_config import ServiceConfig
-from qtpy.QtCore import PYQT5, PYQT6, PYSIDE2, PYSIDE6, QCoreApplication, QObject
+from qtpy.QtCore import PYQT6, PYSIDE6, QCoreApplication, QObject
 from qtpy.QtCore import Signal as pyqtSignal
 
 if TYPE_CHECKING:
@@ -127,14 +127,17 @@ class BECDispatcher:
             return
 
         # shutdown QCoreApp if it exists
-        if PYQT5 or PYQT6:
+        if PYQT6:
             cls.qapp.exit()
-        elif PYSIDE2 or PYSIDE6:
+        elif PYSIDE6:
             cls.qapp.shutdown()
         cls.qapp = None
 
     def connect_slot(
-        self, slot: Callable, topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]]
+        self,
+        slot: Callable,
+        topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]],
+        **kwargs,
     ) -> None:
         """Connect widget's pyqt slot, so that it is called on new pub/sub topic message.
 
@@ -144,7 +147,7 @@ class BECDispatcher:
             topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
         """
         slot = QtThreadSafeCallback(slot)
-        self.client.connector.register(topics, cb=slot)
+        self.client.connector.register(topics, cb=slot, **kwargs)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
         self._slots[slot].update(set(topics_str))
 

bec_widgets/utils/bec_widget.py

@@ -0,0 +1,2 @@
+class BECWidget:
+    """Base class for all BEC widgets."""

bec_widgets/utils/entry_validator.py

@@ -19,7 +19,7 @@ class EntryValidator:
         device = self.devices[name]
         description = device.describe()
 
-        if entry is None:
+        if entry is None or entry == "":
             entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
         if entry not in description:
             raise ValueError(f"Entry '{entry}' not found in device '{name}' signals")

bec_widgets/utils/plugin_utils.py

@@ -1,12 +1,13 @@
 import importlib
 import inspect
 import os
-from typing import Literal
+from dataclasses import dataclass
 
 from bec_lib.plugin_helper import _get_available_plugins
 from qtpy.QtWidgets import QGraphicsWidget, QWidget
 
 from bec_widgets.utils import BECConnector
+from bec_widgets.utils.bec_widget import BECWidget
 
 
 def get_plugin_widgets() -> dict[str, BECConnector]:
@@ -44,9 +45,74 @@ def _filter_plugins(obj):
     return inspect.isclass(obj) and issubclass(obj, BECConnector)
 
 
-def get_rpc_classes(
-    repo_name: str,
-) -> dict[Literal["connector_classes", "top_level_classes"], list[type]]:
+@dataclass
+class BECClassInfo:
+    name: str
+    module: str
+    file: str
+    obj: type
+    is_connector: bool = False
+    is_widget: bool = False
+    is_top_level: bool = False
+
+
+class BECClassContainer:
+    def __init__(self):
+        self._collection = []
+
+    def add_class(self, class_info: BECClassInfo):
+        """
+        Add a class to the collection.
+
+        Args:
+            class_info(BECClassInfo): The class information
+        """
+        self.collection.append(class_info)
+
+    @property
+    def collection(self):
+        """
+        Get the collection of classes.
+        """
+        return self._collection
+
+    @property
+    def connector_classes(self):
+        """
+        Get all connector classes.
+        """
+        return [info.obj for info in self.collection if info.is_connector]
+
+    @property
+    def top_level_classes(self):
+        """
+        Get all top-level classes.
+        """
+        return [info.obj for info in self.collection if info.is_top_level]
+
+    @property
+    def plugins(self):
+        """
+        Get all plugins. These are all classes that are on the top level and are widgets.
+        """
+        return [info.obj for info in self.collection if info.is_widget and info.is_top_level]
+
+    @property
+    def widgets(self):
+        """
+        Get all widgets. These are all classes inheriting from BECWidget.
+        """
+        return [info.obj for info in self.collection if info.is_widget]
+
+    @property
+    def rpc_top_level_classes(self):
+        """
+        Get all top-level classes that are RPC-enabled. These are all classes that users can choose from.
+        """
+        return [info.obj for info in self.collection if info.is_top_level and info.is_connector]
+
+
+def get_rpc_classes(repo_name: str) -> BECClassContainer:
     """
     Get all RPC-enabled classes in the specified repository.
 
@@ -56,8 +122,7 @@ def get_rpc_classes(
     Returns:
         dict: A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
     """
-    connector_classes = []
-    top_level_classes = []
+    collection = BECClassContainer()
     anchor_module = importlib.import_module(f"{repo_name}.widgets")
     directory = os.path.dirname(anchor_module.__file__)
     for root, _, files in sorted(os.walk(directory)):
@@ -78,11 +143,16 @@ def get_rpc_classes(
                 obj = getattr(module, name)
                 if not hasattr(obj, "__module__") or obj.__module__ != module.__name__:
                     continue
-                if isinstance(obj, type) and issubclass(obj, BECConnector):
-                    connector_classes.append(obj)
+                if isinstance(obj, type):
+                    class_info = BECClassInfo(name=name, module=module_name, file=path, obj=obj)
+                    if issubclass(obj, BECConnector):
+                        class_info.is_connector = True
+                    if issubclass(obj, BECWidget):
+                        class_info.is_widget = True
                     if len(subs) == 1 and (
                         issubclass(obj, QWidget) or issubclass(obj, QGraphicsWidget)
                     ):
-                        top_level_classes.append(obj)
+                        class_info.is_top_level = True
+                    collection.add_class(class_info)
 
-    return {"connector_classes": connector_classes, "top_level_classes": top_level_classes}
+    return collection

bec_widgets/utils/ui_loader.py

@@ -1,20 +1,18 @@
+import os
+
 from qtpy import PYQT6, PYSIDE6, QT_VERSION
 from qtpy.QtCore import QFile, QIODevice
 
+from bec_widgets.utils.generate_designer_plugin import DesignerPluginInfo
+from bec_widgets.utils.plugin_utils import get_rpc_classes
+
 if PYSIDE6:
     from PySide6.QtUiTools import QUiLoader
 
-    from bec_widgets.utils.plugin_utils import get_rpc_classes
-    from bec_widgets.widgets.buttons.color_button.color_button import ColorButton
-
     class CustomUiLoader(QUiLoader):
-        def __init__(self, baseinstance):
+        def __init__(self, baseinstance, custom_widgets: dict = None):
             super().__init__(baseinstance)
-            widgets = get_rpc_classes("bec_widgets").get("top_level_classes", [])
-
-            widgets.append(ColorButton)
-
-            self.custom_widgets = {widget.__name__: widget for widget in widgets}
+            self.custom_widgets = custom_widgets or {}
 
             self.baseinstance = baseinstance
 
@@ -27,25 +25,21 @@ if PYSIDE6:
 
 
 class UILoader:
-    """Universal UI loader for PyQt5, PyQt6, PySide2, and PySide6."""
+    """Universal UI loader for PyQt6 and PySide6."""
 
     def __init__(self, parent=None):
         self.parent = parent
-        if QT_VERSION.startswith("5"):
-            # PyQt5 or PySide2
-            from qtpy import uic
 
-            self.loader = uic.loadUi
-        elif QT_VERSION.startswith("6"):
-            # PyQt6 or PySide6
-            if PYSIDE6:
-                self.loader = self.load_ui_pyside6
-            elif PYQT6:
-                from PyQt6.uic import loadUi
+        widgets = get_rpc_classes("bec_widgets").top_level_classes
 
-                self.loader = loadUi
-            else:
-                raise ImportError("No compatible Qt bindings found.")
+        self.custom_widgets = {widget.__name__: widget for widget in widgets}
+
+        if PYSIDE6:
+            self.loader = self.load_ui_pyside6
+        elif PYQT6:
+            self.loader = self.load_ui_pyqt6
+        else:
+            raise ImportError("No compatible Qt bindings found.")
 
     def load_ui_pyside6(self, ui_file, parent=None):
         """
@@ -58,7 +52,7 @@ class UILoader:
             QWidget: The loaded widget.
         """
 
-        loader = CustomUiLoader(parent)
+        loader = CustomUiLoader(parent, self.custom_widgets)
         file = QFile(ui_file)
         if not file.open(QIODevice.ReadOnly):
             raise IOError(f"Cannot open file: {ui_file}")
@@ -66,6 +60,71 @@ class UILoader:
         file.close()
         return widget
 
+    def load_ui_pyqt6(self, ui_file, parent=None):
+        """
+        Specific loader for PyQt6 using loadUi.
+        Args:
+            ui_file(str): Path to the .ui file.
+            parent(QWidget): Parent widget.
+
+        Returns:
+            QWidget: The loaded widget.
+        """
+        from PyQt6.uic.Loader.loader import DynamicUILoader
+
+        class CustomDynamicUILoader(DynamicUILoader):
+            def __init__(self, package, custom_widgets: dict = None):
+                super().__init__(package)
+                self.custom_widgets = custom_widgets or {}
+
+            def _handle_custom_widgets(self, el):
+                """Handle the <customwidgets> element."""
+
+                def header2module(header):
+                    """header2module(header) -> string
+
+                    Convert paths to C++ header files to according Python modules
+                    >>> header2module("foo/bar/baz.h")
+                    'foo.bar.baz'
+                    """
+
+                    if header.endswith(".h"):
+                        header = header[:-2]
+
+                    mpath = []
+                    for part in header.split("/"):
+                        # Ignore any empty parts or those that refer to the current
+                        # directory.
+                        if part not in ("", "."):
+                            if part == "..":
+                                # We should allow this for Python3.
+                                raise SyntaxError(
+                                    "custom widget header file name may not contain '..'."
+                                )
+
+                            mpath.append(part)
+
+                    return ".".join(mpath)
+
+                for custom_widget in el:
+                    classname = custom_widget.findtext("class")
+                    header = custom_widget.findtext("header")
+                    if header:
+                        header = self._translate_bec_widgets_header(header)
+                    self.factory.addCustomWidget(
+                        classname,
+                        custom_widget.findtext("extends") or "QWidget",
+                        header2module(header),
+                    )
+
+            def _translate_bec_widgets_header(self, header):
+                for name, value in self.custom_widgets.items():
+                    if header == DesignerPluginInfo.pascal_to_snake(name):
+                        return value.__module__
+                return header
+
+        return CustomDynamicUILoader("", self.custom_widgets).loadUi(ui_file, parent)
+
     def load_ui(self, ui_file, parent=None):
         """
         Universal UI loader method.

bec_widgets/utils/widget_io.py

@@ -44,8 +44,11 @@ class ComboBoxHandler(WidgetHandler):
     def get_value(self, widget: QComboBox) -> int:
         return widget.currentIndex()
 
-    def set_value(self, widget: QComboBox, value: int) -> None:
-        widget.setCurrentIndex(value)
+    def set_value(self, widget: QComboBox, value: int | str) -> None:
+        if isinstance(value, str):
+            value = widget.findText(value)
+        if isinstance(value, int):
+            widget.setCurrentIndex(value)
 
 
 class TableWidgetHandler(WidgetHandler):
@@ -142,6 +145,26 @@ class WidgetIO:
         elif not ignore_errors:
             raise ValueError(f"No handler for widget type: {type(widget)}")
 
+    @staticmethod
+    def check_and_adjust_limits(spin_box: QDoubleSpinBox, number: float):
+        """
+        Check if the new limits are within the current limits, if not adjust the limits.
+
+        Args:
+            number(float): The new value to check against the limits.
+        """
+
+        min_value = spin_box.minimum()
+        max_value = spin_box.maximum()
+
+        # Calculate the new limits
+        new_limit = number + 5 * number
+
+        if number < min_value:
+            spin_box.setMinimum(new_limit)
+        elif number > max_value:
+            spin_box.setMaximum(new_limit)
+
     @staticmethod
     def _find_handler(widget):
         """

bec_widgets/widgets/bec_status_box/bec_status_box.py

@@ -5,15 +5,16 @@ The widget automatically updates the status of all running BEC services, and dis
 from __future__ import annotations
 
 import sys
+from collections import defaultdict
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 import qdarktheme
 from bec_lib.utils.import_utils import lazy_import_from
-from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import QObject, QTimer, Signal, Slot
-from qtpy.QtWidgets import QTreeWidget, QTreeWidgetItem
+from qtpy.QtWidgets import QHBoxLayout, QTreeWidget, QTreeWidgetItem, QWidget
 
-from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
+from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.widgets.bec_status_box.status_item import StatusItem
 
 if TYPE_CHECKING:
@@ -23,45 +24,18 @@ if TYPE_CHECKING:
 BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
 
 
-class BECStatusBoxConfig(ConnectionConfig):
-    pass
-
-
-class BECServiceInfoContainer(BaseModel):
+@dataclass
+class BECServiceInfoContainer:
     """Container to store information about the BEC services."""
 
     service_name: str
-    status: BECStatus | str = Field(
-        default="NOTCONNECTED",
-        description="The status of the service. Can be any of the BECStatus names, or NOTCONNECTED.",
-    )
+    status: str
     info: dict
     metrics: dict | None
-    model_config: dict = {"validate_assignment": True}
-
-    @field_validator("status")
-    @classmethod
-    def validate_status(cls, v):
-        """Validate input for status. Accept BECStatus and NOTCONNECTED.
-
-        Args:
-            v (BECStatus | str): The input value.
-
-        Returns:
-            str: The validated status.
-        """
-        if v in list(BECStatus.__members__.values()):
-            return v.name
-        if v in list(BECStatus.__members__.keys()) or v == "NOTCONNECTED":
-            return v
-        raise ValueError(
-            f"Status must be one of {BECStatus.__members__.values()} or 'NOTCONNECTED'. Input {v}"
-        )
 
 
 class BECServiceStatusMixin(QObject):
-    """A mixin class to update the service status, and metrics.
-    It emits a signal 'services_update' when the service status is updated.
+    """Mixin to receive the latest service status from the BEC server and emit it via services_update signal.
 
     Args:
         client (BECClient): The client object to connect to the BEC server.
@@ -69,29 +43,26 @@ class BECServiceStatusMixin(QObject):
 
     services_update = Signal(dict, dict)
 
-    def __init__(self, client: BECClient):
-        super().__init__()
+    def __init__(self, parent, client: BECClient):
+        super().__init__(parent)
         self.client = client
         self._service_update_timer = QTimer()
         self._service_update_timer.timeout.connect(self._get_service_status)
         self._service_update_timer.start(1000)
 
     def _get_service_status(self):
-        """Pull latest service and metrics updates from REDIS for all services, and emit both via 'services_update' signal."""
+        """Get the latest service status from the BEC server."""
         # pylint: disable=protected-access
         self.client._update_existing_services()
         self.services_update.emit(self.client._services_info, self.client._services_metric)
 
 
-class BECStatusBox(BECConnector, QTreeWidget):
-    """A widget to display the status of different BEC services.
-    This widget automatically updates the status of all running BEC services, and displays their status.
-    Information about the individual services is collapsible, and double clicking on
-    the individual service will display the metrics about the service.
+class BECStatusBox(BECConnector, QWidget):
+    """An autonomous widget to display the status of BEC services.
 
     Args:
         parent Optional : The parent widget for the BECStatusBox. Defaults to None.
-        service_name Optional(str): The name of the top service label. Defaults to "BEC Server".
+        box_name Optional(str): The name of the top service label. Defaults to "BEC Server".
         client Optional(BECClient): The client object to connect to the BEC server. Defaults to None
         config Optional(BECStatusBoxConfig | dict): The configuration for the status box. Defaults to None.
         gui_id Optional(str): The unique id for the widget. Defaults to None.
@@ -99,58 +70,67 @@ class BECStatusBox(BECConnector, QTreeWidget):
 
     CORE_SERVICES = ["DeviceServer", "ScanServer", "SciHub", "ScanBundler", "FileWriterManager"]
 
-    service_update = Signal(dict)
+    service_update = Signal(BECServiceInfoContainer)
     bec_core_state = Signal(str)
 
     def __init__(
         self,
         parent=None,
-        service_name: str = "BEC Server",
+        box_name: str = "BEC Server",
         client: BECClient = None,
-        config: BECStatusBoxConfig | dict = None,
         bec_service_status_mixin: BECServiceStatusMixin = None,
         gui_id: str = None,
     ):
-        if config is None:
-            config = BECStatusBoxConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = BECStatusBoxConfig(**config)
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QTreeWidget.__init__(self, parent=parent)
+        super().__init__(client=client, gui_id=gui_id)
+        QWidget.__init__(self, parent=parent)
+        self.tree = QTreeWidget(self)
+        self.layout = QHBoxLayout(self)
 
-        self.service_name = service_name
-        self.config = config
-
-        self.bec_service_info_container = {}
-        self.tree_items = {}
-        self.tree_top_item = None
+        self.box_name = box_name
+        self.status_container = defaultdict(lambda: {"info": None, "item": None, "widget": None})
 
         if not bec_service_status_mixin:
-            bec_service_status_mixin = BECServiceStatusMixin(client=self.client)
+            bec_service_status_mixin = BECServiceStatusMixin(self, client=self.client)
         self.bec_service_status = bec_service_status_mixin
 
         self.init_ui()
         self.bec_service_status.services_update.connect(self.update_service_status)
         self.bec_core_state.connect(self.update_top_item_status)
-        self.itemDoubleClicked.connect(self.on_tree_item_double_clicked)
+        self.tree.itemDoubleClicked.connect(self.on_tree_item_double_clicked)
+        self.layout.addWidget(self.tree)
 
     def init_ui(self) -> None:
-        """Initialize the UI for the status box, and add QTreeWidget as the basis for the status box."""
+        """Init the UI for the BECStatusBox widget, should only take place once."""
         self.init_ui_tree_widget()
-        top_label = self._create_status_widget(self.service_name, status=BECStatus.IDLE)
-        self.tree_top_item = QTreeWidgetItem()
-        self.tree_top_item.setExpanded(True)
-        self.tree_top_item.setDisabled(True)
-        self.addTopLevelItem(self.tree_top_item)
-        self.setItemWidget(self.tree_top_item, 0, top_label)
+        top_label = self._create_status_widget(self.box_name, status=BECStatus.IDLE)
+        tree_item = QTreeWidgetItem()
+        tree_item.setExpanded(True)
+        tree_item.setDisabled(True)
+        self.status_container[self.box_name].update({"item": tree_item, "widget": top_label})
+        self.tree.addTopLevelItem(tree_item)
+        self.tree.setItemWidget(tree_item, 0, top_label)
         self.service_update.connect(top_label.update_config)
+        self._initialized = True
+
+    def init_ui_tree_widget(self) -> None:
+        """Initialise the tree widget for the status box."""
+        self.tree.setHeaderHidden(True)
+        # TODO probably here is a problem still with setting the stylesheet
+        self.tree.setStyleSheet(
+            "QTreeWidget::item:!selected "
+            "{ "
+            "border: 1px solid gainsboro; "
+            "border-left: none; "
+            "border-top: none; "
+            "}"
+            "QTreeWidget::item:selected {}"
+        )
 
     def _create_status_widget(
         self, service_name: str, status=BECStatus, info: dict = None, metrics: dict = None
     ) -> StatusItem:
         """Creates a StatusItem (QWidget) for the given service, and stores all relevant
-        information about the service in the bec_service_info_container.
+        information about the service in the status_container.
 
         Args:
             service_name (str): The name of the service.
@@ -163,16 +143,8 @@ class BECStatusBox(BECConnector, QTreeWidget):
         """
         if info is None:
             info = {}
-        self._update_bec_service_container(service_name, status, info, metrics)
-        item = StatusItem(
-            parent=self,
-            config={
-                "service_name": service_name,
-                "status": status.name,
-                "info": info,
-                "metrics": metrics,
-            },
-        )
+        self._update_status_container(service_name, status, info, metrics)
+        item = StatusItem(parent=self, config=self.status_container[service_name]["info"])
         return item
 
     @Slot(str)
@@ -183,30 +155,35 @@ class BECStatusBox(BECConnector, QTreeWidget):
         Args:
             status (BECStatus): The state of the core services.
         """
-        self.bec_service_info_container[self.service_name].status = status
-        self.service_update.emit(self.bec_service_info_container[self.service_name].model_dump())
+        self.status_container[self.box_name]["info"].status = status
+        self.service_update.emit(self.status_container[self.box_name]["info"])
 
-    def _update_bec_service_container(
+    def _update_status_container(
         self, service_name: str, status: BECStatus, info: dict, metrics: dict = None
     ) -> None:
-        """Update the bec_service_info_container with the newest status and metrics for the BEC service.
+        """Update the status_container with the newest status and metrics for the BEC service.
         If information about the service already exists, it will create a new entry.
 
         Args:
             service_name (str): The name of the service.
-            service_info (StatusMessage): A class containing the service status.
-            service_metric (ServiceMetricMessage): A class containing the service metrics.
+            status (BECStatus): The status of the service.
+            info (dict): The information about the service.
+            metrics (dict): The metrics of the service.
         """
-        container = self.bec_service_info_container.get(service_name, None)
+        container = self.status_container[service_name].get("info", None)
+
         if container:
-            container.status = status
+            container.status = status.name
             container.info = info
             container.metrics = metrics
             return
         service_info_item = BECServiceInfoContainer(
-            service_name=service_name, status=status, info=info, metrics=metrics
+            service_name=service_name,
+            status=status.name if isinstance(status, BECStatus) else status,
+            info=info,
+            metrics=metrics,
         )
-        self.bec_service_info_container.update({service_name: service_info_item})
+        self.status_container[service_name].update({"info": service_info_item})
 
     @Slot(dict, dict)
     def update_service_status(self, services_info: dict, services_metric: dict) -> None:
@@ -217,7 +194,7 @@ class BECStatusBox(BECConnector, QTreeWidget):
             services_info (dict): A dictionary containing the service status for all running BEC services.
             services_metric (dict): A dictionary containing the service metrics for all running BEC services.
         """
-        checked = []
+        checked = [self.box_name]
         services_info = self.update_core_services(services_info, services_metric)
         checked.extend(self.CORE_SERVICES)
 
@@ -225,28 +202,19 @@ class BECStatusBox(BECConnector, QTreeWidget):
             checked.append(service_name)
             metric_msg = services_metric.get(service_name, None)
             metrics = metric_msg.metrics if metric_msg else None
-            if service_name in self.tree_items:
-                self._update_bec_service_container(
-                    service_name=service_name, status=msg.status, info=msg.info, metrics=metrics
-                )
-                self.service_update.emit(self.bec_service_info_container[service_name].model_dump())
+            if service_name in self.status_container:
+                if not msg:
+                    self.add_tree_item(service_name, "NOTCONNECTED", {}, metrics)
+                    continue
+                self._update_status_container(service_name, msg.status, msg.info, metrics)
+                self.service_update.emit(self.status_container[service_name]["info"])
                 continue
 
-            item_widget = self._create_status_widget(
-                service_name=service_name, status=msg.status, info=msg.info, metrics=metrics
-            )
-            item = QTreeWidgetItem()
-            item.setDisabled(True)
-            self.service_update.connect(item_widget.update_config)
-            self.tree_top_item.addChild(item)
-            self.setItemWidget(item, 0, item_widget)
-            self.tree_items.update({service_name: (item, item_widget)})
-
+            self.add_tree_item(service_name, msg.status, msg.info, metrics)
         self.check_redundant_tree_items(checked)
 
     def update_core_services(self, services_info: dict, services_metric: dict) -> dict:
-        """Method to process status and metrics updates of core services (stored in CORE_SERVICES).
-        If a core services is not connected, it should not be removed from the status widget
+        """Update the core services of BEC, and emit the updated status to the BECStatusBox.
 
         Args:
             services_info (dict): A dictionary containing the service status of different services.
@@ -255,28 +223,28 @@ class BECStatusBox(BECConnector, QTreeWidget):
         Returns:
             dict: The services_info dictionary after removing the info updates related to the CORE_SERVICES
         """
-        bec_core_state = "RUNNING"
+        core_state = BECStatus.RUNNING
         for service_name in sorted(self.CORE_SERVICES):
             metric_msg = services_metric.get(service_name, None)
             metrics = metric_msg.metrics if metric_msg else None
-            if service_name not in services_info:
-                self.bec_service_info_container[service_name].status = "NOTCONNECTED"
-                bec_core_state = "ERROR"
-            else:
-                msg = services_info.pop(service_name)
-                self._update_bec_service_container(
-                    service_name=service_name, status=msg.status, info=msg.info, metrics=metrics
-                )
-                bec_core_state = (
-                    "RUNNING" if (msg.status.value > 1 and bec_core_state == "RUNNING") else "ERROR"
-                )
-
-            if service_name in self.tree_items:
-                self.service_update.emit(self.bec_service_info_container[service_name].model_dump())
+            msg = services_info.pop(service_name, None)
+            if service_name not in self.status_container:
+                if not msg:
+                    self.add_tree_item(service_name, "NOTCONNECTED", {}, metrics)
+                    continue
+                self.add_tree_item(service_name, msg.status, msg.info, metrics)
                 continue
-            self.add_tree_item(service_name, msg.status, msg.info, metrics)
+            if not msg:
+                self.status_container[service_name]["info"].status = "NOTCONNECTED"
+                core_state = None
+            else:
+                self._update_status_container(service_name, msg.status, msg.info, metrics)
+                if core_state:
+                    core_state = msg.status if msg.status.value < core_state.value else core_state
 
-        self.bec_core_state.emit(bec_core_state)
+            self.service_update.emit(self.status_container[service_name]["info"])
+
+        self.bec_core_state.emit(core_state.name if core_state else "NOTCONNECTED")
         return services_info
 
     def check_redundant_tree_items(self, checked: list) -> None:
@@ -285,11 +253,12 @@ class BECStatusBox(BECConnector, QTreeWidget):
         Args:
             checked (list): A list of services that are currently running.
         """
-        to_be_deleted = [key for key in self.tree_items if key not in checked]
+        to_be_deleted = [key for key in self.status_container if key not in checked]
 
         for key in to_be_deleted:
-            item, _ = self.tree_items.pop(key)
-            self.tree_top_item.removeChild(item)
+            obj = self.status_container.pop(key)
+            item = obj["item"]
+            self.status_container[self.box_name]["item"].removeChild(item)
 
     def add_tree_item(
         self, service_name: str, status: BECStatus, info: dict = None, metrics: dict = None
@@ -298,30 +267,16 @@ class BECStatusBox(BECConnector, QTreeWidget):
 
         Args:
             service_name (str): The name of the service.
-            service_status_msg (StatusMessage): The status of the service.
+            status (BECStatus): The status of the service.
+            info (dict): The information about the service.
             metrics (dict): The metrics of the service.
         """
-        item_widget = self._create_status_widget(
-            service_name=service_name, status=status, info=info, metrics=metrics
-        )
+        item_widget = self._create_status_widget(service_name, status, info, metrics)
         item = QTreeWidgetItem()
         self.service_update.connect(item_widget.update_config)
-        self.tree_top_item.addChild(item)
-        self.setItemWidget(item, 0, item_widget)
-        self.tree_items.update({service_name: (item, item_widget)})
-
-    def init_ui_tree_widget(self) -> None:
-        """Initialise the tree widget for the status box."""
-        self.setHeaderHidden(True)
-        self.setStyleSheet(
-            "QTreeWidget::item:!selected "
-            "{ "
-            "border: 1px solid gainsboro; "
-            "border-left: none; "
-            "border-top: none; "
-            "}"
-            "QTreeWidget::item:selected {}"
-        )
+        self.status_container[self.box_name]["item"].addChild(item)
+        self.tree.setItemWidget(item, 0, item_widget)
+        self.status_container[service_name].update({"item": item, "widget": item_widget})
 
     @Slot(QTreeWidgetItem, int)
     def on_tree_item_double_clicked(self, item: QTreeWidgetItem, column: int) -> None:
@@ -331,13 +286,18 @@ class BECStatusBox(BECConnector, QTreeWidget):
             item (QTreeWidgetItem): The item that was double clicked.
             column (int): The column that was double clicked.
         """
-        for _, (tree_item, status_widget) in self.tree_items.items():
-            if tree_item == item:
-                status_widget.show_popup()
+        for _, objects in self.status_container.items():
+            if objects["item"] == item:
+                objects["widget"].show_popup()
 
     def closeEvent(self, event):
+        """Upon closing the widget, clean up the BECStatusBox and the QWidget.
+
+        Args:
+            event: The close event.
+        """
         super().cleanup()
-        QTreeWidget().closeEvent(event)
+        super().closeEvent(event)
 
 
 def main():

bec_widgets/widgets/bec_status_box/bec_status_box.pyproject

@@ -0,0 +1 @@
+{'files': ['bec_status_box.py']}

bec_widgets/widgets/bec_status_box/bec_status_box_plugin.py

@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.bec_status_box.bec_status_box import BECStatusBox
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECStatusBox' name='bec_status_box'>
+    </widget>
+</ui>
+"""
+
+
+class BECStatusBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECStatusBox(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "bec_status_box"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECStatusBox"
+
+    def toolTip(self):
+        return "An autonomous widget to display the status of BEC services."
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/bec_status_box/register_bec_status_box.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.bec_status_box.bec_status_box_plugin import BECStatusBoxPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECStatusBoxPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/bec_status_box/status_item.py

@@ -2,17 +2,12 @@
 The widget is bound to be used with the BECStatusBox widget."""
 
 import enum
-import sys
 from datetime import datetime
 
-import qdarktheme
 from bec_lib.utils.import_utils import lazy_import_from
-from pydantic import Field
 from qtpy.QtCore import Qt, Slot
 from qtpy.QtWidgets import QDialog, QHBoxLayout, QLabel, QStyle, QVBoxLayout, QWidget
 
-from bec_widgets.utils.bec_connector import ConnectionConfig
-
 # TODO : Put normal imports back when Pydantic gets faster
 BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
 
@@ -27,39 +22,29 @@ class IconsEnum(enum.Enum):
     NOTCONNECTED = "SP_TitleBarContextHelpButton"
 
 
-class StatusWidgetConfig(ConnectionConfig):
-    """Configuration class for the status item widget."""
-
-    service_name: str
-    status: str
-    info: dict
-    metrics: dict | None
-    icon_size: tuple = Field(default=(24, 24), description="The size of the icon in the widget.")
-    font_size: int = Field(16, description="The font size of the text in the widget.")
-
-
 class StatusItem(QWidget):
     """A widget to display the status of a service.
 
     Args:
         parent: The parent widget.
-        config (dict): The configuration for the service.
+        config (dict): The configuration for the service, must be a BECServiceInfoContainer.
     """
 
-    def __init__(self, parent=None, config: dict = None):
-        if config is None:
-            config = StatusWidgetConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = StatusWidgetConfig(**config)
-            self.config = config
+    def __init__(self, parent: QWidget = None, config=None):
         QWidget.__init__(self, parent=parent)
+        if config is None:
+            # needed because we need parent to be the first argument for QT Designer
+            raise ValueError(
+                "Please initialize the StatusItem with a BECServiceInfoContainer for config, received None."
+            )
+        self.config = config
         self.parent = parent
         self.layout = None
-        self.config = config
-        self._popup_label_ref = {}
         self._label = None
         self._icon = None
+        self.icon_size = (24, 24)
+
+        self._popup_label_ref = {}
         self.init_ui()
 
     def init_ui(self) -> None:
@@ -74,23 +59,21 @@ class StatusItem(QWidget):
         self.update_ui()
 
     @Slot(dict)
-    def update_config(self, config: dict) -> None:
-        """Update the configuration of the status item widget.
-        This method is invoked from the parent widget.
-        The UI values are later updated based on the new configuration.
+    def update_config(self, config) -> None:
+        """Update the config of the status item widget.
 
         Args:
-            config (dict): Config updates from parent widget.
+            config (dict): Config updates from parent widget, must be a BECServiceInfoContainer.
         """
-        if config["service_name"] != self.config.service_name:
+        if self.config is None or config.service_name != self.config.service_name:
             return
-        self.config.status = config["status"]
-        self.config.info = config["info"]
-        self.config.metrics = config["metrics"]
+        self.config = config
         self.update_ui()
 
     def update_ui(self) -> None:
         """Update the UI of the labels, and popup dialog."""
+        if self.config is None:
+            return
         self.set_text()
         self.set_status()
         self._set_popup_text()
@@ -99,8 +82,8 @@ class StatusItem(QWidget):
         """Set the text of the QLabel basae on the config."""
         service = self.config.service_name
         status = self.config.status
-        if "BECClient" in service.split("/"):
-            service = service.split("/")[0] + "/..." + service.split("/")[1][-4:]
+        if len(service.split("/")) > 1 and service.split("/")[0].startswith("BEC"):
+            service = service.split("/", maxsplit=1)[0] + "/..." + service.split("/")[1][-4:]
         if status == "NOTCONNECTED":
             status = "NOT CONNECTED"
         text = f"{service} is {status}"
@@ -110,7 +93,7 @@ class StatusItem(QWidget):
         """Set the status icon for the status item widget."""
         icon_name = IconsEnum[self.config.status].value
         icon = self.style().standardIcon(getattr(QStyle.StandardPixmap, icon_name))
-        self._icon.setPixmap(icon.pixmap(*self.config.icon_size))
+        self._icon.setPixmap(icon.pixmap(*self.icon_size))
         self._icon.setAlignment(Qt.AlignmentFlag.AlignRight)
 
     def show_popup(self) -> None:
@@ -153,19 +136,3 @@ class StatusItem(QWidget):
     def _cleanup_popup_label(self) -> None:
         """Cleanup the popup label."""
         self._popup_label_ref.clear()
-
-
-def main():
-    """Run the status item widget."""
-    # pylint: disable=import-outside-toplevel
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    qdarktheme.setup_theme("auto")
-    main_window = StatusItem()
-    main_window.show()
-    sys.exit(app.exec())
-
-
-if __name__ == "__main__":
-    main()

bec_widgets/widgets/buttons/color_button/color_button.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import Literal
+
 import pyqtgraph as pg
 
 
@@ -15,3 +19,18 @@ class ColorButton(pg.ColorButton):
         self.colorDialog.setCurrentColor(self.color())
         self.colorDialog.open()
         self.colorDialog.exec()
+
+    def get_color(self, format: Literal["RGBA", "HEX"] = "RGBA") -> tuple | str:
+        """
+        Get the color of the button in the specified format.
+
+        Args:
+            format(Literal["RGBA", "HEX"]): The format of the returned color.
+
+        Returns:
+            tuple|str: The color in the specified format.
+        """
+        if format == "RGBA":
+            return self.color().getRgb()
+        if format == "HEX":
+            return self.color().name()

bec_widgets/widgets/device_inputs/device_combobox/device_combobox.py

@@ -89,4 +89,4 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
 
     def closeEvent(self, event):
         super().cleanup()
-        QComboBox().closeEvent(event)
+        return QComboBox.closeEvent(self, event)

bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit.py

@@ -101,4 +101,4 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
 
     def closeEvent(self, event):
         super().cleanup()
-        QLineEdit().closeEvent(event)
+        return QLineEdit.closeEvent(self, event)

bec_widgets/widgets/figure/plots/axis_settings.py

@@ -0,0 +1,61 @@
+import os
+
+import qdarktheme
+from qtpy.QtCore import Slot
+from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.widget_io import WidgetIO
+
+
+class AxisSettings(QWidget):
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        current_path = os.path.dirname(__file__)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "axis_settings.ui"), self)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.ui)
+
+        # Hardcoded values for best appearance
+        self.setMinimumHeight(280)
+        self.setMaximumHeight(280)
+        self.resize(380, 280)
+
+    @Slot(dict)
+    def display_current_settings(self, axis_config: dict):
+        # Top Box
+        WidgetIO.set_value(self.ui.plot_title, axis_config["title"])
+
+        # X Axis Box
+        WidgetIO.set_value(self.ui.x_label, axis_config["x_label"])
+        WidgetIO.set_value(self.ui.x_scale, axis_config["x_scale"])
+        WidgetIO.set_value(self.ui.x_grid, axis_config["x_grid"])
+        if axis_config["x_lim"] is not None:
+            WidgetIO.check_and_adjust_limits(self.ui.x_min, axis_config["x_lim"][0])
+            WidgetIO.check_and_adjust_limits(self.ui.x_max, axis_config["x_lim"][1])
+            WidgetIO.set_value(self.ui.x_min, axis_config["x_lim"][0])
+            WidgetIO.set_value(self.ui.x_max, axis_config["x_lim"][1])
+
+        # Y Axis Box
+        WidgetIO.set_value(self.ui.y_label, axis_config["y_label"])
+        WidgetIO.set_value(self.ui.y_scale, axis_config["y_scale"])
+        WidgetIO.set_value(self.ui.y_grid, axis_config["y_grid"])
+        if axis_config["y_lim"] is not None:
+            WidgetIO.check_and_adjust_limits(self.ui.y_min, axis_config["y_lim"][0])
+            WidgetIO.check_and_adjust_limits(self.ui.y_max, axis_config["y_lim"][1])
+            WidgetIO.set_value(self.ui.y_min, axis_config["y_lim"][0])
+            WidgetIO.set_value(self.ui.y_max, axis_config["y_lim"][1])
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    qdarktheme.setup_theme("dark")
+    window = AxisSettings()
+    window.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/figure/plots/axis_settings.ui

@@ -0,0 +1,249 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+    <class>Form</class>
+    <widget class="QWidget" name="Form">
+        <property name="geometry">
+            <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>417</width>
+                <height>250</height>
+            </rect>
+        </property>
+        <property name="minimumSize">
+            <size>
+                <width>0</width>
+                <height>250</height>
+            </size>
+        </property>
+        <property name="maximumSize">
+            <size>
+                <width>16777215</width>
+                <height>278</height>
+            </size>
+        </property>
+        <property name="windowTitle">
+            <string>Form</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout">
+            <item row="0" column="0" colspan="3">
+                <layout class="QHBoxLayout" name="horizontalLayout">
+                    <item>
+                        <widget class="QLabel" name="plot_title_label">
+                            <property name="text">
+                                <string>Plot Title</string>
+                            </property>
+                        </widget>
+                    </item>
+                    <item>
+                        <widget class="QLineEdit" name="plot_title"/>
+                    </item>
+                </layout>
+            </item>
+            <item row="1" column="0" colspan="3">
+                <widget class="Line" name="line_H">
+                    <property name="orientation">
+                        <enum>Qt::Orientation::Horizontal</enum>
+                    </property>
+                </widget>
+            </item>
+            <item row="2" column="0">
+                <widget class="QGroupBox" name="x_axis_box">
+                    <property name="title">
+                        <string>X Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_4">
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="x_scale_label">
+                                <property name="text">
+                                    <string>Scale</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="x_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="x_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="x_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="2">
+                            <widget class="QComboBox" name="x_scale">
+                                <item>
+                                    <property name="text">
+                                        <string>linear</string>
+                                    </property>
+                                </item>
+                                <item>
+                                    <property name="text">
+                                        <string>log</string>
+                                    </property>
+                                </item>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="x_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="x_label"/>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="x_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="2">
+                            <widget class="QCheckBox" name="x_grid">
+                                <property name="text">
+                                    <string/>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="x_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+            <item row="2" column="1">
+                <widget class="Line" name="line_V">
+                    <property name="orientation">
+                        <enum>Qt::Orientation::Vertical</enum>
+                    </property>
+                </widget>
+            </item>
+            <item row="2" column="2">
+                <widget class="QGroupBox" name="y_axis_box">
+                    <property name="title">
+                        <string>Y Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_5">
+                        <item row="3" column="2">
+                            <widget class="QComboBox" name="y_scale">
+                                <item>
+                                    <property name="text">
+                                        <string>linear</string>
+                                    </property>
+                                </item>
+                                <item>
+                                    <property name="text">
+                                        <string>log</string>
+                                    </property>
+                                </item>
+                            </widget>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="y_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="y_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="y_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="y_label"/>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="y_scale_label">
+                                <property name="text">
+                                    <string>Scale</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="y_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="y_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="2">
+                            <widget class="QCheckBox" name="y_grid">
+                                <property name="text">
+                                    <string/>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="y_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+        </layout>
+    </widget>
+    <resources/>
+    <connections/>
+</ui>

bec_widgets/widgets/figure/plots/motor_map/motor_map.py

@@ -10,7 +10,7 @@ from pydantic import Field, ValidationError, field_validator
 from pydantic_core import PydanticCustomError
 from qtpy import QtCore, QtGui
 from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtCore import Slot
 from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils import Colors, EntryValidator
@@ -24,7 +24,7 @@ class MotorMapConfig(SubplotConfig):
         (255, 255, 255, 255), description="The color of the last point of current position."
     )
     scatter_size: Optional[int] = Field(5, description="Size of the scatter points.")
-    max_points: Optional[int] = Field(1000, description="Maximum number of points to display.")
+    max_points: Optional[int] = Field(5000, description="Maximum number of points to display.")
     num_dim_points: Optional[int] = Field(
         100,
         description="Number of points to dim before the color remains same for older recorded position.",
@@ -59,6 +59,7 @@ class BECMotorMap(BECPlotBase):
         "set_scatter_size",
         "get_data",
         "remove",
+        "reset_history",
     ]
 
     # QT Signals
@@ -120,7 +121,7 @@ class BECMotorMap(BECPlotBase):
                 motor_y_entry=self.config.signals.y.entry,
             )
 
-    @pyqtSlot(str, str, str, str, bool)
+    @Slot(str, str, str, str, bool)
     def change_motors(
         self,
         motor_x: str,
@@ -139,6 +140,8 @@ class BECMotorMap(BECPlotBase):
             motor_y_entry(str): Motor entry for the Y axis.
             validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
         """
+        self.plot_item.clear()
+
         motor_x_entry, motor_y_entry = self._validate_signal_entries(
             motor_x, motor_y, motor_x_entry, motor_y_entry, validate_bec
         )
@@ -164,13 +167,22 @@ class BECMotorMap(BECPlotBase):
     def get_data(self) -> dict:
         """
         Get the data of the motor map.
+
         Returns:
             dict: Data of the motor map.
         """
         data = {"x": self.database_buffer["x"], "y": self.database_buffer["y"]}
         return data
 
-    def set_color(self, color: [str | tuple]):
+    def reset_history(self):
+        """
+        Reset the history of the motor map.
+        """
+        self.database_buffer["x"] = [self.database_buffer["x"][-1]]
+        self.database_buffer["y"] = [self.database_buffer["y"][-1]]
+        self.update_signal.emit()
+
+    def set_color(self, color: str | tuple):
         """
         Set color of the motor trace.
 
@@ -428,6 +440,7 @@ class BECMotorMap(BECPlotBase):
             print(f"The device '{motor}' does not have defined limits.")
             return None
 
+    @Slot()
     def _update_plot(self):
         """Update the motor map plot."""
         # If the number of points exceeds max_points, delete the oldest points
@@ -477,7 +490,7 @@ class BECMotorMap(BECPlotBase):
             f"Motor position: ({round(float(current_x),precision)}, {round(float(current_y),precision)})"
         )
 
-    @pyqtSlot(dict)
+    @Slot(dict)
     def on_device_readback(self, msg: dict) -> None:
         """
         Update the motor map plot with the new motor position.

bec_widgets/widgets/figure/plots/waveform/waveform.py

@@ -7,6 +7,7 @@ from typing import Any, Literal, Optional
 import numpy as np
 import pyqtgraph as pg
 from bec_lib import messages
+from bec_lib.device import ReadoutPriority
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.scan_data import ScanData
 from pydantic import Field, ValidationError
@@ -327,7 +328,7 @@ class BECWaveform(BECPlotBase):
         color_map_z: Optional[str] = "plasma",
         label: Optional[str] = None,
         validate_bec: bool = True,
-        source: str = "scan_segment",
+        source: Optional[str] = None,
         dap: Optional[str] = None,
         **kwargs,
     ) -> BECCurve:
@@ -349,8 +350,6 @@ class BECWaveform(BECPlotBase):
         Returns:
             BECCurve: The curve object.
         """
-        # Check if curve already exists
-        curve_source = source
 
         # Get entry if not provided and validate
         x_entry, y_entry, z_entry = self._validate_signal_entries(
@@ -362,6 +361,7 @@ class BECWaveform(BECPlotBase):
         else:
             label = label or f"{y_name}-{y_entry}"
 
+        # Check if curve already exists
         curve_exits = self._check_curve_id(label, self._curves_data)
         if curve_exits:
             raise ValueError(f"Curve with ID '{label}' already exists in widget '{self.gui_id}'.")
@@ -373,6 +373,18 @@ class BECWaveform(BECPlotBase):
             )[-1]
         )
 
+        if source is None:
+            if validate_bec:
+                curve_source = (
+                    "async_readback"
+                    if self.dev[y_name].readout_priority == ReadoutPriority.ASYNC
+                    else "scan_segment"
+                )
+            else:
+                curve_source = "scan_segment"
+        else:
+            curve_source = source
+
         # Create curve by config
         curve_config = CurveConfig(
             widget_class="BECCurve",

bec_widgets/widgets/figure/plots/waveform/waveform_curve.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import TYPE_CHECKING, Literal, Optional
 
 import pyqtgraph as pg
+from bec_lib.endpoints import MessageEndpoints
 from pydantic import BaseModel, Field, field_validator
-from pydantic_core import PydanticCustomError
 from qtpy import QtCore
 
 from bec_widgets.utils import BECConnector, Colors, ConnectionConfig
 
 if TYPE_CHECKING:
+    import numpy as np
+
     from bec_widgets.widgets.figure.plots.waveform import BECWaveform1D
 
 
@@ -103,6 +105,14 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         if kwargs:
             self.set(**kwargs)
 
+        self._async_info = {}
+
+        if self.config.source == "async_readback":
+            # get updates on new scans in order to change the subscription to the correct async readback
+            self.bec_dispatcher.connect_slot(
+                self.on_scan_status_update, MessageEndpoints.scan_status()
+            )
+
     def apply_config(self):
         pen_style_map = {
             "solid": QtCore.Qt.SolidLine,
@@ -137,6 +147,49 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         else:
             raise ValueError(f"Source {self.config.source} do not allow custom data setting.")
 
+    def on_scan_status_update(self, content: dict, metadata: dict):
+        """
+        Update the async info with the latest scan status.
+        """
+        scan_id = content.get("scan_id")
+        if scan_id == self._async_info.get("scan_id"):
+            return
+        active_subscription = self._async_info.get("active_subscription")
+        if active_subscription:
+            self.bec_dispatcher.disconnect_slot(self.on_async_update, active_subscription)
+        self._async_info["scan_id"] = scan_id
+        self._async_info["active_subscription"] = MessageEndpoints.device_async_readback(
+            scan_id, self.config.signals.y.name
+        )
+        self._async_info["data"] = []
+        self.bec_dispatcher.connect_slot(
+            self.on_async_update,
+            MessageEndpoints.device_async_readback(scan_id, self.config.signals.y.name),
+            from_start=True,
+        )
+
+    def on_async_update(self, content: dict, metadata: dict):
+        """
+        Update the curve with the latest async readback data.
+        """
+        async_update = metadata.get("async_update")
+        if not async_update:
+            return
+        signals = content.get("signals")
+        if not signals:
+            return
+        y_data = signals.get(self.config.signals.y.name, {}).get("value", [])
+        if y_data is None:
+            return
+        if async_update == "extend":
+            self._async_info["data"].extend(y_data)
+        elif async_update == "replace":
+            self._async_info["data"] = y_data
+        else:
+            print(f"Warning: Unsupported async update type {async_update}.")
+
+        self.setData(self._async_info["data"])
+
     def set(self, **kwargs):
         """
         Set the properties of the curve.

bec_widgets/widgets/motor_map/assets/connection.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="48px" viewBox="0 0 24 24" width="48px" fill="#FFFFFF">
+    <path d="M0 0h24v24H0V0z" fill="none"/>
+    <path d="M17 7h-4v2h4c1.65 0 3 1.35 3 3s-1.35 3-3 3h-4v2h4c2.76 0 5-2.24 5-5s-2.24-5-5-5zm-6 8H7c-1.65 0-3-1.35-3-3s1.35-3 3-3h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-2zm-3-4h8v2H8z"/>
+</svg>

bec_widgets/widgets/motor_map/assets/history.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="48px" viewBox="0 0 24 24" width="48px" fill="#FFFFFF">
+    <path d="M0 0h24v24H0V0z" fill="none"/>
+    <path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.25 2.52.77-1.28-3.52-2.09V8z"/>
+</svg>

bec_widgets/widgets/motor_map/assets/settings.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="48px" viewBox="0 0 24 24" width="48px" fill="#FFFFFF">
+    <path d="M0 0h24v24H0V0z" fill="none"/>
+    <path d="M19.43 12.98c.04-.32.07-.64.07-.98 0-.34-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.09-.16-.26-.25-.44-.25-.06 0-.12.01-.17.03l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.06-.02-.12-.03-.18-.03-.17 0-.34.09-.43.25l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98 0 .33.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.09.16.26.25.44.25.06 0 .12-.01.17-.03l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.06.02.12.03.18.03.17 0 .34-.09.43-.25l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zm-1.98-1.71c.04.31.05.52.05.73 0 .21-.02.43-.05.73l-.14 1.13.89.7 1.08.84-.7 1.21-1.27-.51-1.04-.42-.9.68c-.43.32-.84.56-1.25.73l-1.06.43-.16 1.13-.2 1.35h-1.4l-.19-1.35-.16-1.13-1.06-.43c-.43-.18-.83-.41-1.23-.71l-.91-.7-1.06.43-1.27.51-.7-1.21 1.08-.84.89-.7-.14-1.13c-.03-.31-.05-.54-.05-.74s.02-.43.05-.73l.14-1.13-.89-.7-1.08-.84.7-1.21 1.27.51 1.04.42.9-.68c.43-.32.84-.56 1.25-.73l1.06-.43.16-1.13.2-1.35h1.39l.19 1.35.16 1.13 1.06.43c.43.18.83.41 1.23.71l.91.7 1.06-.43 1.27-.51.7 1.21-1.07.85-.89.7.14 1.13zM12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"/>
+</svg>

bec_widgets/widgets/motor_map/bec_motor_map_widget.pyproject

@@ -0,0 +1 @@
+{'files': ['motor_map_widget.py','motor_map_widget_plugin.py']}

bec_widgets/widgets/motor_map/bec_motor_map_widget_plugin.py

@@ -0,0 +1,55 @@
+import os
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.motor_map.motor_map_widget import BECMotorMapWidget
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECMotorMapWidget' name='bec_motor_map_widget'>
+    </widget>
+</ui>
+"""
+
+
+class BECMotorMapWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECMotorMapWidget(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Visualization Widgets"
+
+    def icon(self):
+        current_path = os.path.dirname(__file__)
+        icon_path = os.path.join(current_path, "assets", "motor_map.png")
+        return QIcon(icon_path)
+
+    def includeFile(self):
+        return "bec_motor_map_widget"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECMotorMapWidget"
+
+    def toolTip(self):
+        return "BECMotorMapWidget"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/motor_map/motor_map_dialog/motor_map_settings.py

@@ -0,0 +1,73 @@
+import os
+
+from qtpy.QtCore import Slot
+from qtpy.QtWidgets import QDialog, QDialogButtonBox, QLabel, QVBoxLayout, QWidget
+
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.widget_io import WidgetIO
+
+
+class MotorMapSettings(QWidget):
+    def __init__(self, parent=None, target_widget: QWidget = None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+        current_path = os.path.dirname(__file__)
+
+        self.ui = UILoader(self).loader(os.path.join(current_path, "motor_map_settings.ui"))
+        self.target_widget = target_widget
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.ui)
+
+    @Slot(dict)
+    def display_current_settings(self, config: dict):
+        WidgetIO.set_value(self.ui.max_points, config["max_points"])
+        WidgetIO.set_value(self.ui.trace_dim, config["num_dim_points"])
+        WidgetIO.set_value(self.ui.precision, config["precision"])
+        WidgetIO.set_value(self.ui.scatter_size, config["scatter_size"])
+        background_intensity = int((config["background_value"] / 255) * 100)
+        WidgetIO.set_value(self.ui.background_value, background_intensity)
+        color = config["color"]
+        self.ui.color.setColor(color)
+
+    @Slot()
+    def accept_changes(self):
+        max_points = WidgetIO.get_value(self.ui.max_points)
+        num_dim_points = WidgetIO.get_value(self.ui.trace_dim)
+        precision = WidgetIO.get_value(self.ui.precision)
+        scatter_size = WidgetIO.get_value(self.ui.scatter_size)
+        background_intensity = int(WidgetIO.get_value(self.ui.background_value) * 0.01 * 255)
+        color = self.ui.color.color().toTuple()
+
+        if self.target_widget is not None:
+            self.target_widget.set_max_points(max_points)
+            self.target_widget.set_num_dim_points(num_dim_points)
+            self.target_widget.set_precision(precision)
+            self.target_widget.set_scatter_size(scatter_size)
+            self.target_widget.set_background_value(background_intensity)
+            self.target_widget.set_color(color)
+
+
+class MotorMapDialog(QDialog):
+    def __init__(self, parent=None, target_widget: QWidget = None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+
+        self.setModal(False)
+
+        self.setWindowTitle("Motor Map Settings")
+
+        self.target_widget = target_widget
+        self.widget = MotorMapSettings(target_widget=self.target_widget)
+        self.widget.display_current_settings(self.target_widget._config_dict)
+        self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.widget)
+        self.layout.addWidget(self.button_box)
+
+    @Slot()
+    def accept(self):
+        self.widget.accept_changes()
+        super().accept()

bec_widgets/widgets/motor_map/motor_map_dialog/motor_map_settings.ui

@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>243</width>
+    <height>233</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="3" column="1">
+    <widget class="QSpinBox" name="scatter_size">
+     <property name="maximum">
+      <number>20</number>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0">
+    <widget class="QLabel" name="trace_label">
+     <property name="text">
+      <string>Trace Dim</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="0">
+    <widget class="QLabel" name="precision_label">
+     <property name="text">
+      <string>Precision</string>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="0">
+    <widget class="QLabel" name="background_label">
+     <property name="text">
+      <string>Background Intensity</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="1">
+    <widget class="QSpinBox" name="precision">
+     <property name="maximum">
+      <number>15</number>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="1">
+    <widget class="QSpinBox" name="background_value">
+     <property name="maximum">
+      <number>100</number>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0">
+    <widget class="QLabel" name="max_point_label">
+     <property name="text">
+      <string>Max Points</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="0">
+    <widget class="QLabel" name="scatter_size_label">
+     <property name="text">
+      <string>Scatter Size</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1">
+    <widget class="QSpinBox" name="max_points">
+     <property name="maximum">
+      <number>10000</number>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <widget class="QSpinBox" name="trace_dim">
+     <property name="maximum">
+      <number>1000</number>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="0">
+    <widget class="QLabel" name="color_label">
+     <property name="text">
+      <string>Color</string>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="1">
+    <widget class="ColorButton" name="color"/>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>ColorButton</class>
+   <extends>QPushButton</extends>
+   <header>color_button</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/motor_map/motor_map_dialog/motor_map_toolbar.py

@@ -0,0 +1,59 @@
+import os
+
+from qtpy.QtCore import QSize
+from qtpy.QtGui import QAction, QIcon
+from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget
+
+from bec_widgets.widgets.device_inputs import DeviceComboBox
+from bec_widgets.widgets.toolbar.toolbar import ToolBarAction
+
+
+class DeviceSelectionAction(ToolBarAction):
+    def __init__(self, label: str):
+        self.label = label
+        self.device_combobox = DeviceComboBox(device_filter="Positioner")
+
+        self.device_combobox.currentIndexChanged.connect(lambda: self.set_combobox_style("#ffa700"))
+
+    def add_to_toolbar(self, toolbar, target):
+        widget = QWidget()
+        layout = QHBoxLayout(widget)
+
+        label = QLabel(f"{self.label}")
+
+        layout.addWidget(label)
+        layout.addWidget(self.device_combobox)
+        toolbar.addWidget(widget)
+
+    def set_combobox_style(self, color: str):
+        self.device_combobox.setStyleSheet(f"QComboBox {{ background-color: {color}; }}")
+
+
+class ConnectAction(ToolBarAction):
+    def add_to_toolbar(self, toolbar, target):
+        current_path = os.path.dirname(__file__)
+        parent_path = os.path.dirname(current_path)
+        icon = QIcon()
+        icon.addFile(os.path.join(parent_path, "assets", "connection.svg"), size=QSize(20, 20))
+        self.action = QAction(icon, "Connect Motors", target)
+        toolbar.addAction(self.action)
+
+
+class ResetHistoryAction(ToolBarAction):
+    def add_to_toolbar(self, toolbar, target):
+        current_path = os.path.dirname(__file__)
+        parent_path = os.path.dirname(current_path)
+        icon = QIcon()
+        icon.addFile(os.path.join(parent_path, "assets", "history.svg"), size=QSize(20, 20))
+        self.action = QAction(icon, "Reset Trace History", target)
+        toolbar.addAction(self.action)
+
+
+class SettingsAction(ToolBarAction):
+    def add_to_toolbar(self, toolbar, target):
+        current_path = os.path.dirname(__file__)
+        parent_path = os.path.dirname(current_path)
+        icon = QIcon()
+        icon.addFile(os.path.join(parent_path, "assets", "settings.svg"), size=QSize(20, 20))
+        self.action = QAction(icon, "Open Configuration Dialog", target)
+        toolbar.addAction(self.action)

bec_widgets/widgets/motor_map/motor_map_widget.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import sys
+
+from qtpy import PYSIDE6
+from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+from bec_widgets.utils import BECConnector
+from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.figure.plots.motor_map.motor_map import MotorMapConfig
+from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_settings import MotorMapDialog
+from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_toolbar import (
+    ConnectAction,
+    DeviceSelectionAction,
+    ResetHistoryAction,
+    SettingsAction,
+)
+from bec_widgets.widgets.toolbar import ModularToolBar
+
+
+class BECMotorMapWidget(BECConnector, QWidget):
+    USER_ACCESS = [
+        "change_motors",
+        "set_max_points",
+        "set_precision",
+        "set_num_dim_points",
+        "set_background_value",
+        "set_scatter_size",
+        "get_data",
+        "reset_history",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        config: MotorMapConfig | None = None,
+        client=None,
+        gui_id: str | None = None,
+    ) -> None:
+        if not PYSIDE6:
+            raise RuntimeError(
+                "PYSIDE6 is not available in the environment. This widget is compatible only with PySide6."
+            )
+        if config is None:
+            config = MotorMapConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = MotorMapConfig(**config)
+        super().__init__(client=client, gui_id=gui_id)
+        QWidget.__init__(self, parent)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.setSpacing(0)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+
+        self.fig = BECFigure()
+        self.toolbar = ModularToolBar(
+            actions={
+                "motor_x": DeviceSelectionAction("Motor X:"),
+                "motor_y": DeviceSelectionAction("Motor Y:"),
+                "connect": ConnectAction(),
+                "history": ResetHistoryAction(),
+                "config": SettingsAction(),
+            },
+            target_widget=self,
+        )
+
+        self.layout.addWidget(self.toolbar)
+        self.layout.addWidget(self.fig)
+
+        self.map = self.fig.motor_map()
+        self.map.apply_config(config)
+
+        self._hook_actions()
+
+        self.config = config
+
+    def _hook_actions(self):
+        self.toolbar.widgets["connect"].action.triggered.connect(self._action_motors)
+        self.toolbar.widgets["config"].action.triggered.connect(self.show_settings)
+        self.toolbar.widgets["history"].action.triggered.connect(self.reset_history)
+
+        if self.map.motor_x is None and self.map.motor_y is None:
+            self._enable_actions(False)
+
+    def _enable_actions(self, enable: bool):
+        self.toolbar.widgets["config"].action.setEnabled(enable)
+        self.toolbar.widgets["history"].action.setEnabled(enable)
+
+    def _action_motors(self):
+        toolbar_x = self.toolbar.widgets["motor_x"].device_combobox
+        toolbar_y = self.toolbar.widgets["motor_y"].device_combobox
+        motor_x = toolbar_x.currentText()
+        motor_y = toolbar_y.currentText()
+        self.change_motors(motor_x, motor_y, None, None, True)
+        toolbar_x.setStyleSheet("QComboBox {{ background-color: " "; }}")
+        toolbar_y.setStyleSheet("QComboBox {{ background-color: " "; }}")
+
+    def show_settings(self) -> None:
+        dialog = MotorMapDialog(self, target_widget=self)
+        dialog.exec()
+
+    ###################################
+    # User Access Methods from MotorMap
+    ###################################
+
+    def change_motors(
+        self,
+        motor_x: str,
+        motor_y: str,
+        motor_x_entry: str = None,
+        motor_y_entry: str = None,
+        validate_bec: bool = True,
+    ) -> None:
+        """
+        Change the active motors for the plot.
+
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            motor_x_entry(str): Motor entry for the X axis.
+            motor_y_entry(str): Motor entry for the Y axis.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        """
+        self.map.change_motors(motor_x, motor_y, motor_x_entry, motor_y_entry, validate_bec)
+        if self.map.motor_x is not None and self.map.motor_y is not None:
+            self._enable_actions(True)
+        toolbar_x = self.toolbar.widgets["motor_x"].device_combobox
+        toolbar_y = self.toolbar.widgets["motor_y"].device_combobox
+
+        if toolbar_x.currentText() != motor_x:
+            toolbar_x.setCurrentText(motor_x)
+            toolbar_x.setStyleSheet("QComboBox {{ background-color: " "; }}")
+        if toolbar_y.currentText() != motor_y:
+            toolbar_y.setCurrentText(motor_y)
+            toolbar_y.setStyleSheet("QComboBox {{ background-color: " "; }}")
+
+    def get_data(self) -> dict:
+        """
+        Get the data of the motor map.
+
+        Returns:
+            dict: Data of the motor map.
+        """
+        return self.map.get_data()
+
+    def reset_history(self) -> None:
+        """
+        Reset the history of the motor map.
+        """
+        self.map.reset_history()
+
+    def set_color(self, color: str | tuple):
+        """
+        Set the color of the motor map.
+
+        Args:
+            color(str, tuple): Color to set.
+        """
+        self.map.set_color(color)
+
+    def set_max_points(self, max_points: int) -> None:
+        """
+        Set the maximum number of points to display on the motor map.
+
+        Args:
+            max_points(int): Maximum number of points to display.
+        """
+        self.map.set_max_points(max_points)
+
+    def set_precision(self, precision: int) -> None:
+        """
+        Set the precision of the motor map.
+
+        Args:
+            precision(int): Precision to set.
+        """
+        self.map.set_precision(precision)
+
+    def set_num_dim_points(self, num_dim_points: int) -> None:
+        """
+        Set the number of points to display on the motor map.
+
+        Args:
+            num_dim_points(int): Number of points to display.
+        """
+        self.map.set_num_dim_points(num_dim_points)
+
+    def set_background_value(self, background_value: int) -> None:
+        """
+        Set the background value of the motor map.
+
+        Args:
+            background_value(int): Background value of the motor map.
+        """
+        self.map.set_background_value(background_value)
+
+    def set_scatter_size(self, scatter_size: int) -> None:
+        """
+        Set the scatter size of the motor map.
+
+        Args:
+            scatter_size(int): Scatter size of the motor map.
+        """
+        self.map.set_scatter_size(scatter_size)
+
+    def cleanup(self):
+        self.fig.cleanup()
+        self.toolbar.widgets["motor_x"].device_combobox.cleanup()
+        self.toolbar.widgets["motor_y"].device_combobox.cleanup()
+        return super().cleanup()
+
+    def closeEvent(self, event):
+        self.cleanup()
+        QWidget().closeEvent(event)
+
+
+def main():  # pragma: no cover
+
+    if not PYSIDE6:
+        print(
+            "PYSIDE6 is not available in the environment. UI files with BEC custom widgets are runnable only with PySide6."
+        )
+        return
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = BECMotorMapWidget()
+    widget.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/motor_map/register_bec_motor_map_widget.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.motor_map.bec_motor_map_widget_plugin import BECMotorMapWidgetPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECMotorMapWidgetPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/scan_control/scan_control.py

@@ -198,7 +198,7 @@ class ScanControl(BECConnector, QWidget):
 
     def closeEvent(self, event):
         self.cleanup()
-        QWidget().closeEvent(event)
+        return QWidget.closeEvent(self, event)
 
 
 # Application example

bec_widgets/widgets/toolbar/toolbar.py

@@ -1,123 +1,70 @@
 from abc import ABC, abstractmethod
+from collections import defaultdict
 
 # pylint: disable=no-name-in-module
-from qtpy.QtCore import QSize, QTimer
+from qtpy.QtCore import QSize
 from qtpy.QtGui import QAction
-from qtpy.QtWidgets import QApplication, QStyle, QToolBar, QWidget
+from qtpy.QtWidgets import QHBoxLayout, QLabel, QSpinBox, QToolBar, QWidget
 
 
 class ToolBarAction(ABC):
-    """Abstract base class for action creators for the toolbar."""
-
     @abstractmethod
-    def create(self, target: QWidget):
-        """Creates and returns an action to be added to a toolbar.
-
-        This method must be implemented by subclasses.
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """Adds an action or widget to a toolbar.
 
         Args:
-            target (QWidget): The widget that the action will target.
-
-        Returns:
-            QAction: The action created for the toolbar.
+            toolbar (QToolBar): The toolbar to add the action or widget to.
+            target (QWidget): The target widget for the action.
         """
 
 
-class OpenFileAction:  # (ToolBarAction):
-    """Action creator for the 'Open File' action in the toolbar."""
+class ColumnAdjustAction(ToolBarAction):
+    """Toolbar spinbox to adjust number of columns in the plot layout"""
 
-    def create(self, target: QWidget):
-        """Creates an 'Open File' action for the toolbar.
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """Creates a access history button for the toolbar.
 
         Args:
-            target (QWidget): The widget that the 'Open File' action will be targeted.
+            toolbar (QToolBar): The toolbar to add the action to.
+            target (QWidget): The widget that the 'Access Scan History' action will be targeted.
 
         Returns:
-            QAction: The 'Open File' action created for the toolbar.
+            QAction: The 'Access Scan History' action created for the toolbar.
         """
-        icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogOpenButton)
-        action = QAction(icon, "Open File", target)
-        # action = QAction("Open File", target)
-        action.triggered.connect(target.open_file)
-        return action
+        widget = QWidget()
+        layout = QHBoxLayout(widget)
 
+        label = QLabel("Columns:")
+        spin_box = QSpinBox()
+        spin_box.setMinimum(1)  # Set minimum value
+        spin_box.setMaximum(10)  # Set maximum value
+        spin_box.setValue(target.get_column_count())  # Initial value
+        spin_box.valueChanged.connect(lambda value: target.set_column_count(value))
 
-class SaveFileAction:
-    """Action creator for the 'Save File' action in the toolbar."""
-
-    def create(self, target):
-        """Creates a 'Save File' action for the toolbar.
-
-        Args:
-            target (QWidget): The widget that the 'Save File' action will be targeted.
-
-        Returns:
-            QAction: The 'Save File' action created for the toolbar.
-        """
-        icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogSaveButton)
-        action = QAction(icon, "Save File", target)
-        # action = QAction("Save File", target)
-        action.triggered.connect(target.save_file)
-        return action
-
-
-class RunScriptAction:
-    """Action creator for the 'Run Script' action in the toolbar."""
-
-    def create(self, target):
-        """Creates a 'Run Script' action for the toolbar.
-
-        Args:
-            target (QWidget): The widget that the 'Run Script' action will be targeted.
-
-        Returns:
-            QAction: The 'Run Script' action created for the toolbar.
-        """
-        icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay)
-        action = QAction(icon, "Run Script", target)
-        # action = QAction("Run Script", target)
-        action.triggered.connect(target.run_script)
-        return action
+        layout.addWidget(label)
+        layout.addWidget(spin_box)
+        toolbar.addWidget(widget)
 
 
 class ModularToolBar(QToolBar):
     """Modular toolbar with optional automatic initialization.
-
     Args:
         parent (QWidget, optional): The parent widget of the toolbar. Defaults to None.
-        auto_init (bool, optional): If True, automatically populates the toolbar based on the parent widget.
+        actions (list[ToolBarAction], optional): A list of action creators to populate the toolbar. Defaults to None.
+        target_widget (QWidget, optional): The widget that the actions will target. Defaults to None.
+        color (str, optional): The background color of the toolbar. Defaults to "black".
     """
 
-    def __init__(self, parent=None, auto_init=True):
+    def __init__(self, parent=None, actions=None, target_widget=None, color: str = "black"):
         super().__init__(parent)
-        self.auto_init = auto_init
-        self.handler = {
-            "BECEditor": [OpenFileAction(), SaveFileAction(), RunScriptAction()],
-            # BECMonitor: [SomeOtherAction(), AnotherAction()],  # Example for another widget
-        }
-        self.setStyleSheet("QToolBar { background: transparent; }")
-        # Set the icon size for the toolbar
-        self.setIconSize(QSize(20, 20))
 
-        if self.auto_init:
-            QTimer.singleShot(0, self.auto_detect_and_populate)
+        self.widgets = defaultdict(dict)
+        self.set_background_color(color)
 
-    def auto_detect_and_populate(self):
-        """Automatically detects the parent widget and populates the toolbar with relevant actions."""
-        if not self.auto_init:
-            return
+        if actions is not None and target_widget is not None:
+            self.populate_toolbar(actions, target_widget)
 
-        parent_widget = self.parent()
-        if parent_widget is None:
-            return
-
-        parent_widget_class_name = type(parent_widget).__name__
-        for widget_type_name, actions in self.handler.items():
-            if parent_widget_class_name == widget_type_name:
-                self.populate_toolbar(actions, parent_widget)
-                return
-
-    def populate_toolbar(self, actions, target_widget):
+    def populate_toolbar(self, actions: dict, target_widget):
         """Populates the toolbar with a set of actions.
 
         Args:
@@ -125,20 +72,13 @@ class ModularToolBar(QToolBar):
             target_widget (QWidget): The widget that the actions will target.
         """
         self.clear()
-        for action_creator in actions:
-            action = action_creator.create(target_widget)
-            self.addAction(action)
+        for action_id, action in actions.items():
+            action.add_to_toolbar(self, target_widget)
+            self.widgets[action_id] = action
 
-    def set_manual_actions(self, actions, target_widget):
-        """Manually sets the actions for the toolbar.
-
-        Args:
-            actions (list[QAction or ToolBarAction]): A list of actions or action creators to populate the toolbar.
-            target_widget (QWidget): The widget that the actions will target.
-        """
-        self.clear()
-        for action in actions:
-            if isinstance(action, QAction):
-                self.addAction(action)
-            elif isinstance(action, ToolBarAction):
-                self.addAction(action.create(target_widget))
+    def set_background_color(self, color: str):
+        self.setStyleSheet(f"QToolBar {{ background: {color}; }}")
+        self.setIconSize(QSize(20, 20))
+        self.setMovable(False)
+        self.setFloatable(False)
+        self.setContentsMargins(0, 0, 0, 0)

docs/introduction/introduction.md

@@ -10,7 +10,7 @@ Targeting the unique needs of beamline scientists, BEC Widgets stands out with i
 **Key Features**:
 
 - **Integration:** Seamlessly integrates with [BEC (Beamline Experiment Control)](https://gitlab.psi.ch/bec/bec), ensuring a cohesive and efficient experiment control experience.
-- **Support for PyQt5 and PyQt6:** Provides compatibility with both PyQt5 and PyQt6, offering versatility in your development environment.
+- **Support for Pyside6 and PyQt6:** Provides compatibility with both Pyside6 and PyQt6, offering versatility in your development environment.
 - **Widget Modularity:** Features modular widgets that can be easily combined to create customized applications, perfectly aligning with the diverse needs of beamline experiments.
 
 ## Getting Started

docs/user/getting_started/installation.md

@@ -16,10 +16,10 @@ To install BEC Widgets using the pip package manager, execute the following comm
 pip install 'bec_widgets[pyqt6]'
 ```
 
-In case you want to use PyQt5, you can install it by using the following command:
+In case you want to use Pyside6, you can install it by using the following command:
 
 ```bash
-pip install 'bec_widgets[pyqt5]'
+pip install 'bec_widgets[pyside6]'
 ```
 
 **Troubleshooting**

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "0.78.1"
+version = "0.81.0"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -37,7 +37,6 @@ dev = [
     "pytest-xvfb~=3.0",
     "pytest~=8.0",
 ]
-pyqt5 = ["PyQt5>=5.9", "PyQtWebEngine>=5.9"]
 pyqt6 = ["PyQt6>=6.7", "PyQt6-WebEngine>=6.7"]
 pyside6 = ["PySide6>=6.7"]
 

tests/unit_tests/test_bec_status_box.py

@@ -1,3 +1,4 @@
+# pylint: skip-file
 from unittest import mock
 
 import pytest
@@ -15,19 +16,18 @@ def service_status_fixture():
 
 @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
-    )
+    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.children()[0].children()[0].config.status == "IDLE"
+    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.bec_service_info_container["test"].status == "RUNNING"
-    assert status_box.children()[0].children()[0].config.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):
@@ -48,13 +48,13 @@ def test_bec_service_container(status_box):
     info = {"test": "test"}
     metrics = {"metric": "test_metric"}
     expected_return = BECServiceInfoContainer(
-        service_name=name, status=status, info=info, metrics=metrics
+        service_name=name, status=status.name, 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
+    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):
@@ -62,10 +62,10 @@ def test_add_tree_item(status_box):
     status = BECStatus.IDLE
     info = {"test": "test"}
     metrics = {"metric": "test_metric"}
-    assert len(status_box.children()[0].children()) == 1
+    assert len(status_box.tree.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
+    assert len(status_box.tree.children()[0].children()) == 2
+    assert name in status_box.status_container
 
 
 def test_update_service_status(status_box):
@@ -82,10 +82,10 @@ def test_update_service_status(status_box):
     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
+        assert not_connected_name in status_box.status_container
         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
+        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):
@@ -98,15 +98,15 @@ def test_update_core_services(status_box):
     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
+    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.children()[0].children()[0].config.status == "ERROR"
-    assert status_box.tree_items[name][1].config.metrics == 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):
@@ -115,7 +115,9 @@ def test_double_click_item(status_box):
     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]
+    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.itemDoubleClicked.emit(item, 0)
+        status_box.tree.itemDoubleClicked.emit(item, 0)
         assert mock_show_popup.call_count == 1

tests/unit_tests/test_generate_cli_client.py

@@ -4,6 +4,7 @@ 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
 
@@ -33,11 +34,31 @@ class MockBECFigure:
 
 def test_client_generator_with_black_formatting():
     generator = ClientGenerator()
-    rpc_classes = {
-        "connector_classes": [MockBECWaveform1D, MockBECFigure],
-        "top_level_classes": [MockBECFigure],
-    }
-    generator.generate_client(rpc_classes)
+    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(
@@ -51,6 +72,7 @@ def test_client_generator_with_black_formatting():
 
         # pylint: skip-file
 
+
         class Widgets(str, enum.Enum):
             """
             Enum for the available widgets.
@@ -59,18 +81,6 @@ def test_client_generator_with_black_formatting():
             MockBECFigure = "MockBECFigure"
 
 
-        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.
-                """ 
-        
         class MockBECFigure(RPCBase):
             @rpc_call
             def add_plot(self, plot_id: str):
@@ -83,6 +93,20 @@ def test_client_generator_with_black_formatting():
                 """
                 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.
+                """
     '''
     )
 

tests/unit_tests/test_plugin_utils.py

@@ -3,9 +3,8 @@ from bec_widgets.utils.plugin_utils import get_rpc_classes
 
 def test_client_generator_classes():
     out = get_rpc_classes("bec_widgets")
-    assert list(out.keys()) == ["connector_classes", "top_level_classes"]
-    connector_cls_names = [cls.__name__ for cls in out["connector_classes"]]
-    top_level_cls_names = [cls.__name__ for cls in out["top_level_classes"]]
+    connector_cls_names = [cls.__name__ for cls in out.connector_classes]
+    top_level_cls_names = [cls.__name__ for cls in out.top_level_classes]
 
     assert "BECFigure" in connector_cls_names
     assert "BECWaveform" in connector_cls_names