test: cleanup to simplify testing

.gitlab-ci.yml

@@ -61,7 +61,6 @@ stages:
   - pip install -e ./ophyd_devices
   - pip install -e ./bec/bec_lib[dev]
   - pip install -e ./bec/bec_ipython_client
-  - pip install -e ./bec/pytest_bec_e2e
 
 .install-os-packages: &install-os-packages
   - apt-get update

bec_widgets/cli/auto_updates.py

@@ -27,17 +27,25 @@ class AutoUpdates:
 
     def __init__(self, gui: BECDockArea):
         self.gui = gui
-        self._default_dock = None
-        self._default_fig = None
+        self.msg_queue = Queue()
+        self.auto_update_thread = None
+        self._shutdown_sentinel = object()
+        self.start()
+
+    def start(self):
+        """
+        Start the auto update thread.
+        """
+        self.auto_update_thread = threading.Thread(target=self.process_queue)
+        self.auto_update_thread.start()
 
     def start_default_dock(self):
         """
         Create a default dock for the auto updates.
         """
+        dock = self.gui.add_dock("default_figure")
+        dock.add_widget("BECFigure")
         self.dock_name = "default_figure"
-        self._default_dock = self.gui.add_dock(self.dock_name)
-        self._default_dock.add_widget("BECFigure")
-        self._default_fig = self._default_dock.widget_list[0]
 
     @staticmethod
     def get_scan_info(msg) -> ScanInfo:
@@ -65,9 +73,15 @@ class AutoUpdates:
         """
         Get the default figure from the GUI.
         """
-        return self._default_fig
+        dock = self.gui.panels.get(self.dock_name, [])
+        if not dock:
+            return None
+        widgets = dock.widget_list
+        if not widgets:
+            return None
+        return widgets[0]
 
-    def do_update(self, msg):
+    def run(self, msg):
         """
         Run the update function if enabled.
         """
@@ -76,9 +90,20 @@ class AutoUpdates:
         if msg.status != "open":
             return
         info = self.get_scan_info(msg)
-        return self.handler(info)
+        self.handler(info)
 
-    def get_selected_device(self, monitored_devices, selected_device):
+    def process_queue(self):
+        """
+        Process the message queue.
+        """
+        while True:
+            msg = self.msg_queue.get()
+            if msg is self._shutdown_sentinel:
+                break
+            self.run(msg)
+
+    @staticmethod
+    def get_selected_device(monitored_devices, selected_device):
         """
         Get the selected device for the plot. If no device is selected, the first
         device in the monitored devices list is selected.
@@ -95,11 +120,14 @@ class AutoUpdates:
         Default update function.
         """
         if info.scan_name == "line_scan" and info.scan_report_devices:
-            return self.simple_line_scan(info)
+            self.simple_line_scan(info)
+            return
         if info.scan_name == "grid_scan" and info.scan_report_devices:
-            return self.simple_grid_scan(info)
+            self.simple_grid_scan(info)
+            return
         if info.scan_report_devices:
-            return self.best_effort(info)
+            self.best_effort(info)
+            return
 
     def simple_line_scan(self, info: ScanInfo) -> None:
         """
@@ -109,19 +137,12 @@ class AutoUpdates:
         if not fig:
             return
         dev_x = info.scan_report_devices[0]
-        selected_device = yield self.gui.selected_device
-        dev_y = self.get_selected_device(info.monitored_devices, selected_device)
+        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
         if not dev_y:
             return
-        yield fig.clear_all()
-        yield fig.plot(
-            x_name=dev_x,
-            y_name=dev_y,
-            label=f"Scan {info.scan_number} - {dev_y}",
-            title=f"Scan {info.scan_number}",
-            x_label=dev_x,
-            y_label=dev_y,
-        )
+        fig.clear_all()
+        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
+        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
 
     def simple_grid_scan(self, info: ScanInfo) -> None:
         """
@@ -132,18 +153,12 @@ class AutoUpdates:
             return
         dev_x = info.scan_report_devices[0]
         dev_y = info.scan_report_devices[1]
-        selected_device = yield self.gui.selected_device
-        dev_z = self.get_selected_device(info.monitored_devices, selected_device)
-        yield fig.clear_all()
-        yield fig.plot(
-            x_name=dev_x,
-            y_name=dev_y,
-            z_name=dev_z,
-            label=f"Scan {info.scan_number} - {dev_z}",
-            title=f"Scan {info.scan_number}",
-            x_label=dev_x,
-            y_label=dev_y,
+        dev_z = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
+        fig.clear_all()
+        plt = fig.plot(
+            x_name=dev_x, y_name=dev_y, z_name=dev_z, label=f"Scan {info.scan_number} - {dev_z}"
         )
+        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
 
     def best_effort(self, info: ScanInfo) -> None:
         """
@@ -153,16 +168,17 @@ class AutoUpdates:
         if not fig:
             return
         dev_x = info.scan_report_devices[0]
-        selected_device = yield self.gui.selected_device
-        dev_y = self.get_selected_device(info.monitored_devices, selected_device)
+        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
         if not dev_y:
             return
-        yield fig.clear_all()
-        yield fig.plot(
-            x_name=dev_x,
-            y_name=dev_y,
-            label=f"Scan {info.scan_number} - {dev_y}",
-            title=f"Scan {info.scan_number}",
-            x_label=dev_x,
-            y_label=dev_y,
-        )
+        fig.clear_all()
+        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
+        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
+
+    def shutdown(self):
+        """
+        Shutdown the auto update thread.
+        """
+        self.msg_queue.put(self._shutdown_sentinel)
+        if self.auto_update_thread:
+            self.auto_update_thread.join()

bec_widgets/cli/client.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import enum
 from typing import Literal, Optional, overload
 
-from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
+from bec_widgets.cli.client_utils import BECGuiClientMixin, RPCBase, rpc_call
 
 # pylint: skip-file
 
@@ -31,7 +31,6 @@ class Widgets(str, enum.Enum):
     DeviceComboBox = "DeviceComboBox"
     DeviceLineEdit = "DeviceLineEdit"
     LMFitDialog = "LMFitDialog"
-    Minesweeper = "Minesweeper"
     PositionIndicator = "PositionIndicator"
     PositionerBox = "PositionerBox"
     PositionerControlLine = "PositionerControlLine"
@@ -43,6 +42,7 @@ class Widgets(str, enum.Enum):
     SignalLineEdit = "SignalLineEdit"
     StopButton = "StopButton"
     TextBox = "TextBox"
+    UserScriptWidget = "UserScriptWidget"
     VSCodeEditor = "VSCodeEditor"
     WebsiteWidget = "WebsiteWidget"
 
@@ -343,7 +343,7 @@ class BECDock(RPCBase):
         """
 
 
-class BECDockArea(RPCBase):
+class BECDockArea(RPCBase, BECGuiClientMixin):
     @property
     @rpc_call
     def _config_dict(self) -> "dict":
@@ -354,13 +354,6 @@ class BECDockArea(RPCBase):
             dict: The configuration of the widget.
         """
 
-    @property
-    @rpc_call
-    def selected_device(self) -> "str":
-        """
-        None
-        """
-
     @property
     @rpc_call
     def panels(self) -> "dict[str, BECDock]":
@@ -488,12 +481,6 @@ class BECDockArea(RPCBase):
         Hide all windows including floating docks.
         """
 
-    @rpc_call
-    def delete(self):
-        """
-        None
-        """
-
 
 class BECFigure(RPCBase):
     @property
@@ -3182,9 +3169,6 @@ class LMFitDialog(RPCBase):
         """
 
 
-class Minesweeper(RPCBase): ...
-
-
 class PositionIndicator(RPCBase):
     @rpc_call
     def set_value(self, position: float):
@@ -3705,6 +3689,9 @@ class TextBox(RPCBase):
         """
 
 
+class UserScriptWidget(RPCBase): ...
+
+
 class VSCodeEditor(RPCBase): ...
 
 

bec_widgets/cli/client_utils.py

@@ -7,33 +7,61 @@ import os
 import select
 import subprocess
 import threading
-from contextlib import contextmanager
-from dataclasses import dataclass
+import time
+import uuid
+from functools import wraps
 from typing import TYPE_CHECKING
 
+from bec_lib.client import BECClient
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import isinstance_based_on_class_name, lazy_import, lazy_import_from
 
 import bec_widgets.cli.client as client
 from bec_widgets.cli.auto_updates import AutoUpdates
-from bec_widgets.cli.rpc.rpc_base import RPCBase
 
 if TYPE_CHECKING:
-    from bec_lib import messages
-    from bec_lib.connector import MessageObject
     from bec_lib.device import DeviceBase
 
-    from bec_widgets.utils.bec_dispatcher import BECDispatcher
-else:
-    messages = lazy_import("bec_lib.messages")
-    # from bec_lib.connector import MessageObject
-    MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
-    BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
+messages = lazy_import("bec_lib.messages")
+# from bec_lib.connector import MessageObject
+MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
+BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
 
 logger = bec_logger.logger
 
 
+def rpc_call(func):
+    """
+    A decorator for calling a function on the server.
+
+    Args:
+        func: The function to call.
+
+    Returns:
+        The result of the function call.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # we could rely on a strict type check here, but this is more flexible
+        # moreover, it would anyway crash for objects...
+        out = []
+        for arg in args:
+            if hasattr(arg, "name"):
+                arg = arg.name
+            out.append(arg)
+        args = tuple(out)
+        for key, val in kwargs.items():
+            if hasattr(val, "name"):
+                kwargs[key] = val.name
+        if not self.gui_is_alive():
+            raise RuntimeError("GUI is not alive")
+        return self._run_rpc(func.__name__, *args, **kwargs)
+
+    return wrapper
+
+
 def _get_output(process, logger) -> None:
     log_func = {process.stdout: logger.debug, process.stderr: logger.error}
     stream_buffer = {process.stdout: [], process.stderr: []}
@@ -104,79 +132,29 @@ class RepeatTimer(threading.Timer):
             self.function(*self.args, **self.kwargs)
 
 
-@contextmanager
-def wait_for_server(client):
-    timeout = client._startup_timeout
-    if not timeout:
-        if client.gui_is_alive():
-            # there is hope, let's wait a bit
-            timeout = 1
-        else:
-            raise RuntimeError("GUI is not alive")
-    try:
-        if client._gui_started_event.wait(timeout=timeout):
-            client._gui_started_timer.cancel()
-            client._gui_started_timer.join()
-        else:
-            raise TimeoutError("Could not connect to GUI server")
-    finally:
-        # after initial waiting period, do not wait so much any more
-        # (only relevant if GUI didn't start)
-        client._startup_timeout = 0
-    yield
-
-
-### ----------------------------
-### NOTE
-### it is far easier to extend the 'delete' method on the client side,
-### to know when the client is deleted, rather than listening to server
-### to get notified. However, 'generate_cli.py' cannot add extra stuff
-### in the generated client module. So, here a class with the same name
-### is created, and client module is patched.
-class BECDockArea(client.BECDockArea):
-    def delete(self):
-        if self is BECGuiClient._top_level["main"].widget:
-            raise RuntimeError("Cannot delete main window")
-        super().delete()
-        try:
-            del BECGuiClient._top_level[self._gui_id]
-        except KeyError:
-            # if a dock area is not at top level
-            pass
-
-
-client.BECDockArea = BECDockArea
-### ----------------------------
-
-
-@dataclass
-class WidgetDesc:
-    title: str
-    widget: BECDockArea
-
-
-class BECGuiClient(RPCBase):
-    _top_level = {}
-
+class BECGuiClientMixin:
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._auto_updates_enabled = True
         self._auto_updates = None
-        self._startup_timeout = 0
         self._gui_started_timer = None
         self._gui_started_event = threading.Event()
         self._process = None
         self._process_output_processing_thread = None
-
-    @property
-    def windows(self):
-        return self._top_level
+        self._target_endpoint = MessageEndpoints.scan_status()
+        self._selected_device = None
 
     @property
     def auto_updates(self):
         if self._auto_updates_enabled:
-            with wait_for_server(self):
-                return self._auto_updates
+            self._gui_started_event.wait()
+        return self._auto_updates
+
+    def shutdown_auto_updates(self):
+        if self._auto_updates_enabled:
+            if self._auto_updates is not None:
+                self._auto_updates.shutdown()
+                self._auto_updates = None
 
     def _get_update_script(self) -> AutoUpdates | None:
         eps = imd.entry_points(group="bec.widgets.auto_updates")
@@ -197,59 +175,49 @@ class BECGuiClient(RPCBase):
         """
         Selected device for the plot.
         """
-        auto_update_config_ep = MessageEndpoints.gui_auto_update_config(self._gui_id)
-        auto_update_config = self._client.connector.get(auto_update_config_ep)
-        if auto_update_config:
-            return auto_update_config.selected_device
-        return None
+        return self._selected_device
 
     @selected_device.setter
     def selected_device(self, device: str | DeviceBase):
         if isinstance_based_on_class_name(device, "bec_lib.device.DeviceBase"):
-            self._client.connector.set_and_publish(
-                MessageEndpoints.gui_auto_update_config(self._gui_id),
-                messages.GUIAutoUpdateConfigMessage(selected_device=device.name),
-            )
+            self._selected_device = device.name
         elif isinstance(device, str):
-            self._client.connector.set_and_publish(
-                MessageEndpoints.gui_auto_update_config(self._gui_id),
-                messages.GUIAutoUpdateConfigMessage(selected_device=device),
-            )
+            self._selected_device = device
         else:
             raise ValueError("Device must be a string or a device object")
 
     def _start_update_script(self) -> None:
-        self._client.connector.register(MessageEndpoints.scan_status(), cb=self._handle_msg_update)
+        self._client.connector.register(
+            self._target_endpoint, cb=self._handle_msg_update, parent=self
+        )
 
-    def _handle_msg_update(self, msg: MessageObject) -> None:
-        if self.auto_updates is not None:
+    @staticmethod
+    def _handle_msg_update(msg: MessageObject, parent: BECGuiClientMixin) -> None:
+        if parent.auto_updates is not None:
             # pylint: disable=protected-access
-            return self._update_script_msg_parser(msg.value)
+            parent._update_script_msg_parser(msg.value)
 
     def _update_script_msg_parser(self, msg: messages.BECMessage) -> None:
         if isinstance(msg, messages.ScanStatusMessage):
             if not self.gui_is_alive():
                 return
             if self._auto_updates_enabled:
-                return self.auto_updates.do_update(msg)
+                self.auto_updates.msg_queue.put(msg)
 
     def _gui_post_startup(self):
-        self._top_level["main"] = WidgetDesc(
-            title="BEC Widgets", widget=BECDockArea(gui_id=self._gui_id)
-        )
         if self._auto_updates_enabled:
             if self._auto_updates is None:
                 auto_updates = self._get_update_script()
                 if auto_updates is None:
                     AutoUpdates.create_default_dock = True
                     AutoUpdates.enabled = True
-                    auto_updates = AutoUpdates(self._top_level["main"].widget)
+                    auto_updates = AutoUpdates(gui=self)
                 if auto_updates.create_default_dock:
                     auto_updates.start_default_dock()
-                self._start_update_script()
+                    # fig = auto_updates.get_default_figure()
                 self._auto_updates = auto_updates
-        self._do_show_all()
         self._gui_started_event.set()
+        self.show_all()
 
     def start_server(self, wait=False) -> None:
         """
@@ -257,8 +225,8 @@ class BECGuiClient(RPCBase):
         """
         if self._process is None or self._process.poll() is not None:
             logger.success("GUI starting...")
-            self._startup_timeout = 5
             self._gui_started_event.clear()
+            self._start_update_script()
             self._process, self._process_output_processing_thread = _start_plot_process(
                 self._gui_id, self.__class__, self._client._service_config.config, logger=logger
             )
@@ -271,66 +239,27 @@ class BECGuiClient(RPCBase):
                     threading.current_thread().cancel()
 
             self._gui_started_timer = RepeatTimer(
-                0.5, lambda: self.gui_is_alive() and gui_started_callback(self._gui_post_startup)
+                1, lambda: self.gui_is_alive() and gui_started_callback(self._gui_post_startup)
             )
             self._gui_started_timer.start()
 
         if wait:
             self._gui_started_event.wait()
 
-    def _dump(self):
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
-        return rpc_client._run_rpc("_dump")
-
-    def start(self):
-        return self.start_server()
-
-    def _do_show_all(self):
+    def show_all(self):
+        self._gui_started_event.wait()
         rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
         rpc_client._run_rpc("show")
-        for window in self._top_level.values():
-            window.widget.show()
-
-    def show_all(self):
-        with wait_for_server(self):
-            return self._do_show_all()
 
     def hide_all(self):
-        with wait_for_server(self):
-            rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
-            rpc_client._run_rpc("hide")
-            for window in self._top_level.values():
-                window.widget.hide()
-
-    def show(self):
-        if self._process is not None:
-            return self.show_all()
-        # backward compatibility: show() was also starting server
-        return self.start_server(wait=True)
-
-    def hide(self):
-        return self.hide_all()
-
-    @property
-    def main(self):
-        """Return client to main dock area (in main window)"""
-        with wait_for_server(self):
-            return self._top_level["main"].widget
-
-    def new(self, title):
-        """Ask main window to create a new top-level dock area"""
-        with wait_for_server(self):
-            rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
-            widget = rpc_client._run_rpc("new_dock_area", title)
-            self._top_level[widget._gui_id] = WidgetDesc(title=title, widget=widget)
-            return widget
+        self._gui_started_event.wait()
+        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
+        rpc_client._run_rpc("hide")
 
     def close(self) -> None:
         """
         Close the gui window.
         """
-        self._top_level.clear()
-
         if self._gui_started_timer is not None:
             self._gui_started_timer.cancel()
             self._gui_started_timer.join()
@@ -345,3 +274,130 @@ class BECGuiClient(RPCBase):
                 self._process_output_processing_thread.join()
             self._process.wait()
             self._process = None
+        self.shutdown_auto_updates()
+
+
+class RPCResponseTimeoutError(Exception):
+    """Exception raised when an RPC response is not received within the expected time."""
+
+    def __init__(self, request_id, timeout):
+        super().__init__(
+            f"RPC response not received within {timeout} seconds for request ID {request_id}"
+        )
+
+
+class RPCBase:
+    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
+        self._client = BECClient()  # BECClient is a singleton; here, we simply get the instance
+        self._config = config if config is not None else {}
+        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())[:5]
+        self._parent = parent
+        self._msg_wait_event = threading.Event()
+        self._rpc_response = None
+        super().__init__()
+        # print(f"RPCBase: {self._gui_id}")
+
+    def __repr__(self):
+        type_ = type(self)
+        qualname = type_.__qualname__
+        return f"<{qualname} object at {hex(id(self))}>"
+
+    @property
+    def _root(self):
+        """
+        Get the root widget. This is the BECFigure widget that holds
+        the anchor gui_id.
+        """
+        parent = self
+        # pylint: disable=protected-access
+        while parent._parent is not None:
+            parent = parent._parent
+        return parent
+
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs):
+        """
+        Run the RPC call.
+
+        Args:
+            method: The method to call.
+            args: The arguments to pass to the method.
+            wait_for_rpc_response: Whether to wait for the RPC response.
+            kwargs: The keyword arguments to pass to the method.
+
+        Returns:
+            The result of the RPC call.
+        """
+        request_id = str(uuid.uuid4())
+        rpc_msg = messages.GUIInstructionMessage(
+            action=method,
+            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
+            metadata={"request_id": request_id},
+        )
+
+        # pylint: disable=protected-access
+        receiver = self._root._gui_id
+        if wait_for_rpc_response:
+            self._rpc_response = None
+            self._msg_wait_event.clear()
+            self._client.connector.register(
+                MessageEndpoints.gui_instruction_response(request_id),
+                cb=self._on_rpc_response,
+                parent=self,
+            )
+
+        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
+
+        if wait_for_rpc_response:
+            try:
+                finished = self._msg_wait_event.wait(10)
+                if not finished:
+                    raise RPCResponseTimeoutError(request_id, timeout)
+            finally:
+                self._msg_wait_event.clear()
+                self._client.connector.unregister(
+                    MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
+                )
+            # get class name
+            if not self._rpc_response.accepted:
+                raise ValueError(self._rpc_response.message["error"])
+            msg_result = self._rpc_response.message.get("result")
+            self._rpc_response = None
+            return self._create_widget_from_msg_result(msg_result)
+
+    @staticmethod
+    def _on_rpc_response(msg: MessageObject, parent: RPCBase) -> None:
+        msg = msg.value
+        parent._msg_wait_event.set()
+        parent._rpc_response = msg
+
+    def _create_widget_from_msg_result(self, msg_result):
+        if msg_result is None:
+            return None
+        if isinstance(msg_result, list):
+            return [self._create_widget_from_msg_result(res) for res in msg_result]
+        if isinstance(msg_result, dict):
+            if "__rpc__" not in msg_result:
+                return {
+                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
+                }
+            cls = msg_result.pop("widget_class", None)
+            msg_result.pop("__rpc__", None)
+
+            if not cls:
+                return msg_result
+
+            cls = getattr(client, cls)
+            # print(msg_result)
+            return cls(parent=self, **msg_result)
+        return msg_result
+
+    def gui_is_alive(self):
+        """
+        Check if the GUI is alive.
+        """
+        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
+        if heart is None:
+            return False
+        if heart.status == messages.BECStatus.RUNNING:
+            return True
+        return False

bec_widgets/cli/generate_cli.py

@@ -35,7 +35,7 @@ from __future__ import annotations
 import enum
 from typing import Literal, Optional, overload
 
-from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
+from bec_widgets.cli.client_utils import RPCBase, rpc_call, BECGuiClientMixin
 
 # pylint: skip-file"""
 
@@ -84,7 +84,7 @@ class Widgets(str, enum.Enum):
         # Generate the content
         if cls.__name__ == "BECDockArea":
             self.content += f"""
-class {class_name}(RPCBase):"""
+class {class_name}(RPCBase, BECGuiClientMixin):"""
         else:
             self.content += f"""
 class {class_name}(RPCBase):"""

bec_widgets/cli/rpc/rpc_base.py

@@ -1,177 +0,0 @@
-from __future__ import annotations
-
-import threading
-import uuid
-from functools import wraps
-from typing import TYPE_CHECKING
-
-from bec_lib.client import BECClient
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.utils.import_utils import lazy_import, lazy_import_from
-
-import bec_widgets.cli.client as client
-
-if TYPE_CHECKING:
-    from bec_lib import messages
-    from bec_lib.connector import MessageObject
-else:
-    messages = lazy_import("bec_lib.messages")
-    # from bec_lib.connector import MessageObject
-    MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
-
-
-def rpc_call(func):
-    """
-    A decorator for calling a function on the server.
-
-    Args:
-        func: The function to call.
-
-    Returns:
-        The result of the function call.
-    """
-
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        # we could rely on a strict type check here, but this is more flexible
-        # moreover, it would anyway crash for objects...
-        out = []
-        for arg in args:
-            if hasattr(arg, "name"):
-                arg = arg.name
-            out.append(arg)
-        args = tuple(out)
-        for key, val in kwargs.items():
-            if hasattr(val, "name"):
-                kwargs[key] = val.name
-        if not self.gui_is_alive():
-            raise RuntimeError("GUI is not alive")
-        return self._run_rpc(func.__name__, *args, **kwargs)
-
-    return wrapper
-
-
-class RPCResponseTimeoutError(Exception):
-    """Exception raised when an RPC response is not received within the expected time."""
-
-    def __init__(self, request_id, timeout):
-        super().__init__(
-            f"RPC response not received within {timeout} seconds for request ID {request_id}"
-        )
-
-
-class RPCBase:
-    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
-        self._client = BECClient()  # BECClient is a singleton; here, we simply get the instance
-        self._config = config if config is not None else {}
-        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())[:5]
-        self._parent = parent
-        self._msg_wait_event = threading.Event()
-        self._rpc_response = None
-        super().__init__()
-        # print(f"RPCBase: {self._gui_id}")
-
-    def __repr__(self):
-        type_ = type(self)
-        qualname = type_.__qualname__
-        return f"<{qualname} object at {hex(id(self))}>"
-
-    @property
-    def _root(self):
-        """
-        Get the root widget. This is the BECFigure widget that holds
-        the anchor gui_id.
-        """
-        parent = self
-        # pylint: disable=protected-access
-        while parent._parent is not None:
-            parent = parent._parent
-        return parent
-
-    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs):
-        """
-        Run the RPC call.
-
-        Args:
-            method: The method to call.
-            args: The arguments to pass to the method.
-            wait_for_rpc_response: Whether to wait for the RPC response.
-            kwargs: The keyword arguments to pass to the method.
-
-        Returns:
-            The result of the RPC call.
-        """
-        request_id = str(uuid.uuid4())
-        rpc_msg = messages.GUIInstructionMessage(
-            action=method,
-            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
-            metadata={"request_id": request_id},
-        )
-
-        # pylint: disable=protected-access
-        receiver = self._root._gui_id
-        if wait_for_rpc_response:
-            self._rpc_response = None
-            self._msg_wait_event.clear()
-            self._client.connector.register(
-                MessageEndpoints.gui_instruction_response(request_id),
-                cb=self._on_rpc_response,
-                parent=self,
-            )
-
-        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
-
-        if wait_for_rpc_response:
-            try:
-                finished = self._msg_wait_event.wait(timeout)
-                if not finished:
-                    raise RPCResponseTimeoutError(request_id, timeout)
-            finally:
-                self._msg_wait_event.clear()
-                self._client.connector.unregister(
-                    MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
-                )
-            # get class name
-            if not self._rpc_response.accepted:
-                raise ValueError(self._rpc_response.message["error"])
-            msg_result = self._rpc_response.message.get("result")
-            self._rpc_response = None
-            return self._create_widget_from_msg_result(msg_result)
-
-    @staticmethod
-    def _on_rpc_response(msg: MessageObject, parent: RPCBase) -> None:
-        msg = msg.value
-        parent._msg_wait_event.set()
-        parent._rpc_response = msg
-
-    def _create_widget_from_msg_result(self, msg_result):
-        if msg_result is None:
-            return None
-        if isinstance(msg_result, list):
-            return [self._create_widget_from_msg_result(res) for res in msg_result]
-        if isinstance(msg_result, dict):
-            if "__rpc__" not in msg_result:
-                return {
-                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
-                }
-            cls = msg_result.pop("widget_class", None)
-            msg_result.pop("__rpc__", None)
-
-            if not cls:
-                return msg_result
-
-            cls = getattr(client, cls)
-            # print(msg_result)
-            return cls(parent=self, **msg_result)
-        return msg_result
-
-    def gui_is_alive(self):
-        """
-        Check if the GUI is alive.
-        """
-        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
-        if heart is None:
-            return False
-        if heart.status == messages.BECStatus.RUNNING:
-            return True
-        return False

bec_widgets/cli/server.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
-import functools
 import json
 import signal
 import sys
-import types
-from contextlib import contextmanager, redirect_stderr, redirect_stdout
+from contextlib import redirect_stderr, redirect_stdout
 from typing import Union
 
 from bec_lib.endpoints import MessageEndpoints
@@ -14,8 +12,7 @@ from bec_lib.service_config import ServiceConfig
 from bec_lib.utils.import_utils import lazy_import
 from qtpy.QtCore import Qt, QTimer
 
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.qt_utils.error_popups import ErrorPopupUtility
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.widgets.containers.dock import BECDockArea
@@ -26,27 +23,6 @@ messages = lazy_import("bec_lib.messages")
 logger = bec_logger.logger
 
 
-@contextmanager
-def rpc_exception_hook(err_func):
-    """This context replaces the popup message box for error display with a specific hook"""
-    # get error popup utility singleton
-    popup = ErrorPopupUtility()
-    # save current setting
-    old_exception_hook = popup.custom_exception_hook
-
-    # install err_func, if it is a callable
-    def custom_exception_hook(self, exc_type, value, tb, **kwargs):
-        err_func({"error": popup.get_error_message(exc_type, value, tb)})
-
-    popup.custom_exception_hook = types.MethodType(custom_exception_hook, popup)
-
-    try:
-        yield popup
-    finally:
-        # restore state of error popup utility singleton
-        popup.custom_exception_hook = old_exception_hook
-
-
 class BECWidgetsCLIServer:
 
     def __init__(
@@ -81,19 +57,18 @@ class BECWidgetsCLIServer:
     def on_rpc_update(self, msg: dict, metadata: dict):
         request_id = metadata.get("request_id")
         logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
-        with rpc_exception_hook(functools.partial(self.send_response, request_id, False)):
-            try:
-                obj = self.get_object_from_config(msg["parameter"])
-                method = msg["action"]
-                args = msg["parameter"].get("args", [])
-                kwargs = msg["parameter"].get("kwargs", {})
-                res = self.run_rpc(obj, method, args, kwargs)
-            except Exception as e:
-                logger.error(f"Error while executing RPC instruction: {e}")
-                self.send_response(request_id, False, {"error": str(e)})
-            else:
-                logger.debug(f"RPC instruction executed successfully: {res}")
-                self.send_response(request_id, True, {"result": res})
+        try:
+            obj = self.get_object_from_config(msg["parameter"])
+            method = msg["action"]
+            args = msg["parameter"].get("args", [])
+            kwargs = msg["parameter"].get("kwargs", {})
+            res = self.run_rpc(obj, method, args, kwargs)
+        except Exception as e:
+            logger.error(f"Error while executing RPC instruction: {e}")
+            self.send_response(request_id, False, {"error": str(e)})
+        else:
+            logger.debug(f"RPC instruction executed successfully: {res}")
+            self.send_response(request_id, True, {"result": res})
 
     def send_response(self, request_id: str, accepted: bool, msg: dict):
         self.client.connector.set_and_publish(
@@ -206,8 +181,14 @@ def main():
 
     import bec_widgets
 
+    bec_logger.level = bec_logger.LOGLEVEL.DEBUG
+    if __name__ != "__main__":
+        # if not running as main, set the log level to critical
+        # pylint: disable=protected-access
+        bec_logger._stderr_log_level = bec_logger.LOGLEVEL.CRITICAL
+
     parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
-    parser.add_argument("--id", type=str, default="test", help="The id of the server")
+    parser.add_argument("--id", type=str, help="The id of the server")
     parser.add_argument(
         "--gui_class",
         type=str,
@@ -218,20 +199,10 @@ def main():
 
     args = parser.parse_args()
 
-    if args.hide:
-        # if we start hidden, it means we are under control of the client
-        # -> set the log level to critical to not see all the messages
-        # pylint: disable=protected-access
-        # bec_logger._stderr_log_level = bec_logger.LOGLEVEL.CRITICAL
-        bec_logger.level = bec_logger.LOGLEVEL.CRITICAL
-    else:
-        # verbose log
-        bec_logger.level = bec_logger.LOGLEVEL.DEBUG
-
-    if args.gui_class == "BECDockArea":
-        gui_class = BECDockArea
-    elif args.gui_class == "BECFigure":
+    if args.gui_class == "BECFigure":
         gui_class = BECFigure
+    elif args.gui_class == "BECDockArea":
+        gui_class = BECDockArea
     else:
         print(
             "Please specify a valid gui_class to run. Use -h for help."
@@ -242,10 +213,8 @@ def main():
     with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):
         with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):
             app = QApplication(sys.argv)
-            # set close on last window, only if not under control of client ;
-            # indeed, Qt considers a hidden window a closed window, so if all windows
-            # are hidden by default it exits
-            app.setQuitOnLastWindowClosed(not args.hide)
+            app.setQuitOnLastWindowClosed(False)
+            app.setApplicationName("BEC Figure")
             module_path = os.path.dirname(bec_widgets.__file__)
             icon = QIcon()
             icon.addFile(
@@ -253,8 +222,6 @@ def main():
                 size=QSize(48, 48),
             )
             app.setWindowIcon(icon)
-            # store gui id within QApplication object, to make it available to all widgets
-            app.gui_id = args.id
 
             server = _start_server(args.id, gui_class, args.config)
 
@@ -266,6 +233,7 @@ def main():
 
             gui = server.gui
             win.setCentralWidget(gui)
+            win.resize(800, 600)
             if not args.hide:
                 win.show()
 
@@ -274,12 +242,6 @@ def main():
             def sigint_handler(*args):
                 # display message, for people to let it terminate gracefully
                 print("Caught SIGINT, exiting")
-                # first hide all top level windows
-                # this is to discriminate the cases between "user clicks on [X]"
-                # (which should be filtered, to not close -see BECDockArea-)
-                # or "app is asked to close"
-                for window in app.topLevelWidgets():
-                    window.hide()  # so, we know we can exit because it is hidden
                 app.quit()
 
             signal.signal(signal.SIGINT, sigint_handler)
@@ -288,5 +250,6 @@ def main():
             sys.exit(app.exec())
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
+    sys.argv = ["bec_widgets.cli.server", "--id", "e2860", "--gui_class", "BECDockArea"]
     main()

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -7,7 +7,6 @@ from qtpy.QtWidgets import (
     QApplication,
     QGroupBox,
     QHBoxLayout,
-    QPushButton,
     QSplitter,
     QTabWidget,
     QVBoxLayout,
@@ -18,7 +17,6 @@ from bec_widgets.utils import BECDispatcher
 from bec_widgets.utils.colors import apply_theme
 from bec_widgets.widgets.containers.dock import BECDockArea
 from bec_widgets.widgets.containers.figure import BECFigure
-from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
 from bec_widgets.widgets.editors.jupyter_console.jupyter_console import BECJupyterConsole
 
 
@@ -52,16 +50,11 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "d1": self.d1,
                     "d2": self.d2,
                     "wave": self.wf,
+                    # "bar": self.bar,
+                    # "cm": self.colormap,
                     "im": self.im,
                     "mm": self.mm,
                     "mw": self.mw,
-                    "lm": self.lm,
-                    "btn1": self.btn1,
-                    "btn2": self.btn2,
-                    "btn3": self.btn3,
-                    "btn4": self.btn4,
-                    "btn5": self.btn5,
-                    "btn6": self.btn6,
                 }
             )
 
@@ -86,25 +79,11 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         second_tab_layout.addWidget(self.figure)
         tab_widget.addTab(second_tab, "BEC Figure")
 
-        third_tab = QWidget()
-        third_tab_layout = QVBoxLayout(third_tab)
-        self.lm = LayoutManagerWidget()
-        third_tab_layout.addWidget(self.lm)
-        tab_widget.addTab(third_tab, "Layout Manager Widget")
-
         group_box = QGroupBox("Jupyter Console", splitter)
         group_box_layout = QVBoxLayout(group_box)
         self.console = BECJupyterConsole(inprocess=True)
         group_box_layout.addWidget(self.console)
 
-        # Some buttons for layout testing
-        self.btn1 = QPushButton("Button 1")
-        self.btn2 = QPushButton("Button 2")
-        self.btn3 = QPushButton("Button 3")
-        self.btn4 = QPushButton("Button 4")
-        self.btn5 = QPushButton("Button 5")
-        self.btn6 = QPushButton("Button 6")
-
         # add stuff to figure
         self._init_figure()
 
@@ -114,7 +93,15 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.setWindowTitle("Jupyter Console Window")
 
     def _init_figure(self):
-        self.w1 = self.figure.plot(x_name="samx", y_name="bpm4i", row=0, col=0)
+        self.w1 = self.figure.plot(
+            x_name="samx",
+            y_name="bpm4i",
+            # title="Standard Plot with sync device, custom labels - w1",
+            # x_label="Motor Position",
+            # y_label="Intensity (A.U.)",
+            row=0,
+            col=0,
+        )
         self.w1.set(
             title="Standard Plot with sync device, custom labels - w1",
             x_label="Motor Position",
@@ -182,6 +169,14 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.wf = self.d2.add_widget("BECFigure", row=0, col=0)
 
         self.mw = self.wf.multi_waveform(monitor="waveform")  # , config=config)
+        # self.wf.plot(x_name="samx", y_name="bpm3a")
+        # self.wf.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
+        # self.bar = self.d2.add_widget("RingProgressBar", row=0, col=1)
+        # self.bar.set_diameter(200)
+
+        # self.d3 = self.dock.add_dock(name="dock_3", position="bottom")
+        # self.colormap = pg.GradientWidget()
+        # self.d3.add_widget(self.colormap, row=0, col=0)
 
         self.dock.save_state()
 

bec_widgets/qt_utils/collapsible_panel_manager.py

@@ -1,380 +0,0 @@
-from __future__ import annotations
-
-import sys
-from typing import Literal
-
-import pyqtgraph as pg
-from qtpy.QtCore import Property, QEasingCurve, QObject, QPropertyAnimation
-from qtpy.QtWidgets import (
-    QApplication,
-    QHBoxLayout,
-    QMainWindow,
-    QPushButton,
-    QSizePolicy,
-    QVBoxLayout,
-    QWidget,
-)
-from typeguard import typechecked
-
-from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
-
-
-class DimensionAnimator(QObject):
-    """
-    Helper class to animate the size of a panel widget.
-    """
-
-    def __init__(self, panel_widget: QWidget, direction: str):
-        super().__init__()
-        self.panel_widget = panel_widget
-        self.direction = direction
-        self._size = 0
-
-    @Property(int)
-    def panel_width(self):
-        """
-        Returns the current width of the panel widget.
-        """
-        return self._size
-
-    @panel_width.setter
-    def panel_width(self, val: int):
-        """
-        Set the width of the panel widget.
-
-        Args:
-            val(int): The width to set.
-        """
-        self._size = val
-        self.panel_widget.setFixedWidth(val)
-
-    @Property(int)
-    def panel_height(self):
-        """
-        Returns the current height of the panel widget.
-        """
-        return self._size
-
-    @panel_height.setter
-    def panel_height(self, val: int):
-        """
-        Set the height of the panel widget.
-
-        Args:
-            val(int): The height to set.
-        """
-        self._size = val
-        self.panel_widget.setFixedHeight(val)
-
-
-class CollapsiblePanelManager(QObject):
-    """
-    Manager class to handle collapsible panels from a main widget using LayoutManagerWidget.
-    """
-
-    def __init__(self, layout_manager: LayoutManagerWidget, reference_widget: QWidget, parent=None):
-        super().__init__(parent)
-        self.layout_manager = layout_manager
-        self.reference_widget = reference_widget
-        self.animations = {}
-        self.panels = {}
-        self.direction_settings = {
-            "left": {"property": b"maximumWidth", "default_size": 200},
-            "right": {"property": b"maximumWidth", "default_size": 200},
-            "top": {"property": b"maximumHeight", "default_size": 150},
-            "bottom": {"property": b"maximumHeight", "default_size": 150},
-        }
-
-    def add_panel(
-        self,
-        direction: Literal["left", "right", "top", "bottom"],
-        panel_widget: QWidget,
-        target_size: int | None = None,
-        duration: int = 300,
-    ):
-        """
-        Add a panel widget to the layout manager.
-
-        Args:
-            direction(Literal["left", "right", "top", "bottom"]): Direction of the panel.
-            panel_widget(QWidget): The panel widget to add.
-            target_size(int, optional): The target size of the panel. Defaults to None.
-            duration(int): The duration of the animation in milliseconds. Defaults to 300.
-        """
-        if direction not in self.direction_settings:
-            raise ValueError("Direction must be one of 'left', 'right', 'top', 'bottom'.")
-
-        if target_size is None:
-            target_size = self.direction_settings[direction]["default_size"]
-
-        self.layout_manager.add_widget_relative(
-            widget=panel_widget, reference_widget=self.reference_widget, position=direction
-        )
-        panel_widget.setVisible(False)
-
-        # Set initial constraints as flexible
-        if direction in ["left", "right"]:
-            panel_widget.setMaximumWidth(0)
-            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        else:
-            panel_widget.setMaximumHeight(0)
-            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-        self.panels[direction] = {
-            "widget": panel_widget,
-            "direction": direction,
-            "target_size": target_size,
-            "duration": duration,
-            "animator": None,
-        }
-
-    def toggle_panel(
-        self,
-        direction: Literal["left", "right", "top", "bottom"],
-        target_size: int | None = None,
-        duration: int | None = None,
-        easing_curve: QEasingCurve = QEasingCurve.InOutQuad,
-        ensure_max: bool = False,
-        scale: float | None = None,
-        animation: bool = True,
-    ):
-        """
-        Toggle the specified panel.
-
-        Parameters:
-            direction (Literal["left", "right", "top", "bottom"]): Direction of the panel to toggle.
-            target_size (int, optional): Override target size for this toggle.
-            duration (int, optional): Override the animation duration.
-            easing_curve (QEasingCurve): Animation easing curve.
-            ensure_max (bool): If True, animate as a fixed-size panel.
-            scale (float, optional): If provided, calculate target_size from main widget size.
-            animation (bool): If False, no animation is performed; panel instantly toggles.
-        """
-        if direction not in self.panels:
-            raise ValueError(f"No panel found in direction '{direction}'.")
-
-        panel_info = self.panels[direction]
-        panel_widget = panel_info["widget"]
-        dir_settings = self.direction_settings[direction]
-
-        # Determine final target size
-        if scale is not None:
-            main_rect = self.reference_widget.geometry()
-            if direction in ["left", "right"]:
-                computed_target = int(main_rect.width() * scale)
-            else:
-                computed_target = int(main_rect.height() * scale)
-            final_target_size = computed_target
-        else:
-            if target_size is None:
-                final_target_size = panel_info["target_size"]
-            else:
-                final_target_size = target_size
-
-        if duration is None:
-            duration = panel_info["duration"]
-
-        expanding_property = dir_settings["property"]
-        currently_visible = panel_widget.isVisible()
-
-        if ensure_max:
-            if panel_info["animator"] is None:
-                panel_info["animator"] = DimensionAnimator(panel_widget, direction)
-            animator = panel_info["animator"]
-
-            if direction in ["left", "right"]:
-                prop_name = b"panel_width"
-            else:
-                prop_name = b"panel_height"
-        else:
-            animator = None
-            prop_name = expanding_property
-
-        if currently_visible:
-            # Hide the panel
-            if ensure_max:
-                start_value = final_target_size
-                end_value = 0
-                finish_callback = lambda w=panel_widget, d=direction: self._after_hide_reset(w, d)
-            else:
-                start_value = (
-                    panel_widget.width()
-                    if direction in ["left", "right"]
-                    else panel_widget.height()
-                )
-                end_value = 0
-                finish_callback = lambda w=panel_widget: w.setVisible(False)
-        else:
-            # Show the panel
-            start_value = 0
-            end_value = final_target_size
-            finish_callback = None
-            if ensure_max:
-                # Fix panel exactly
-                if direction in ["left", "right"]:
-                    panel_widget.setMinimumWidth(0)
-                    panel_widget.setMaximumWidth(final_target_size)
-                    panel_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
-                else:
-                    panel_widget.setMinimumHeight(0)
-                    panel_widget.setMaximumHeight(final_target_size)
-                    panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
-            else:
-                # Flexible mode
-                if direction in ["left", "right"]:
-                    panel_widget.setMinimumWidth(0)
-                    panel_widget.setMaximumWidth(final_target_size)
-                    panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-                else:
-                    panel_widget.setMinimumHeight(0)
-                    panel_widget.setMaximumHeight(final_target_size)
-                    panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-            panel_widget.setVisible(True)
-
-        if not animation:
-            # No animation: instantly set final state
-            if end_value == 0:
-                # Hiding
-                if ensure_max:
-                    # Reset after hide
-                    self._after_hide_reset(panel_widget, direction)
-                else:
-                    panel_widget.setVisible(False)
-            else:
-                # Showing
-                if ensure_max:
-                    # Already set fixed size
-                    if direction in ["left", "right"]:
-                        panel_widget.setFixedWidth(end_value)
-                    else:
-                        panel_widget.setFixedHeight(end_value)
-                else:
-                    # Just set maximum dimension
-                    if direction in ["left", "right"]:
-                        panel_widget.setMaximumWidth(end_value)
-                    else:
-                        panel_widget.setMaximumHeight(end_value)
-            return
-
-        # With animation
-        animation = QPropertyAnimation(animator if ensure_max else panel_widget, prop_name)
-        animation.setDuration(duration)
-        animation.setStartValue(start_value)
-        animation.setEndValue(end_value)
-        animation.setEasingCurve(easing_curve)
-
-        if end_value == 0 and finish_callback:
-            animation.finished.connect(finish_callback)
-        elif end_value == 0 and not finish_callback:
-            animation.finished.connect(lambda w=panel_widget: w.setVisible(False))
-
-        animation.start()
-        self.animations[panel_widget] = animation
-
-    @typechecked
-    def _after_hide_reset(
-        self, panel_widget: QWidget, direction: Literal["left", "right", "top", "bottom"]
-    ):
-        """
-        Reset the panel widget after hiding it in ensure_max mode.
-
-        Args:
-            panel_widget(QWidget): The panel widget to reset.
-            direction(Literal["left", "right", "top", "bottom"]): The direction of the panel.
-        """
-        # Called after hiding a panel in ensure_max mode
-        panel_widget.setVisible(False)
-        if direction in ["left", "right"]:
-            panel_widget.setMinimumWidth(0)
-            panel_widget.setMaximumWidth(0)
-            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        else:
-            panel_widget.setMinimumHeight(0)
-            panel_widget.setMaximumHeight(16777215)
-            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-
-####################################################################################################
-# The following code is for the GUI control panel to interact with the CollapsiblePanelManager.
-# It is not covered by any tests as it serves only as an example for the CollapsiblePanelManager class.
-####################################################################################################
-
-
-class MainWindow(QMainWindow):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("Panels with ensure_max, scale, and animation toggle")
-        self.resize(800, 600)
-
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-        main_layout = QVBoxLayout(central_widget)
-        main_layout.setContentsMargins(10, 10, 10, 10)
-        main_layout.setSpacing(10)
-
-        # Buttons
-        buttons_layout = QHBoxLayout()
-        self.btn_left = QPushButton("Toggle Left (ensure_max=True)")
-        self.btn_top = QPushButton("Toggle Top (scale=0.5, no animation)")
-        self.btn_right = QPushButton("Toggle Right (ensure_max=True, scale=0.3)")
-        self.btn_bottom = QPushButton("Toggle Bottom (no animation)")
-
-        buttons_layout.addWidget(self.btn_left)
-        buttons_layout.addWidget(self.btn_top)
-        buttons_layout.addWidget(self.btn_right)
-        buttons_layout.addWidget(self.btn_bottom)
-
-        main_layout.addLayout(buttons_layout)
-
-        self.layout_manager = LayoutManagerWidget()
-        main_layout.addWidget(self.layout_manager)
-
-        # Main widget
-        self.main_plot = pg.PlotWidget()
-        self.main_plot.plot([1, 2, 3, 4], [4, 3, 2, 1])
-        self.layout_manager.add_widget(self.main_plot, 0, 0)
-
-        self.panel_manager = CollapsiblePanelManager(self.layout_manager, self.main_plot)
-
-        # Panels
-        self.left_panel = pg.PlotWidget()
-        self.left_panel.plot([1, 2, 3], [3, 2, 1])
-        self.panel_manager.add_panel("left", self.left_panel, target_size=200)
-
-        self.right_panel = pg.PlotWidget()
-        self.right_panel.plot([10, 20, 30], [1, 10, 1])
-        self.panel_manager.add_panel("right", self.right_panel, target_size=200)
-
-        self.top_panel = pg.PlotWidget()
-        self.top_panel.plot([1, 2, 3], [1, 2, 3])
-        self.panel_manager.add_panel("top", self.top_panel, target_size=150)
-
-        self.bottom_panel = pg.PlotWidget()
-        self.bottom_panel.plot([2, 4, 6], [10, 5, 10])
-        self.panel_manager.add_panel("bottom", self.bottom_panel, target_size=150)
-
-        # Connect buttons
-        # Left with ensure_max
-        self.btn_left.clicked.connect(
-            lambda: self.panel_manager.toggle_panel("left", ensure_max=True)
-        )
-        # Top with scale=0.5 and no animation
-        self.btn_top.clicked.connect(
-            lambda: self.panel_manager.toggle_panel("top", scale=0.5, animation=False)
-        )
-        # Right with ensure_max, scale=0.3
-        self.btn_right.clicked.connect(
-            lambda: self.panel_manager.toggle_panel("right", ensure_max=True, scale=0.3)
-        )
-        # Bottom no animation
-        self.btn_bottom.clicked.connect(
-            lambda: self.panel_manager.toggle_panel("bottom", target_size=100, animation=False)
-        )
-
-
-if __name__ == "__main__":  # pragma: no cover
-    app = QApplication(sys.argv)
-    w = MainWindow()
-    w.show()
-    sys.exit(app.exec())

bec_widgets/qt_utils/error_popups.py

@@ -2,46 +2,10 @@ import functools
 import sys
 import traceback
 
-from qtpy.QtCore import Property, QObject, Qt, Signal, Slot
+from qtpy.QtCore import QObject, Qt, Signal, Slot
 from qtpy.QtWidgets import QApplication, QMessageBox, QPushButton, QVBoxLayout, QWidget
 
 
-def SafeProperty(prop_type, *prop_args, popup_error: bool = False, **prop_kwargs):
-    """
-    Decorator to create a Qt Property with a safe setter that won't crash Designer on errors.
-    Behaves similarly to SafeSlot, but for properties.
-
-    Args:
-        prop_type: The property type (e.g., str, bool, "QStringList", etc.)
-        popup_error (bool): If True, show popup on error, otherwise just handle it silently.
-        *prop_args, **prop_kwargs: Additional arguments and keyword arguments accepted by Property.
-    """
-
-    def decorator(getter):
-        class PropertyWrapper:
-            def __init__(self, getter_func):
-                self.getter_func = getter_func
-
-            def setter(self, setter_func):
-                @functools.wraps(setter_func)
-                def safe_setter(self_, value):
-                    try:
-                        return setter_func(self_, value)
-                    except Exception:
-                        if popup_error:
-                            ErrorPopupUtility().custom_exception_hook(
-                                *sys.exc_info(), popup_error=True
-                            )
-                        else:
-                            return
-
-                return Property(prop_type, self.getter_func, safe_setter, *prop_args, **prop_kwargs)
-
-        return PropertyWrapper(getter)
-
-    return decorator
-
-
 def SafeSlot(*slot_args, **slot_kwargs):  # pylint: disable=invalid-name
     """Function with args, acting like a decorator, applying "error_managed" decorator + Qt Slot
     to the passed function, to display errors instead of potentially raising an exception
@@ -127,12 +91,6 @@ class _ErrorPopupUtility(QObject):
         msg.setMinimumHeight(400)
         msg.exec_()
 
-    def show_property_error(self, title, message, widget):
-        """
-        Show a property-specific error message.
-        """
-        self.error_occurred.emit(title, message, widget)
-
     def format_traceback(self, traceback_message: str) -> str:
         """
         Format the traceback message to be displayed in the error popup by adding indentation to each line.
@@ -169,14 +127,12 @@ class _ErrorPopupUtility(QObject):
             error_message = " ".join(captured_message)
         return error_message
 
-    def get_error_message(self, exctype, value, tb):
-        return "".join(traceback.format_exception(exctype, value, tb))
-
     def custom_exception_hook(self, exctype, value, tb, popup_error=False):
         if popup_error or self.enable_error_popup:
+            error_message = traceback.format_exception(exctype, value, tb)
             self.error_occurred.emit(
                 "Method error" if popup_error else "Application Error",
-                self.get_error_message(exctype, value, tb),
+                "".join(error_message),
                 self.parent(),
             )
         else:

bec_widgets/qt_utils/round_frame.py

@@ -1,177 +0,0 @@
-import pyqtgraph as pg
-from qtpy.QtCore import Property
-from qtpy.QtWidgets import QApplication, QFrame, QVBoxLayout, QWidget
-
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
-
-
-class RoundedFrame(BECWidget, QFrame):
-    """
-    A custom QFrame with rounded corners and optional theme updates.
-    The frame can contain any QWidget, however it is mainly designed to wrap PlotWidgets to provide a consistent look and feel with other BEC Widgets.
-    """
-
-    def __init__(
-        self,
-        parent=None,
-        content_widget: QWidget = None,
-        background_color: str = None,
-        theme_update: bool = True,
-        radius: int = 10,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        QFrame.__init__(self, parent)
-
-        self.background_color = background_color
-        self.theme_update = theme_update if background_color is None else False
-        self._radius = radius
-
-        # Apply rounded frame styling
-        self.setObjectName("roundedFrame")
-        self.update_style()
-
-        # Create a layout for the frame
-        layout = QVBoxLayout(self)
-        layout.setContentsMargins(5, 5, 5, 5)  # Set 5px margin
-
-        # Add the content widget to the layout
-        if content_widget:
-            layout.addWidget(content_widget)
-
-        # Store reference to the content widget
-        self.content_widget = content_widget
-
-        # Automatically apply initial styles to the PlotWidget if applicable
-        if isinstance(content_widget, pg.PlotWidget):
-            self.apply_plot_widget_style()
-
-        self._connect_to_theme_change()
-
-    def apply_theme(self, theme: str):
-        """
-        Apply the theme to the frame and its content if theme updates are enabled.
-        """
-        if not self.theme_update:
-            return
-
-        # Update background color based on the theme
-        if theme == "light":
-            self.background_color = "#e9ecef"  # Subtle contrast for light mode
-        else:
-            self.background_color = "#141414"  # Dark mode
-
-        self.update_style()
-
-        # Update PlotWidget's background color and axis styles if applicable
-        if isinstance(self.content_widget, pg.PlotWidget):
-            self.apply_plot_widget_style()
-
-    @Property(int)
-    def radius(self):
-        """Radius of the rounded corners."""
-        return self._radius
-
-    @radius.setter
-    def radius(self, value: int):
-        self._radius = value
-        self.update_style()
-
-    def update_style(self):
-        """
-        Update the style of the frame based on the background color.
-        """
-        if self.background_color:
-            self.setStyleSheet(
-                f"""
-                QFrame#roundedFrame {{
-                    background-color: {self.background_color}; 
-                    border-radius: {self._radius}; /* Rounded corners */
-                }}
-            """
-            )
-
-    def apply_plot_widget_style(self, border: str = "none"):
-        """
-        Automatically apply background, border, and axis styles to the PlotWidget.
-
-        Args:
-            border (str): Border style (e.g., 'none', '1px solid red').
-        """
-        if isinstance(self.content_widget, pg.PlotWidget):
-            # Sync PlotWidget's background color with the RoundedFrame's background color
-            self.content_widget.setBackground(self.background_color)
-
-            # Calculate contrast-optimized axis and label colors
-            if self.background_color == "#e9ecef":  # Light mode
-                label_color = "#000000"
-                axis_color = "#666666"
-            else:  # Dark mode
-                label_color = "#FFFFFF"
-                axis_color = "#CCCCCC"
-
-            # Apply axis label and tick colors
-            plot_item = self.content_widget.getPlotItem()
-            plot_item.getAxis("left").setPen(pg.mkPen(color=axis_color))
-            plot_item.getAxis("bottom").setPen(pg.mkPen(color=axis_color))
-            plot_item.getAxis("left").setTextPen(pg.mkPen(color=label_color))
-            plot_item.getAxis("bottom").setTextPen(pg.mkPen(color=label_color))
-
-            # Apply border style via stylesheet
-            self.content_widget.setStyleSheet(
-                f"""
-                PlotWidget {{
-                    border: {border}; /* Explicitly set the border */
-                }}
-            """
-            )
-
-
-class ExampleApp(QWidget):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("Rounded Plots Example")
-
-        # Main layout
-        layout = QVBoxLayout(self)
-
-        dark_button = DarkModeButton()
-
-        # Create PlotWidgets
-        plot1 = pg.PlotWidget()
-        plot1.plot([1, 3, 2, 4, 6, 5], pen="r")
-
-        plot2 = pg.PlotWidget()
-        plot2.plot([1, 2, 4, 8, 16, 32], pen="r")
-
-        # Wrap PlotWidgets in RoundedFrame
-        rounded_plot1 = RoundedFrame(content_widget=plot1, theme_update=True)
-        rounded_plot2 = RoundedFrame(content_widget=plot2, theme_update=True)
-        round = RoundedFrame()
-
-        # Add to layout
-        layout.addWidget(dark_button)
-        layout.addWidget(rounded_plot1)
-        layout.addWidget(rounded_plot2)
-        layout.addWidget(round)
-
-        self.setLayout(layout)
-
-        # Simulate theme change after 2 seconds
-        from qtpy.QtCore import QTimer
-
-        def change_theme():
-            rounded_plot1.apply_theme("light")
-            rounded_plot2.apply_theme("dark")
-
-        QTimer.singleShot(100, change_theme)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    app = QApplication([])
-
-    window = ExampleApp()
-    window.show()
-
-    app.exec()

bec_widgets/qt_utils/side_panel.py

@@ -1,386 +0,0 @@
-import sys
-from typing import Literal, Optional
-
-from qtpy.QtCore import Property, QEasingCurve, QPropertyAnimation
-from qtpy.QtGui import QAction
-from qtpy.QtWidgets import (
-    QApplication,
-    QHBoxLayout,
-    QLabel,
-    QMainWindow,
-    QSizePolicy,
-    QSpacerItem,
-    QStackedWidget,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.qt_utils.toolbar import MaterialIconAction, ModularToolBar
-from bec_widgets.widgets.plots.waveform.waveform_widget import BECWaveformWidget
-
-
-class SidePanel(QWidget):
-    """
-    Side panel widget that can be placed on the left, right, top, or bottom of the main widget.
-    """
-
-    def __init__(
-        self,
-        parent=None,
-        orientation: Literal["left", "right", "top", "bottom"] = "left",
-        panel_max_width: int = 200,
-        animation_duration: int = 200,
-        animations_enabled: bool = True,
-    ):
-        super().__init__(parent=parent)
-
-        self._orientation = orientation
-        self._panel_max_width = panel_max_width
-        self._animation_duration = animation_duration
-        self._animations_enabled = animations_enabled
-        self._orientation = orientation
-
-        self._panel_width = 0
-        self._panel_height = 0
-        self.panel_visible = False
-        self.current_action: Optional[QAction] = None
-        self.current_index: Optional[int] = None
-        self.switching_actions = False
-
-        self._init_ui()
-
-    def _init_ui(self):
-        """
-        Initialize the UI elements.
-        """
-        if self._orientation in ("left", "right"):
-            self.main_layout = QHBoxLayout(self)
-            self.main_layout.setContentsMargins(0, 0, 0, 0)
-            self.main_layout.setSpacing(0)
-
-            self.toolbar = ModularToolBar(target_widget=self, orientation="vertical")
-
-            self.container = QWidget()
-            self.container.layout = QVBoxLayout(self.container)
-            self.container.layout.setContentsMargins(0, 0, 0, 0)
-            self.container.layout.setSpacing(0)
-
-            self.stack_widget = QStackedWidget()
-            self.stack_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
-            self.stack_widget.setMinimumWidth(5)
-
-            if self._orientation == "left":
-                self.main_layout.addWidget(self.toolbar)
-                self.main_layout.addWidget(self.container)
-            else:
-                self.main_layout.addWidget(self.container)
-                self.main_layout.addWidget(self.toolbar)
-
-            self.container.layout.addWidget(self.stack_widget)
-            self.stack_widget.setMaximumWidth(self._panel_max_width)
-
-        else:
-            self.main_layout = QVBoxLayout(self)
-            self.main_layout.setContentsMargins(0, 0, 0, 0)
-            self.main_layout.setSpacing(0)
-
-            self.toolbar = ModularToolBar(target_widget=self, orientation="horizontal")
-
-            self.container = QWidget()
-            self.container.layout = QVBoxLayout(self.container)
-            self.container.layout.setContentsMargins(0, 0, 0, 0)
-            self.container.layout.setSpacing(0)
-
-            self.stack_widget = QStackedWidget()
-            self.stack_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
-            self.stack_widget.setMinimumHeight(5)
-
-            if self._orientation == "top":
-                self.main_layout.addWidget(self.toolbar)
-                self.main_layout.addWidget(self.container)
-            else:
-                self.main_layout.addWidget(self.container)
-                self.main_layout.addWidget(self.toolbar)
-
-            self.container.layout.addWidget(self.stack_widget)
-            self.stack_widget.setMaximumHeight(self._panel_max_width)
-
-        if self._orientation in ("left", "right"):
-            self.menu_anim = QPropertyAnimation(self, b"panel_width")
-        else:
-            self.menu_anim = QPropertyAnimation(self, b"panel_height")
-
-        self.menu_anim.setDuration(self._animation_duration)
-        self.menu_anim.setEasingCurve(QEasingCurve.InOutQuad)
-
-        if self._orientation in ("left", "right"):
-            self.panel_width = 0
-        else:
-            self.panel_height = 0
-
-    @Property(int)
-    def panel_width(self):
-        """
-        Get the panel width.
-        """
-        return self._panel_width
-
-    @panel_width.setter
-    def panel_width(self, width: int):
-        """
-        Set the panel width.
-
-        Args:
-            width(int): The width of the panel.
-        """
-        self._panel_width = width
-        if self._orientation in ("left", "right"):
-            self.stack_widget.setFixedWidth(width)
-
-    @Property(int)
-    def panel_height(self):
-        """
-        Get the panel height.
-        """
-        return self._panel_height
-
-    @panel_height.setter
-    def panel_height(self, height: int):
-        """
-        Set the panel height.
-
-        Args:
-            height(int): The height of the panel.
-        """
-        self._panel_height = height
-        if self._orientation in ("top", "bottom"):
-            self.stack_widget.setFixedHeight(height)
-
-    @Property(int)
-    def panel_max_width(self):
-        """
-        Get the maximum width of the panel.
-        """
-        return self._panel_max_width
-
-    @panel_max_width.setter
-    def panel_max_width(self, size: int):
-        """
-        Set the maximum width of the panel.
-
-        Args:
-            size(int): The maximum width of the panel.
-        """
-        self._panel_max_width = size
-        if self._orientation in ("left", "right"):
-            self.stack_widget.setMaximumWidth(self._panel_max_width)
-        else:
-            self.stack_widget.setMaximumHeight(self._panel_max_width)
-
-    @Property(int)
-    def animation_duration(self):
-        """
-        Get the duration of the animation.
-        """
-        return self._animation_duration
-
-    @animation_duration.setter
-    def animation_duration(self, duration: int):
-        """
-        Set the duration of the animation.
-
-        Args:
-            duration(int): The duration of the animation.
-        """
-        self._animation_duration = duration
-        self.menu_anim.setDuration(duration)
-
-    @Property(bool)
-    def animations_enabled(self):
-        """
-        Get the status of the animations.
-        """
-        return self._animations_enabled
-
-    @animations_enabled.setter
-    def animations_enabled(self, enabled: bool):
-        """
-        Set the status of the animations.
-
-        Args:
-            enabled(bool): The status of the animations.
-        """
-        self._animations_enabled = enabled
-
-    def show_panel(self, idx: int):
-        """
-        Show the side panel with animation and switch to idx.
-
-        Args:
-            idx(int): The index of the panel to show.
-        """
-        self.stack_widget.setCurrentIndex(idx)
-        self.panel_visible = True
-        self.current_index = idx
-
-        if self._orientation in ("left", "right"):
-            start_val, end_val = 0, self._panel_max_width
-        else:
-            start_val, end_val = 0, self._panel_max_width
-
-        if self._animations_enabled:
-            self.menu_anim.stop()
-            self.menu_anim.setStartValue(start_val)
-            self.menu_anim.setEndValue(end_val)
-            self.menu_anim.start()
-        else:
-            if self._orientation in ("left", "right"):
-                self.panel_width = end_val
-            else:
-                self.panel_height = end_val
-
-    def hide_panel(self):
-        """
-        Hide the side panel with animation.
-        """
-        self.panel_visible = False
-        self.current_index = None
-
-        if self._orientation in ("left", "right"):
-            start_val, end_val = self._panel_max_width, 0
-        else:
-            start_val, end_val = self._panel_max_width, 0
-
-        if self._animations_enabled:
-            self.menu_anim.stop()
-            self.menu_anim.setStartValue(start_val)
-            self.menu_anim.setEndValue(end_val)
-            self.menu_anim.start()
-        else:
-            if self._orientation in ("left", "right"):
-                self.panel_width = end_val
-            else:
-                self.panel_height = end_val
-
-    def switch_to(self, idx: int):
-        """
-        Switch to the specified index without animation.
-
-        Args:
-            idx(int): The index of the panel to switch to.
-        """
-        if self.current_index != idx:
-            self.stack_widget.setCurrentIndex(idx)
-            self.current_index = idx
-
-    def add_menu(self, action_id: str, icon_name: str, tooltip: str, widget: QWidget, title: str):
-        """
-        Add a menu to the side panel.
-
-        Args:
-            action_id(str): The ID of the action.
-            icon_name(str): The name of the icon.
-            tooltip(str): The tooltip for the action.
-            widget(QWidget): The widget to add to the panel.
-            title(str): The title of the panel.
-        """
-        container_widget = QWidget()
-        container_layout = QVBoxLayout(container_widget)
-        container_widget.setStyleSheet("background-color: rgba(0,0,0,0);")
-        title_label = QLabel(f"<b>{title}</b>")
-        title_label.setStyleSheet("font-size: 16px;")
-        spacer = QSpacerItem(0, 0, QSizePolicy.Minimum, QSizePolicy.Expanding)
-        container_layout.addWidget(title_label)
-        container_layout.addWidget(widget)
-        container_layout.addItem(spacer)
-        container_layout.setContentsMargins(5, 5, 5, 5)
-        container_layout.setSpacing(5)
-
-        index = self.stack_widget.count()
-        self.stack_widget.addWidget(container_widget)
-
-        action = MaterialIconAction(icon_name=icon_name, tooltip=tooltip, checkable=True)
-        self.toolbar.add_action(action_id, action, target_widget=self)
-
-        def on_action_toggled(checked: bool):
-            if self.switching_actions:
-                return
-
-            if checked:
-                if self.current_action and self.current_action != action.action:
-                    self.switching_actions = True
-                    self.current_action.setChecked(False)
-                    self.switching_actions = False
-
-                self.current_action = action.action
-
-                if not self.panel_visible:
-                    self.show_panel(index)
-                else:
-                    self.switch_to(index)
-            else:
-                if self.current_action == action.action:
-                    self.current_action = None
-                    self.hide_panel()
-
-        action.action.toggled.connect(on_action_toggled)
-
-
-class ExampleApp(QMainWindow):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("Side Panel Example")
-
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-
-        self.side_panel = SidePanel(self, orientation="left")
-
-        self.layout = QHBoxLayout(central_widget)
-
-        self.layout.addWidget(self.side_panel)
-        self.plot = BECWaveformWidget()
-        self.layout.addWidget(self.plot)
-        self.add_side_menus()
-
-    def add_side_menus(self):
-        widget1 = QWidget()
-        widget1_layout = QVBoxLayout(widget1)
-        widget1_layout.addWidget(QLabel("This is Widget 1"))
-        self.side_panel.add_menu(
-            action_id="widget1",
-            icon_name="counter_1",
-            tooltip="Show Widget 1",
-            widget=widget1,
-            title="Widget 1 Panel",
-        )
-
-        widget2 = QWidget()
-        widget2_layout = QVBoxLayout(widget2)
-        widget2_layout.addWidget(QLabel("This is Widget 2"))
-        self.side_panel.add_menu(
-            action_id="widget2",
-            icon_name="counter_2",
-            tooltip="Show Widget 2",
-            widget=widget2,
-            title="Widget 2 Panel",
-        )
-
-        widget3 = QWidget()
-        widget3_layout = QVBoxLayout(widget3)
-        widget3_layout.addWidget(QLabel("This is Widget 3"))
-        self.side_panel.add_menu(
-            action_id="widget3",
-            icon_name="counter_3",
-            tooltip="Show Widget 3",
-            widget=widget3,
-            title="Widget 3 Panel",
-        )
-
-
-if __name__ == "__main__":  # pragma: no cover
-    app = QApplication(sys.argv)
-    window = ExampleApp()
-    window.resize(800, 600)
-    window.show()
-    sys.exit(app.exec())

bec_widgets/qt_utils/toolbar.py

@@ -261,31 +261,17 @@ class ExpandableMenuAction(ToolBarAction):
 
 class ModularToolBar(QToolBar):
     """Modular toolbar with optional automatic initialization.
-
     Args:
         parent (QWidget, optional): The parent widget of the toolbar. Defaults to None.
-        actions (dict, optional): A dictionary of action creators to populate the toolbar. Defaults to None.
+        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.
-        orientation (Literal["horizontal", "vertical"], optional): The initial orientation of the toolbar. Defaults to "horizontal".
-        background_color (str, optional): The background color of the toolbar. Defaults to "rgba(0, 0, 0, 0)" - transparent background.
     """
 
-    def __init__(
-        self,
-        parent=None,
-        actions: dict | None = None,
-        target_widget=None,
-        orientation: Literal["horizontal", "vertical"] = "horizontal",
-        background_color: str = "rgba(0, 0, 0, 0)",
-    ):
+    def __init__(self, parent=None, actions: dict | None = None, target_widget=None):
         super().__init__(parent)
 
         self.widgets = defaultdict(dict)
-        self.background_color = background_color
-        self.set_background_color(self.background_color)
-
-        # Set the initial orientation
-        self.set_orientation(orientation)
+        self.set_background_color()
 
         if actions is not None and target_widget is not None:
             self.populate_toolbar(actions, target_widget)
@@ -294,7 +280,7 @@ class ModularToolBar(QToolBar):
         """Populates the toolbar with a set of actions.
 
         Args:
-            actions (dict): A dictionary of action creators to populate the toolbar.
+            actions (list[ToolBarAction]): A list of action creators to populate the toolbar.
             target_widget (QWidget): The widget that the actions will target.
         """
         self.clear()
@@ -302,83 +288,9 @@ class ModularToolBar(QToolBar):
             action.add_to_toolbar(self, target_widget)
             self.widgets[action_id] = action
 
-    def set_background_color(self, color: str = "rgba(0, 0, 0, 0)"):
-        """
-        Sets the background color and other appearance settings.
-
-        Args:
-            color(str): The background color of the toolbar.
-        """
+    def set_background_color(self):
         self.setIconSize(QSize(20, 20))
         self.setMovable(False)
         self.setFloatable(False)
         self.setContentsMargins(0, 0, 0, 0)
-        self.background_color = color
-        self.setStyleSheet(f"QToolBar {{ background-color: {color}; border: none; }}")
-
-    def set_orientation(self, orientation: Literal["horizontal", "vertical"]):
-        """Sets the orientation of the toolbar.
-
-        Args:
-            orientation (Literal["horizontal", "vertical"]): The desired orientation of the toolbar.
-        """
-        if orientation == "horizontal":
-            self.setOrientation(Qt.Horizontal)
-        elif orientation == "vertical":
-            self.setOrientation(Qt.Vertical)
-        else:
-            raise ValueError("Orientation must be 'horizontal' or 'vertical'.")
-
-    def update_material_icon_colors(self, new_color: str | tuple | QColor):
-        """
-        Updates the color of all MaterialIconAction icons in the toolbar.
-
-        Args:
-            new_color (str | tuple | QColor): The new color for the icons.
-        """
-        for action in self.widgets.values():
-            if isinstance(action, MaterialIconAction):
-                action.color = new_color
-                # Refresh the icon
-                updated_icon = action.get_icon()
-                action.action.setIcon(updated_icon)
-
-    def add_action(self, action_id: str, action: ToolBarAction, target_widget: QWidget):
-        """
-        Adds a new action to the toolbar dynamically.
-
-        Args:
-            action_id (str): Unique identifier for the action.
-            action (ToolBarAction): The action to add to the toolbar.
-            target_widget (QWidget): The target widget for the action.
-        """
-        if action_id in self.widgets:
-            raise ValueError(f"Action with ID '{action_id}' already exists.")
-        action.add_to_toolbar(self, target_widget)
-        self.widgets[action_id] = action
-
-    def hide_action(self, action_id: str):
-        """
-        Hides a specific action on the toolbar.
-
-        Args:
-            action_id (str): Unique identifier for the action to hide.
-        """
-        if action_id not in self.widgets:
-            raise ValueError(f"Action with ID '{action_id}' does not exist.")
-        action = self.widgets[action_id]
-        if hasattr(action, "action") and isinstance(action.action, QAction):
-            action.action.setVisible(False)
-
-    def show_action(self, action_id: str):
-        """
-        Shows a specific action on the toolbar.
-
-        Args:
-            action_id (str): Unique identifier for the action to show.
-        """
-        if action_id not in self.widgets:
-            raise ValueError(f"Action with ID '{action_id}' does not exist.")
-        action = self.widgets[action_id]
-        if hasattr(action, "action") and isinstance(action.action, QAction):
-            action.action.setVisible(True)
+        self.setStyleSheet("QToolBar { background-color: rgba(0, 0, 0, 0); border: none; }")

bec_widgets/tests/utils.py

@@ -224,11 +224,3 @@ DEVICES = [
     Positioner("test", limits=[-10, 10], read_value=2.0),
     Device("test_device"),
 ]
-
-
-def check_remote_data_size(widget, plot_name, num_elements):
-    """
-    Check if the remote data has the correct number of elements.
-    Used in the qtbot.waitUntil function.
-    """
-    return len(widget.get_all_data()[plot_name]["x"]) == num_elements

bec_widgets/utils/bec_connector.py

@@ -12,7 +12,7 @@ from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
 from qtpy.QtWidgets import QApplication
 
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.qt_utils.error_popups import ErrorPopupUtility
 from bec_widgets.qt_utils.error_popups import SafeSlot as pyqtSlot
 from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui

bec_widgets/utils/bec_designer.py

@@ -93,24 +93,17 @@ def patch_designer():  # pragma: no cover
             _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"
-            current_pid = os.getpid()
-            with open(f"/proc/{current_pid}/maps", "rt") as f:
-                for line in f:
-                    if "libpython" in line:
-                        lib_path = line.split()[-1]
-                        os.environ[env_var] = lib_path
-                        break
-
         elif sys.platform == "darwin":
             suffix = ".dylib"
             env_var = "DYLD_INSERT_LIBRARIES"
-            version = f"{major_version}.{minor_version}"
-            library_name = f"libpython{version}{suffix}"
-            lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
-            os.environ[env_var] = lib_path
         else:
             raise RuntimeError(f"Unsupported platform: {sys.platform}")
+        version = f"{major_version}.{minor_version}"
+        library_name = f"libpython{version}{suffix}"
+        lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
+        os.environ[env_var] = lib_path
 
         if is_pyenv_python() or is_virtual_env():
             # append all editable packages to the PYTHONPATH

bec_widgets/utils/widget_io.py

@@ -1,5 +1,6 @@
 # pylint: disable=no-name-in-module
 from abc import ABC, abstractmethod
+from typing import Literal
 
 from qtpy.QtWidgets import (
     QApplication,
@@ -27,15 +28,6 @@ class WidgetHandler(ABC):
     def set_value(self, widget: QWidget, value):
         """Set a value on the widget instance."""
 
-    def connect_change_signal(self, widget: QWidget, slot):
-        """
-        Connect a change signal from this widget to the given slot.
-        If the widget type doesn't have a known "value changed" signal, do nothing.
-
-        slot: a function accepting two arguments (widget, value)
-        """
-        pass
-
 
 class LineEditHandler(WidgetHandler):
     """Handler for QLineEdit widgets."""
@@ -46,9 +38,6 @@ class LineEditHandler(WidgetHandler):
     def set_value(self, widget: QLineEdit, value: str) -> None:
         widget.setText(value)
 
-    def connect_change_signal(self, widget: QLineEdit, slot):
-        widget.textChanged.connect(lambda text, w=widget: slot(w, text))
-
 
 class ComboBoxHandler(WidgetHandler):
     """Handler for QComboBox widgets."""
@@ -64,11 +53,6 @@ class ComboBoxHandler(WidgetHandler):
         if isinstance(value, int):
             widget.setCurrentIndex(value)
 
-    def connect_change_signal(self, widget: QComboBox, slot):
-        # currentIndexChanged(int) or currentIndexChanged(str) both possible.
-        # We use currentIndexChanged(int) for a consistent behavior.
-        widget.currentIndexChanged.connect(lambda idx, w=widget: slot(w, self.get_value(w)))
-
 
 class TableWidgetHandler(WidgetHandler):
     """Handler for QTableWidget widgets."""
@@ -88,16 +72,6 @@ class TableWidgetHandler(WidgetHandler):
                 item = QTableWidgetItem(str(cell_value))
                 widget.setItem(row, col, item)
 
-    def connect_change_signal(self, widget: QTableWidget, slot):
-        # If desired, we could connect cellChanged(row, col) and then fetch all data.
-        # This might be noisy if table is large.
-        # For demonstration, connect cellChanged to update entire table value.
-        def on_cell_changed(row, col, w=widget):
-            val = self.get_value(w)
-            slot(w, val)
-
-        widget.cellChanged.connect(on_cell_changed)
-
 
 class SpinBoxHandler(WidgetHandler):
     """Handler for QSpinBox and QDoubleSpinBox widgets."""
@@ -108,9 +82,6 @@ class SpinBoxHandler(WidgetHandler):
     def set_value(self, widget, value):
         widget.setValue(value)
 
-    def connect_change_signal(self, widget: QSpinBox | QDoubleSpinBox, slot):
-        widget.valueChanged.connect(lambda val, w=widget: slot(w, val))
-
 
 class CheckBoxHandler(WidgetHandler):
     """Handler for QCheckBox widgets."""
@@ -121,9 +92,6 @@ class CheckBoxHandler(WidgetHandler):
     def set_value(self, widget, value):
         widget.setChecked(value)
 
-    def connect_change_signal(self, widget: QCheckBox, slot):
-        widget.toggled.connect(lambda val, w=widget: slot(w, val))
-
 
 class LabelHandler(WidgetHandler):
     """Handler for QLabel widgets."""
@@ -131,15 +99,12 @@ class LabelHandler(WidgetHandler):
     def get_value(self, widget, **kwargs):
         return widget.text()
 
-    def set_value(self, widget: QLabel, value):
+    def set_value(self, widget, value):
         widget.setText(value)
 
-    # QLabel typically doesn't have user-editable changes. No signal to connect.
-    # If needed, this can remain empty.
-
 
 class WidgetIO:
-    """Public interface for getting, setting values and connecting signals using handler mapping"""
+    """Public interface for getting and setting values using handler mapping"""
 
     _handlers = {
         QLineEdit: LineEditHandler,
@@ -183,17 +148,6 @@ class WidgetIO:
         elif not ignore_errors:
             raise ValueError(f"No handler for widget type: {type(widget)}")
 
-    @staticmethod
-    def connect_widget_change_signal(widget, slot):
-        """
-        Connect the widget's value-changed signal to a generic slot function (widget, value).
-        This now delegates the logic to the widget's handler.
-        """
-        handler_class = WidgetIO._find_handler(widget)
-        if handler_class:
-            handler = handler_class()
-            handler.connect_change_signal(widget, slot)
-
     @staticmethod
     def check_and_adjust_limits(spin_box: QDoubleSpinBox, number: float):
         """
@@ -355,8 +309,8 @@ class WidgetHierarchy:
                 WidgetHierarchy.import_config_from_dict(child, widget_config, set_values)
 
 
-# Example usage
-def hierarchy_example():  # pragma: no cover
+# Example application to demonstrate the usage of the functions
+if __name__ == "__main__":  # pragma: no cover
     app = QApplication([])
 
     # Create instance of WidgetHierarchy
@@ -411,37 +365,3 @@ def hierarchy_example():  # pragma: no cover
     print(f"Config dict new REDUCED: {config_dict_new_reduced}")
 
     app.exec()
-
-
-def widget_io_signal_example():  # pragma: no cover
-    app = QApplication([])
-
-    main_widget = QWidget()
-    layout = QVBoxLayout(main_widget)
-    line_edit = QLineEdit(main_widget)
-    combo_box = QComboBox(main_widget)
-    spin_box = QSpinBox(main_widget)
-    combo_box.addItems(["Option 1", "Option 2", "Option 3"])
-
-    layout.addWidget(line_edit)
-    layout.addWidget(combo_box)
-    layout.addWidget(spin_box)
-
-    main_widget.show()
-
-    def universal_slot(w, val):
-        print(f"Widget {w.objectName() or w} changed, new value: {val}")
-
-    # Connect all supported widgets through their handlers
-    WidgetIO.connect_widget_change_signal(line_edit, universal_slot)
-    WidgetIO.connect_widget_change_signal(combo_box, universal_slot)
-    WidgetIO.connect_widget_change_signal(spin_box, universal_slot)
-
-    app.exec_()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    # Change example function to test different scenarios
-
-    # hierarchy_example()
-    widget_io_signal_example()

bec_widgets/widgets/containers/dock/dock.py

@@ -6,7 +6,7 @@ from pydantic import Field
 from pyqtgraph.dockarea import Dock, DockLabel
 from qtpy import QtCore, QtGui
 
-from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
+from bec_widgets.cli.rpc_wigdet_handler import widget_handler
 from bec_widgets.utils import ConnectionConfig, GridLayoutManager
 from bec_widgets.utils.bec_widget import BECWidget
 

bec_widgets/widgets/containers/dock/dock_area.py

@@ -3,12 +3,11 @@ from __future__ import annotations
 from typing import Literal, Optional
 from weakref import WeakValueDictionary
 
-from bec_lib.endpoints import MessageEndpoints
 from pydantic import Field
 from pyqtgraph.dockarea.DockArea import DockArea
-from qtpy.QtCore import QSize, Qt
+from qtpy.QtCore import Qt
 from qtpy.QtGui import QPainter, QPaintEvent
-from qtpy.QtWidgets import QApplication, QSizePolicy, QVBoxLayout, QWidget
+from qtpy.QtWidgets import QSizePolicy, QVBoxLayout, QWidget
 
 from bec_widgets.qt_utils.error_popups import SafeSlot
 from bec_widgets.qt_utils.toolbar import (
@@ -44,7 +43,6 @@ class BECDockArea(BECWidget, QWidget):
     PLUGIN = True
     USER_ACCESS = [
         "_config_dict",
-        "selected_device",
         "panels",
         "save_state",
         "remove_dock",
@@ -57,7 +55,6 @@ class BECDockArea(BECWidget, QWidget):
         "temp_areas",
         "show",
         "hide",
-        "delete",
     ]
 
     def __init__(
@@ -161,9 +158,6 @@ class BECDockArea(BECWidget, QWidget):
         self.toolbar.addWidget(DarkModeButton(toolbar=True))
         self._hook_toolbar()
 
-    def minimumSizeHint(self):
-        return QSize(800, 600)
-
     def _hook_toolbar(self):
         # Menu Plot
         self.toolbar.widgets["menu_plots"].widgets["waveform"].triggered.connect(
@@ -216,17 +210,6 @@ class BECDockArea(BECWidget, QWidget):
                 "Add docks using 'add_dock' method from CLI\n or \n Add widget docks using the toolbar",
             )
 
-    @property
-    def selected_device(self) -> str:
-        gui_id = QApplication.instance().gui_id
-        auto_update_config = self.client.connector.get(
-            MessageEndpoints.gui_auto_update_config(gui_id)
-        )
-        try:
-            return auto_update_config.selected_device
-        except AttributeError:
-            return None
-
     @property
     def panels(self) -> dict[str, BECDock]:
         """
@@ -423,17 +406,6 @@ class BECDockArea(BECWidget, QWidget):
         self.dock_area.deleteLater()
         super().cleanup()
 
-    def closeEvent(self, event):
-        if self.parent() is None:
-            # we are at top-level (independent window)
-            if self.isVisible():
-                # we are visible => user clicked on [X]
-                # (when closeEvent is called from shutdown procedure,
-                # everything is hidden first)
-                # so, let's ignore "close", and do hide instead
-                event.ignore()
-                self.setVisible(False)
-
     def close(self):
         """
         Close the dock area and cleanup.
@@ -446,24 +418,14 @@ class BECDockArea(BECWidget, QWidget):
         """Show all windows including floating docks."""
         super().show()
         for docks in self.panels.values():
-            if docks.window() is self:
-                # avoid recursion
-                continue
             docks.window().show()
 
     def hide(self):
         """Hide all windows including floating docks."""
         super().hide()
         for docks in self.panels.values():
-            if docks.window() is self:
-                # avoid recursion
-                continue
             docks.window().hide()
 
-    def delete(self):
-        self.hide()
-        self.deleteLater()
-
 
 if __name__ == "__main__":
     from qtpy.QtWidgets import QApplication

bec_widgets/widgets/containers/layout_manager/layout_manager.py

@@ -1,881 +0,0 @@
-import math
-import sys
-from typing import Dict, Literal, Optional, Set, Tuple, Union
-
-from qtpy.QtWidgets import (
-    QApplication,
-    QComboBox,
-    QGridLayout,
-    QGroupBox,
-    QHBoxLayout,
-    QLabel,
-    QLineEdit,
-    QMainWindow,
-    QMessageBox,
-    QPushButton,
-    QSpinBox,
-    QSplitter,
-    QVBoxLayout,
-    QWidget,
-)
-from typeguard import typechecked
-
-from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
-
-
-class LayoutManagerWidget(QWidget):
-    """
-    A robust layout manager that extends QGridLayout functionality, allowing
-    users to add/remove widgets, access widgets by coordinates, shift widgets,
-    and change the layout dynamically with automatic reindexing to keep the grid compact.
-
-    Supports adding widgets via QWidget instances or string identifiers referencing the widget handler.
-    """
-
-    def __init__(self, parent=None, auto_reindex=True):
-        super().__init__(parent)
-        self.layout = QGridLayout(self)
-        self.auto_reindex = auto_reindex
-
-        # Mapping from widget to its position (row, col, rowspan, colspan)
-        self.widget_positions: Dict[QWidget, Tuple[int, int, int, int]] = {}
-
-        # Mapping from (row, col) to widget
-        self.position_widgets: Dict[Tuple[int, int], QWidget] = {}
-
-        # Keep track of the current position for automatic placement
-        self.current_row = 0
-        self.current_col = 0
-
-    def add_widget(
-        self,
-        widget: QWidget | str,
-        row: int | None = None,
-        col: Optional[int] = None,
-        rowspan: int = 1,
-        colspan: int = 1,
-        shift_existing: bool = True,
-        shift_direction: Literal["down", "up", "left", "right"] = "right",
-    ) -> QWidget:
-        """
-        Add a widget to the grid with enhanced shifting capabilities.
-
-        Args:
-            widget (QWidget | str): The widget to add. If str, it is used to create a widget via widget_handler.
-            row (int, optional): The row to add the widget to. If None, the next available row is used.
-            col (int, optional): The column to add the widget to. If None, the next available column is used.
-            rowspan (int): Number of rows the widget spans. Default is 1.
-            colspan (int): Number of columns the widget spans. Default is 1.
-            shift_existing (bool): Whether to shift existing widgets if the target position is occupied. Default is True.
-            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets. Default is "right".
-
-        Returns:
-            QWidget: The widget that was added.
-        """
-        # Handle widget creation if a BECWidget string identifier is provided
-        if isinstance(widget, str):
-            widget = widget_handler.create_widget(widget)
-
-        if row is None:
-            row = self.current_row
-        if col is None:
-            col = self.current_col
-
-        if (row, col) in self.position_widgets:
-            if shift_existing:
-                # Attempt to shift the existing widget in the specified direction
-                self.shift_widgets(direction=shift_direction, start_row=row, start_col=col)
-            else:
-                raise ValueError(f"Position ({row}, {col}) is already occupied.")
-
-            # Add the widget to the layout
-        self.layout.addWidget(widget, row, col, rowspan, colspan)
-        self.widget_positions[widget] = (row, col, rowspan, colspan)
-        self.position_widgets[(row, col)] = widget
-
-        # Update current position for automatic placement
-        self.current_col = col + colspan
-        self.current_row = max(self.current_row, row)
-
-        if self.auto_reindex:
-            self.reindex_grid()
-
-        return widget
-
-    def add_widget_relative(
-        self,
-        widget: QWidget | str,
-        reference_widget: QWidget,
-        position: Literal["left", "right", "top", "bottom"],
-        rowspan: int = 1,
-        colspan: int = 1,
-        shift_existing: bool = True,
-        shift_direction: Literal["down", "up", "left", "right"] = "right",
-    ) -> QWidget:
-        """
-        Add a widget relative to an existing widget.
-
-        Args:
-            widget (QWidget | str): The widget to add. If str, it is used to create a widget via widget_handler.
-            reference_widget (QWidget): The widget relative to which the new widget will be placed.
-            position (Literal["left", "right", "top", "bottom"]): Position relative to the reference widget.
-            rowspan (int): Number of rows the widget spans. Default is 1.
-            colspan (int): Number of columns the widget spans. Default is 1.
-            shift_existing (bool): Whether to shift existing widgets if the target position is occupied.
-            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets.
-
-        Returns:
-            QWidget: The widget that was added.
-
-        Raises:
-            ValueError: If the reference widget is not found.
-        """
-        if reference_widget not in self.widget_positions:
-            raise ValueError("Reference widget not found in layout.")
-
-        ref_row, ref_col, ref_rowspan, ref_colspan = self.widget_positions[reference_widget]
-
-        # Determine new widget position based on the specified relative position
-        if position == "left":
-            new_row = ref_row
-            new_col = ref_col - 1
-        elif position == "right":
-            new_row = ref_row
-            new_col = ref_col + ref_colspan
-        elif position == "top":
-            new_row = ref_row - 1
-            new_col = ref_col
-        elif position == "bottom":
-            new_row = ref_row + ref_rowspan
-            new_col = ref_col
-        else:
-            raise ValueError("Invalid position. Choose from 'left', 'right', 'top', 'bottom'.")
-
-        # Add the widget at the calculated position
-        return self.add_widget(
-            widget=widget,
-            row=new_row,
-            col=new_col,
-            rowspan=rowspan,
-            colspan=colspan,
-            shift_existing=shift_existing,
-            shift_direction=shift_direction,
-        )
-
-    def move_widget_by_coords(
-        self,
-        current_row: int,
-        current_col: int,
-        new_row: int,
-        new_col: int,
-        shift: bool = True,
-        shift_direction: Literal["down", "up", "left", "right"] = "right",
-    ) -> None:
-        """
-        Move a widget from (current_row, current_col) to (new_row, new_col).
-
-        Args:
-            current_row (int): Current row of the widget.
-            current_col (int): Current column of the widget.
-            new_row (int): Target row.
-            new_col (int): Target column.
-            shift (bool): Whether to shift existing widgets if the target position is occupied.
-            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets.
-
-        Raises:
-            ValueError: If the widget is not found or target position is invalid.
-        """
-        self.move_widget(
-            old_row=current_row,
-            old_col=current_col,
-            new_row=new_row,
-            new_col=new_col,
-            shift=shift,
-            shift_direction=shift_direction,
-        )
-
-    @typechecked
-    def move_widget_by_object(
-        self,
-        widget: QWidget,
-        new_row: int,
-        new_col: int,
-        shift: bool = True,
-        shift_direction: Literal["down", "up", "left", "right"] = "right",
-    ) -> None:
-        """
-        Move a widget to a new position using the widget object.
-
-        Args:
-            widget (QWidget): The widget to move.
-            new_row (int): Target row.
-            new_col (int): Target column.
-            shift (bool): Whether to shift existing widgets if the target position is occupied.
-            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets.
-
-        Raises:
-            ValueError: If the widget is not found or target position is invalid.
-        """
-        if widget not in self.widget_positions:
-            raise ValueError("Widget not found in layout.")
-
-        old_position = self.widget_positions[widget]
-        old_row, old_col = old_position[0], old_position[1]
-
-        self.move_widget(
-            old_row=old_row,
-            old_col=old_col,
-            new_row=new_row,
-            new_col=new_col,
-            shift=shift,
-            shift_direction=shift_direction,
-        )
-
-    @typechecked
-    def move_widget(
-        self,
-        old_row: int | None = None,
-        old_col: int | None = None,
-        new_row: int | None = None,
-        new_col: int | None = None,
-        shift: bool = True,
-        shift_direction: Literal["down", "up", "left", "right"] = "right",
-    ) -> None:
-        """
-        Move a widget to a new position. If the new position is occupied and shift is True,
-        shift the existing widget to the specified direction.
-
-        Args:
-            old_row (int, optional): The current row of the widget.
-            old_col (int, optional): The current column of the widget.
-            new_row (int, optional): The target row to move the widget to.
-            new_col (int, optional): The target column to move the widget to.
-            shift (bool): Whether to shift existing widgets if the target position is occupied.
-            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets.
-
-        Raises:
-            ValueError: If the widget is not found or target position is invalid.
-        """
-        if new_row is None or new_col is None:
-            raise ValueError("Must provide both new_row and new_col to move a widget.")
-
-        if old_row is None and old_col is None:
-            raise ValueError(f"No widget found at position ({old_row}, {old_col}).")
-        widget = self.get_widget(old_row, old_col)
-
-        if (new_row, new_col) in self.position_widgets:
-            if not shift:
-                raise ValueError(f"Position ({new_row}, {new_col}) is already occupied.")
-            # Shift the existing widget to make space
-            self.shift_widgets(
-                direction=shift_direction,
-                start_row=new_row if shift_direction in ["down", "up"] else 0,
-                start_col=new_col if shift_direction in ["left", "right"] else 0,
-            )
-
-        # Proceed to move the widget
-        self.layout.removeWidget(widget)
-        old_position = self.widget_positions.pop(widget)
-        self.position_widgets.pop((old_position[0], old_position[1]))
-
-        self.layout.addWidget(widget, new_row, new_col, old_position[2], old_position[3])
-        self.widget_positions[widget] = (new_row, new_col, old_position[2], old_position[3])
-        self.position_widgets[(new_row, new_col)] = widget
-
-        # Update current_row and current_col for automatic placement if needed
-        self.current_row = max(self.current_row, new_row)
-        self.current_col = max(self.current_col, new_col + old_position[3])
-
-        if self.auto_reindex:
-            self.reindex_grid()
-
-    @typechecked
-    def shift_widgets(
-        self,
-        direction: Literal["down", "up", "left", "right"],
-        start_row: int = 0,
-        start_col: int = 0,
-    ) -> None:
-        """
-        Shift widgets in the grid in the specified direction starting from the given position.
-
-        Args:
-            direction (Literal["down", "up", "left", "right"]): Direction to shift widgets.
-            start_row (int): Starting row index.
-            start_col (int): Starting column index.
-
-        Raises:
-            ValueError: If shifting causes widgets to go out of grid boundaries.
-        """
-        shifts = []
-        positions_to_shift = [(start_row, start_col)]
-        visited_positions = set()
-
-        while positions_to_shift:
-            row, col = positions_to_shift.pop(0)
-            if (row, col) in visited_positions:
-                continue
-            visited_positions.add((row, col))
-
-            widget = self.position_widgets.get((row, col))
-            if widget is None:
-                continue  # No widget at this position
-
-            # Compute new position based on the direction
-            if direction == "down":
-                new_row = row + 1
-                new_col = col
-            elif direction == "up":
-                new_row = row - 1
-                new_col = col
-            elif direction == "right":
-                new_row = row
-                new_col = col + 1
-            elif direction == "left":
-                new_row = row
-                new_col = col - 1
-
-            # Check for negative indices
-            if new_row < 0 or new_col < 0:
-                raise ValueError("Shifting widgets out of grid boundaries.")
-
-            # If the new position is occupied, add it to the positions to shift
-            if (new_row, new_col) in self.position_widgets:
-                positions_to_shift.append((new_row, new_col))
-
-            shifts.append(
-                (widget, (row, col), (new_row, new_col), self.widget_positions[widget][2:])
-            )
-
-        # Remove all widgets from their old positions
-        for widget, (old_row, old_col), _, _ in shifts:
-            self.layout.removeWidget(widget)
-            self.position_widgets.pop((old_row, old_col))
-
-        # Add widgets to their new positions
-        for widget, _, (new_row, new_col), (rowspan, colspan) in shifts:
-            self.layout.addWidget(widget, new_row, new_col, rowspan, colspan)
-            self.widget_positions[widget] = (new_row, new_col, rowspan, colspan)
-            self.position_widgets[(new_row, new_col)] = widget
-
-            # Update current_row and current_col if needed
-            self.current_row = max(self.current_row, new_row)
-            self.current_col = max(self.current_col, new_col + colspan)
-
-    def shift_all_widgets(self, direction: Literal["down", "up", "left", "right"]) -> None:
-        """
-        Shift all widgets in the grid in the specified direction to make room and prevent negative indices.
-
-        Args:
-            direction (Literal["down", "up", "left", "right"]): Direction to shift all widgets.
-        """
-        # First, collect all the shifts to perform
-        shifts = []
-        for widget, (row, col, rowspan, colspan) in self.widget_positions.items():
-
-            if direction == "down":
-                new_row = row + 1
-                new_col = col
-            elif direction == "up":
-                new_row = row - 1
-                new_col = col
-            elif direction == "right":
-                new_row = row
-                new_col = col + 1
-            elif direction == "left":
-                new_row = row
-                new_col = col - 1
-
-            # Check for negative indices
-            if new_row < 0 or new_col < 0:
-                raise ValueError("Shifting widgets out of grid boundaries.")
-
-            shifts.append((widget, (row, col), (new_row, new_col), (rowspan, colspan)))
-
-        # Now perform the shifts
-        for widget, (old_row, old_col), (new_row, new_col), (rowspan, colspan) in shifts:
-            self.layout.removeWidget(widget)
-            self.position_widgets.pop((old_row, old_col))
-
-        for widget, (old_row, old_col), (new_row, new_col), (rowspan, colspan) in shifts:
-            self.layout.addWidget(widget, new_row, new_col, rowspan, colspan)
-            self.widget_positions[widget] = (new_row, new_col, rowspan, colspan)
-            self.position_widgets[(new_row, new_col)] = widget
-
-        # Update current_row and current_col based on new widget positions
-        self.current_row = max((pos[0] for pos in self.position_widgets.keys()), default=0)
-        self.current_col = max((pos[1] for pos in self.position_widgets.keys()), default=0)
-
-    def remove(
-        self,
-        row: int | None = None,
-        col: int | None = None,
-        coordinates: Tuple[int, int] | None = None,
-    ) -> None:
-        """
-        Remove a widget from the layout. Can be removed by widget ID or by coordinates.
-
-        Args:
-            row (int, optional): The row coordinate of the widget to remove.
-            col (int, optional): The column coordinate of the widget to remove.
-            coordinates (tuple[int, int], optional): The (row, col) coordinates of the widget to remove.
-
-        Raises:
-            ValueError: If the widget to remove is not found.
-        """
-        if coordinates:
-            row, col = coordinates
-            widget = self.get_widget(row, col)
-            if widget is None:
-                raise ValueError(f"No widget found at coordinates {coordinates}.")
-        elif row is not None and col is not None:
-            widget = self.get_widget(row, col)
-            if widget is None:
-                raise ValueError(f"No widget found at position ({row}, {col}).")
-        else:
-            raise ValueError(
-                "Must provide either widget_id, coordinates, or both row and col for removal."
-            )
-
-        self.remove_widget(widget)
-
-    def remove_widget(self, widget: QWidget) -> None:
-        """
-        Remove a widget from the grid and reindex the grid to keep it compact.
-
-        Args:
-            widget (QWidget): The widget to remove.
-
-        Raises:
-            ValueError: If the widget is not found in the layout.
-        """
-        if widget not in self.widget_positions:
-            raise ValueError("Widget not found in layout.")
-
-        position = self.widget_positions.pop(widget)
-        self.position_widgets.pop((position[0], position[1]))
-        self.layout.removeWidget(widget)
-        widget.setParent(None)  # Remove widget from the parent
-        widget.deleteLater()
-
-        # Reindex the grid to maintain compactness
-        if self.auto_reindex:
-            self.reindex_grid()
-
-    def get_widget(self, row: int, col: int) -> QWidget | None:
-        """
-        Get the widget at the specified position.
-
-        Args:
-            row (int): The row coordinate.
-            col (int): The column coordinate.
-
-        Returns:
-            QWidget | None: The widget at the specified position, or None if empty.
-        """
-        return self.position_widgets.get((row, col))
-
-    def get_widget_position(self, widget: QWidget) -> Tuple[int, int, int, int] | None:
-        """
-        Get the position of the specified widget.
-
-        Args:
-            widget (QWidget): The widget to query.
-
-        Returns:
-            Tuple[int, int, int, int] | None: The (row, col, rowspan, colspan) tuple, or None if not found.
-        """
-        return self.widget_positions.get(widget)
-
-    def change_layout(self, num_rows: int | None = None, num_cols: int | None = None) -> None:
-        """
-        Change the layout to have a certain number of rows and/or columns,
-        rearranging the widgets accordingly.
-
-        If only one of num_rows or num_cols is provided, the other is calculated automatically
-        based on the number of widgets and the provided constraint.
-
-        If both are provided, num_rows is calculated based on num_cols.
-
-        Args:
-            num_rows (int | None): The new maximum number of rows.
-            num_cols (int | None): The new maximum number of columns.
-        """
-        if num_rows is None and num_cols is None:
-            return  # Nothing to change
-
-        total_widgets = len(self.widget_positions)
-
-        if num_cols is not None:
-            # Calculate num_rows based on num_cols
-            num_rows = math.ceil(total_widgets / num_cols)
-        elif num_rows is not None:
-            # Calculate num_cols based on num_rows
-            num_cols = math.ceil(total_widgets / num_rows)
-
-        # Sort widgets by current position (row-major order)
-        widgets_sorted = sorted(
-            self.widget_positions.items(),
-            key=lambda item: (item[1][0], item[1][1]),  # Sort by row, then column
-        )
-
-        # Clear the layout without deleting widgets
-        for widget, _ in widgets_sorted:
-            self.layout.removeWidget(widget)
-
-        # Reset position mappings
-        self.widget_positions.clear()
-        self.position_widgets.clear()
-
-        # Re-add widgets based on new layout constraints
-        current_row, current_col = 0, 0
-        for widget, _ in widgets_sorted:
-            if current_col >= num_cols:
-                current_col = 0
-                current_row += 1
-            self.layout.addWidget(widget, current_row, current_col, 1, 1)
-            self.widget_positions[widget] = (current_row, current_col, 1, 1)
-            self.position_widgets[(current_row, current_col)] = widget
-            current_col += 1
-
-        # Update current_row and current_col for automatic placement
-        self.current_row = current_row
-        self.current_col = current_col
-
-        # Reindex the grid to ensure compactness
-        self.reindex_grid()
-
-    def clear_layout(self) -> None:
-        """
-        Remove all widgets from the layout without deleting them.
-        """
-        for widget in list(self.widget_positions):
-            self.layout.removeWidget(widget)
-            self.position_widgets.pop(
-                (self.widget_positions[widget][0], self.widget_positions[widget][1])
-            )
-            self.widget_positions.pop(widget)
-            widget.setParent(None)  # Optionally hide/remove the widget
-
-        self.current_row = 0
-        self.current_col = 0
-
-    def reindex_grid(self) -> None:
-        """
-        Reindex the grid to remove empty rows and columns, ensuring that
-        widget coordinates are contiguous and start from (0, 0).
-        """
-        # Step 1: Collect all occupied positions
-        occupied_positions = sorted(self.position_widgets.keys())
-
-        if not occupied_positions:
-            # No widgets to reindex
-            self.clear_layout()
-            return
-
-        # Step 2: Determine the new mapping by eliminating empty columns and rows
-        # Find unique rows and columns
-        unique_rows = sorted(set(pos[0] for pos in occupied_positions))
-        unique_cols = sorted(set(pos[1] for pos in occupied_positions))
-
-        # Create mappings from old to new indices
-        row_mapping = {old_row: new_row for new_row, old_row in enumerate(unique_rows)}
-        col_mapping = {old_col: new_col for new_col, old_col in enumerate(unique_cols)}
-
-        # Step 3: Collect widgets with their new positions
-        widgets_with_new_positions = []
-        for widget, (row, col, rowspan, colspan) in self.widget_positions.items():
-            new_row = row_mapping[row]
-            new_col = col_mapping[col]
-            widgets_with_new_positions.append((widget, new_row, new_col, rowspan, colspan))
-
-        # Step 4: Clear the layout and reset mappings
-        self.clear_layout()
-
-        # Reset current_row and current_col
-        self.current_row = 0
-        self.current_col = 0
-
-        # Step 5: Re-add widgets with new positions
-        for widget, new_row, new_col, rowspan, colspan in widgets_with_new_positions:
-            self.layout.addWidget(widget, new_row, new_col, rowspan, colspan)
-            self.widget_positions[widget] = (new_row, new_col, rowspan, colspan)
-            self.position_widgets[(new_row, new_col)] = widget
-
-            # Update current position for automatic placement
-            self.current_col = max(self.current_col, new_col + colspan)
-            self.current_row = max(self.current_row, new_row)
-
-    def get_widgets_positions(self) -> Dict[QWidget, Tuple[int, int, int, int]]:
-        """
-        Get the positions of all widgets in the layout.
-
-        Returns:
-            Dict[QWidget, Tuple[int, int, int, int]]: Mapping of widgets to their (row, col, rowspan, colspan).
-        """
-        return self.widget_positions.copy()
-
-    def print_all_button_text(self):
-        """Debug function to print the text of all QPushButton widgets."""
-        print("Coordinates - Button Text")
-        for coord, widget in self.position_widgets.items():
-            if isinstance(widget, QPushButton):
-                print(f"{coord} - {widget.text()}")
-
-
-####################################################################################################
-# The following code is for the GUI control panel to interact with the LayoutManagerWidget.
-# It is not covered by any tests as it serves only as an example for the LayoutManagerWidget class.
-####################################################################################################
-
-
-class ControlPanel(QWidget):  # pragma: no cover
-    def __init__(self, layout_manager: LayoutManagerWidget):
-        super().__init__()
-        self.layout_manager = layout_manager
-        self.init_ui()
-
-    def init_ui(self):
-        main_layout = QVBoxLayout()
-
-        # Add Widget by Coordinates
-        add_coord_group = QGroupBox("Add Widget by Coordinates")
-        add_coord_layout = QGridLayout()
-
-        add_coord_layout.addWidget(QLabel("Text:"), 0, 0)
-        self.text_input = QLineEdit()
-        add_coord_layout.addWidget(self.text_input, 0, 1)
-
-        add_coord_layout.addWidget(QLabel("Row:"), 1, 0)
-        self.row_input = QSpinBox()
-        self.row_input.setMinimum(0)
-        add_coord_layout.addWidget(self.row_input, 1, 1)
-
-        add_coord_layout.addWidget(QLabel("Column:"), 2, 0)
-        self.col_input = QSpinBox()
-        self.col_input.setMinimum(0)
-        add_coord_layout.addWidget(self.col_input, 2, 1)
-
-        self.add_button = QPushButton("Add at Coordinates")
-        self.add_button.clicked.connect(self.add_at_coordinates)
-        add_coord_layout.addWidget(self.add_button, 3, 0, 1, 2)
-
-        add_coord_group.setLayout(add_coord_layout)
-        main_layout.addWidget(add_coord_group)
-
-        # Add Widget Relative
-        add_rel_group = QGroupBox("Add Widget Relative to Existing")
-        add_rel_layout = QGridLayout()
-
-        add_rel_layout.addWidget(QLabel("Text:"), 0, 0)
-        self.rel_text_input = QLineEdit()
-        add_rel_layout.addWidget(self.rel_text_input, 0, 1)
-
-        add_rel_layout.addWidget(QLabel("Reference Widget:"), 1, 0)
-        self.ref_widget_combo = QComboBox()
-        add_rel_layout.addWidget(self.ref_widget_combo, 1, 1)
-
-        add_rel_layout.addWidget(QLabel("Position:"), 2, 0)
-        self.position_combo = QComboBox()
-        self.position_combo.addItems(["left", "right", "top", "bottom"])
-        add_rel_layout.addWidget(self.position_combo, 2, 1)
-
-        self.add_rel_button = QPushButton("Add Relative")
-        self.add_rel_button.clicked.connect(self.add_relative)
-        add_rel_layout.addWidget(self.add_rel_button, 3, 0, 1, 2)
-
-        add_rel_group.setLayout(add_rel_layout)
-        main_layout.addWidget(add_rel_group)
-
-        # Remove Widget
-        remove_group = QGroupBox("Remove Widget")
-        remove_layout = QGridLayout()
-
-        remove_layout.addWidget(QLabel("Row:"), 0, 0)
-        self.remove_row_input = QSpinBox()
-        self.remove_row_input.setMinimum(0)
-        remove_layout.addWidget(self.remove_row_input, 0, 1)
-
-        remove_layout.addWidget(QLabel("Column:"), 1, 0)
-        self.remove_col_input = QSpinBox()
-        self.remove_col_input.setMinimum(0)
-        remove_layout.addWidget(self.remove_col_input, 1, 1)
-
-        self.remove_button = QPushButton("Remove at Coordinates")
-        self.remove_button.clicked.connect(self.remove_widget)
-        remove_layout.addWidget(self.remove_button, 2, 0, 1, 2)
-
-        remove_group.setLayout(remove_layout)
-        main_layout.addWidget(remove_group)
-
-        # Change Layout
-        change_layout_group = QGroupBox("Change Layout")
-        change_layout_layout = QGridLayout()
-
-        change_layout_layout.addWidget(QLabel("Number of Rows:"), 0, 0)
-        self.change_rows_input = QSpinBox()
-        self.change_rows_input.setMinimum(1)
-        self.change_rows_input.setValue(1)  # Default value
-        change_layout_layout.addWidget(self.change_rows_input, 0, 1)
-
-        change_layout_layout.addWidget(QLabel("Number of Columns:"), 1, 0)
-        self.change_cols_input = QSpinBox()
-        self.change_cols_input.setMinimum(1)
-        self.change_cols_input.setValue(1)  # Default value
-        change_layout_layout.addWidget(self.change_cols_input, 1, 1)
-
-        self.change_layout_button = QPushButton("Apply Layout Change")
-        self.change_layout_button.clicked.connect(self.change_layout)
-        change_layout_layout.addWidget(self.change_layout_button, 2, 0, 1, 2)
-
-        change_layout_group.setLayout(change_layout_layout)
-        main_layout.addWidget(change_layout_group)
-
-        # Remove All Widgets
-        self.clear_all_button = QPushButton("Clear All Widgets")
-        self.clear_all_button.clicked.connect(self.clear_all_widgets)
-        main_layout.addWidget(self.clear_all_button)
-
-        # Refresh Reference Widgets and Print Button
-        self.refresh_button = QPushButton("Refresh Reference Widgets")
-        self.refresh_button.clicked.connect(self.refresh_references)
-        self.print_button = QPushButton("Print All Button Text")
-        self.print_button.clicked.connect(self.layout_manager.print_all_button_text)
-        main_layout.addWidget(self.refresh_button)
-        main_layout.addWidget(self.print_button)
-
-        main_layout.addStretch()
-        self.setLayout(main_layout)
-        self.refresh_references()
-
-    def refresh_references(self):
-        self.ref_widget_combo.clear()
-        widgets = self.layout_manager.get_widgets_positions()
-        for widget in widgets:
-            if isinstance(widget, QPushButton):
-                self.ref_widget_combo.addItem(widget.text(), widget)
-
-    def add_at_coordinates(self):
-        text = self.text_input.text()
-        row = self.row_input.value()
-        col = self.col_input.value()
-
-        if not text:
-            QMessageBox.warning(self, "Input Error", "Please enter text for the button.")
-            return
-
-        button = QPushButton(text)
-        try:
-            self.layout_manager.add_widget(widget=button, row=row, col=col)
-            self.refresh_references()
-        except Exception as e:
-            QMessageBox.critical(self, "Error", str(e))
-
-    def add_relative(self):
-        text = self.rel_text_input.text()
-        ref_index = self.ref_widget_combo.currentIndex()
-        ref_widget = self.ref_widget_combo.itemData(ref_index)
-        position = self.position_combo.currentText()
-
-        if not text:
-            QMessageBox.warning(self, "Input Error", "Please enter text for the button.")
-            return
-
-        if ref_widget is None:
-            QMessageBox.warning(self, "Input Error", "Please select a reference widget.")
-            return
-
-        button = QPushButton(text)
-        try:
-            self.layout_manager.add_widget_relative(
-                widget=button, reference_widget=ref_widget, position=position
-            )
-            self.refresh_references()
-        except Exception as e:
-            QMessageBox.critical(self, "Error", str(e))
-
-    def remove_widget(self):
-        row = self.remove_row_input.value()
-        col = self.remove_col_input.value()
-
-        try:
-            widget = self.layout_manager.get_widget(row, col)
-            if widget is None:
-                QMessageBox.warning(self, "Not Found", f"No widget found at ({row}, {col}).")
-                return
-            self.layout_manager.remove_widget(widget)
-            self.refresh_references()
-        except Exception as e:
-            QMessageBox.critical(self, "Error", str(e))
-
-    def change_layout(self):
-        num_rows = self.change_rows_input.value()
-        num_cols = self.change_cols_input.value()
-
-        try:
-            self.layout_manager.change_layout(num_rows=num_rows, num_cols=num_cols)
-            self.refresh_references()
-        except Exception as e:
-            QMessageBox.critical(self, "Error", str(e))
-
-    def clear_all_widgets(self):
-        reply = QMessageBox.question(
-            self,
-            "Confirm Clear",
-            "Are you sure you want to remove all widgets?",
-            QMessageBox.Yes | QMessageBox.No,
-            QMessageBox.No,
-        )
-
-        if reply == QMessageBox.Yes:
-            try:
-                self.layout_manager.clear_layout()
-                self.refresh_references()
-            except Exception as e:
-                QMessageBox.critical(self, "Error", str(e))
-
-
-class MainWindow(QMainWindow):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("Layout Manager Demo")
-        self.resize(800, 600)
-        self.init_ui()
-
-    def init_ui(self):
-        central_widget = QWidget()
-        main_layout = QHBoxLayout()
-
-        # Layout Area GroupBox
-        layout_group = QGroupBox("Layout Area")
-        layout_group.setMinimumSize(400, 400)
-        layout_layout = QVBoxLayout()
-
-        self.layout_manager = LayoutManagerWidget()
-        layout_layout.addWidget(self.layout_manager)
-
-        layout_group.setLayout(layout_layout)
-
-        # Splitter
-        splitter = QSplitter()
-        splitter.addWidget(layout_group)
-
-        # Control Panel
-        control_panel = ControlPanel(self.layout_manager)
-        control_group = QGroupBox("Control Panel")
-        control_layout = QVBoxLayout()
-        control_layout.addWidget(control_panel)
-        control_layout.addStretch()
-        control_group.setLayout(control_layout)
-        splitter.addWidget(control_group)
-
-        main_layout.addWidget(splitter)
-        central_widget.setLayout(main_layout)
-        self.setCentralWidget(central_widget)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    app = QApplication(sys.argv)
-    window = MainWindow()
-    window.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/containers/main_window/main_window.py

@@ -1,41 +1,9 @@
-from qtpy.QtWidgets import QApplication, QMainWindow
+from qtpy.QtWidgets import QMainWindow
 
 from bec_widgets.utils import BECConnector
-from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
 
 
 class BECMainWindow(QMainWindow, BECConnector):
     def __init__(self, *args, **kwargs):
         BECConnector.__init__(self, **kwargs)
         QMainWindow.__init__(self, *args, **kwargs)
-
-    def _dump(self):
-        """Return a dictionary with informations about the application state, for use in tests"""
-        # TODO: ModularToolBar and something else leak top-level widgets (3 or 4 QMenu + 2 QWidget);
-        # so, a filtering based on title is applied here, but the solution is to not have those widgets
-        # as top-level (so for now, a window with no title does not appear in _dump() result)
-
-        # NOTE: the main window itself is excluded, since we want to dump dock areas
-        info = {
-            tlw.gui_id: {
-                "title": tlw.windowTitle(),
-                "visible": tlw.isVisible(),
-                "class": str(type(tlw)),
-            }
-            for tlw in QApplication.instance().topLevelWidgets()
-            if tlw is not self and tlw.windowTitle()
-        }
-        # Add the main window dock area
-        info[self.centralWidget().gui_id] = {
-            "title": self.windowTitle(),
-            "visible": self.isVisible(),
-            "class": str(type(self.centralWidget())),
-        }
-        return info
-
-    def new_dock_area(self, name):
-        dock_area = BECDockArea()
-        dock_area.resize(dock_area.minimumSizeHint())
-        dock_area.window().setWindowTitle(name)
-        dock_area.show()
-        return dock_area

bec_widgets/widgets/editors/console/console.py

@@ -16,6 +16,7 @@ import sys
 import time
 
 import pyte
+from bec_lib.logger import bec_logger
 from pygments.token import Token
 from pyte.screens import History
 from qtpy import QtCore, QtGui, QtWidgets
@@ -27,6 +28,8 @@ from qtpy.QtWidgets import QApplication, QHBoxLayout, QScrollBar, QSizePolicy
 
 from bec_widgets.qt_utils.error_popups import SafeSlot as Slot
 
+logger = bec_logger.logger
+
 ansi_colors = {
     "black": "#000000",
     "red": "#CD0000",
@@ -361,6 +364,24 @@ class BECConsole(QtWidgets.QWidget):
     def send_ctrl_c(self, timeout=None):
         self.term.send_ctrl_c(timeout)
 
+    def cleanup(self):
+        """Cleanup the terminal"""
+        self.execute_command("\x03")  # Ctrl-C
+        self.execute_command("exit()")
+        timeout = 5
+        interval = 0.1
+        timer = 0
+        # os.close(self.term.fd)
+        while self.term.fd is not None:
+            time.sleep(interval)
+            timer += interval
+            if timer > 0.8 * timeout:
+                logger.warning(f"Terminal still cleaning up after {timer:.1f} seconds")
+            if timer > timeout:
+                logger.error(f"Terminal cleanup timed out after {timeout} seconds")
+                break
+        self.deleteLater()
+
     cols = pyqtProperty(int, get_cols, set_cols)
     rows = pyqtProperty(int, get_rows, set_rows)
     bgcolor = pyqtProperty(QColor, get_bgcolor, set_bgcolor)

bec_widgets/widgets/editors/user_script/register_user_script_widget.py

@@ -6,9 +6,11 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.games.minesweeper_plugin import MinesweeperPlugin
+    from bec_widgets.widgets.editors.user_script.user_script_widget_plugin import (
+        UserScriptWidgetPlugin,
+    )
 
-    QPyDesignerCustomWidgetCollection.addCustomWidget(MinesweeperPlugin())
+    QPyDesignerCustomWidgetCollection.addCustomWidget(UserScriptWidgetPlugin())
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/widgets/editors/user_script/user_script.py

@@ -0,0 +1,569 @@
+import glob
+import importlib
+import inspect
+import os
+import pathlib
+from collections import defaultdict
+from pathlib import Path
+from typing import Literal
+
+import bec_lib
+from bec_qthemes import material_icon
+from pydantic import BaseModel
+from pygments.token import Token
+from qtpy.QtCore import QSize, Signal, Slot
+from qtpy.QtWidgets import (
+    QDialog,
+    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QSizePolicy,
+    QSpacerItem,
+    QToolButton,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.qt_utils.error_popups import SafeSlot
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import get_accent_colors, set_theme
+from bec_widgets.widgets.editors.console.console import BECConsole
+from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
+
+logger = bec_lib.bec_logger.logger
+
+
+class EnchancedQTreeWidget(QTreeWidget):
+    """Thin wrapper around QTreeWidget to add some functionality for user scripting"""
+
+    play_button_clicked = Signal(str)
+    edit_button_clicked = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setColumnCount(2)
+        self.setHeaderHidden(True)
+        self.setObjectName(__class__.__name__)
+        self._update_style_sheet()
+        self._icon_size = QSize(24, 24)
+        self.setRootIsDecorated(False)
+        self.setUniformRowHeights(True)
+        self.setWordWrap(True)
+        self.setAnimated(True)
+        self.setIndentation(24)
+        self._adjust_size_policy()
+
+    def _adjust_size_policy(self):
+        """Adjust the size policy"""
+        header = self.header()
+        header.setMinimumSectionSize(42)
+        header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
+        header.setSectionResizeMode(1, QHeaderView.Stretch)
+
+    def _update_style_sheet(self) -> None:
+        """Update the style sheet"""
+        name = __class__.__name__
+        colors = get_accent_colors()
+        # pylint: disable=protected-access
+        color = colors._palette.midlight().color().name()
+        self.setStyleSheet(
+            f"""
+            {name}::item {{
+                    border: none;
+                    background: transparent;
+                }}
+                QTreeView::branch:hover {{
+                    background: transparent;
+                    color: {color};
+                }}
+                {name}::item:hover {{
+                    background: {color};
+                }}
+                {name}::item:selected:hover {{
+                    background: {color};
+                }}
+                """
+        )
+
+    def add_top_item(self, label: str) -> QTreeWidgetItem:
+        """Add a top item to the tree widget
+
+        Args:
+            label (str): The label for the top item
+
+        Returns:
+            QTreeWidgetItem: The top item
+        """
+        top_item = QTreeWidgetItem(self, [label])
+        top_item.setExpanded(True)
+        top_item.setSelected(False)
+        self.resizeColumnToContents(0)
+        return top_item
+
+    def add_module_item(self, top_item: QTreeWidgetItem, mod_name: str) -> QTreeWidgetItem:
+        """Add a top item to the tree widget together with an edit button in column 0 and label in 1
+
+        Args:
+            top_item (QTreeWidgetItem): The top item to add the child item to
+            mod_name (str): The label for the child item
+
+        Returns:
+            QTreeWidgetItem: The top item
+        """
+        child_item = QTreeWidgetItem(top_item)
+        # Add label
+        label = QLabel(mod_name, parent=top_item.treeWidget())
+        # Add edit button with label as parent
+        edit_button = self._create_button(parent=label, button_type="edit")
+        edit_button.clicked.connect(self._handle_edit_button_clicked)
+        self.setItemWidget(child_item, 0, edit_button)
+        self.setItemWidget(child_item, 1, label)
+        self.resizeColumnToContents(0)
+        return child_item
+
+    def add_child_item(self, top_item: QTreeWidgetItem, label: str) -> None:
+        """Add a child item to the top item together with a play button in column 1
+
+        Args:
+            top_item (QTreeWidgetItem): The top item to add the child item to
+            label (str): The label for the child item
+
+        Returns:
+            QTreeWidgetItem: The child item
+        """
+        widget = QWidget(top_item.treeWidget())
+        label = QLabel(label)
+        spacer = QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Minimum)
+        layout = QHBoxLayout(widget)
+        layout.addWidget(label)
+        layout.addItem(spacer)
+        layout.setSpacing(4)
+        layout.setContentsMargins(0, 0, 0, 0)
+        button = self._create_button(parent=top_item.treeWidget(), button_type="play")
+        button.clicked.connect(self._handle_play_button_clicked)
+        layout.addWidget(button)
+        child_item = QTreeWidgetItem(top_item)
+        self.setItemWidget(child_item, 1, widget)
+        return child_item
+
+    @Slot()
+    def _handle_edit_button_clicked(self):
+        """Handle the click of the edit button"""
+        button = self.sender()
+        tree_widget_item = self.itemAt(button.pos())
+        text = self.itemWidget(tree_widget_item, 1).text()
+        self.edit_button_clicked.emit(text)
+
+    @Slot()
+    def _handle_play_button_clicked(self):
+        """Handle the click of the play button"""
+        button = self.sender()
+        widget = button.parent()
+        text = widget.findChild(QLabel).text()
+        self.play_button_clicked.emit(text)
+
+    def _create_button(self, parent: QWidget, button_type: Literal["edit", "play"]) -> QToolButton:
+        """Create a button for 'edit' or 'play'
+
+        Args:
+            button_type (Literal["edit", "play"]): The type of button to create
+        """
+        colors = get_accent_colors()
+        if button_type == "edit":
+            color = colors.highlight
+            name = "edit_document"
+        elif button_type == "play":
+            color = colors.success
+            name = "play_arrow"
+        else:
+            raise ValueError("Invalid button type")
+        button = QToolButton(
+            parent=parent,
+            icon=material_icon(
+                name, filled=False, color=color, size=self._icon_size, convert_to_pixmap=False
+            ),
+        )
+        button.setContentsMargins(0, 0, 0, 0)
+        button.setStyleSheet("QToolButton { border: none; }")
+        return button
+
+    def _hide_buttons(self, exclude_item: QWidget = None):
+        for button in self.viewport().findChildren(QToolButton):
+            if exclude_item is not None:
+                if button.parent() == exclude_item:
+                    continue
+            button.setVisible(False)
+
+
+class VSCodeDialog(QDialog):
+    """Dialog for the VSCode editor"""
+
+    def __init__(self, parent=None, client=None, editor: VSCodeEditor = None):
+        super().__init__(parent=parent)
+        self.setWindowTitle("VSCode Editor")
+        self.setMinimumWidth(800)
+        self.setMinimumHeight(600)
+        self.layout = QVBoxLayout(self)
+        self.editor = editor
+        self.init_ui()
+
+    def init_ui(self):
+        """Initialize the UI. Note: this makes the code easier to test."""
+        self.layout.addWidget(self.editor)
+
+
+class InputDialog(QDialog):
+    """Dialog for input
+
+    Args:
+        header (str): The header of the dialog
+        info (str): The information of the dialog
+        fields (dict): The fields of the dialog
+        parent (QWidget): The parent widget
+    """
+
+    def __init__(self, header: str, info: str, fields: dict, parent=None):
+        super().__init__(parent=parent)
+        self.header = header
+        self.info = info
+        self.fields = fields
+        self._layout = QVBoxLayout(self)
+        self.button_ok = QPushButton(parent=self, text="OK")
+        self.button_cancel = QPushButton(parent=self, text="Cancel")
+        self._init_ui()
+        self.button_ok.clicked.connect(self.accept)
+        self.button_cancel.clicked.connect(self.reject)
+
+    def _init_ui(self):
+        """Initialize the UI"""
+        self.setWindowTitle(f"{self.header}")
+        self.setMinimumWidth(200)
+        box = QGroupBox(self)
+        box.setTitle(self.info)
+        layout = QGridLayout(box)
+        layout.setSpacing(4)
+        layout.setContentsMargins(4, 30, 4, 30)
+        row = 0
+        for name, default in self.fields.items():
+            label = QLabel(parent=self, text=name)
+            line_input = QLineEdit(parent=self)
+            line_input.setObjectName(name)
+            if default is not None:
+                line_input.setText(f"{default}")
+            layout.addWidget(label, row, 0)
+            layout.addWidget(line_input, row, 1)
+            row += 1
+        self._layout.addWidget(box)
+        widget = QWidget(self)
+        sub_layout = QHBoxLayout(widget)
+        sub_layout.addWidget(self.button_ok)
+        sub_layout.addWidget(self.button_cancel)
+        self._layout.addWidget(widget)
+        self.setLayout(self._layout)
+        self.resize(self._layout.sizeHint() * 1.05)
+
+    def get_inputs(self):
+        """Get the input from the dialog"""
+        out = {}
+        for name, _ in self.fields.items():
+            line_input = self.findChild(QLineEdit, name)
+            if line_input is not None:
+                out[name] = line_input.text()
+        return out
+
+
+class ScriptBlock(BaseModel):
+    """Model block for a script"""
+
+    location: Literal["BEC", "USER", "BL"]
+    fname: str
+    module_name: str
+    user_script_name: str | None = None
+
+
+class UserScriptWidget(BECWidget, QWidget):
+    """Dialog for displaying the fit summary and params for LMFit DAP processes."""
+
+    PLUGIN = True
+
+    USER_ACCESS = []
+    ICON_NAME = "manage_accounts"
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        config=None,
+        gui_id: str | None = None,
+        vs_code_editor=None,
+        bec_console=None,
+    ):
+        """
+        Initialize the widget
+
+        Args:
+            parent (QWidget): The parent widget
+            client (BECClient): The BEC client
+            config (dict): The configuration
+            gui_id (str): The GUI ID
+            vs_code_editor (VSCodeEditor): The VSCode editor, dep injection here makes makes testing easier, if None defaults to VSCodeEditor
+            bec_console (BECConsole): The BEC console, note this makes testing easier, if None defaults to BECConsole
+        """
+        super().__init__(client=client, config=config, gui_id=gui_id, theme_update=True)
+        QWidget.__init__(self, parent=parent)
+        self.button_new_script = QPushButton(parent=self, text="New Script")
+        self.button_new_script.setObjectName("button_new_script")
+        if vs_code_editor is None:
+            vs_code_editor = VSCodeEditor(parent=self, client=self.client, gui_id=self.gui_id)
+        self._vscode_editor = vs_code_editor
+        if bec_console is None:
+            bec_console = BECConsole(parent=self)
+        self._console = bec_console
+        self.tree_widget = EnchancedQTreeWidget(parent=self)
+        self.layout = QVBoxLayout(self)
+        self.user_scripts = defaultdict(lambda: ScriptBlock)
+        self._base_path = os.path.join(str(Path.home()), "bec", "scripts")
+        self._icon_size = QSize(16, 16)
+        self._script_button_register = {}
+        self._code_dialog = None
+        self._script_dialog = None
+        self._new_script_dialog = None
+
+        self.init_ui()
+        self.button_new_script.clicked.connect(self.new_script)
+        self.tree_widget.edit_button_clicked.connect(self.handle_edit_button_clicked)
+        self.tree_widget.play_button_clicked.connect(self.handle_play_button_clicked)
+
+    def apply_theme(self, theme: str):
+        """Apply the theme"""
+        self._update_button_ui()
+        self.update_user_scripts()
+        self.tree_widget._update_style_sheet()
+        super().apply_theme(theme)
+
+    def _setup_console(self):
+        """Setup the console. Toents are needed to allow for the console to check for the prompt during shutdown."""
+        self._console.set_prompt_tokens(
+            (Token.OutPromptNum, "•"),
+            (Token.Prompt, ""),  # will match arbitrary string,
+            (Token.Prompt, " ["),
+            (Token.PromptNum, "3"),
+            (Token.Prompt, "/"),
+            (Token.PromptNum, "1"),
+            (Token.Prompt, "] "),
+            (Token.Prompt, "❯❯"),
+        )
+        self._console.start()
+        # Comment to not hide the console for debugging
+        self._console.hide()
+
+    def init_ui(self):
+        """Initialize the UI"""
+        # Add buttons
+        widget = QWidget(self)
+        layout = QHBoxLayout(widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(4)
+        layout.addWidget(self.button_new_script)
+        self.layout.addWidget(widget)
+        self.layout.addWidget(self.tree_widget)
+        # Uncomment to show the console for debugging
+        # self.layout.addWidget(self._console)
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+        self._vscode_editor.hide()
+        self._update_button_ui()
+        self._setup_console()
+        self.update_user_scripts()
+        self._vscode_editor.file_saved.connect(self._handle_file_saved)
+
+    @Slot(str)
+    def _handle_file_saved(self, fname: str):
+        """Handle the file saved signal"""
+        self.update_user_scripts()
+
+    def _update_button_ui(self):
+        """Update the button UI"""
+        colors = get_accent_colors()
+        name = self.button_new_script.objectName()
+        self.button_new_script.setStyleSheet(
+            f"QWidget#{name} {{ color: {colors._palette.windowText().color().name()}; }}"
+        )
+
+    def save_script(self):
+        """Save the script"""
+        self._vscode_editor.save_file()
+        self._vscode_editor.hide()
+        if self._code_dialog is not None:
+            self._code_dialog.hide()
+        self.update_user_scripts()
+
+    def open_script(self, fname: str):
+        """Open a script
+
+        Args:
+            fname (str): The file name of the script
+        """
+        if self._code_dialog is None:
+            self._code_dialog = VSCodeDialog(parent=self, editor=self._vscode_editor)
+            self._code_dialog.show()
+            self._vscode_editor.show()
+            # Only works after show was called for the first time
+            self._vscode_editor.zen_mode()
+        else:
+            self._code_dialog.show()
+            self._vscode_editor.show()
+        self._vscode_editor.open_file(fname)
+
+    @SafeSlot(popup_error=True)
+    def new_script(self, *args, **kwargs):
+        """Create a new script"""
+        self._new_script_dialog = InputDialog(
+            header="New Script", info="Enter filename for new script", fields={"Filename": ""}
+        )
+        if self._new_script_dialog.exec_():
+            name = self._new_script_dialog.get_inputs()["Filename"]
+            check_name = name.replace("_", "").replace("-", "")
+            if not check_name.isalnum() or not check_name.isascii():
+                raise NameError(f"Invalid name {name}, must be alphanumeric and ascii")
+            if not name.endswith(".py"):
+                name = name + ".py"
+            fname = os.path.join(self._base_path, name)
+            # Check if file exists on disk
+            if os.path.exists(fname):
+                logger.error(f"File {fname} already exists")
+                raise FileExistsError(f"File {fname} already exists")
+            try:
+                os.makedirs(os.path.dirname(fname), exist_ok=True, mode=0o775)
+                with open(fname, "w", encoding="utf-8") as f:
+                    f.write("# New BEC Script\n")
+            except Exception as e:
+                logger.error(f"Error creating new script: {e}")
+                raise e
+            self.open_script(fname)
+
+    def get_script_files(self) -> dict:
+        """Get all script files in the base path"""
+        files = {"BEC": [], "USER": [], "BL": []}
+        # bec
+        bec_lib_path = pathlib.Path(bec_lib.__file__).parent.parent.resolve()
+        bec_scripts_dir = os.path.join(str(bec_lib_path), "scripts")
+        files["BEC"].extend(glob.glob(os.path.abspath(os.path.join(bec_scripts_dir, "*.py"))))
+
+        # user
+        user_scripts_dir = os.path.join(os.path.expanduser("~"), "bec", "scripts")
+        if os.path.exists(user_scripts_dir):
+            files["USER"].extend(glob.glob(os.path.abspath(os.path.join(user_scripts_dir, "*.py"))))
+
+        # load scripts from the beamline plugin
+        plugins = importlib.metadata.entry_points(group="bec")
+        for plugin in plugins:
+            if plugin.name == "plugin_bec":
+                plugin = plugin.load()
+                plugin_scripts_dir = os.path.join(plugin.__path__[0], "scripts")
+                if os.path.exists(plugin_scripts_dir):
+                    files["BL"].extend(
+                        glob.glob(os.path.abspath(os.path.join(plugin_scripts_dir, "*.py")))
+                    )
+        return files
+
+    @SafeSlot()
+    def reload_user_scripts(self, *args, **kwargs):
+        """Reload the user scripts"""
+        self.client.load_all_user_scripts()
+
+    @Slot()
+    def update_user_scripts(self) -> None:
+        """Update the user scripts"""
+        self.user_scripts.clear()
+        self.tree_widget.clear()
+        script_files = self.get_script_files()
+        for key, files in script_files.items():
+            if len(files) == 0:
+                continue
+            top_item = self.tree_widget.add_top_item(key)
+            for fname in files:
+                mod_name = fname.split("/")[-1].strip(".py")
+                self.user_scripts[mod_name] = ScriptBlock(
+                    fname=fname, module_name=mod_name, location=key
+                )
+                child_item = self.tree_widget.add_module_item(top_item, mod_name)
+                # pylint: disable=protected-access
+                self.reload_user_scripts(popup_error=True)
+                for user_script_name, info in self.client._scripts.items():
+                    if info["fname"] == fname:
+                        self.user_scripts[mod_name].user_script_name = user_script_name
+                        _ = self.tree_widget.add_child_item(child_item, user_script_name)
+        self.tree_widget.expandAll()
+
+    @Slot(str)
+    def handle_edit_button_clicked(self, text: str):
+        """Handle the click of the edit button"""
+        self.open_script(self.user_scripts[text].fname)
+
+    @Slot(str)
+    def handle_play_button_clicked(self, text: str):
+        """Handle the click of the play button"""
+        self._console.execute_command("bec.load_all_user_scripts()")
+        info = self.client._scripts[text]
+        caller_args = inspect.getfullargspec(info["cls"])
+        args = caller_args.args + caller_args.kwonlyargs
+        if args:
+            self._handle_call_with_args(text, caller_args)
+        else:
+            self._console.execute_command(f"{text}()")
+
+    def _handle_call_with_args(self, text: str, caller_args: inspect.FullArgSpec) -> None:
+        """Handle the call with arguments"""
+        defaults = []
+        args = caller_args.args + caller_args.kwonlyargs
+        for value in args:
+            if caller_args.kwonlydefaults is not None:
+                defaults.append(caller_args.kwonlydefaults.get(value, None))
+        fields = dict((arg, default) for arg, default in zip(args, defaults))
+        info = ", ".join([f"{k}={v}" for k, v in fields.items()]).replace("None", "")
+        info = f"Example: {text}({info})"
+        self._script_dialog = InputDialog(
+            parent=self, header="Script Arguments", info=info, fields=fields
+        )
+        if self._script_dialog.exec_():
+            args = self._script_dialog.get_inputs()
+            args = ", ".join([f"{k}={v}" for k, v in args.items()])
+            self._console.execute_command(f"{text}({args})")
+            self._script_dialog = None
+
+    def cleanup(self):
+        """Cleanup the widget"""
+        self._vscode_editor.cleanup()
+        self._vscode_editor.deleteLater()
+        if self._code_dialog is not None:
+            self._code_dialog.deleteLater()
+        if self._script_dialog is not None:
+            self._script_dialog.deleteLater()
+        if self._new_script_dialog is not None:
+            self._new_script_dialog.deleteLater()
+        self.tree_widget.clear()
+        self._console.cleanup()
+
+
+if __name__ == "__main__":
+
+    from qtpy.QtWidgets import QApplication
+
+    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+    app = QApplication([])
+    set_theme("dark")
+    w = QWidget()
+    layout = QVBoxLayout(w)
+    layout.addWidget(UserScriptWidget())
+    w.setFixedHeight(400)
+    w.setFixedWidth(400)
+    w.show()
+    app.exec_()

bec_widgets/widgets/editors/user_script/user_script_widget.pyproject

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

bec_widgets/widgets/editors/user_script/user_script_widget_plugin.py

@@ -4,36 +4,36 @@
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.games.minesweeper import Minesweeper
+from bec_widgets.widgets.editors.user_script.user_script import UserScriptWidget
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='Minesweeper' name='minesweeper'>
+    <widget class='UserScriptWidget' name='user_script_widget'>
     </widget>
 </ui>
 """
 
 
-class MinesweeperPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+class UserScriptWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
         super().__init__()
         self._form_editor = None
 
     def createWidget(self, parent):
-        t = Minesweeper(parent)
+        t = UserScriptWidget(parent)
         return t
 
     def domXml(self):
         return DOM_XML
 
     def group(self):
-        return "BEC Games"
+        return "BEC Services"
 
     def icon(self):
-        return designer_material_icon(Minesweeper.ICON_NAME)
+        return designer_material_icon(UserScriptWidget.ICON_NAME)
 
     def includeFile(self):
-        return "minesweeper"
+        return "user_script_widget"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -45,10 +45,10 @@ class MinesweeperPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return self._form_editor is not None
 
     def name(self):
-        return "Minesweeper"
+        return "UserScriptWidget"
 
     def toolTip(self):
-        return "Minesweeper"
+        return "Dialog for displaying the fit summary and params for LMFit DAP processes"
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/games/__init__.py

@@ -1,3 +0,0 @@
-from bec_widgets.widgets.games.minesweeper import Minesweeper
-
-__ALL__ = ["Minesweeper"]

bec_widgets/widgets/games/minesweeper.py

@@ -1,413 +0,0 @@
-import enum
-import random
-import time
-
-from bec_qthemes import material_icon
-from qtpy.QtCore import QSize, Qt, QTimer, Signal, Slot
-from qtpy.QtGui import QBrush, QColor, QPainter, QPen
-from qtpy.QtWidgets import (
-    QApplication,
-    QComboBox,
-    QGridLayout,
-    QHBoxLayout,
-    QLabel,
-    QPushButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.utils.bec_widget import BECWidget
-
-NUM_COLORS = {
-    1: QColor("#f44336"),
-    2: QColor("#9C27B0"),
-    3: QColor("#3F51B5"),
-    4: QColor("#03A9F4"),
-    5: QColor("#00BCD4"),
-    6: QColor("#4CAF50"),
-    7: QColor("#E91E63"),
-    8: QColor("#FF9800"),
-}
-
-LEVELS: dict[str, tuple[int, int]] = {"1": (8, 10), "2": (16, 40), "3": (24, 99)}
-
-
-class GameStatus(enum.Enum):
-    READY = 0
-    PLAYING = 1
-    FAILED = 2
-    SUCCESS = 3
-
-
-class Pos(QWidget):
-    expandable = Signal(int, int)
-    clicked = Signal()
-    ohno = Signal()
-
-    def __init__(self, x, y, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.setFixedSize(QSize(20, 20))
-
-        self.x = x
-        self.y = y
-        self.is_start = False
-        self.is_mine = False
-        self.adjacent_n = 0
-        self.is_revealed = False
-        self.is_flagged = False
-
-    def reset(self):
-        """Restore the tile to its original state before mine status is assigned"""
-        self.is_start = False
-        self.is_mine = False
-        self.adjacent_n = 0
-
-        self.is_revealed = False
-        self.is_flagged = False
-
-        self.update()
-
-    def paintEvent(self, event):
-        p = QPainter(self)
-
-        r = event.rect()
-
-        if self.is_revealed:
-            color = self.palette().base().color()
-            outer, inner = color, color
-        else:
-            outer, inner = (self.palette().highlightedText().color(), self.palette().text().color())
-
-        p.fillRect(r, QBrush(inner))
-        pen = QPen(outer)
-        pen.setWidth(1)
-        p.setPen(pen)
-        p.drawRect(r)
-
-        if self.is_revealed:
-            if self.is_mine:
-                p.drawPixmap(r, material_icon("experiment", convert_to_pixmap=True, filled=True))
-
-            elif self.adjacent_n > 0:
-                pen = QPen(NUM_COLORS[self.adjacent_n])
-                p.setPen(pen)
-                f = p.font()
-                f.setBold(True)
-                p.setFont(f)
-                p.drawText(r, Qt.AlignHCenter | Qt.AlignVCenter, str(self.adjacent_n))
-
-        elif self.is_flagged:
-            p.drawPixmap(
-                r,
-                material_icon(
-                    "flag",
-                    size=(50, 50),
-                    convert_to_pixmap=True,
-                    filled=True,
-                    color=self.palette().base().color(),
-                ),
-            )
-        p.end()
-
-    def flag(self):
-        self.is_flagged = not self.is_flagged
-        self.update()
-
-        self.clicked.emit()
-
-    def reveal(self):
-        self.is_revealed = True
-        self.update()
-
-    def click(self):
-        if not self.is_revealed:
-            self.reveal()
-            if self.adjacent_n == 0:
-                self.expandable.emit(self.x, self.y)
-
-        self.clicked.emit()
-
-    def mouseReleaseEvent(self, event):
-        if event.button() == Qt.MouseButton.RightButton and not self.is_revealed:
-            self.flag()
-            return
-
-        if event.button() == Qt.MouseButton.LeftButton:
-            self.click()
-            if self.is_mine:
-                self.ohno.emit()
-
-
-class Minesweeper(BECWidget, QWidget):
-
-    PLUGIN = True
-    ICON_NAME = "videogame_asset"
-    USER_ACCESS = []
-
-    def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        QWidget.__init__(self, parent=parent)
-
-        self._ui_initialised = False
-        self._timer_start_num_seconds = 0
-        self._set_level_params(LEVELS["1"])
-
-        self._init_ui()
-        self._init_map()
-
-        self.update_status(GameStatus.READY)
-        self.reset_map()
-        self.update_status(GameStatus.READY)
-
-    def _init_ui(self):
-        if self._ui_initialised:
-            return
-        self._ui_initialised = True
-
-        status_hb = QHBoxLayout()
-        self.mines = QLabel()
-        self.mines.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
-        f = self.mines.font()
-        f.setPointSize(24)
-        self.mines.setFont(f)
-
-        self.reset_button = QPushButton()
-        self.reset_button.setFixedSize(QSize(32, 32))
-        self.reset_button.setIconSize(QSize(32, 32))
-        self.reset_button.setFlat(True)
-        self.reset_button.pressed.connect(self.reset_button_pressed)
-
-        self.clock = QLabel()
-        self.clock.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
-        self.clock.setFont(f)
-        self._timer = QTimer()
-        self._timer.timeout.connect(self.update_timer)
-        self._timer.start(1000)  # 1 second timer
-        self.mines.setText(f"{self.num_mines:03d}")
-        self.clock.setText("000")
-
-        status_hb.addWidget(self.mines)
-        status_hb.addWidget(self.reset_button)
-        status_hb.addWidget(self.clock)
-
-        level_hb = QHBoxLayout()
-        self.level_selector = QComboBox()
-        self.level_selector.addItems(list(LEVELS.keys()))
-        level_hb.addWidget(QLabel("Level: "))
-        level_hb.addWidget(self.level_selector)
-        self.level_selector.currentTextChanged.connect(self.change_level)
-
-        vb = QVBoxLayout()
-        vb.addLayout(level_hb)
-        vb.addLayout(status_hb)
-
-        self.grid = QGridLayout()
-        self.grid.setSpacing(5)
-
-        vb.addLayout(self.grid)
-        self.setLayout(vb)
-
-    def _init_map(self):
-        """Redraw the grid of mines"""
-
-        # Remove any previous grid items and reset the grid
-        for i in reversed(range(self.grid.count())):
-            w: Pos = self.grid.itemAt(i).widget()
-            w.clicked.disconnect(self.on_click)
-            w.expandable.disconnect(self.expand_reveal)
-            w.ohno.disconnect(self.game_over)
-            w.setParent(None)
-            w.deleteLater()
-
-        # Add positions to the map
-        for x in range(0, self.b_size):
-            for y in range(0, self.b_size):
-                w = Pos(x, y)
-                self.grid.addWidget(w, y, x)
-                # Connect signal to handle expansion.
-                w.clicked.connect(self.on_click)
-                w.expandable.connect(self.expand_reveal)
-                w.ohno.connect(self.game_over)
-
-    def reset_map(self):
-        """
-        Reset the map and add new mines.
-        """
-        # Clear all mine positions
-        for x in range(0, self.b_size):
-            for y in range(0, self.b_size):
-                w = self.grid.itemAtPosition(y, x).widget()
-                w.reset()
-
-        # Add mines to the positions
-        positions = []
-        while len(positions) < self.num_mines:
-            x, y = (random.randint(0, self.b_size - 1), random.randint(0, self.b_size - 1))
-            if (x, y) not in positions:
-                w = self.grid.itemAtPosition(y, x).widget()
-                w.is_mine = True
-                positions.append((x, y))
-
-        def get_adjacency_n(x, y):
-            positions = self.get_surrounding(x, y)
-            num_mines = sum(1 if w.is_mine else 0 for w in positions)
-
-            return num_mines
-
-        # Add adjacencies to the positions
-        for x in range(0, self.b_size):
-            for y in range(0, self.b_size):
-                w = self.grid.itemAtPosition(y, x).widget()
-                w.adjacent_n = get_adjacency_n(x, y)
-
-        # Place starting marker
-        while True:
-            x, y = (random.randint(0, self.b_size - 1), random.randint(0, self.b_size - 1))
-            w = self.grid.itemAtPosition(y, x).widget()
-            # We don't want to start on a mine.
-            if (x, y) not in positions:
-                w = self.grid.itemAtPosition(y, x).widget()
-                w.is_start = True
-
-                # Reveal all positions around this, if they are not mines either.
-                for w in self.get_surrounding(x, y):
-                    if not w.is_mine:
-                        w.click()
-                break
-
-    def get_surrounding(self, x, y):
-        positions = []
-        for xi in range(max(0, x - 1), min(x + 2, self.b_size)):
-            for yi in range(max(0, y - 1), min(y + 2, self.b_size)):
-                positions.append(self.grid.itemAtPosition(yi, xi).widget())
-        return positions
-
-    def get_num_hidden(self) -> int:
-        """
-        Get the number of hidden positions.
-        """
-        return sum(
-            1
-            for x in range(0, self.b_size)
-            for y in range(0, self.b_size)
-            if not self.grid.itemAtPosition(y, x).widget().is_revealed
-        )
-
-    def get_num_remaining_flags(self) -> int:
-        """
-        Get the number of remaining flags.
-        """
-        return self.num_mines - sum(
-            1
-            for x in range(0, self.b_size)
-            for y in range(0, self.b_size)
-            if self.grid.itemAtPosition(y, x).widget().is_flagged
-        )
-
-    def reset_button_pressed(self):
-        match self.status:
-            case GameStatus.PLAYING:
-                self.game_over()
-            case GameStatus.FAILED | GameStatus.SUCCESS:
-                self.reset_map()
-
-    def reveal_map(self):
-        for x in range(0, self.b_size):
-            for y in range(0, self.b_size):
-                w = self.grid.itemAtPosition(y, x).widget()
-                w.reveal()
-
-    @Slot(str)
-    def change_level(self, level: str):
-        self._set_level_params(LEVELS[level])
-        self._init_map()
-        self.reset_map()
-
-    @Slot(int, int)
-    def expand_reveal(self, x, y):
-        """
-        Expand the reveal to the surrounding
-
-        Args:
-            x (int): The x position.
-            y (int): The y position.
-        """
-        for xi in range(max(0, x - 1), min(x + 2, self.b_size)):
-            for yi in range(max(0, y - 1), min(y + 2, self.b_size)):
-                w = self.grid.itemAtPosition(yi, xi).widget()
-                if not w.is_mine:
-                    w.click()
-
-    @Slot()
-    def on_click(self):
-        """
-        Handle the click event. If the game is not started, start the game.
-        """
-        self.update_available_flags()
-        if self.status != GameStatus.PLAYING:
-            # First click.
-            self.update_status(GameStatus.PLAYING)
-            # Start timer.
-            self._timer_start_num_seconds = int(time.time())
-            return
-        self.check_win()
-
-    def update_available_flags(self):
-        """
-        Update the number of available flags.
-        """
-        self.mines.setText(f"{self.get_num_remaining_flags():03d}")
-
-    def check_win(self):
-        """
-        Check if the game is won.
-        """
-        if self.get_num_hidden() == self.num_mines:
-            self.update_status(GameStatus.SUCCESS)
-
-    def update_status(self, status: GameStatus):
-        """
-        Update the status of the game.
-
-        Args:
-            status (GameStatus): The status of the game.
-        """
-        self.status = status
-        match status:
-            case GameStatus.READY:
-                icon = material_icon(icon_name="add", convert_to_pixmap=False)
-            case GameStatus.PLAYING:
-                icon = material_icon(icon_name="smart_toy", convert_to_pixmap=False)
-            case GameStatus.FAILED:
-                icon = material_icon(icon_name="error", convert_to_pixmap=False)
-            case GameStatus.SUCCESS:
-                icon = material_icon(icon_name="celebration", convert_to_pixmap=False)
-        self.reset_button.setIcon(icon)
-
-    def update_timer(self):
-        """
-        Update the timer.
-        """
-        if self.status == GameStatus.PLAYING:
-            num_seconds = int(time.time()) - self._timer_start_num_seconds
-            self.clock.setText(f"{num_seconds:03d}")
-
-    def game_over(self):
-        """Cause the game to end early"""
-        self.reveal_map()
-        self.update_status(GameStatus.FAILED)
-
-    def _set_level_params(self, level: tuple[int, int]):
-        self.b_size, self.num_mines = level
-
-
-if __name__ == "__main__":
-    from bec_widgets.utils.colors import set_theme
-
-    app = QApplication([])
-    set_theme("light")
-    widget = Minesweeper()
-    widget.show()
-
-    app.exec_()

bec_widgets/widgets/games/minesweeper.pyproject

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

bec_widgets/widgets/services/bec_status_box/bec_status_box.py

@@ -124,16 +124,41 @@ class BECStatusBox(BECWidget, CompactPopupWidget):
         self.tree = QTreeWidget(self)
         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 {}"
+        # )
         self.tree.setStyleSheet(
-            "QTreeWidget::item:!selected "
-            "{ "
+            "QTreeWidget::item:!selected { "
             "border: 1px solid gainsboro; "
             "border-left: none; "
             "border-top: none; "
+            "} "
+            "QTreeWidget::item:selected {} "
+            "QTreeView::branch { "
+            "border-image: none; "
+            "background: transparent; "
+            "} "
+            "QTreeView::branch:has-siblings:!adjoins-item { "
+            "border-image: none; "
+            "} "
+            "QTreeView::branch:has-children:!has-siblings:closed, "
+            "QTreeView::branch:closed:has-children:has-siblings { "
+            "border-image: none; "
+            "} "
+            "QTreeView::branch:open:has-children:!has-siblings, "
+            "QTreeView::branch:open:has-children:has-siblings { "
+            "border-image: none; "
             "}"
-            "QTreeWidget::item:selected {}"
         )
 
+        # self.tree.setRootIsDecorated(False)
+
     def _create_status_widget(
         self, service_name: str, status=BECStatus, info: dict = None, metrics: dict = None
     ) -> StatusItem:

bec_widgets/widgets/services/bec_status_box/status_item.py

@@ -23,7 +23,7 @@ MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 class IconsEnum(enum.Enum):
     """Enum class for icons in the status item widget."""
 
-    RUNNING = "done_outline"
+    RUNNING = "check_circle"
     BUSY = "progress_activity"
     IDLE = "progress_activity"
     ERROR = "emergency_home"

docs/user/widgets/games/games.md

@@ -1,11 +0,0 @@
-(user.widgets.games)=
-
-# Game widgets
-
-To provide some entertainment during long nights at the beamline, there are game widgets available. Well, only one, so far.
-
-## Minesweeper
-
-![Minesweeper](./minesweeper.png)
-
-The classic game Minesweeper. You may select from three different levels. The game can be ended or reset by clicking on the icon in the top-centre (the robot in the screenshot).

docs/user/widgets/user_script_widget/user_script_widget.md

@@ -0,0 +1,35 @@
+(user.widgets.user_script_widget)=
+# User Script Widget
+
+````{tab} Overview
+
+The [`UserScriptWidget`] is designed to allow users to run their user-defined scripts directly from a BEC GUI. This widget lists all available user scripts and allows users to execute them with a single click. The widget also provides an interface to open a VSCode editor to modify the files hosting the user scripts. This widget is particularly useful to provide a user-friendly interface to run custom scripts to users without using the command line. We note that the scripts are executed in a BEC client that does not share the full namespace with the BEC IPython kernel.
+
+## Key Features:
+- **User Script Execution**: Run user-defined scripts directly from the BEC GUI.
+- **VSCode Integration**: Open the VSCode editor to modify the files hosting the user scripts.
+
+
+````{tab} Examples
+
+The `UserScriptWidget` widget can be integrated within a [`BECDockArea`](user.widgets.bec_dock_area) or used as an individual component in your application through `BECDesigner`. Below are examples demonstrating how to create and use the `BECStatusBox` widget.
+
+## Example 1 - Adding BEC Status Box to BECDockArea
+
+In this example, we demonstrate how to add a `BECStatusBox` widget to a `BECDockArea`, allowing users to monitor the status of BEC processes directly from the GUI.
+
+```python
+# Add a new dock with a BECStatusBox widget
+user_script = gui.add_dock().add_widget("UserScriptWidget")
+```
+
+```{hint}
+The widget will automatically display the list of available user scripts. Users can click on the script name to execute it.
+```
+````
+
+````{tab} API
+```{eval-rst} 
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.UserScriptWidget.rst
+```
+````

docs/user/widgets/widgets.md

@@ -134,6 +134,15 @@ Display status of BEC services.
 
 Display current scan queue.
 ```
+
+```{grid-item-card} User Script Widget
+:link: user.widgets.user_script_widget
+:link-type: ref
+:img-top: /assets/widget_screenshots/user_script_widget.png
+
+Run user-defined scripts directly from the BEC GUI.
+```
+
 ````
 
 ## BEC Utility Widgets
@@ -238,6 +247,7 @@ Display DAP summaries of LMFit models in a window.
 
 Select DAP model from a list of DAP processes.
 ```
+
 ````
 
 ```{toctree}
@@ -270,6 +280,6 @@ signal_input/signal_input.md
 position_indicator/position_indicator.md
 lmfit_dialog/lmfit_dialog.md
 dap_combo_box/dap_combo_box.md
-games/games.md
+user_script_widget/user_script_widget.md
 
 ```

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "1.14.0"
+version = "1.7.0"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -30,7 +30,7 @@ dependencies = [
 dev = [
     "coverage~=7.0",
     "fakeredis~=2.23, >=2.23.2",
-    "pytest-bec-e2e>=2.21.4, <=4.0",
+    "pytest-bec-e2e~=2.16",
     "pytest-qt~=4.4",
     "pytest-random-order~=1.1",
     "pytest-timeout~=2.2",

tests/end-2-end/conftest.py

@@ -5,7 +5,8 @@ from contextlib import contextmanager
 import pytest
 from bec_lib.endpoints import MessageEndpoints
 
-from bec_widgets.cli.client_utils import BECGuiClient, _start_plot_process
+from bec_widgets.cli.client import BECDockArea
+from bec_widgets.cli.client_utils import _start_plot_process
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.widgets.containers.figure import BECFigure
 
@@ -40,37 +41,27 @@ def plot_server(gui_id, klass, client_lib):
 
 
 @pytest.fixture
-def connected_client_figure(gui_id, bec_client_lib):
+def rpc_server_figure(gui_id, bec_client_lib):
     with plot_server(gui_id, BECFigure, bec_client_lib) as server:
         yield server
 
 
 @pytest.fixture
-def connected_client_gui_obj(gui_id, bec_client_lib):
-    gui = BECGuiClient(gui_id=gui_id)
+def rpc_server_dock(gui_id, bec_client_lib):
+    dock_area = BECDockArea(gui_id=gui_id)
+    dock_area._auto_updates_enabled = False
     try:
-        gui.start_server(wait=True)
-        yield gui
+        dock_area.start_server(wait=True)
+        yield dock_area
     finally:
-        gui.close()
+        dock_area.close()
 
 
 @pytest.fixture
-def connected_client_dock(gui_id, bec_client_lib):
-    gui = BECGuiClient(gui_id=gui_id)
-    gui._auto_updates_enabled = False
+def rpc_server_dock_w_auto_updates(gui_id, bec_client_lib):
+    dock_area = BECDockArea(gui_id=gui_id)
     try:
-        gui.start_server(wait=True)
-        yield gui.main
+        dock_area.start_server(wait=True)
+        yield dock_area
     finally:
-        gui.close()
-
-
-@pytest.fixture
-def connected_client_dock_w_auto_updates(gui_id, bec_client_lib):
-    gui = BECGuiClient(gui_id=gui_id)
-    try:
-        gui.start_server(wait=True)
-        yield gui, gui.main
-    finally:
-        gui.close()
+        dock_area.close()

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -1,11 +1,10 @@
 import time
 
 import numpy as np
-import pytest
 from bec_lib.endpoints import MessageEndpoints
 
-from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
-from bec_widgets.tests.utils import check_remote_data_size
+from bec_widgets.cli.auto_updates import AutoUpdates
+from bec_widgets.cli.client import BECDockArea, BECFigure, BECImageShow, BECMotorMap, BECWaveform
 from bec_widgets.utils import Colors
 
 # pylint: disable=unused-argument
@@ -13,9 +12,9 @@ from bec_widgets.utils import Colors
 # pylint: disable=too-many-locals
 
 
-def test_rpc_add_dock_with_figure_e2e(qtbot, bec_client_lib, connected_client_dock):
+def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
     # BEC client shortcuts
-    dock = connected_client_dock
+    dock = rpc_server_dock
     client = bec_client_lib
     dev = client.device_manager.devices
     scans = client.scans
@@ -89,17 +88,14 @@ def test_rpc_add_dock_with_figure_e2e(qtbot, bec_client_lib, connected_client_do
 
     # Try to make a scan
     status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-    status.wait()
+
+    # wait for scan to finish
+    while not status.status == "COMPLETED":
+        time.sleep(0.2)
 
     # plot
     item = queue.scan_storage.storage[-1]
     plt_last_scan_data = item.live_data if hasattr(item, "live_data") else item.data
-    num_elements = len(plt_last_scan_data["samx"]["samx"].val)
-
-    plot_name = "bpm4i-bpm4i"
-
-    qtbot.waitUntil(lambda: check_remote_data_size(plt, plot_name, num_elements))
-
     plt_data = plt.get_all_data()
     assert plt_data["bpm4i-bpm4i"]["x"] == plt_last_scan_data["samx"]["samx"].val
     assert plt_data["bpm4i-bpm4i"]["y"] == plt_last_scan_data["bpm4i"]["bpm4i"].val
@@ -127,8 +123,8 @@ def test_rpc_add_dock_with_figure_e2e(qtbot, bec_client_lib, connected_client_do
     )
 
 
-def test_dock_manipulations_e2e(connected_client_dock):
-    dock = connected_client_dock
+def test_dock_manipulations_e2e(rpc_server_dock):
+    dock = rpc_server_dock
 
     d0 = dock.add_dock("dock_0")
     d1 = dock.add_dock("dock_1")
@@ -159,8 +155,8 @@ def test_dock_manipulations_e2e(connected_client_dock):
     assert len(dock.temp_areas) == 0
 
 
-def test_ring_bar(connected_client_dock):
-    dock = connected_client_dock
+def test_ring_bar(rpc_server_dock):
+    dock = rpc_server_dock
 
     d0 = dock.add_dock(name="dock_0")
 
@@ -186,8 +182,8 @@ def test_ring_bar(connected_client_dock):
     assert bar_colors == expected_colors_light or bar_colors == expected_colors_dark
 
 
-def test_ring_bar_scan_update(bec_client_lib, connected_client_dock):
-    dock = connected_client_dock
+def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
+    dock = rpc_server_dock
 
     d0 = dock.add_dock("dock_0")
 
@@ -238,20 +234,19 @@ def test_ring_bar_scan_update(bec_client_lib, connected_client_dock):
     assert bar_config["rings"][1]["max_value"] == final_samy
 
 
-def test_auto_update(bec_client_lib, connected_client_dock_w_auto_updates, qtbot):
+def test_auto_update(bec_client_lib, rpc_server_dock_w_auto_updates, qtbot):
     client = bec_client_lib
     dev = client.device_manager.devices
     scans = client.scans
     queue = client.queue
-    gui, dock = connected_client_dock_w_auto_updates
-    auto_updates = gui.auto_updates
+    dock = rpc_server_dock_w_auto_updates
 
     def get_default_figure():
-        return auto_updates.get_default_figure()
+        return dock.auto_updates.get_default_figure()
 
     plt = get_default_figure()
 
-    gui.selected_device = "bpm4i"
+    dock.selected_device = "bpm4i"
 
     status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
     status.wait()
@@ -259,17 +254,11 @@ def test_auto_update(bec_client_lib, connected_client_dock_w_auto_updates, qtbot
     # get data from curves
     widgets = plt.widget_list
     qtbot.waitUntil(lambda: len(plt.widget_list) > 0, timeout=5000)
+    plt_data = widgets[0].get_all_data()
 
     item = queue.scan_storage.storage[-1]
     last_scan_data = item.live_data if hasattr(item, "live_data") else item.data
 
-    num_elements = len(last_scan_data["samx"]["samx"].val)
-
-    plot_name = f"Scan {status.scan.scan_number} - {dock.selected_device}"
-
-    qtbot.waitUntil(lambda: check_remote_data_size(widgets[0], plot_name, num_elements))
-    plt_data = widgets[0].get_all_data()
-
     # check plotted data
     assert (
         plt_data[f"Scan {status.scan.scan_number} - bpm4i"]["x"]
@@ -285,20 +274,14 @@ def test_auto_update(bec_client_lib, connected_client_dock_w_auto_updates, qtbot
     )
     status.wait()
 
-    plt = auto_updates.get_default_figure()
+    plt = dock.auto_updates.get_default_figure()
     widgets = plt.widget_list
-
     qtbot.waitUntil(lambda: len(plt.widget_list) > 0, timeout=5000)
+    plt_data = widgets[0].get_all_data()
 
     item = queue.scan_storage.storage[-1]
     last_scan_data = item.live_data if hasattr(item, "live_data") else item.data
 
-    plot_name = f"Scan {status.scan.scan_number} - bpm4i"
-
-    num_elements_bec = len(last_scan_data["samx"]["samx"].val)
-    qtbot.waitUntil(lambda: check_remote_data_size(widgets[0], plot_name, num_elements_bec))
-    plt_data = widgets[0].get_all_data()
-
     # check plotted data
     assert (
         plt_data[f"Scan {status.scan.scan_number} - {dock.selected_device}"]["x"]
@@ -308,70 +291,3 @@ def test_auto_update(bec_client_lib, connected_client_dock_w_auto_updates, qtbot
         plt_data[f"Scan {status.scan.scan_number} - {dock.selected_device}"]["y"]
         == last_scan_data["samy"]["samy"].val
     )
-
-
-def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
-    gui = connected_client_gui_obj
-
-    assert gui.selected_device is None
-    assert len(gui.windows) == 1
-    assert gui.windows["main"].widget is gui.main
-    assert gui.windows["main"].title == "BEC Widgets"
-    mw = gui.main
-    assert mw.__class__.__name__ == "BECDockArea"
-
-    xw = gui.new("X")
-    assert xw.__class__.__name__ == "BECDockArea"
-    assert len(gui.windows) == 2
-
-    gui_info = gui._dump()
-    mw_info = gui_info[mw._gui_id]
-    assert mw_info["title"] == "BEC Widgets"
-    assert mw_info["visible"]
-    xw_info = gui_info[xw._gui_id]
-    assert xw_info["title"] == "X"
-    assert xw_info["visible"]
-
-    gui.hide()
-    gui_info = gui._dump()
-    assert not any(windows["visible"] for windows in gui_info.values())
-
-    gui.show()
-    gui_info = gui._dump()
-    assert all(windows["visible"] for windows in gui_info.values())
-
-    assert gui.gui_is_alive()
-    gui.close()
-    assert not gui.gui_is_alive()
-    gui.start_server(wait=True)
-    assert gui.gui_is_alive()
-    # calling start multiple times should not change anything
-    gui.start_server(wait=True)
-    gui.start()
-    # gui.windows should have main, and main dock area should have same gui_id as before
-    assert len(gui.windows) == 1
-    assert gui.windows["main"].widget._gui_id == mw._gui_id
-    # communication should work, main dock area should have same id and be visible
-    gui_info = gui._dump()
-    assert gui_info[mw._gui_id]["visible"]
-
-    with pytest.raises(RuntimeError):
-        gui.main.delete()
-
-    yw = gui.new("Y")
-    assert len(gui.windows) == 2
-    yw.delete()
-    assert len(gui.windows) == 1
-    # check it is really deleted on server
-    gui_info = gui._dump()
-    assert yw._gui_id not in gui_info
-
-
-def test_rpc_call_with_exception_in_safeslot_error_popup(connected_client_gui_obj, qtbot):
-    gui = connected_client_gui_obj
-
-    gui.main.add_dock("test")
-    qtbot.waitUntil(lambda: len(gui.main.panels) == 2)  # default_figure + test
-    with pytest.raises(ValueError):
-        gui.main.add_dock("test")
-        # time.sleep(0.1)

tests/end-2-end/test_bec_figure_rpc_e2e.py

@@ -1,14 +1,14 @@
 import time
 
 import numpy as np
+import pytest
 from bec_lib.endpoints import MessageEndpoints
 
 from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
-from bec_widgets.tests.utils import check_remote_data_size
 
 
-def test_rpc_waveform1d_custom_curve(connected_client_figure):
-    fig = BECFigure(connected_client_figure)
+def test_rpc_waveform1d_custom_curve(rpc_server_figure):
+    fig = BECFigure(rpc_server_figure)
 
     ax = fig.plot()
     curve = ax.plot(x=[1, 2, 3], y=[1, 2, 3])
@@ -20,8 +20,8 @@ def test_rpc_waveform1d_custom_curve(connected_client_figure):
     assert len(fig.widgets[ax._rpc_id].curves) == 1
 
 
-def test_rpc_plotting_shortcuts_init_configs(connected_client_figure, qtbot):
-    fig = BECFigure(connected_client_figure)
+def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
+    fig = BECFigure(rpc_server_figure)
 
     plt = fig.plot(x_name="samx", y_name="bpm4i")
     im = fig.image("eiger")
@@ -78,8 +78,8 @@ def test_rpc_plotting_shortcuts_init_configs(connected_client_figure, qtbot):
     }
 
 
-def test_rpc_waveform_scan(qtbot, connected_client_figure, bec_client_lib):
-    fig = BECFigure(connected_client_figure)
+def test_rpc_waveform_scan(rpc_server_figure, bec_client_lib):
+    fig = BECFigure(rpc_server_figure)
 
     # add 3 different curves to track
     plt = fig.plot(x_name="samx", y_name="bpm4i")
@@ -97,11 +97,6 @@ def test_rpc_waveform_scan(qtbot, connected_client_figure, bec_client_lib):
     item = queue.scan_storage.storage[-1]
     last_scan_data = item.live_data if hasattr(item, "live_data") else item.data
 
-    num_elements = len(last_scan_data["samx"]["samx"].val)
-
-    for plot_name in ["bpm4i-bpm4i", "bpm3a-bpm3a", "bpm4d-bpm4d"]:
-        qtbot.waitUntil(lambda: check_remote_data_size(plt, plot_name, num_elements))
-
     # get data from curves
     plt_data = plt.get_all_data()
 
@@ -114,8 +109,8 @@ def test_rpc_waveform_scan(qtbot, connected_client_figure, bec_client_lib):
     assert plt_data["bpm4d-bpm4d"]["y"] == last_scan_data["bpm4d"]["bpm4d"].val
 
 
-def test_rpc_image(connected_client_figure, bec_client_lib):
-    fig = BECFigure(connected_client_figure)
+def test_rpc_image(rpc_server_figure, bec_client_lib):
+    fig = BECFigure(rpc_server_figure)
 
     im = fig.image("eiger")
 
@@ -135,8 +130,8 @@ def test_rpc_image(connected_client_figure, bec_client_lib):
     np.testing.assert_equal(last_image_device, last_image_plot)
 
 
-def test_rpc_motor_map(connected_client_figure, bec_client_lib):
-    fig = BECFigure(connected_client_figure)
+def test_rpc_motor_map(rpc_server_figure, bec_client_lib):
+    fig = BECFigure(rpc_server_figure)
 
     motor_map = fig.motor_map("samx", "samy")
 
@@ -164,9 +159,9 @@ def test_rpc_motor_map(connected_client_figure, bec_client_lib):
     )
 
 
-def test_dap_rpc(connected_client_figure, bec_client_lib, qtbot):
+def test_dap_rpc(rpc_server_figure, bec_client_lib, qtbot):
 
-    fig = BECFigure(connected_client_figure)
+    fig = BECFigure(rpc_server_figure)
     plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
 
     client = bec_client_lib
@@ -204,8 +199,8 @@ def test_dap_rpc(connected_client_figure, bec_client_lib, qtbot):
     qtbot.waitUntil(wait_for_fit, timeout=10000)
 
 
-def test_removing_subplots(connected_client_figure, bec_client_lib):
-    fig = BECFigure(connected_client_figure)
+def test_removing_subplots(rpc_server_figure, bec_client_lib):
+    fig = BECFigure(rpc_server_figure)
     plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
     im = fig.image(monitor="eiger")
     mm = fig.motor_map(motor_x="samx", motor_y="samy")

tests/end-2-end/test_rpc_register_e2e.py

@@ -3,8 +3,8 @@ import pytest
 from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
 
 
-def test_rpc_register_list_connections(connected_client_figure):
-    fig = BECFigure(connected_client_figure)
+def test_rpc_register_list_connections(rpc_server_figure):
+    fig = BECFigure(rpc_server_figure)
 
     plt = fig.plot(x_name="samx", y_name="bpm4i")
     im = fig.image("eiger")

tests/unit_tests/conftest.py

@@ -5,7 +5,7 @@ from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
 from qtpy.QtCore import QTimer
 from qtpy.QtWidgets import QApplication
 
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.qt_utils import error_popups
 from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
 

tests/unit_tests/test_client_utils.py

@@ -4,7 +4,7 @@ from unittest import mock
 import pytest
 
 from bec_widgets.cli.client import BECFigure
-from bec_widgets.cli.client_utils import BECGuiClient, _start_plot_process
+from bec_widgets.cli.client_utils import BECGuiClientMixin, _start_plot_process
 from bec_widgets.tests.utils import FakeDevice
 
 
@@ -63,14 +63,15 @@ def test_client_utils_passes_client_config_to_server(bec_dispatcher):
 
     @contextmanager
     def bec_client_mixin():
-        mixin = BECGuiClient()
+        mixin = BECGuiClientMixin()
         mixin._client = bec_dispatcher.client
         mixin._gui_id = "gui_id"
         mixin.gui_is_alive = mock.MagicMock()
         mixin.gui_is_alive.side_effect = [True]
 
         try:
-            yield mixin
+            with mock.patch.object(mixin, "_start_update_script"):
+                yield mixin
         finally:
             mixin.close()
 
@@ -81,5 +82,6 @@ def test_client_utils_passes_client_config_to_server(bec_dispatcher):
                 wait=False
             )  # the started event will not be set, wait=True would block forever
             mock_start_plot.assert_called_once_with(
-                "gui_id", BECGuiClient, mixin._client._service_config.config, logger=mock.ANY
+                "gui_id", BECGuiClientMixin, mixin._client._service_config.config, logger=mock.ANY
             )
+            mixin._start_update_script.assert_called_once()

tests/unit_tests/test_collapsible_panel_manager.py

@@ -1,308 +0,0 @@
-import pytest
-from qtpy.QtCore import QEasingCurve
-from qtpy.QtWidgets import QPushButton, QVBoxLayout, QWidget
-
-from bec_widgets.qt_utils.collapsible_panel_manager import (
-    CollapsiblePanelManager,
-    DimensionAnimator,
-)
-from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
-
-
-@pytest.fixture
-def reference_widget(qtbot):
-    widget = QWidget()
-    layout = QVBoxLayout(widget)
-    btn = QPushButton("Reference")
-    layout.addWidget(btn)
-    qtbot.addWidget(widget)
-    widget.setVisible(True)
-    qtbot.waitExposed(widget)
-    return widget
-
-
-@pytest.fixture
-def layout_manager(qtbot, reference_widget):
-    manager = LayoutManagerWidget()
-    qtbot.addWidget(manager)
-    manager.add_widget(reference_widget, row=0, col=0)
-    manager.setVisible(True)
-    qtbot.waitExposed(manager)
-    return manager
-
-
-@pytest.fixture
-def panel_manager(layout_manager, reference_widget):
-    manager = CollapsiblePanelManager(layout_manager, reference_widget)
-    return manager
-
-
-@pytest.fixture
-def test_panel_widget(qtbot):
-    widget = QWidget()
-    qtbot.addWidget(widget)
-    return widget
-
-
-def test_dimension_animator_width_setting(qtbot, test_panel_widget):
-    animator = DimensionAnimator(test_panel_widget, "left")
-    animator.panel_width = 100
-    assert animator.panel_width == 100
-    assert test_panel_widget.width() == 100
-
-
-def test_dimension_animator_height_setting(qtbot, test_panel_widget):
-    animator = DimensionAnimator(test_panel_widget, "top")
-    animator.panel_height = 150
-    assert animator.panel_height == 150
-    assert test_panel_widget.height() == 150
-
-
-def test_add_panel(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200)
-    assert panel_manager.panels["left"]["widget"] == test_panel_widget
-    # Initially hidden
-    assert not test_panel_widget.isVisible()
-    assert test_panel_widget.maximumWidth() == 0
-
-
-def test_add_panel_no_target_size(panel_manager, test_panel_widget):
-    panel_manager.add_panel("top", test_panel_widget)
-    assert panel_manager.panels["top"]["target_size"] == 150
-    assert not test_panel_widget.isVisible()
-
-
-def test_add_panel_invalid_direction(panel_manager, test_panel_widget):
-    with pytest.raises(ValueError) as exc_info:
-        panel_manager.add_panel("invalid", test_panel_widget)
-    assert "Direction must be one of 'left', 'right', 'top', 'bottom'." in str(exc_info.value)
-
-
-def test_toggle_panel_show(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200)
-    assert not test_panel_widget.isVisible()
-
-    panel_manager.toggle_panel("left", animation=False)
-    assert test_panel_widget.isVisible()
-
-
-def test_toggle_panel_hide(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200)
-    panel_manager.toggle_panel("left", animation=False)
-    assert test_panel_widget.isVisible()
-
-    panel_manager.toggle_panel("left", animation=False)
-    assert not test_panel_widget.isVisible()
-
-
-def test_toggle_panel_scale(panel_manager, test_panel_widget, reference_widget):
-    reference_widget.resize(800, 600)
-    panel_manager.add_panel("right", test_panel_widget)
-    panel_manager.toggle_panel("right", scale=0.25, animation=False)
-    assert test_panel_widget.isVisible()
-    assert test_panel_widget.maximumWidth() == 200
-
-
-def test_toggle_panel_ensure_max(panel_manager, test_panel_widget):
-    panel_manager.add_panel("bottom", test_panel_widget, target_size=150)
-    panel_manager.toggle_panel("bottom", ensure_max=True, animation=False)
-    assert test_panel_widget.isVisible()
-    assert test_panel_widget.maximumHeight() == 150
-    panel_manager.toggle_panel("bottom", ensure_max=True, animation=False)
-    assert not test_panel_widget.isVisible()
-    assert test_panel_widget.maximumHeight() == 16777215
-
-
-def test_toggle_panel_easing_curve(panel_manager, test_panel_widget):
-    panel_manager.add_panel("top", test_panel_widget, target_size=100, duration=500)
-    panel_manager.toggle_panel("top", easing_curve=QEasingCurve.OutBounce, animation=True)
-    assert panel_manager.animations.get(test_panel_widget) is not None
-
-
-def test_toggle_nonexistent_panel(panel_manager):
-    with pytest.raises(ValueError) as exc_info:
-        panel_manager.toggle_panel("invalid")
-    assert "No panel found in direction 'invalid'." in str(exc_info.value)
-
-
-def test_toggle_panel_without_animation(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200)
-    panel_manager.toggle_panel("left", animation=False)
-    assert test_panel_widget.isVisible()
-    assert test_panel_widget.maximumWidth() == 200
-    panel_manager.toggle_panel("left", animation=False)
-    assert not test_panel_widget.isVisible()
-
-
-def test_after_hide_reset(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200)
-    panel_manager.toggle_panel("left", ensure_max=True, animation=False)
-    assert test_panel_widget.isVisible()
-    panel_manager.toggle_panel("left", ensure_max=True, animation=False)
-    assert not test_panel_widget.isVisible()
-    assert test_panel_widget.minimumWidth() == 0
-    assert test_panel_widget.maximumWidth() == 0
-
-
-def test_toggle_panel_repeated(panel_manager, test_panel_widget):
-    panel_manager.add_panel("right", test_panel_widget, target_size=200)
-    panel_manager.toggle_panel("right", animation=False)
-    assert test_panel_widget.isVisible()
-    panel_manager.toggle_panel("right", animation=False)
-    assert not test_panel_widget.isVisible()
-    panel_manager.toggle_panel("right", animation=False)
-    assert test_panel_widget.isVisible()
-
-
-def test_toggle_panel_with_custom_duration(panel_manager, test_panel_widget):
-    panel_manager.add_panel("bottom", test_panel_widget, target_size=150, duration=1000)
-    panel_manager.toggle_panel("bottom", duration=2000, animation=True)
-    animation = panel_manager.animations.get(test_panel_widget)
-    assert animation is not None
-    assert animation.duration() == 2000
-
-
-def test_toggle_panel_ensure_max_scale(panel_manager, test_panel_widget, reference_widget):
-    reference_widget.resize(1000, 800)
-    panel_manager.add_panel("top", test_panel_widget)
-    panel_manager.toggle_panel("top", ensure_max=True, scale=0.5, animation=False)
-    assert test_panel_widget.isVisible()
-    assert test_panel_widget.maximumHeight() == 400
-
-
-def test_no_animation_mode(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200)
-    panel_manager.toggle_panel("left", animation=False)
-    assert test_panel_widget.isVisible()
-    panel_manager.toggle_panel("left", animation=False)
-    assert not test_panel_widget.isVisible()
-
-
-def test_toggle_panel_nondefault_easing(panel_manager, test_panel_widget):
-    panel_manager.add_panel("right", test_panel_widget, target_size=200)
-    panel_manager.toggle_panel("right", easing_curve=QEasingCurve.InCurve, animation=True)
-    animation = panel_manager.animations.get(test_panel_widget)
-    assert animation is not None
-    assert animation.easingCurve() == QEasingCurve.InCurve
-
-
-def test_toggle_panel_ensure_max_no_animation(panel_manager, test_panel_widget):
-    panel_manager.add_panel("bottom", test_panel_widget, target_size=150)
-    panel_manager.toggle_panel("bottom", ensure_max=True, animation=False)
-    assert test_panel_widget.isVisible()
-    assert test_panel_widget.maximumHeight() == 150
-    panel_manager.toggle_panel("bottom", ensure_max=True, animation=False)
-    assert not test_panel_widget.isVisible()
-    assert test_panel_widget.maximumHeight() == 16777215
-
-
-def test_toggle_panel_new_target_size(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200)
-    panel_manager.toggle_panel("left", target_size=300, animation=False)
-    assert test_panel_widget.isVisible()
-    assert test_panel_widget.maximumWidth() == 300
-    panel_manager.toggle_panel("left", animation=False)
-    assert not test_panel_widget.isVisible()
-
-
-def test_toggle_panel_new_duration(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200, duration=300)
-    panel_manager.toggle_panel("left", duration=1000, animation=True)
-    animation = panel_manager.animations.get(test_panel_widget)
-    assert animation.duration() == 1000
-
-
-def test_toggle_panel_wrong_direction(panel_manager):
-    with pytest.raises(ValueError) as exc:
-        panel_manager.toggle_panel("unknown_direction")
-    assert "No panel found in direction 'unknown_direction'." in str(exc.value)
-
-
-def test_toggle_panel_no_panels(panel_manager):
-    with pytest.raises(ValueError) as exc:
-        panel_manager.toggle_panel("top")
-    assert "No panel found in direction 'top'." in str(exc.value)
-
-
-def test_multiple_panels_interaction(panel_manager):
-    widget_left = QWidget()
-    widget_right = QWidget()
-    panel_manager.add_panel("left", widget_left, target_size=200)
-    panel_manager.add_panel("right", widget_right, target_size=300)
-
-    panel_manager.toggle_panel("left", animation=False)
-    assert widget_left.isVisible()
-
-    panel_manager.toggle_panel("right", animation=False)
-    assert widget_right.isVisible()
-
-    panel_manager.toggle_panel("left", animation=False)
-    assert not widget_left.isVisible()
-    assert widget_right.isVisible()
-
-    panel_manager.toggle_panel("right", animation=False)
-    assert not widget_right.isVisible()
-
-
-def test_panel_manager_custom_easing(panel_manager, test_panel_widget):
-    panel_manager.add_panel("top", test_panel_widget, target_size=150)
-    panel_manager.toggle_panel("top", easing_curve=QEasingCurve.InQuad, animation=True)
-    animation = panel_manager.animations.get(test_panel_widget)
-    assert animation is not None
-    assert animation.easingCurve() == QEasingCurve.InQuad
-
-
-def test_toggle_panel_scale_no_animation(panel_manager, test_panel_widget, reference_widget):
-    reference_widget.resize(400, 300)
-    panel_manager.add_panel("bottom", test_panel_widget)
-    panel_manager.toggle_panel("bottom", scale=0.5, animation=False)
-    assert test_panel_widget.isVisible()
-    assert test_panel_widget.maximumHeight() == 150
-    panel_manager.toggle_panel("bottom", animation=False)
-    assert not test_panel_widget.isVisible()
-
-
-def test_after_hide_reset_properties(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200)
-    panel_manager.toggle_panel("left", ensure_max=True, animation=False)
-    panel_manager.toggle_panel("left", ensure_max=True, animation=False)
-    assert not test_panel_widget.isVisible()
-    assert test_panel_widget.minimumWidth() == 0
-    assert test_panel_widget.maximumWidth() == 0
-
-
-def test_toggle_panel_no_animation_show_only(panel_manager, test_panel_widget):
-    panel_manager.add_panel("right", test_panel_widget, target_size=100)
-    panel_manager.toggle_panel("right", animation=False)
-    assert test_panel_widget.isVisible()
-    assert test_panel_widget.maximumWidth() == 100
-
-
-def test_toggle_panel_no_animation_hide_only(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=100)
-    panel_manager.toggle_panel("left", animation=False)
-    assert test_panel_widget.isVisible()
-    panel_manager.toggle_panel("left", animation=False)
-    assert not test_panel_widget.isVisible()
-
-
-def test_toggle_panel_easing_inout(panel_manager, test_panel_widget):
-    panel_manager.add_panel("top", test_panel_widget, target_size=120)
-    panel_manager.toggle_panel("top", easing_curve=QEasingCurve.InOutQuad, animation=True)
-    animation = panel_manager.animations.get(test_panel_widget)
-    assert animation is not None
-    assert animation.easingCurve() == QEasingCurve.InOutQuad
-
-
-def test_toggle_panel_ensure_max_width(panel_manager, test_panel_widget):
-    panel_manager.add_panel("right", test_panel_widget, target_size=200)
-    panel_manager.toggle_panel("right", ensure_max=True, animation=False)
-    assert test_panel_widget.isVisible()
-    assert test_panel_widget.maximumWidth() == 200
-
-
-def test_toggle_panel_invalid_direction_twice(panel_manager, test_panel_widget):
-    panel_manager.add_panel("left", test_panel_widget, target_size=200)
-    with pytest.raises(ValueError) as exc_info:
-        panel_manager.toggle_panel("invalid_direction")
-    assert "No panel found in direction 'invalid_direction'." in str(exc_info.value)

tests/unit_tests/test_generate_cli_client.py

@@ -70,7 +70,7 @@ def test_client_generator_with_black_formatting():
         import enum
         from typing import Literal, Optional, overload
 
-        from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
+        from bec_widgets.cli.client_utils import BECGuiClientMixin, RPCBase, rpc_call
 
         # pylint: skip-file
 

tests/unit_tests/test_layout_manager.py

@@ -1,368 +0,0 @@
-from typing import Optional
-from unittest.mock import patch
-
-import pytest
-from qtpy.QtWidgets import QLabel, QPushButton, QWidget
-
-from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
-
-
-class MockWidgetHandler:
-    def create_widget(self, widget_type: str) -> Optional[QWidget]:
-        if widget_type == "ButtonWidget":
-            return QPushButton()
-        elif widget_type == "LabelWidget":
-            return QLabel()
-        else:
-            return None
-
-
-@pytest.fixture
-def mock_widget_handler():
-    handler = MockWidgetHandler()
-    with patch(
-        "bec_widgets.widgets.containers.layout_manager.layout_manager.widget_handler", handler
-    ):
-        yield handler
-
-
-@pytest.fixture
-def layout_manager(qtbot, mock_widget_handler):
-    widget = LayoutManagerWidget()
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_add_widget_empty_position(layout_manager):
-    """Test adding a widget to an empty position without shifting."""
-    btn1 = QPushButton("Button 1")
-    layout_manager.add_widget(btn1, row=0, col=0)
-
-    assert layout_manager.get_widget(0, 0) == btn1
-    assert layout_manager.widget_positions[btn1] == (0, 0, 1, 1)
-    assert layout_manager.position_widgets[(0, 0)] == btn1
-
-
-def test_add_widget_occupied_position(layout_manager):
-    """Test adding a widget to an occupied position with shifting (default direction right)."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-    layout_manager.add_widget(btn1, row=0, col=0)
-    layout_manager.add_widget(btn2, row=0, col=0)  # This should shift btn1 to the right
-
-    assert layout_manager.get_widget(0, 0) == btn2
-    assert layout_manager.get_widget(0, 1) == btn1
-    assert layout_manager.widget_positions[btn2] == (0, 0, 1, 1)
-    assert layout_manager.widget_positions[btn1] == (0, 1, 1, 1)
-
-
-def test_add_widget_directional_shift_down(layout_manager):
-    """Test adding a widget to an occupied position but shifting down instead of right."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-    btn3 = QPushButton("Button 3")
-    layout_manager.add_widget(btn1, row=0, col=0)
-    layout_manager.add_widget(btn2, row=0, col=0)  # Shifts btn1 to the right by default
-
-    # Now add btn3 at (0,1) but shift direction is down, so it should push btn1 down.
-    layout_manager.add_widget(btn3, row=0, col=1, shift_direction="down")
-
-    assert layout_manager.get_widget(0, 0) == btn2
-    assert layout_manager.get_widget(0, 1) == btn3
-    assert layout_manager.get_widget(1, 1) == btn1
-
-
-def test_remove_widget_by_position(layout_manager):
-    """Test removing a widget by specifying its row and column."""
-    btn1 = QPushButton("Button 1")
-    layout_manager.add_widget(btn1, row=0, col=0)
-
-    layout_manager.remove(row=0, col=0)
-
-    assert layout_manager.get_widget(0, 0) is None
-    assert btn1 not in layout_manager.widget_positions
-
-
-def test_move_widget_with_shift(layout_manager):
-    """Test moving a widget to an occupied position, triggering a shift."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-    btn3 = QPushButton("Button 3")
-
-    layout_manager.add_widget(btn1, row=0, col=0)
-    layout_manager.add_widget(btn2, row=0, col=1)
-    layout_manager.add_widget(btn3, row=1, col=0)
-
-    layout_manager.move_widget(old_row=0, old_col=0, new_row=0, new_col=1, shift_direction="right")
-
-    assert layout_manager.get_widget(0, 1) == btn1
-    assert layout_manager.get_widget(0, 2) == btn2
-    assert layout_manager.get_widget(1, 0) == btn3
-
-
-def test_move_widget_without_shift(layout_manager):
-    """Test moving a widget to an occupied position without shifting."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-
-    layout_manager.add_widget(btn1, row=0, col=0)
-    layout_manager.add_widget(btn2, row=0, col=1)
-
-    with pytest.raises(ValueError) as exc_info:
-        layout_manager.move_widget(old_row=0, old_col=0, new_row=0, new_col=1, shift=False)
-
-    assert "Position (0, 1) is already occupied." in str(exc_info.value)
-
-
-def test_change_layout_num_cols(layout_manager):
-    """Test changing the layout by specifying only the number of columns."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-    btn3 = QPushButton("Button 3")
-    btn4 = QPushButton("Button 4")
-
-    layout_manager.add_widget(btn1)
-    layout_manager.add_widget(btn2)
-    layout_manager.add_widget(btn3)
-    layout_manager.add_widget(btn4)
-
-    layout_manager.change_layout(num_cols=2)
-
-    assert layout_manager.get_widget(0, 0) == btn1
-    assert layout_manager.get_widget(0, 1) == btn2
-    assert layout_manager.get_widget(1, 0) == btn3
-    assert layout_manager.get_widget(1, 1) == btn4
-
-
-def test_change_layout_num_rows(layout_manager):
-    """Test changing the layout by specifying only the number of rows."""
-    btn_list = [QPushButton(f"Button {i}") for i in range(1, 7)]
-    for btn in btn_list:
-        layout_manager.add_widget(btn)
-
-    layout_manager.change_layout(num_rows=3)
-
-    assert layout_manager.get_widget(0, 0) == btn_list[0]
-    assert layout_manager.get_widget(0, 1) == btn_list[1]
-    assert layout_manager.get_widget(1, 0) == btn_list[2]
-    assert layout_manager.get_widget(1, 1) == btn_list[3]
-    assert layout_manager.get_widget(2, 0) == btn_list[4]
-    assert layout_manager.get_widget(2, 1) == btn_list[5]
-
-
-def test_shift_all_widgets(layout_manager):
-    """Test shifting all widgets down and then up."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-
-    layout_manager.add_widget(btn1, row=0, col=0)
-    layout_manager.add_widget(btn2, row=0, col=1)
-
-    # Shift all down
-    layout_manager.shift_all_widgets(direction="down")
-
-    assert layout_manager.get_widget(1, 0) == btn1
-    assert layout_manager.get_widget(1, 1) == btn2
-
-    # Shift all up
-    layout_manager.shift_all_widgets(direction="up")
-
-    assert layout_manager.get_widget(0, 0) == btn1
-    assert layout_manager.get_widget(0, 1) == btn2
-
-
-def test_add_widget_auto_position(layout_manager):
-    """Test adding widgets without specifying row and column."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-
-    layout_manager.add_widget(btn1)
-    layout_manager.add_widget(btn2)
-
-    assert layout_manager.get_widget(0, 0) == btn1
-    assert layout_manager.get_widget(0, 1) == btn2
-
-
-def test_clear_layout(layout_manager):
-    """Test clearing the entire layout."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-    layout_manager.add_widget(btn1)
-    layout_manager.add_widget(btn2)
-
-    layout_manager.clear_layout()
-
-    assert layout_manager.get_widget(0, 0) is None
-    assert layout_manager.get_widget(0, 1) is None
-    assert len(layout_manager.widget_positions) == 0
-
-
-def test_add_widget_with_span(layout_manager):
-    """Test adding a widget with rowspan and colspan."""
-    btn1 = QPushButton("Button 1")
-    layout_manager.add_widget(btn1, row=0, col=0, rowspan=2, colspan=2)
-
-    assert layout_manager.widget_positions[btn1] == (0, 0, 2, 2)
-
-
-def test_add_widget_overlap_with_span(layout_manager):
-    """
-    Test adding a widget that overlaps with an existing widget's span.
-    The code will attempt to shift widgets accordingly.
-    """
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-
-    layout_manager.add_widget(btn1, row=0, col=0, rowspan=2, colspan=1)
-
-    layout_manager.add_widget(btn2, row=1, col=1, shift_direction="right")
-
-    assert layout_manager.get_widget(0, 0) == btn1
-    assert layout_manager.widget_positions[btn1] == (0, 0, 2, 1)
-    assert layout_manager.get_widget(1, 1) == btn2
-    assert layout_manager.widget_positions[btn2] == (1, 1, 1, 1)
-
-
-@pytest.mark.parametrize(
-    "position, btn3_coords",
-    [("left", (1, 0)), ("right", (1, 2)), ("top", (0, 1)), ("bottom", (2, 1))],
-)
-def test_add_widget_relative(layout_manager, position, btn3_coords):
-    """Test adding a widget relative to an existing widget using parameterized data."""
-    expected_row, expected_col = btn3_coords
-
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-    btn3 = QPushButton("Button 3")
-
-    layout_manager.add_widget(btn1, row=0, col=0)
-    layout_manager.add_widget(btn2, row=1, col=1)
-
-    layout_manager.add_widget_relative(btn3, reference_widget=btn2, position=position)
-
-    assert layout_manager.get_widget(0, 0) == btn1
-    assert layout_manager.get_widget(1, 1) == btn2
-    assert layout_manager.get_widget(expected_row, expected_col) == btn3
-
-
-def test_add_widget_relative_invalid_position(layout_manager):
-    """Test adding a widget relative to an existing widget with an invalid position."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-
-    layout_manager.add_widget(btn1, row=1, col=1)
-    with pytest.raises(ValueError) as exc_info:
-        layout_manager.add_widget_relative(btn2, reference_widget=btn1, position="invalid_position")
-
-    assert "Invalid position. Choose from 'left', 'right', 'top', 'bottom'." in str(exc_info.value)
-    btn2.deleteLater()
-
-
-def test_add_widget_relative_to_nonexistent_widget(layout_manager):
-    """Test adding a widget relative to a widget that does not exist in the layout."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-
-    with pytest.raises(ValueError) as exc_info:
-        layout_manager.add_widget_relative(btn2, reference_widget=btn1, position="left")
-
-    assert "Reference widget not found in layout." in str(exc_info.value)
-    btn1.deleteLater()
-    btn2.deleteLater()
-
-
-def test_add_widget_relative_with_shift(layout_manager):
-    """Test adding a widget relative to an existing widget with shifting."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-    btn3 = QPushButton("Button 3")
-
-    layout_manager.add_widget(btn1, row=1, col=1)
-    layout_manager.add_widget(btn2, row=1, col=0)
-
-    layout_manager.add_widget_relative(
-        btn3, reference_widget=btn1, position="left", shift_direction="right"
-    )
-
-    assert layout_manager.get_widget(0, 0) == btn3
-    assert layout_manager.get_widget(1, 1) == btn2
-    assert layout_manager.get_widget(0, 1) == btn1
-
-
-def test_move_widget_by_object(layout_manager):
-    """Test moving a widget using the widget object."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-
-    layout_manager.add_widget(btn1)
-    layout_manager.add_widget(btn2, row=0, col=1)
-
-    layout_manager.move_widget_by_object(btn1, new_row=1, new_col=1)
-
-    # the grid is reindex after each move, so the new positions are (0,0) and (1,0), because visually there is only one column
-    assert layout_manager.get_widget(1, 0) == btn1
-    assert layout_manager.get_widget(0, 0) == btn2
-
-
-def test_move_widget_by_coords(layout_manager):
-    """Test moving a widget using its current coordinates."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-
-    layout_manager.add_widget(btn1)
-    layout_manager.add_widget(btn2, row=0, col=1)
-
-    layout_manager.move_widget_by_coords(0, 0, 1, 0, shift_direction="down")
-
-    assert layout_manager.get_widget(1, 0) == btn1
-    assert layout_manager.get_widget(0, 1) == btn2
-
-
-def test_change_layout_no_arguments(layout_manager):
-    """Test changing the layout with no arguments (should do nothing)."""
-    btn1 = QPushButton("Button 1")
-    layout_manager.add_widget(btn1, row=0, col=0)
-
-    layout_manager.change_layout()
-
-    assert layout_manager.get_widget(0, 0) == btn1
-    assert len(layout_manager.widget_positions) == 1
-
-
-def test_remove_nonexistent_widget(layout_manager):
-    """Test removing a widget that doesn't exist in the layout."""
-    with pytest.raises(ValueError) as exc_info:
-        layout_manager.remove(row=0, col=0)
-
-    assert "No widget found at position (0, 0)." in str(exc_info.value)
-
-
-def test_reindex_grid_after_removal(layout_manager):
-    """Test reindexing the grid after removing a widget."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-    layout_manager.add_widget(btn1)
-    layout_manager.add_widget(btn2, row=0, col=1)
-
-    layout_manager.remove_widget(btn1)
-    layout_manager.reindex_grid()
-
-    # After removal and reindex, btn2 should shift to (0,0)
-    assert layout_manager.get_widget(0, 0) == btn2
-    assert layout_manager.widget_positions[btn2] == (0, 0, 1, 1)
-
-
-def test_shift_all_widgets_up_at_top_row(layout_manager):
-    """Test shifting all widgets up when they are already at the top row."""
-    btn1 = QPushButton("Button 1")
-    btn2 = QPushButton("Button 2")
-
-    layout_manager.add_widget(btn1, row=0, col=0)
-    layout_manager.add_widget(btn2, row=0, col=1)
-
-    # Shifting up should cause an error since widgets can't move above row 0
-    with pytest.raises(ValueError) as exc_info:
-        layout_manager.shift_all_widgets(direction="up")
-
-    assert "Shifting widgets out of grid boundaries." in str(exc_info.value)

tests/unit_tests/test_minesweeper.py

@@ -1,50 +0,0 @@
-# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
-
-import pytest
-from qtpy.QtCore import Qt
-
-from bec_widgets.widgets.games import Minesweeper
-from bec_widgets.widgets.games.minesweeper import LEVELS, GameStatus, Pos
-
-
-@pytest.fixture
-def minesweeper(qtbot):
-    widget = Minesweeper()
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_minesweeper_init(minesweeper: Minesweeper):
-    assert minesweeper.status == GameStatus.READY
-
-
-def test_changing_level_updates_size_and_removes_old_grid_items(minesweeper: Minesweeper):
-    assert minesweeper.b_size == LEVELS["1"][0]
-    grid_items = [minesweeper.grid.itemAt(i).widget() for i in range(minesweeper.grid.count())]
-    for w in grid_items:
-        assert w.parent() is not None
-    minesweeper.change_level("2")
-    assert minesweeper.b_size == LEVELS["2"][0]
-    for w in grid_items:
-        assert w.parent() is None
-
-
-def test_game_state_changes_to_failed_on_loss(qtbot, minesweeper: Minesweeper):
-    assert minesweeper.status == GameStatus.READY
-    grid_items: list[Pos] = [
-        minesweeper.grid.itemAt(i).widget() for i in range(minesweeper.grid.count())
-    ]
-    mine = [p for p in grid_items if p.is_mine][0]
-
-    with qtbot.waitSignal(mine.ohno, timeout=1000):
-        qtbot.mouseRelease(mine, Qt.MouseButton.LeftButton)
-    assert minesweeper.status == GameStatus.FAILED
-
-
-def test_game_resets_on_reset_click(minesweeper: Minesweeper):
-    assert minesweeper.status == GameStatus.READY
-    minesweeper.grid.itemAt(1).widget().ohno.emit()
-    assert minesweeper.status == GameStatus.FAILED
-    minesweeper.reset_button_pressed()
-    assert minesweeper.status == GameStatus.PLAYING

tests/unit_tests/test_modular_toolbar.py

@@ -1,279 +0,0 @@
-from typing import Literal
-
-import pytest
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import QComboBox, QLabel, QToolButton, QWidget
-
-from bec_widgets.qt_utils.toolbar import (
-    DeviceSelectionAction,
-    ExpandableMenuAction,
-    IconAction,
-    MaterialIconAction,
-    ModularToolBar,
-    SeparatorAction,
-    WidgetAction,
-)
-
-
-@pytest.fixture
-def dummy_widget(qtbot):
-    """Fixture to create a simple widget to be used as target widget."""
-    widget = QWidget()
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    return widget
-
-
-@pytest.fixture(params=["horizontal", "vertical"])
-def toolbar_fixture(qtbot, request, dummy_widget):
-    """Parametrized fixture to create a ModularToolBar with different orientations."""
-    orientation: Literal["horizontal", "vertical"] = request.param
-    toolbar = ModularToolBar(
-        target_widget=dummy_widget,
-        orientation=orientation,
-        background_color="rgba(255, 255, 255, 255)",  # White background for testing
-    )
-    qtbot.addWidget(toolbar)
-    qtbot.waitExposed(toolbar)
-    yield toolbar
-    toolbar.close()
-
-
-@pytest.fixture
-def separator_action():
-    """Fixture to create a SeparatorAction."""
-    return SeparatorAction()
-
-
-@pytest.fixture
-def icon_action():
-    """Fixture to create an IconAction."""
-    return IconAction(icon_path="assets/BEC-Icon.png", tooltip="Test Icon Action", checkable=True)
-
-
-@pytest.fixture
-def material_icon_action():
-    """Fixture to create a MaterialIconAction."""
-    return MaterialIconAction(
-        icon_name="home", tooltip="Test Material Icon Action", checkable=False
-    )
-
-
-@pytest.fixture
-def device_selection_action():
-    """Fixture to create a DeviceSelectionAction."""
-    device_combobox = QComboBox()
-    device_combobox.addItems(["Device 1", "Device 2", "Device 3"])
-    device_combobox.setCurrentIndex(0)
-    return DeviceSelectionAction(label="Select Device:", device_combobox=device_combobox)
-
-
-@pytest.fixture
-def widget_action():
-    """Fixture to create a WidgetAction."""
-    sample_widget = QLabel("Sample Widget")
-    return WidgetAction(label="Sample Label:", widget=sample_widget)
-
-
-@pytest.fixture
-def expandable_menu_action():
-    """Fixture to create an ExpandableMenuAction."""
-    action1 = MaterialIconAction(icon_name="counter_1", tooltip="Menu Action 1", checkable=False)
-    action2 = MaterialIconAction(icon_name="counter_2", tooltip="Menu Action 2", checkable=True)
-    actions = {"action1": action1, "action2": action2}
-    return ExpandableMenuAction(
-        label="Expandable Menu", actions=actions, icon_path="assets/BEC-Icon.png"
-    )
-
-
-def test_initialization(toolbar_fixture):
-    """Test that ModularToolBar initializes correctly with different orientations."""
-    toolbar = toolbar_fixture
-    if toolbar.orientation() == Qt.Horizontal:
-        assert toolbar.orientation() == Qt.Horizontal
-    elif toolbar.orientation() == Qt.Vertical:
-        assert toolbar.orientation() == Qt.Vertical
-    else:
-        pytest.fail("Toolbar orientation is neither horizontal nor vertical.")
-    assert toolbar.background_color == "rgba(255, 255, 255, 255)"
-    assert toolbar.widgets == {}
-    assert not toolbar.isMovable()
-    assert not toolbar.isFloatable()
-
-
-def test_set_background_color(toolbar_fixture):
-    """Test setting the background color of the toolbar."""
-    toolbar = toolbar_fixture
-    new_color = "rgba(0, 0, 0, 255)"  # Black
-    toolbar.set_background_color(new_color)
-    assert toolbar.background_color == new_color
-    # Verify stylesheet
-    expected_style = f"QToolBar {{ background-color: {new_color}; border: none; }}"
-    assert toolbar.styleSheet() == expected_style
-
-
-def test_set_orientation(toolbar_fixture, qtbot, dummy_widget):
-    """Test changing the orientation of the toolbar."""
-    toolbar = toolbar_fixture
-    if toolbar.orientation() == Qt.Horizontal:
-        new_orientation = "vertical"
-    else:
-        new_orientation = "horizontal"
-    toolbar.set_orientation(new_orientation)
-    qtbot.wait(100)
-    if new_orientation == "horizontal":
-        assert toolbar.orientation() == Qt.Horizontal
-    else:
-        assert toolbar.orientation() == Qt.Vertical
-
-
-def test_add_action(
-    toolbar_fixture, icon_action, separator_action, material_icon_action, dummy_widget
-):
-    """Test adding different types of actions to the toolbar."""
-    toolbar = toolbar_fixture
-
-    # Add IconAction
-    toolbar.add_action("icon_action", icon_action, dummy_widget)
-    assert "icon_action" in toolbar.widgets
-    assert toolbar.widgets["icon_action"] == icon_action
-    assert icon_action.action in toolbar.actions()
-
-    # Add SeparatorAction
-    toolbar.add_action("separator_action", separator_action, dummy_widget)
-    assert "separator_action" in toolbar.widgets
-    assert toolbar.widgets["separator_action"] == separator_action
-
-    # Add MaterialIconAction
-    toolbar.add_action("material_icon_action", material_icon_action, dummy_widget)
-    assert "material_icon_action" in toolbar.widgets
-    assert toolbar.widgets["material_icon_action"] == material_icon_action
-    assert material_icon_action.action in toolbar.actions()
-
-
-def test_hide_show_action(toolbar_fixture, icon_action, qtbot, dummy_widget):
-    """Test hiding and showing actions on the toolbar."""
-    toolbar = toolbar_fixture
-
-    # Add an action
-    toolbar.add_action("icon_action", icon_action, dummy_widget)
-    assert icon_action.action.isVisible()
-
-    # Hide the action
-    toolbar.hide_action("icon_action")
-    qtbot.wait(100)
-    assert not icon_action.action.isVisible()
-
-    # Show the action
-    toolbar.show_action("icon_action")
-    qtbot.wait(100)
-    assert icon_action.action.isVisible()
-
-
-def test_add_duplicate_action(toolbar_fixture, icon_action, dummy_widget):
-    """Test that adding an action with a duplicate action_id raises a ValueError."""
-    toolbar = toolbar_fixture
-
-    # Add an action
-    toolbar.add_action("icon_action", icon_action, dummy_widget)
-    assert "icon_action" in toolbar.widgets
-
-    # Attempt to add another action with the same ID
-    with pytest.raises(ValueError) as excinfo:
-        toolbar.add_action("icon_action", icon_action, dummy_widget)
-    assert "Action with ID 'icon_action' already exists." in str(excinfo.value)
-
-
-def test_update_material_icon_colors(toolbar_fixture, material_icon_action, dummy_widget):
-    """Test updating the color of MaterialIconAction icons."""
-    toolbar = toolbar_fixture
-
-    # Add MaterialIconAction
-    toolbar.add_action("material_icon_action", material_icon_action, dummy_widget)
-    assert material_icon_action.action is not None
-
-    # Initial icon
-    initial_icon = material_icon_action.action.icon()
-
-    # Update color
-    new_color = "#ff0000"  # Red
-    toolbar.update_material_icon_colors(new_color)
-
-    # Updated icon
-    updated_icon = material_icon_action.action.icon()
-
-    # Assuming that the icon changes when color is updated
-    assert initial_icon != updated_icon
-
-
-def test_device_selection_action(toolbar_fixture, device_selection_action, dummy_widget):
-    """Test adding a DeviceSelectionAction to the toolbar."""
-    toolbar = toolbar_fixture
-    toolbar.add_action("device_selection", device_selection_action, dummy_widget)
-    assert "device_selection" in toolbar.widgets
-    # DeviceSelectionAction adds a QWidget, so it should be present in the toolbar's widgets
-    # Check if the widget is added
-    widget = device_selection_action.device_combobox.parentWidget()
-    assert widget in toolbar.findChildren(QWidget)
-    # Verify that the label is correct
-    label = widget.findChild(QLabel)
-    assert label.text() == "Select Device:"
-
-
-def test_widget_action(toolbar_fixture, widget_action, dummy_widget):
-    """Test adding a WidgetAction to the toolbar."""
-    toolbar = toolbar_fixture
-    toolbar.add_action("widget_action", widget_action, dummy_widget)
-    assert "widget_action" in toolbar.widgets
-    # WidgetAction adds a QWidget to the toolbar
-    container = widget_action.widget.parentWidget()
-    assert container in toolbar.findChildren(QWidget)
-    # Verify the label if present
-    label = container.findChild(QLabel)
-    assert label.text() == "Sample Label:"
-
-
-def test_expandable_menu_action(toolbar_fixture, expandable_menu_action, dummy_widget):
-    """Test adding an ExpandableMenuAction to the toolbar."""
-    toolbar = toolbar_fixture
-    toolbar.add_action("expandable_menu", expandable_menu_action, dummy_widget)
-    assert "expandable_menu" in toolbar.widgets
-    # ExpandableMenuAction adds a QToolButton with a QMenu
-    # Find the QToolButton
-    tool_buttons = toolbar.findChildren(QToolButton)
-    assert len(tool_buttons) > 0
-    button = tool_buttons[-1]  # Assuming it's the last one added
-    menu = button.menu()
-    assert menu is not None
-    # Check that menu has the correct actions
-    for action_id, sub_action in expandable_menu_action.actions.items():
-        # Check if a sub-action with the correct tooltip exists
-        matched = False
-        for menu_action in menu.actions():
-            if menu_action.toolTip() == sub_action.tooltip:
-                matched = True
-                break
-        assert matched, f"Sub-action with tooltip '{sub_action.tooltip}' not found in menu."
-
-
-def test_update_material_icon_colors_no_material_actions(toolbar_fixture, dummy_widget):
-    """Test updating material icon colors when there are no MaterialIconActions."""
-    toolbar = toolbar_fixture
-    # Ensure there are no MaterialIconActions
-    toolbar.update_material_icon_colors("#00ff00")
-
-
-def test_hide_action_nonexistent(toolbar_fixture):
-    """Test hiding an action that does not exist raises a ValueError."""
-    toolbar = toolbar_fixture
-    with pytest.raises(ValueError) as excinfo:
-        toolbar.hide_action("nonexistent_action")
-    assert "Action with ID 'nonexistent_action' does not exist." in str(excinfo.value)
-
-
-def test_show_action_nonexistent(toolbar_fixture):
-    """Test showing an action that does not exist raises a ValueError."""
-    toolbar = toolbar_fixture
-    with pytest.raises(ValueError) as excinfo:
-        toolbar.show_action("nonexistent_action")
-    assert "Action with ID 'nonexistent_action' does not exist." in str(excinfo.value)

tests/unit_tests/test_round_frame.py

@@ -1,64 +0,0 @@
-import pyqtgraph as pg
-import pytest
-
-from bec_widgets.qt_utils.round_frame import RoundedFrame
-
-
-def cleanup_pyqtgraph(plot_widget):
-    item = plot_widget.getPlotItem()
-    item.vb.menu.close()
-    item.vb.menu.deleteLater()
-    item.ctrlMenu.close()
-    item.ctrlMenu.deleteLater()
-
-
-@pytest.fixture
-def basic_rounded_frame(qtbot):
-    frame = RoundedFrame()
-    qtbot.addWidget(frame)
-    qtbot.waitExposed(frame)
-    yield frame
-
-
-@pytest.fixture
-def plot_rounded_frame(qtbot):
-    plot_widget = pg.PlotWidget()
-    plot_widget.plot([0, 1, 2], [2, 1, 0])
-    frame = RoundedFrame(content_widget=plot_widget, theme_update=True)
-    qtbot.addWidget(frame)
-    qtbot.waitExposed(frame)
-    yield frame
-    cleanup_pyqtgraph(plot_widget)
-
-
-def test_basic_rounded_frame_initialization(basic_rounded_frame):
-    assert basic_rounded_frame.radius == 10
-    assert basic_rounded_frame.content_widget is None
-    assert basic_rounded_frame.background_color is None
-    assert basic_rounded_frame.theme_update is True
-
-
-def test_set_radius(basic_rounded_frame):
-    basic_rounded_frame.radius = 20
-    assert basic_rounded_frame.radius == 20
-
-
-def test_apply_theme_light(plot_rounded_frame):
-    plot_rounded_frame.apply_theme("light")
-
-    assert plot_rounded_frame.background_color == "#e9ecef"
-
-
-def test_apply_theme_dark(plot_rounded_frame):
-    plot_rounded_frame.apply_theme("dark")
-
-    assert plot_rounded_frame.background_color == "#141414"
-
-
-def test_apply_plot_widget_style(plot_rounded_frame):
-    # Verify that a PlotWidget can have its style applied
-    plot_rounded_frame.apply_plot_widget_style(border="1px solid red")
-
-    # Ensure style application did not break anything
-    assert plot_rounded_frame.content_widget is not None
-    assert isinstance(plot_rounded_frame.content_widget, pg.PlotWidget)

tests/unit_tests/test_rpc_register.py

@@ -1,4 +1,4 @@
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.cli.rpc_register import RPCRegister
 
 
 class FakeObject:

tests/unit_tests/test_rpc_widget_handler.py

@@ -1,4 +1,4 @@
-from bec_widgets.cli.rpc.rpc_widget_handler import RPCWidgetHandler
+from bec_widgets.cli.rpc_wigdet_handler import RPCWidgetHandler
 
 
 def test_rpc_widget_handler():

tests/unit_tests/test_side_menu.py

@@ -1,366 +0,0 @@
-from typing import Literal
-
-import pytest
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import QHBoxLayout, QLabel, QVBoxLayout, QWidget
-
-from bec_widgets.qt_utils.side_panel import SidePanel
-
-
-@pytest.fixture(params=["left", "right", "top", "bottom"])
-def side_panel_fixture(qtbot, request):
-    """
-    Parametrized fixture to create SidePanel with different orientations.
-
-    Yields:
-        tuple: (SidePanel instance, orientation string)
-    """
-    orientation: Literal["left", "right", "top", "bottom"] = request.param
-    panel = SidePanel(orientation=orientation)
-    qtbot.addWidget(panel)
-    qtbot.waitExposed(panel)
-    yield panel, orientation
-
-
-@pytest.fixture
-def menu_widget(qtbot):
-    """Fixture to create a simple widget to add to the SidePanel."""
-    widget = QWidget()
-    layout = QVBoxLayout(widget)
-    label = QLabel("Test Widget")
-    layout.addWidget(label)
-    widget.setLayout(layout)
-    return widget
-
-
-def test_initialization(side_panel_fixture):
-    """Test that SidePanel initializes correctly with different orientations."""
-    panel, orientation = side_panel_fixture
-
-    assert panel._orientation == orientation
-    assert panel.panel_max_width == 200
-    assert panel.animation_duration == 200
-    assert panel.animations_enabled is True
-    assert panel.panel_visible is False
-    assert panel.current_action is None
-    assert panel.current_index is None
-    assert panel.switching_actions is False
-
-    if orientation in ("left", "right"):
-        assert panel.toolbar.orientation() == Qt.Vertical
-        assert isinstance(panel.main_layout, QHBoxLayout)
-    else:
-        assert panel.toolbar.orientation() == Qt.Horizontal
-        assert isinstance(panel.main_layout, QVBoxLayout)
-
-
-def test_set_panel_max_width(side_panel_fixture, qtbot):
-    """Test setting the panel_max_width property."""
-    panel, orientation = side_panel_fixture
-    new_max_width = 300
-    panel.panel_max_width = new_max_width
-    qtbot.wait(100)
-
-    assert panel.panel_max_width == new_max_width
-    if orientation in ("left", "right"):
-        assert panel.stack_widget.maximumWidth() == new_max_width
-    else:
-        assert panel.stack_widget.maximumHeight() == new_max_width
-
-
-def test_set_animation_duration(side_panel_fixture, qtbot):
-    """Test setting the animationDuration property."""
-    panel, _ = side_panel_fixture
-    new_duration = 500
-    panel.animation_duration = new_duration
-    qtbot.wait(100)
-
-    assert panel.animation_duration == new_duration
-    assert panel.menu_anim.duration() == new_duration
-
-
-def test_set_animations_enabled(side_panel_fixture, qtbot):
-    """Test setting the animationsEnabled property."""
-    panel, _ = side_panel_fixture
-    panel.animationsEnabled = False
-    qtbot.wait(100)
-
-    assert panel.animationsEnabled is False
-
-    panel.animationsEnabled = True
-    qtbot.wait(100)
-
-    assert panel.animationsEnabled is True
-
-
-def test_show_hide_panel_with_animation(side_panel_fixture, qtbot):
-    """Test showing and hiding the panel with animations enabled."""
-    panel, orientation = side_panel_fixture
-    panel.animationsEnabled = True
-
-    # Show panel
-    panel.show_panel(0)
-    qtbot.wait(panel.animation_duration + 100)  # Wait for animation to complete
-
-    final_size = panel.panel_max_width
-    if orientation in ("left", "right"):
-        assert panel.panel_width == final_size
-    else:
-        assert panel.panel_height == final_size
-    assert panel.panel_visible is True
-
-    # Hide panel
-    panel.hide_panel()
-    qtbot.wait(panel.animation_duration + 100)  # Wait for animation to complete
-
-    if orientation in ("left", "right"):
-        assert panel.panel_width == 0
-    else:
-        assert panel.panel_height == 0
-    assert panel.panel_visible is False
-
-
-def test_add_menu(side_panel_fixture, menu_widget, qtbot):
-    """Test adding a menu to the SidePanel."""
-    panel, _ = side_panel_fixture
-    initial_count = panel.stack_widget.count()
-
-    panel.add_menu(
-        action_id="test_action",
-        icon_name="counter_1",
-        tooltip="Test Tooltip",
-        widget=menu_widget,
-        title="Test Panel",
-    )
-    qtbot.wait(100)
-
-    assert panel.stack_widget.count() == initial_count + 1
-    # Verify the action is added to the toolbar
-    action = panel.toolbar.widgets.get("test_action")
-    assert action is not None
-    assert action.tooltip == "Test Tooltip"
-    assert action.action in panel.toolbar.actions()
-
-
-def test_toggle_action_show_panel(side_panel_fixture, menu_widget, qtbot):
-    """Test that toggling an action shows the corresponding panel."""
-    panel, _ = side_panel_fixture
-
-    panel.add_menu(
-        action_id="toggle_action",
-        icon_name="counter_1",
-        tooltip="Toggle Tooltip",
-        widget=menu_widget,
-        title="Toggle Panel",
-    )
-    qtbot.wait(100)
-
-    action = panel.toolbar.widgets.get("toggle_action")
-    assert action is not None
-
-    # Initially, panel should be hidden
-    assert panel.panel_visible is False
-
-    # Toggle the action to show the panel
-    action.action.trigger()
-    qtbot.wait(panel.animation_duration + 100)
-
-    assert panel.panel_visible is True
-    assert panel.current_action == action.action
-    assert panel.current_index == panel.stack_widget.count() - 1
-
-    # Toggle the action again to hide the panel
-    action.action.trigger()
-    qtbot.wait(panel.animation_duration + 100)
-
-    assert panel.panel_visible is False
-    assert panel.current_action is None
-    assert panel.current_index is None
-
-
-def test_switch_actions(side_panel_fixture, menu_widget, qtbot):
-    """Test switching between multiple actions and panels."""
-    panel, _ = side_panel_fixture
-
-    # Add two menus
-    panel.add_menu(
-        action_id="action1",
-        icon_name="counter_1",
-        tooltip="Tooltip1",
-        widget=menu_widget,
-        title="Panel 1",
-    )
-    panel.add_menu(
-        action_id="action2",
-        icon_name="counter_2",
-        tooltip="Tooltip2",
-        widget=menu_widget,
-        title="Panel 2",
-    )
-    qtbot.wait(100)
-
-    action1 = panel.toolbar.widgets.get("action1")
-    action2 = panel.toolbar.widgets.get("action2")
-    assert action1 is not None
-    assert action2 is not None
-
-    # Activate first action
-    action1.action.trigger()
-    qtbot.wait(panel.animation_duration + 100)
-    assert panel.panel_visible is True
-    assert panel.current_action == action1.action
-    assert panel.current_index == 0
-
-    # Activate second action
-    action2.action.trigger()
-    qtbot.wait(panel.animation_duration + 100)
-    assert panel.panel_visible is True
-    assert panel.current_action == action2.action
-    assert panel.current_index == 1
-
-    # Deactivate second action
-    action2.action.trigger()
-    qtbot.wait(panel.animation_duration + 100)
-    assert panel.panel_visible is False
-    assert panel.current_action is None
-    assert panel.current_index is None
-
-
-def test_multiple_add_menu(side_panel_fixture, menu_widget, qtbot):
-    """Test adding multiple menus and ensure they are all added correctly."""
-    panel, _ = side_panel_fixture
-    initial_count = panel.stack_widget.count()
-
-    for i in range(3):
-        panel.add_menu(
-            action_id=f"action{i}",
-            icon_name=f"counter_{i}",
-            tooltip=f"Tooltip{i}",
-            widget=menu_widget,
-            title=f"Panel {i}",
-        )
-        qtbot.wait(100)
-        assert panel.stack_widget.count() == initial_count + i + 1
-        action = panel.toolbar.widgets.get(f"action{i}")
-        assert action is not None
-        assert action.tooltip == f"Tooltip{i}"
-        assert action.action in panel.toolbar.actions()
-
-
-def test_switch_to_method(side_panel_fixture, menu_widget, qtbot):
-    """Test the switch_to method to change panels without animation."""
-    panel, _ = side_panel_fixture
-
-    # Add two menus
-    panel.add_menu(
-        action_id="action1",
-        icon_name="counter_1",
-        tooltip="Tooltip1",
-        widget=menu_widget,
-        title="Panel 1",
-    )
-    panel.add_menu(
-        action_id="action2",
-        icon_name="counter_2",
-        tooltip="Tooltip2",
-        widget=menu_widget,
-        title="Panel 2",
-    )
-    qtbot.wait(100)
-
-    # Show first panel
-    panel.show_panel(0)
-    qtbot.wait(panel.animation_duration + 100)
-    assert panel.current_index == 0
-
-    # Switch to second panel
-    panel.switch_to(1)
-    qtbot.wait(100)
-    assert panel.current_index == 1
-
-
-def test_animation_enabled_parametrization(qtbot):
-    """Test SidePanel with animations enabled and disabled."""
-    for animations_enabled in [True, False]:
-        panel = SidePanel(animations_enabled=animations_enabled)
-        qtbot.addWidget(panel)
-        qtbot.waitExposed(panel)
-
-        assert panel.animations_enabled == animations_enabled
-
-        panel.close()
-
-
-def test_orientation_layouts(qtbot):
-    """Test that the layouts are correctly set based on orientation."""
-    orientations = {
-        "left": ("horizontal", Qt.Vertical),
-        "right": ("horizontal", Qt.Vertical),
-        "top": ("vertical", Qt.Horizontal),
-        "bottom": ("vertical", Qt.Horizontal),
-    }
-
-    for orientation, (main_layout_dir, toolbar_orientation) in orientations.items():
-        panel = SidePanel(orientation=orientation)
-        qtbot.addWidget(panel)
-        qtbot.waitExposed(panel)
-
-        # Verify main layout direction
-        if main_layout_dir == "horizontal":
-            assert isinstance(panel.main_layout, QHBoxLayout)
-        else:
-            assert isinstance(panel.main_layout, QVBoxLayout)
-
-        # Verify toolbar orientation
-        bar_orientation = panel.toolbar.orientation()
-        assert bar_orientation == toolbar_orientation
-
-        panel.close()
-
-
-def test_panel_width_height_properties(side_panel_fixture, qtbot):
-    """Test that setting panel_width and panel_height works correctly."""
-    panel, orientation = side_panel_fixture
-
-    if orientation in ("left", "right"):
-        panel.panel_width = 150
-        qtbot.wait(100)
-        assert panel.panel_width == 150
-        assert panel.stack_widget.width() == 150
-    else:
-        panel.panel_height = 150
-        qtbot.wait(100)
-        assert panel.panel_height == 150
-        assert panel.stack_widget.height() == 150
-
-
-def test_no_panel_initially(side_panel_fixture, qtbot):
-    """Test that the panel is initially hidden."""
-    panel, orientation = side_panel_fixture
-
-    if orientation in ("left", "right"):
-        assert panel.panel_width == 0
-    else:
-        assert panel.panel_height == 0
-    assert panel.panel_visible is False
-
-
-def test_add_multiple_menus(side_panel_fixture, menu_widget, qtbot):
-    """Test adding multiple menus and ensure they are all added correctly."""
-    panel, _ = side_panel_fixture
-    initial_count = panel.stack_widget.count()
-
-    for i in range(3):
-        panel.add_menu(
-            action_id=f"action{i}",
-            icon_name=f"counter_{i}",
-            tooltip=f"Tooltip{i}",
-            widget=menu_widget,
-            title=f"Panel {i}",
-        )
-        qtbot.wait(100)
-        assert panel.stack_widget.count() == initial_count + i + 1
-        action = panel.toolbar.widgets.get(f"action{i}")
-        assert action is not None
-        assert action.tooltip == f"Tooltip{i}"
-        assert action.action in panel.toolbar.actions()

tests/unit_tests/test_user_script.py

@@ -0,0 +1,119 @@
+import inspect
+from unittest import mock
+
+import pytest
+from qtpy.QtWidgets import QLabel
+
+from bec_widgets.widgets.editors.user_script.user_script import UserScriptWidget
+
+from .client_mocks import mocked_client
+
+
+def dummy_script():
+    pass
+
+
+def dummy_script_with_args(arg1: str, arg2: int = 0):
+    pass
+
+
+@pytest.fixture
+def SCRIPTS(tmp_path):
+    """Create dummy script files"""
+    home_script = f"{tmp_path}/dummy_path_home_scripts/home_testing.py"
+    bec_script = f"{tmp_path}/dummy_path_bec_lib_scripts/bec_testing.py"
+    rtr = {
+        "dummy_script": {"cls": dummy_script, "fname": home_script},
+        "dummy_script_with_args": {"cls": dummy_script_with_args, "fname": bec_script},
+    }
+    return rtr
+
+
+@pytest.fixture
+def user_script_widget(SCRIPTS, qtbot, mocked_client):
+    mocked_client._scripts = SCRIPTS
+    files = {
+        "USER": [SCRIPTS["dummy_script"]["fname"]],
+        "BEC": [SCRIPTS["dummy_script_with_args"]["fname"]],
+    }
+    mock_console = mock.MagicMock()
+    mock_vscode = mock.MagicMock()
+    with mock.patch(
+        "bec_widgets.widgets.editors.user_script.user_script.UserScriptWidget.get_script_files",
+        return_value=files,
+    ):
+        with mock.patch("bec_widgets.widgets.editors.user_script.user_script.VSCodeDialog.init_ui"):
+            widget = UserScriptWidget(
+                client=mocked_client, vs_code_editor=mock_vscode, bec_console=mock_console
+            )
+            qtbot.addWidget(widget)
+            qtbot.waitExposed(widget)
+            yield widget
+
+
+def test_user_script_widget_start_up(SCRIPTS, user_script_widget):
+    """Test init the user_script widget with dummy scripts from above"""
+    assert user_script_widget.tree_widget.columnCount() == 2
+    assert len(user_script_widget.tree_widget.children()[0].children()) == 6
+    assert user_script_widget.user_scripts["home_testing"].location == "USER"
+    assert user_script_widget.user_scripts["home_testing"].module_name == "home_testing"
+    assert user_script_widget.user_scripts["home_testing"].fname == SCRIPTS["dummy_script"]["fname"]
+    assert user_script_widget.user_scripts["home_testing"].user_script_name == dummy_script.__name__
+
+    assert user_script_widget.user_scripts["bec_testing"].location == "BEC"
+    assert user_script_widget.user_scripts["bec_testing"].module_name == "bec_testing"
+    assert (
+        user_script_widget.user_scripts["bec_testing"].fname
+        == SCRIPTS["dummy_script_with_args"]["fname"]
+    )
+    assert (
+        user_script_widget.user_scripts["bec_testing"].user_script_name
+        == dummy_script_with_args.__name__
+    )
+    for label in user_script_widget.tree_widget.children()[0].findChildren(QLabel):
+        assert label.text() in [
+            "home_testing",
+            "bec_testing",
+            "dummy_script",
+            "dummy_script_with_args",
+        ]
+
+
+def test_handle_open_script(SCRIPTS, user_script_widget):
+    """Test handling open script"""
+    with mock.patch.object(user_script_widget, "open_script") as mock_open_script:
+        user_script_widget.handle_edit_button_clicked("home_testing")
+        fp = SCRIPTS["dummy_script"]["fname"]
+        mock_open_script.assert_called_once_with(fp)
+
+
+def test_open_script(user_script_widget):
+    """Test opening script"""
+    assert user_script_widget._code_dialog is None
+    # Override the _vscode_ed
+    with mock.patch.object(user_script_widget._vscode_editor, "show") as mock_show:
+        with mock.patch.object(user_script_widget._vscode_editor, "open_file") as mock_open_file:
+            with mock.patch.object(user_script_widget._vscode_editor, "zen_mode") as mock_zen_mode:
+                user_script_widget.open_script("/dummy_path_home_scripts/home_testing.py")
+                mock_show.assert_called_once()
+                mock_open_file.assert_called_once_with("/dummy_path_home_scripts/home_testing.py")
+                mock_zen_mode.assert_called_once()
+                assert user_script_widget._code_dialog is not None
+
+
+def test_play_button(user_script_widget):
+    """Test play button"""
+    with mock.patch.object(user_script_widget, "_console") as mock_console:
+        with mock.patch.object(user_script_widget, "_handle_call_with_args") as mock_handle_call:
+            # Test first with no args
+            user_script_widget.handle_play_button_clicked("dummy_script")
+            mock_console.execute_command.caller_args == [
+                mock.call("bec.load_all_user_scripts()"),
+                mock.call("dummy_script()"),
+            ]
+            assert user_script_widget._script_dialog is None
+
+            # Test with args
+            user_script_widget.handle_play_button_clicked("dummy_script_with_args")
+            caller_args = inspect.getfullargspec(dummy_script_with_args)
+            assert mock_handle_call.call_args == mock.call("dummy_script_with_args", caller_args)

tests/unit_tests/test_widget_io.py

@@ -1,17 +1,8 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import pytest
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import (
-    QComboBox,
-    QLineEdit,
-    QSpinBox,
-    QTableWidget,
-    QTableWidgetItem,
-    QVBoxLayout,
-    QWidget,
-)
+from qtpy.QtWidgets import QComboBox, QLineEdit, QSpinBox, QTableWidget, QVBoxLayout, QWidget
 
-from bec_widgets.utils.widget_io import WidgetHierarchy, WidgetIO
+from bec_widgets.utils.widget_io import WidgetHierarchy
 
 
 @pytest.fixture(scope="function")
@@ -31,12 +22,6 @@ def example_widget(qtbot):
     # Add text items to the combo box
     combo_box.addItems(["Option 1", "Option 2", "Option 3"])
 
-    # Populate the table widget
-    table_widget.setItem(0, 0, QTableWidgetItem("Initial A"))
-    table_widget.setItem(0, 1, QTableWidgetItem("Initial B"))
-    table_widget.setItem(1, 0, QTableWidgetItem("Initial C"))
-    table_widget.setItem(1, 1, QTableWidgetItem("Initial D"))
-
     qtbot.addWidget(main_widget)
     qtbot.waitExposed(main_widget)
     yield main_widget
@@ -103,73 +88,3 @@ def test_export_import_config(example_widget):
 
     assert exported_config_full == expected_full
     assert exported_config_reduced == expected_reduced
-
-
-def test_widget_io_get_set_value(example_widget):
-    # Extract widgets
-    line_edit = example_widget.findChild(QLineEdit)
-    combo_box = example_widget.findChild(QComboBox)
-    table_widget = example_widget.findChild(QTableWidget)
-    spin_box = example_widget.findChild(QSpinBox)
-
-    # Check initial values
-    assert WidgetIO.get_value(line_edit) == ""
-    assert WidgetIO.get_value(combo_box) == 0  # first index
-    assert WidgetIO.get_value(table_widget) == [
-        ["Initial A", "Initial B"],
-        ["Initial C", "Initial D"],
-    ]
-    assert WidgetIO.get_value(spin_box) == 0
-
-    # Set new values
-    WidgetIO.set_value(line_edit, "Hello")
-    WidgetIO.set_value(combo_box, "Option 2")
-    WidgetIO.set_value(table_widget, [["X", "Y"], ["Z", "W"]])
-    WidgetIO.set_value(spin_box, 5)
-
-    # Check updated values
-    assert WidgetIO.get_value(line_edit) == "Hello"
-    assert WidgetIO.get_value(combo_box, as_string=True) == "Option 2"
-    assert WidgetIO.get_value(table_widget) == [["X", "Y"], ["Z", "W"]]
-    assert WidgetIO.get_value(spin_box) == 5
-
-
-def test_widget_io_signal(qtbot, example_widget):
-    # Extract widgets
-    line_edit = example_widget.findChild(QLineEdit)
-    combo_box = example_widget.findChild(QComboBox)
-    spin_box = example_widget.findChild(QSpinBox)
-    table_widget = example_widget.findChild(QTableWidget)
-
-    # We'll store changes in a list to verify the slot is called
-    changes = []
-
-    def universal_slot(w, val):
-        changes.append((w, val))
-
-    # Connect signals
-    WidgetIO.connect_widget_change_signal(line_edit, universal_slot)
-    WidgetIO.connect_widget_change_signal(combo_box, universal_slot)
-    WidgetIO.connect_widget_change_signal(spin_box, universal_slot)
-    WidgetIO.connect_widget_change_signal(table_widget, universal_slot)
-
-    # Trigger changes
-    line_edit.setText("NewText")
-    qtbot.waitUntil(lambda: len(changes) > 0)
-    assert changes[-1][1] == "NewText"
-
-    combo_box.setCurrentIndex(2)
-    qtbot.waitUntil(lambda: len(changes) > 1)
-    # combo_box change should give the current index or value
-    # We set "Option 3" is index 2
-    assert changes[-1][1] == 2 or changes[-1][1] == "Option 3"
-
-    spin_box.setValue(42)
-    qtbot.waitUntil(lambda: len(changes) > 2)
-    assert changes[-1][1] == 42
-
-    # For the table widget, changing a cell triggers cellChanged
-    table_widget.setItem(0, 0, QTableWidgetItem("ChangedCell"))
-    qtbot.waitUntil(lambda: len(changes) > 3)
-    # The entire table value should be retrieved
-    assert changes[-1][1][0][0] == "ChangedCell"