wip various fixes for csaxs testing

CHANGELOG.md

@@ -1,148 +1,6 @@
 # CHANGELOG
 
 
-## v3.13.5 (2026-06-02)
-
-### Bug Fixes
-
-- Change prints into proper logs
-  ([`c8275fc`](https://github.com/bec-project/bec_widgets/commit/c8275fcfd5c920393df3aa201c32a632ac8086a5))
-
-- **abort_button**: From __future__ import annotations
-  ([`3796984`](https://github.com/bec-project/bec_widgets/commit/37969841822c8c38c23a1d8fca8e38aec684957b))
-
-- **client_utils**: Increase default rpc timeout to 60s
-  ([`07515d2`](https://github.com/bec-project/bec_widgets/commit/07515d24be6e930b1b40170fc710255914cb7454))
-
-- **client_utils**: Stop output reader thread on shutdown
-  ([`4572760`](https://github.com/bec-project/bec_widgets/commit/4572760b56ca2ab6435db3a6a4ba0d270e9008d1))
-
-- **companion_app**: Disable logging of bec_lib.scan_items on widget side
-  ([`bd66afb`](https://github.com/bec-project/bec_widgets/commit/bd66afb98dcb76ca87b0db1334df3c1af0a9dbad))
-
-- **forms**: Gridlayout applied to widget which already has layout
-  ([`1427c70`](https://github.com/bec-project/bec_widgets/commit/1427c70cfb6f84bbced7f72ec5cfa55ac0b9b742))
-
-- **launch_window**: Exclude launcher check for non-parented widgets for BECMainWindow
-  ([`ed68eb5`](https://github.com/bec-project/bec_widgets/commit/ed68eb5ac6b20cfc7ca2c0b91864dc54fb579499))
-
-- **launcher**: Avoid orphan widgets detection and logging
-  ([`9f94ca7`](https://github.com/bec-project/bec_widgets/commit/9f94ca7748d73a30622ecbaef384f4bc73a3d2fb))
-
-- **logging**: Removed args/kwargs from logging messages
-  ([`2fb7fb2`](https://github.com/bec-project/bec_widgets/commit/2fb7fb2ff487863c3bc931498496da74b25e52d8))
-
-- **rpc**: Additional logs
-  ([`e41e609`](https://github.com/bec-project/bec_widgets/commit/e41e60956b54890b70b3390b981196c9477abd93))
-
-- **rpc**: Client/server rpc handshake for shutdown
-  ([`8a180ea`](https://github.com/bec-project/bec_widgets/commit/8a180eaa7be5c1603d893cf3b50585f88f9b0c83))
-
-- **rpc**: Log dispatcher receipt before qt callback
-  ([`878745b`](https://github.com/bec-project/bec_widgets/commit/878745b99ac1e22c0fbddecc294e599469a2adfe))
-
-- **rpc**: More robust shutdown section with PID logging
-  ([`e42a982`](https://github.com/bec-project/bec_widgets/commit/e42a9824ccd54b71a3141aaf2aa4e02af6a13782))
-
-- **rpc_server**: Log warning if rpc call is repeated
-  ([`859563a`](https://github.com/bec-project/bec_widgets/commit/859563abb3e94ff55886e72db3177522900a89b8))
-
-### Refactoring
-
-- **client_utils**: Simplify PID fetching
-  ([`154ae60`](https://github.com/bec-project/bec_widgets/commit/154ae6026a6471b7c1db42f7c2ff3dc7be4b4afb))
-
-- **rpc**: Share logging helpers
-  ([`8e1e282`](https://github.com/bec-project/bec_widgets/commit/8e1e282fac22ab6f726049758306c7ca17af70eb))
-
-
-## v3.13.4 (2026-05-29)
-
-### Bug Fixes
-
-- **positioner_box**: Fix STOP button
-  ([`9a58dba`](https://github.com/bec-project/bec_widgets/commit/9a58dba414d9eec32fd7de7fc64c97c38f020b84))
-
-
-## v3.13.3 (2026-05-22)
-
-### Bug Fixes
-
-- **tests**: Rename description attribute to _description in FakeDevice
-  ([`668b1bd`](https://github.com/bec-project/bec_widgets/commit/668b1bd9cd158fc12cff2c340d7317f30a212121))
-
-
-## v3.13.2 (2026-05-22)
-
-### Bug Fixes
-
-- **tests**: Rename description attribute to _description in FakePositioner
-  ([`c346bd0`](https://github.com/bec-project/bec_widgets/commit/c346bd0f18ce873ff5ca6c59150c9581c9edca8d))
-
-
-## v3.13.1 (2026-05-21)
-
-### Bug Fixes
-
-- Use .show instead of .start
-  ([`b4beb27`](https://github.com/bec-project/bec_widgets/commit/b4beb274da745da618f9b37ec241cd0109c088f1))
-
-- **gui**: Replace window.show() with window.raise_window() and add hide() method
-  ([`f7a48b5`](https://github.com/bec-project/bec_widgets/commit/f7a48b5f6a51d391dca26ca42d03bad4f278ff22))
-
-
-## v3.13.0 (2026-05-21)
-
-### Features
-
-- **rpc-base**: Set default RPC timeout and allow customization
-  ([`f03a5d9`](https://github.com/bec-project/bec_widgets/commit/f03a5d9e853bd62b8ec1bad1c1e112fe01befe70))
-
-
-## v3.12.2 (2026-05-21)
-
-### Bug Fixes
-
-- **toggle**: Disable styling implemented
-  ([`9eb0541`](https://github.com/bec-project/bec_widgets/commit/9eb05416ab68dcb88732dca8974c665030d34e0b))
-
-
-## v3.12.1 (2026-05-21)
-
-### Bug Fixes
-
-- **device_input**: Correct cleanup unsubscribe
-  ([`56427a7`](https://github.com/bec-project/bec_widgets/commit/56427a7f0c3a89fe847d415c8b45212e663434c4))
-
-- **device_input**: Ensure callback is removed after cleanup
-  ([`d99db7d`](https://github.com/bec-project/bec_widgets/commit/d99db7d04208945b86a39d65022b211ba093caed))
-
-- **signal_combobox**: Signature matched for update_signals_from_filters
-  ([`a976837`](https://github.com/bec-project/bec_widgets/commit/a976837cff612349f2a3f17900903c203bc3d250))
-
-
-## v3.12.0 (2026-05-20)
-
-### Bug Fixes
-
-- **scan-control**: Filter out private scans from allowed scans
-  ([`2dc0227`](https://github.com/bec-project/bec_widgets/commit/2dc0227d38f0e217e252a5e5751bafd60363a5a4))
-
-- **scan-control**: Hide hidden scan arguments
-  ([`2d8e1ee`](https://github.com/bec-project/bec_widgets/commit/2d8e1eed4d6503c42a38c8de910ddaa54132405d))
-
-- **scan-control**: Reject unsupported scan input types
-  ([`3b579e7`](https://github.com/bec-project/bec_widgets/commit/3b579e740f36c60c3635681a9b2c35b518498f58))
-
-- **scan-control**: Skip duplicate visible scan kwargs
-  ([`b8740c9`](https://github.com/bec-project/bec_widgets/commit/b8740c95941d36102f07a51d74a50e6f262a6646))
-
-### Features
-
-- Add support for new scan signatures including units
-  ([`d5bf10e`](https://github.com/bec-project/bec_widgets/commit/d5bf10e21682ae8270078c7858a036bafbabf10e))
-
-
 ## v3.11.1 (2026-05-18)
 
 ### Bug Fixes

bec_widgets/applications/companion_app.py

@@ -5,7 +5,6 @@ import json
 import os
 import signal
 import sys
-import traceback
 from contextlib import redirect_stderr, redirect_stdout
 
 import darkdetect
@@ -64,7 +63,6 @@ class GUIServer:
         self.app: QApplication | None = None
         self.launcher_window: LaunchWindow | None = None
         self.dispatcher: BECDispatcher | None = None
-        self._shutdown_started = False
 
     def start(self):
         """
@@ -76,7 +74,6 @@ class GUIServer:
             bec_logger._stderr_log_level = bec_logger.LOGLEVEL.ERROR
             bec_logger._update_sinks()
 
-        bec_logger.disabled_modules = ["bec_lib.scan_items"]
         with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):  # type: ignore
             with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):  # type: ignore
                 self._run()
@@ -125,8 +122,17 @@ class GUIServer:
         self.app.aboutToQuit.connect(self.shutdown)
         self.app.setQuitOnLastWindowClosed(True)
 
-        signal.signal(signal.SIGINT, self.request_shutdown)
-        signal.signal(signal.SIGTERM, self.request_shutdown)
+        def sigint_handler(*args):
+            # display message, for people to let it terminate gracefully
+            print("Caught SIGINT, exiting")
+            # Widgets should be all closed.
+            with RPCRegister.delayed_broadcast():
+                for widget in QApplication.instance().topLevelWidgets():  # type: ignore
+                    widget.close()
+            self.shutdown()
+
+        signal.signal(signal.SIGINT, sigint_handler)
+        signal.signal(signal.SIGTERM, sigint_handler)
 
         sys.exit(self.app.exec())
 
@@ -143,67 +149,16 @@ class GUIServer:
         )
         self.app.setWindowIcon(icon)
 
-    def request_shutdown(self, signum=None, _frame=None):
-        """
-        Request Qt application shutdown from an RPC call or OS signal.
-
-        Cleanup itself is handled by ``shutdown()``, which is connected to
-        ``QApplication.aboutToQuit``. Calling it directly here would run BEC/RPC
-        teardown before Qt has processed the widget close events.
-        """
-        signal_name = signal.Signals(signum).name if signum is not None else "shutdown"
-        pid = os.getpid()
-        if self.app is None:
-            logger.info(f"Caught {signal_name}, shutting down GUI server pid={pid} without app")
-            self.shutdown()
-            return
-
-        widgets = [
-            f"{widget.__class__.__name__}(objectName={widget.objectName()!r})"
-            for widget in self.app.topLevelWidgets()
-        ]
-        logger.info(
-            f"Caught {signal_name}, requesting GUI server shutdown pid={pid} "
-            f"top_level_widgets={widgets}"
-        )
-        with RPCRegister.delayed_broadcast():
-            for widget in self.app.topLevelWidgets():
-                widget.close()
-        self.app.quit()
-
-    @staticmethod
-    def _run_shutdown_step(step: str, callback):
-        try:
-            callback()
-        except Exception as exc:
-            logger.error(
-                f"GUIServer shutdown step failed pid={os.getpid()} step={step}: {exc}\n"
-                f"{traceback.format_exc()}"
-            )
-
     def shutdown(self):
-        if self._shutdown_started:
-            return
-        self._shutdown_started = True
-        logger.info(f"Shutdown GUIServer pid={os.getpid()} {repr(self)}")
-
-        def close_launcher_window():
-            if self.launcher_window and shiboken6.isValid(self.launcher_window):
-                self.launcher_window.close()
-                self.launcher_window.deleteLater()
-
-        def stop_pylsp_server():
-            if pylsp_server.is_running():
-                pylsp_server.stop()
-
-        def stop_dispatcher():
-            if self.dispatcher:
-                self.dispatcher.stop_cli_server()
-                self.dispatcher.disconnect_all()
-
-        self._run_shutdown_step("close_launcher_window", close_launcher_window)
-        self._run_shutdown_step("stop_pylsp_server", stop_pylsp_server)
-        self._run_shutdown_step("stop_dispatcher", stop_dispatcher)
+        logger.info("Shutdown GUIServer", repr(self))
+        if self.launcher_window and shiboken6.isValid(self.launcher_window):
+            self.launcher_window.close()
+            self.launcher_window.deleteLater()
+        if pylsp_server.is_running():
+            pylsp_server.stop()
+        if self.dispatcher:
+            self.dispatcher.stop_cli_server()
+            self.dispatcher.disconnect_all()
 
 
 def main():

bec_widgets/applications/launch_window.py

@@ -207,7 +207,6 @@ class LaunchWindow(BECMainWindow):
 
         self.app = QApplication.instance()
         self.tiles: dict[str, LaunchTile] = {}
-        self._logged_unparented_connections: set[str] = set()
         # Track the smallest main‑label font size chosen so far
         self._min_main_label_pt: int | None = None
 
@@ -656,83 +655,53 @@ class LaunchWindow(BECMainWindow):
         super().showEvent(event)
         self.setFixedSize(self.size())
 
-    def _has_external_window(self, connections: dict) -> bool:
+    def _launcher_is_last_widget(self, connections: dict) -> bool:
         """
-        Check if any registered non-launcher connection owns a top-level Qt window.
+        Check if the launcher is the last widget in the application.
         """
+
+        # get all parents of connections
         for connection in connections.values():
-            if self._connection_belongs_to_launcher(connection):
-                continue
-            if isinstance(connection, QWidget) and connection.isWindow():
-                return True
-        return False
-
-    def _log_unparented_connections(self, connections: dict) -> None:
-        """
-        Log non-launcher RPC connections that remain without an active top-level window.
-        """
-        for connection in connections.values():
-            if self._connection_belongs_to_launcher(connection):
-                continue
-            if isinstance(connection, QWidget) and connection.isWindow():
-                continue
-
-            connection_description = (
-                f"type={type(connection).__name__} objectName={connection.objectName()!r} "
-                f"gui_id={connection.gui_id!r}"
-            )
-            if connection_description in self._logged_unparented_connections:
-                continue
-            self._logged_unparented_connections.add(connection_description)
-            logger.warning(
-                "Registered non-launcher RPC connection has no active top-level window: "
-                f"{connection_description}"
-            )
-
-    def _connection_belongs_to_launcher(self, connection: QObject) -> bool:
-        """
-        Check whether a registered connection is the launcher itself or part of its Qt hierarchy.
-        """
-        if connection is self or connection.gui_id == self.gui_id:
-            return True
-
-        parent = connection.parent()
-        while parent is not None:
-            if parent is self:
-                return True
-            parent = parent.parent()
-
-        return False
+            try:
+                parent = connection.parent()
+                if parent is None and connection.objectName() != self.objectName():
+                    logger.info(
+                        f"Found non-launcher connection without parent: {connection.objectName()}"
+                    )
+                    return False
+            except Exception as e:
+                logger.error(f"Error getting parent of connection: {e}")
+                return False
+        return True
 
     def _turn_off_the_lights(self, connections: dict):
         """
         If there is only one connection remaining, it is the launcher, so we show it.
         Once the launcher is closed as the last window, we quit the application.
         """
-        if self._has_external_window(connections):
-            self.hide()
+        if self._launcher_is_last_widget(connections):
+            self.show()
+            self.activateWindow()
+            self.raise_()
             if self.app:
-                self.app.setQuitOnLastWindowClosed(False)  # type: ignore
+                self.app.setQuitOnLastWindowClosed(True)  # type: ignore
             return
 
-        self._log_unparented_connections(connections)
-        self.show()
-        self.activateWindow()
-        self.raise_()
+        self.hide()
         if self.app:
-            self.app.setQuitOnLastWindowClosed(True)  # type: ignore
+            self.app.setQuitOnLastWindowClosed(False)  # type: ignore
 
     def closeEvent(self, event):
         """
         Close the launcher window.
         """
         connections = self.register.list_all_connections()
-        if self._has_external_window(connections):
-            event.ignore()
-            self.hide()
+        if self._launcher_is_last_widget(connections):
+            event.accept()
             return
 
-        event.accept()
+        event.ignore()
+        self.hide()
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/cli/client.py

@@ -32,7 +32,6 @@ _Widgets = {
     "BECQueue": "BECQueue",
     "BECShell": "BECShell",
     "BECStatusBox": "BECStatusBox",
-    "BeamlineStateManager": "BeamlineStateManager",
     "BecConsole": "BecConsole",
     "DapComboBox": "DapComboBox",
     "DeviceBrowser": "DeviceBrowser",
@@ -718,56 +717,6 @@ class BaseROI(RPCBase):
         """
 
 
-class BeamlineStateManager(RPCBase):
-    """Widget displaying and managing all BEC beamline states."""
-
-    _IMPORT_MODULE = "bec_widgets.widgets.services.beamline_states.beamline_state_pill"
-
-    @property
-    @rpc_call
-    def idle_card_background(self) -> "bool":
-        """
-        Whether idle collapsed pills keep the status-tinted card background.
-        """
-
-    @rpc_call
-    def set_idle_card_background(self, enabled: "bool") -> "None":
-        """
-        Set whether idle collapsed pills keep the status-tinted card background.
-        """
-
-    @rpc_call
-    def clear_filters(self) -> "None":
-        """
-        None
-        """
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-    @rpc_call
-    def attach(self):
-        """
-        None
-        """
-
-    @rpc_call
-    def detach(self):
-        """
-        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
-        """
-
-    @rpc_timeout(None)
-    @rpc_call
-    def screenshot(self, file_name: "str | None" = None):
-        """
-        Take a screenshot of the dock area and save it to a file.
-        """
-
-
 class BecConsole(RPCBase):
     """A console widget with access to a shared registry of terminals, such that instances can be moved around."""
 

bec_widgets/cli/client_utils.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import json
 import os
 import select
-import signal
 import subprocess
 import threading
 import time
@@ -34,12 +33,6 @@ else:
 logger = bec_logger.logger
 
 IGNORE_WIDGETS = ["LaunchWindow"]
-PROCESS_TERMINATION_TIMEOUT = 10
-PROCESS_OUTPUT_THREAD_JOIN_TIMEOUT = 2
-PROCESS_OUTPUT_SELECT_TIMEOUT = 0.2
-GRACEFUL_SERVER_SHUTDOWN_RPC_TIMEOUT = 3
-GRACEFUL_SERVER_SHUTDOWN_TIMEOUT = 5
-OUTPUT_READER_STOP_EVENT_ATTR = "_bec_output_reader_stop_event"
 
 RegistryState: TypeAlias = dict[
     Literal["gui_id", "name", "widget_class", "config", "__rpc__", "container_proxy"],
@@ -60,16 +53,14 @@ def _filter_output(output: str) -> str:
     return output
 
 
-def _get_output(process, logger, stop_event: threading.Event | None = None) -> None:
+def _get_output(process, logger) -> None:
     log_func = {process.stdout: logger.debug, process.stderr: logger.info}
     stream_buffer = {process.stdout: [], process.stderr: []}
     try:
         os.set_blocking(process.stdout.fileno(), False)
         os.set_blocking(process.stderr.fileno(), False)
-        while process.poll() is None and not (stop_event and stop_event.is_set()):
-            readylist, _, _ = select.select(
-                [process.stdout, process.stderr], [], [], PROCESS_OUTPUT_SELECT_TIMEOUT
-            )
+        while process.poll() is None:
+            readylist, _, _ = select.select([process.stdout, process.stderr], [], [], 1)
             for stream in (process.stdout, process.stderr):
                 buf = stream_buffer[stream]
                 if stream in readylist:
@@ -84,95 +75,6 @@ def _get_output(process, logger, stop_event: threading.Event | None = None) -> N
         logger.error(f"Error reading process output: {str(e)}")
 
 
-def _process_group_snapshot(process) -> str:
-    try:
-        pgid = os.getpgid(process.pid)
-    except ProcessLookupError:
-        return "Process group snapshot unavailable: process already exited"
-    try:
-        result = subprocess.run(
-            ["ps", "-o", "pid,ppid,pgid,stat,command", "-g", str(pgid)],
-            check=False,
-            capture_output=True,
-            text=True,
-            timeout=2,
-        )
-    except Exception as exc:
-        return f"Process group snapshot unavailable: {exc}"
-    output = result.stdout.strip()
-    if not output:
-        return f"Process group snapshot empty for pgid={pgid}"
-    return output
-
-
-def _terminate_plot_process(process, logger, timeout: float = PROCESS_TERMINATION_TIMEOUT) -> None:
-    if process.poll() is not None:
-        return
-
-    process_info = f"pid={process.pid} command={process.args}"
-    try:
-        pgid = os.getpgid(process.pid)
-        process_info = f"pid={process.pid} pgid={pgid} command={process.args}"
-        logger.info(f"Terminating GUI process group {process_info}")
-        os.killpg(pgid, signal.SIGTERM)
-    except ProcessLookupError:
-        process.wait(timeout=timeout)
-        return
-    except Exception as exc:
-        logger.warning("Failed to terminate GUI process group; terminating process only.")
-        logger.info(f"GUI process termination failure details: {exc}. pid={process.pid}")
-        process.terminate()
-
-    try:
-        process.wait(timeout=timeout)
-        return
-    except subprocess.TimeoutExpired:
-        logger.warning(f"GUI process did not stop within {timeout}s; killing it.")
-        logger.info(
-            f"GUI process force-kill details: {process_info}\n"
-            f"{_process_group_snapshot(process)}"
-        )
-
-    try:
-        os.killpg(os.getpgid(process.pid), signal.SIGKILL)
-    except ProcessLookupError as e:
-        logger.error(f"Failed to kill GUI process group: {e}")
-        process.wait(timeout=timeout)
-        return
-    process.wait(timeout=timeout)
-
-
-def _wait_for_process_exit(process, timeout: float) -> bool:
-    try:
-        process.wait(timeout=timeout)
-    except subprocess.TimeoutExpired:
-        return False
-    return True
-
-
-def _join_process_output_thread(process, thread: threading.Thread | None, logger) -> None:
-    if thread is None:
-        return
-    thread.join(timeout=PROCESS_OUTPUT_THREAD_JOIN_TIMEOUT)
-    if not thread.is_alive():
-        return
-
-    if stop_event := getattr(thread, OUTPUT_READER_STOP_EVENT_ATTR, None):
-        stop_event.set()
-
-    for stream in (process.stdout, process.stderr):
-        if stream is None:
-            continue
-        try:
-            stream.close()
-        except OSError as e:
-            logger.error(f"Failed to close stream {str(e)}")
-    thread.join(timeout=PROCESS_OUTPUT_THREAD_JOIN_TIMEOUT)
-    if thread.is_alive():
-        logger.warning("GUI process output reader thread did not stop after process shutdown.")
-        logger.info(f"GUI process output reader thread details: pid={process.pid}")
-
-
 def _start_plot_process(
     gui_id: str,
     gui_class_id: str,
@@ -224,14 +126,8 @@ def _start_plot_process(
     if logger is None:
         process_output_processing_thread = None
     else:
-        process_output_stop_event = threading.Event()
         process_output_processing_thread = threading.Thread(
-            target=_get_output, args=(process, logger, process_output_stop_event)
-        )
-        setattr(
-            process_output_processing_thread,
-            OUTPUT_READER_STOP_EVENT_ATTR,
-            process_output_stop_event,
+            target=_get_output, args=(process, logger)
         )
         process_output_processing_thread.start()
     return process, process_output_processing_thread
@@ -326,7 +222,6 @@ class BECGuiClient(RPCBase):
         self._ipython_registry: dict[str, RPCReference] = {}
         self.available_widgets = AvailableWidgetsNamespace()
         register_serializer_extension()
-        self._rpc_timeout = 60
 
     ####################
     #### Client API ####
@@ -337,16 +232,6 @@ class BECGuiClient(RPCBase):
         """The launcher object."""
         return RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self, object_name="launcher")
 
-    def set_rpc_timeout(self, timeout: float):
-        """Set the timeout for RPC calls to the GUI server.
-
-        Args:
-            timeout(float): The timeout in seconds.
-        """
-        if not isinstance(timeout, (int, float)) or timeout < 0:
-            raise ValueError("Timeout must be a non-negative number.")
-        self._rpc_timeout = timeout
-
     def _safe_register_stream(self, endpoint: EndpointInfo, cb: Callable, **kwargs):
         """Check if already registered for registration in idempotent functions."""
         if not self._client.connector.any_stream_is_registered(endpoint, cb=cb):
@@ -473,7 +358,7 @@ class BECGuiClient(RPCBase):
             )
 
         if not self._check_if_server_is_alive():
-            self.show(wait=True)
+            self.start(wait=True)
         if wait:
             with wait_for_server(self):
                 return self._new_impl(
@@ -569,13 +454,11 @@ class BECGuiClient(RPCBase):
 
         if self._process:
             logger.success("Stopping GUI...")
-            if not self._request_server_shutdown():
-                _terminate_plot_process(self._process, logger)
-            _join_process_output_thread(
-                self._process, self._process_output_processing_thread, logger
-            )
+            self._process.terminate()
+            if self._process_output_processing_thread:
+                self._process_output_processing_thread.join()
+            self._process.wait()
             self._process = None
-            self._process_output_processing_thread = None
 
         # Unregister the registry state
         self._client.connector.unregister(
@@ -594,37 +477,6 @@ class BECGuiClient(RPCBase):
     #### Private methods ####
     #########################
 
-    def _request_server_shutdown(self) -> bool:
-        if self._process is None or self._process.poll() is not None:
-            return True
-        process_details = f"pid={self._process.pid} command={self._process.args}"
-        logger.info(f"Requesting graceful GUI shutdown {process_details}")
-        try:
-            self.launcher._run_rpc(  # pylint: disable=protected-access
-                "system.shutdown",
-                wait_for_rpc_response=True,
-                timeout=GRACEFUL_SERVER_SHUTDOWN_RPC_TIMEOUT,
-            )
-        except Exception as exc:
-            logger.warning(
-                "Could not confirm graceful GUI shutdown via RPC; "
-                "falling back to process termination."
-            )
-            logger.info(f"Graceful GUI shutdown RPC failure details: {exc}. {process_details}")
-            return False
-        if _wait_for_process_exit(self._process, GRACEFUL_SERVER_SHUTDOWN_TIMEOUT):
-            logger.info(f"GUI server exited after graceful shutdown {process_details}")
-            return True
-        logger.warning(
-            "GUI server did not exit after graceful shutdown request; "
-            "falling back to process termination."
-        )
-        logger.info(
-            f"Graceful GUI shutdown timeout details: {process_details}\n"
-            f"{_process_group_snapshot(self._process)}"
-        )
-        return False
-
     def _check_if_server_is_alive(self):
         """Checks if the process is alive"""
         if self._process is None:
@@ -698,7 +550,7 @@ class BECGuiClient(RPCBase):
         if self.launcher and len(self._top_level) == 0:
             self.launcher._run_rpc("show")  # pylint: disable=protected-access
         for window in self._top_level.values():
-            window.raise_window()
+            window.show()
 
     def _show_all(self):
         with wait_for_server(self):
@@ -717,7 +569,7 @@ class BECGuiClient(RPCBase):
         if self.launcher and len(self._top_level) == 0:
             self.launcher._run_rpc("raise")  # pylint: disable=protected-access
         for window in self._top_level.values():
-            window.raise_window()
+            window._run_rpc("raise")  # type: ignore[attr-defined]
 
     def _raise_all(self):
         with wait_for_server(self):

bec_widgets/cli/designer_plugins.py

@@ -19,10 +19,6 @@ designer_plugins = {
     "BECShell": ("bec_widgets.widgets.editors.bec_console.bec_console", "BECShell"),
     "BECSpinBox": ("bec_widgets.widgets.utility.spinbox.decimal_spinbox", "BECSpinBox"),
     "BECStatusBox": ("bec_widgets.widgets.services.bec_status_box.bec_status_box", "BECStatusBox"),
-    "BeamlineStateManager": (
-        "bec_widgets.widgets.services.beamline_states.beamline_state_pill",
-        "BeamlineStateManager",
-    ),
     "BecConsole": ("bec_widgets.widgets.editors.bec_console.bec_console", "BecConsole"),
     "ColorButton": ("bec_widgets.widgets.utility.visual.color_button.color_button", "ColorButton"),
     "ColorButtonNative": (
@@ -122,7 +118,6 @@ widget_icons = {
     "BECShell": "hub",
     "BECSpinBox": "123",
     "BECStatusBox": "widgets",
-    "BeamlineStateManager": "format_list_bulleted",
     "BecConsole": "terminal",
     "ColorButton": "colors",
     "ColorButtonNative": "colors",

bec_widgets/cli/rpc/rpc_base.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import inspect
 import threading
-import time
 import uuid
 from functools import wraps
 from typing import TYPE_CHECKING, Any, cast
@@ -10,7 +9,6 @@ from typing import TYPE_CHECKING, Any, cast
 from bec_lib.client import BECClient
 from bec_lib.device import DeviceBaseWithConfig
 from bec_lib.endpoints import MessageEndpoints
-from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import, lazy_import_from
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -26,9 +24,6 @@ else:
 
 # pylint: disable=protected-access
 
-_DEFAULT_RPC_TIMEOUT = object()
-logger = bec_logger.logger
-
 
 def _name_arg(arg):
     if isinstance(arg, DeviceBaseWithConfig):
@@ -159,7 +154,6 @@ class RPCReference:
 
 
 class RPCBase:
-
     def __init__(
         self,
         gui_id: str | None = None,
@@ -213,16 +207,12 @@ class RPCBase:
         # Use explicit call to ensure action name is 'raise' (not 'raise_')
         return self._run_rpc("raise")
 
-    def hide(self):
-        """Hide this widget (or its container)."""
-        return self._run_rpc("hide")
-
     def _run_rpc(
         self,
         method,
         *args,
-        wait_for_rpc_response: bool = True,
-        timeout: float | None | object = _DEFAULT_RPC_TIMEOUT,
+        wait_for_rpc_response=True,
+        timeout=5,
         gui_id: str | None = None,
         **kwargs,
     ) -> Any:
@@ -233,16 +223,13 @@ class RPCBase:
             method: The method to call.
             args: The arguments to pass to the method.
             wait_for_rpc_response: Whether to wait for the RPC response.
-            timeout: The timeout for the RPC response. If omitted, the client's default RPC
-                timeout is used. If explicitly set to None, wait indefinitely.
+            timeout: The timeout for the RPC response.
             gui_id: The GUI ID to use for the RPC call. If None, the default GUI ID is used.
             kwargs: The keyword arguments to pass to the method.
 
         Returns:
             The result of the RPC call.
         """
-        if timeout is _DEFAULT_RPC_TIMEOUT:
-            timeout = self._root._rpc_timeout
         if method in ["show", "hide", "raise"] and gui_id is None:
             obj = self._root._server_registry.get(self._gui_id)
             if obj is None:
@@ -264,39 +251,12 @@ class RPCBase:
                 MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
             )
 
-        target_gui_id = gui_id or self._gui_id
-        sent_at = time.time()
-        deadline = sent_at + timeout if timeout is not None else None
-        rpc_msg.metadata.update(
-            {
-                "method": method,
-                "receiver": receiver,
-                "target_gui_id": target_gui_id,
-                "object_name": self.object_name,
-                "wait_for_response": wait_for_rpc_response,
-                "timeout": timeout,
-                "sent_at": sent_at,
-                "deadline": deadline,
-            }
-        )
-        logger.info(
-            "Sending GUI RPC request "
-            f"request_id={request_id} method={method} receiver={receiver} "
-            f"target_gui_id={target_gui_id} object_name={self.object_name} "
-            f"wait_for_response={wait_for_rpc_response} timeout={timeout}"
-        )
         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:
-                    logger.error(
-                        "GUI RPC response timeout "
-                        f"request_id={request_id} method={method} receiver={receiver} "
-                        f"target_gui_id={target_gui_id} object_name={self.object_name} "
-                        f"timeout={timeout}"
-                    )
                     raise RPCResponseTimeoutError(request_id, timeout)
             finally:
                 self._msg_wait_event.clear()
@@ -308,12 +268,6 @@ class RPCBase:
             # the _on_rpc_response method
             assert isinstance(self._rpc_response, messages.RequestResponseMessage)
 
-            logger.info(
-                "Received GUI RPC response "
-                f"request_id={request_id} method={method} receiver={receiver} "
-                f"target_gui_id={target_gui_id} object_name={self.object_name} "
-                f"accepted={self._rpc_response.accepted}"
-            )
             if not self._rpc_response.accepted:
                 raise ValueError(self._rpc_response.message["error"])
             msg_result = self._rpc_response.message.get("result")
@@ -322,7 +276,6 @@ class RPCBase:
 
     def _on_rpc_response(self, msg_obj: MessageObject) -> None:
         msg = cast(messages.RequestResponseMessage, msg_obj.value)
-        logger.debug(f"GUI RPC response callback received: {msg}")
         self._rpc_response = msg
         self._msg_wait_event.set()
 

bec_widgets/tests/utils.py

@@ -15,7 +15,7 @@ class FakeDevice(BECDevice):
         super().__init__(name=name)
         self._enabled = enabled
         self.signals = {self.name: {"value": 1.0}}
-        self._description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
         self._readout_priority = readout_priority
         self._config = {
             "readoutPriority": "baseline",
@@ -74,7 +74,7 @@ class FakeDevice(BECDevice):
         Returns:
             dict: Description of the device
         """
-        return self._description
+        return self.description
 
 
 class FakePositioner(BECPositioner):
@@ -96,7 +96,7 @@ class FakePositioner(BECPositioner):
         self._limits = limits
         self._readout_priority = readout_priority
         self.signals = {self.name: {"value": 1.0}}
-        self._description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
         self._config = {
             "readoutPriority": "baseline",
             "deviceClass": "ophyd_devices.SimPositioner",
@@ -176,7 +176,7 @@ class FakePositioner(BECPositioner):
         Returns:
             dict: Description of the device
         """
-        return self._description
+        return self.description
 
     @property
     def precision(self):

bec_widgets/utils/bec_dispatcher.py

@@ -3,9 +3,8 @@ from __future__ import annotations
 import collections
 import random
 import string
-import time
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, DefaultDict, Hashable, Union
+from typing import TYPE_CHECKING, DefaultDict, Hashable, Union
 
 import louie
 import redis
@@ -16,7 +15,6 @@ from bec_lib.service_config import ServiceConfig
 from qtpy.QtCore import QObject
 from qtpy.QtCore import Signal as pyqtSignal
 
-from bec_widgets.utils.rpc_logging import elapsed_seconds, format_elapsed
 from bec_widgets.utils.serialization import register_serializer_extension
 
 logger = bec_logger.logger
@@ -27,39 +25,6 @@ if TYPE_CHECKING:  # pragma: no cover
     from bec_widgets.utils.rpc_server import RPCServer
 
 
-def _log_rpc_dispatcher_receive(msg_content: Any, metadata: Any) -> None:
-    if not isinstance(msg_content, dict) or not isinstance(metadata, dict):
-        return
-    request_id = metadata.get("request_id")
-    method = msg_content.get("action")
-    parameter = msg_content.get("parameter")
-    if request_id is None or method is None or not isinstance(parameter, dict):
-        return
-
-    dispatch_received_at = time.time()
-    sent_at = metadata.get("sent_at")
-    deadline = metadata.get("deadline")
-    timeout = metadata.get("timeout")
-    dispatch_latency = elapsed_seconds(sent_at, dispatch_received_at)
-    stale_on_dispatch = deadline is not None and dispatch_received_at > deadline
-    target_gui_id = parameter.get("gui_id") or metadata.get("target_gui_id")
-
-    logger.info(
-        "GUI RPC dispatcher received request before Qt callback emit "
-        f"request_id={request_id} method={method} receiver={metadata.get('receiver')} "
-        f"target_gui_id={target_gui_id} object_name={metadata.get('object_name')} "
-        f"timeout={timeout} dispatch_latency_s={format_elapsed(dispatch_latency)} "
-        f"stale_on_dispatch={stale_on_dispatch}"
-    )
-    if stale_on_dispatch:
-        logger.warning(
-            "GUI RPC dispatcher received request after client timeout deadline "
-            f"request_id={request_id} method={method} receiver={metadata.get('receiver')} "
-            f"target_gui_id={target_gui_id} object_name={metadata.get('object_name')} "
-            f"timeout={timeout} dispatch_latency_s={format_elapsed(dispatch_latency)}"
-        )
-
-
 class QtThreadSafeCallback(QObject):
     """QtThreadSafeCallback is a wrapper around a callback function to make it thread-safe for Qt."""
 
@@ -123,12 +88,10 @@ class QtRedisConnector(RedisConnector):
 
             # we can notice kwargs are lost when passed to Qt slot
             metadata = msg.metadata
-            _log_rpc_dispatcher_receive(msg.content, metadata)
             cb(msg.content, metadata)
         else:
             # from stream
             msg = msg["data"]
-            _log_rpc_dispatcher_receive(msg.content, msg.metadata)
             cb(msg.content, msg.metadata)
 
 

bec_widgets/utils/bec_widget.py

@@ -20,6 +20,7 @@ from bec_widgets.widgets.utility.spinner.spinner import SpinnerWidget
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_widgets.utils.busy_loader import BusyLoaderOverlay
+    from bec_widgets.widgets.containers.dock import BECDock
 
 logger = bec_logger.logger
 
@@ -330,34 +331,32 @@ class BECWidget(BECConnector):
             # All widgets need to call super().cleanup() in their cleanup method
             logger.info(f"Registry cleanup for widget {self.__class__.__name__}")
             self.rpc_register.remove_rpc(self)
-            children = self.findChildren(BECWidget)
-            for child in children:
-                if not shiboken6.isValid(child):
-                    # If the child is not valid, it means it has already been deleted
-                    continue
-                child.close()
-                child.deleteLater()
+        children = self.findChildren(BECWidget)
+        for child in children:
+            if not shiboken6.isValid(child):
+                # If the child is not valid, it means it has already been deleted
+                continue
+            child.close()
+            child.deleteLater()
 
-            # Tear down busy overlay explicitly to stop spinner and remove filters
-            overlay = getattr(self, "_busy_overlay", None)
-            if overlay is not None and shiboken6.isValid(overlay):
-                try:
-                    overlay.hide()
-                    filt = getattr(overlay, "_filter", None)
-                    if filt is not None and shiboken6.isValid(filt):
-                        try:
-                            self.removeEventFilter(filt)
-                        except Exception as exc:
-                            logger.warning(
-                                f"Failed to remove event filter from busy overlay: {exc}"
-                            )
+        # Tear down busy overlay explicitly to stop spinner and remove filters
+        overlay = getattr(self, "_busy_overlay", None)
+        if overlay is not None and shiboken6.isValid(overlay):
+            try:
+                overlay.hide()
+                filt = getattr(overlay, "_filter", None)
+                if filt is not None and shiboken6.isValid(filt):
+                    try:
+                        self.removeEventFilter(filt)
+                    except Exception as exc:
+                        logger.warning(f"Failed to remove event filter from busy overlay: {exc}")
 
-                    # Cleanup the overlay widget. This will call cleanup on the custom widget if present.
+                # Cleanup the overlay widget. This will call cleanup on the custom widget if present.
 
-                    overlay.cleanup()
-                    overlay.deleteLater()
-                except Exception as exc:
-                    logger.warning(f"Failed to delete busy overlay: {exc}")
+                overlay.cleanup()
+                overlay.deleteLater()
+            except Exception as exc:
+                logger.warning(f"Failed to delete busy overlay: {exc}")
 
     def closeEvent(self, event):
         """Wrap the close even to ensure the rpc_register is cleaned up."""

bec_widgets/utils/colors.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 from functools import lru_cache
-from typing import Any, Literal
+from typing import Literal
 
 import numpy as np
 import pyqtgraph as pg
@@ -21,7 +21,8 @@ logger = bec_logger.logger
 def get_theme_name():
     if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
         return "dark"
-    return QApplication.instance().theme.theme
+    else:
+        return QApplication.instance().theme.theme
 
 
 def get_theme_palette():
@@ -57,26 +58,6 @@ def apply_theme(theme: Literal["dark", "light"]):
     process_all_deferred_deletes(QApplication.instance())
 
 
-def theme_color(theme: Any | None, key: str, fallback: QColor | str) -> QColor:
-    """
-    Return a QColor from a BEC theme with a robust fallback.
-    """
-    fallback_color = fallback if isinstance(fallback, QColor) else QColor(str(fallback))
-    if theme is None or not hasattr(theme, "color"):
-        return fallback_color
-    color = theme.color(key, fallback_color.name())
-    return color if isinstance(color, QColor) else QColor(str(color))
-
-
-def rgba(color: QColor | str, alpha: int) -> str:
-    """
-    Return a QSS-compatible rgba string with alpha clamped to the 0-255 range.
-    """
-    qcolor = color if isinstance(color, QColor) else QColor(str(color))
-    alpha = max(0, min(255, alpha))
-    return f"rgba({qcolor.red()}, {qcolor.green()}, {qcolor.blue()}, {alpha})"
-
-
 class Colors:
     @staticmethod
     def list_available_colormaps() -> list[str]:
@@ -169,6 +150,25 @@ class Colors:
 
         return ge.colorMap()
 
+    @staticmethod
+    def golden_ratio(num: int) -> list:
+        """Calculate the golden ratio for a given number of angles.
+
+        Args:
+            num (int): Number of angles
+
+        Returns:
+            list: List of angles calculated using the golden ratio.
+        """
+        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
+        angles = []
+        for ii in range(num):
+            x = np.cos(ii * phi)
+            y = np.sin(ii * phi)
+            angle = np.arctan2(y, x)
+            angles.append(angle)
+        return angles
+
     @staticmethod
     def set_theme_offset(theme: Literal["light", "dark"] | None = None, offset=0.2) -> tuple:
         """
@@ -239,7 +239,20 @@ class Colors:
         else:
             positions = np.linspace(min_pos, max_pos, num)
 
-        return Colors._format_mapped_colors(cmap.map(positions, mode="float"), format)
+        # Sample colors from the colormap at the calculated positions
+        colors = cmap.map(positions, mode="float")
+        color_list = []
+
+        for color in colors:
+            if format.upper() == "HEX":
+                color_list.append(QColor.fromRgbF(*color).name())
+            elif format.upper() == "RGB":
+                color_list.append(tuple((np.array(color) * 255).astype(int)))
+            elif format.upper() == "QCOLOR":
+                color_list.append(QColor.fromRgbF(*color))
+            else:
+                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
+        return color_list
 
     @staticmethod
     def golden_angle_color(
@@ -275,19 +288,20 @@ class Colors:
         positions = np.mod(np.arange(num) * golden_angle_conjugate, 1)
         positions = min_pos + positions * (max_pos - min_pos)
 
-        return Colors._format_mapped_colors(cmap.map(positions, mode="float"), format)
+        # Sample colors from the colormap at the calculated positions
+        colors = cmap.map(positions, mode="float")
+        color_list = []
 
-    @staticmethod
-    def _format_mapped_colors(colors: np.ndarray, format: Literal["QColor", "HEX", "RGB"]) -> list:
-        color_format = format.upper()
-        if color_format not in {"QCOLOR", "HEX", "RGB"}:
-            raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
-
-        if color_format == "QCOLOR":
-            return [QColor.fromRgbF(*color) for color in colors]
-        if color_format == "HEX":
-            return [QColor.fromRgbF(*color).name() for color in colors]
-        return [tuple((np.array(color) * 255).astype(int)) for color in colors]
+        for color in colors:
+            if format.upper() == "HEX":
+                color_list.append(QColor.fromRgbF(*color).name())
+            elif format.upper() == "RGB":
+                color_list.append(tuple((np.array(color) * 255).astype(int)))
+            elif format.upper() == "QCOLOR":
+                color_list.append(QColor.fromRgbF(*color))
+            else:
+                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
+        return color_list
 
     @staticmethod
     def hex_to_rgba(hex_color: str, alpha=255) -> tuple:
@@ -311,6 +325,22 @@ class Colors:
             raise ValueError("HEX color must be 6 or 8 characters long.")
         return (r, g, b, alpha)
 
+    @staticmethod
+    def rgba_to_hex(r: int, g: int, b: int, a: int = 255) -> str:
+        """
+        Convert RGBA color to HEX.
+
+        Args:
+            r(int): Red value (0-255).
+            g(int): Green value (0-255).
+            b(int): Blue value (0-255).
+            a(int): Alpha value (0-255). Default is 255 (opaque).
+
+        Returns:
+            hec_color(str): HEX color string.
+        """
+        return "#{:02X}{:02X}{:02X}{:02X}".format(r, g, b, a)
+
     @staticmethod
     def validate_color(color: tuple | str) -> tuple | str:
         """

bec_widgets/utils/forms_from_types/forms.py

@@ -150,7 +150,7 @@ class TypedForm(BECWidget, QWidget):
         self.adjustSize()
 
     def _new_grid_layout(self):
-        new_grid = QGridLayout()
+        new_grid = QGridLayout(self)
         new_grid.setContentsMargins(0, 0, 0, 0)
         return new_grid
 

bec_widgets/utils/forms_from_types/pydantic_model_info_adapter.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-from typing import Any
-
-from pydantic import BaseModel
-from pydantic_core import PydanticUndefined
-
-from bec_widgets.utils.scan_arg_metadata import ui_config_from_metadata
-
-NUMERIC_BOUND_KEYS = {"gt", "ge", "lt", "le"}
-
-
-def pydantic_model_input_configs(model: type[BaseModel]) -> list[dict[str, Any]]:
-    """Return scan-control-style field items for a Pydantic model."""
-    configs = []
-    for name, info in model.model_fields.items():
-        metadata: dict[str, Any] = {}
-        for entry in info.metadata:
-            for key in NUMERIC_BOUND_KEYS:
-                value = getattr(entry, key, None)
-                if value is not None:
-                    metadata.setdefault(key, value)
-
-        if isinstance(info.json_schema_extra, Mapping):
-            metadata.update(dict(info.json_schema_extra))
-
-        if info.description and metadata.get("description") is None:
-            metadata["description"] = info.description
-
-        default: Any
-        if info.default is not PydanticUndefined:
-            default = info.default
-        elif info.default_factory is not None:
-            default = info.get_default(call_default_factory=True)
-        else:
-            default = None
-
-        display_name = metadata.get("display_name") or info.title
-        if display_name is None:
-            display_name = name.replace("_", " ").capitalize()
-
-        item = ui_config_from_metadata(
-            name=name, metadata=metadata, default=default, display_name=display_name
-        )
-        item.update({key: value for key, value in metadata.items() if key not in item})
-        configs.append(item)
-
-    return configs

bec_widgets/utils/forms_from_types/pydantic_widget_form.py

@@ -1,653 +0,0 @@
-from __future__ import annotations
-
-from types import NoneType
-from typing import Any, Literal, get_args, get_origin
-
-from bec_lib.device import DeviceBase, Signal
-from pydantic import BaseModel, ValidationError
-from pydantic.fields import FieldInfo
-from qtpy.QtCore import Qt
-from qtpy.QtCore import Signal as QtSignal
-from qtpy.QtWidgets import (
-    QCheckBox,
-    QComboBox,
-    QDoubleSpinBox,
-    QFormLayout,
-    QHBoxLayout,
-    QLineEdit,
-    QSpinBox,
-    QWidget,
-)
-
-from bec_widgets.utils.forms_from_types.pydantic_model_info_adapter import (
-    NUMERIC_BOUND_KEYS,
-    pydantic_model_input_configs,
-)
-from bec_widgets.utils.scan_arg_metadata import (
-    apply_numeric_limits,
-    apply_numeric_precision,
-    apply_unit_metadata,
-    device_units,
-)
-from bec_widgets.utils.widget_io import WidgetIO
-from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
-from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
-from bec_widgets.widgets.utility.spinbox.decimal_spinbox import BECSpinBox
-
-
-class OptionalValueWidget(QWidget):
-    """Generic optional-value wrapper preserving ``None`` for editor widgets."""
-
-    value_changed = QtSignal(object)
-
-    def __init__(self, value_widget: QWidget, parent: QWidget | None = None) -> None:
-        super().__init__(parent=parent)
-        self._value_widget = value_widget
-        self._checkbox = QCheckBox(self)
-        self._checkbox.setToolTip("Enable value")
-        self._value_widget.setParent(self)
-
-        layout = QHBoxLayout(self)
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(8)
-        layout.addWidget(self._checkbox)
-        layout.addWidget(self._value_widget, 1)
-
-        self._checkbox.toggled.connect(self._on_enabled_changed)
-        WidgetIO.connect_widget_change_signal(self._value_widget, self._emit_current_value)
-        self._on_enabled_changed(False)
-
-    @property
-    def value_widget(self) -> QWidget:
-        return self._value_widget
-
-    @property
-    def checkbox(self) -> QCheckBox:
-        return self._checkbox
-
-    def value(self) -> Any:
-        if not self._checkbox.isChecked():
-            return None
-        return WidgetIO.get_value(self._value_widget)
-
-    def set_value(self, value: Any) -> None:
-        enabled = value is not None
-        self._checkbox.setChecked(enabled)
-        self._value_widget.setEnabled(enabled)
-        if enabled:
-            WidgetIO.set_value(self._value_widget, value)
-
-    def _on_enabled_changed(self, enabled: bool) -> None:
-        self._value_widget.setEnabled(enabled)
-        self.value_changed.emit(self.value())
-
-    def _emit_current_value(self, *_args) -> None:
-        self.value_changed.emit(self.value())
-
-
-class PydanticWidgetForm(QWidget):
-    """Qt form generated from a Pydantic model using type-based widget selection."""
-
-    changed = QtSignal()
-    validity_changed = QtSignal(bool)
-
-    def __init__(
-        self,
-        model: type[BaseModel],
-        parent: QWidget | None = None,
-        *,
-        data: BaseModel | dict[str, Any] | None = None,
-        read_only_fields: set[str] | None = None,
-        client=None,
-    ) -> None:
-        super().__init__(parent=parent)
-        self._model = model
-        self._client = client
-        self._read_only_fields = set(read_only_fields or set())
-        self._widgets: dict[str, QWidget] = {}
-        self._field_configs: dict[str, dict[str, Any]] = {}
-        self._baseline: dict[str, Any] = {}
-
-        self._layout = QFormLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self._layout.setHorizontalSpacing(10)
-        self._layout.setVerticalSpacing(8)
-        self._layout.setFieldGrowthPolicy(QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
-        self._layout.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
-        self.setLayout(self._layout)
-
-        self._populate()
-        if data is not None:
-            self.set_data(data)
-        self.mark_clean()
-
-    @property
-    def model(self) -> type[BaseModel]:
-        return self._model
-
-    @property
-    def widgets(self) -> dict[str, QWidget]:
-        return dict(self._widgets)
-
-    def field_widget(self, name: str) -> QWidget:
-        return self._widgets[name]
-
-    def input_widget(self, name: str) -> QWidget:
-        widget = self._widgets[name]
-        if isinstance(widget, OptionalValueWidget):
-            return widget.value_widget
-        return widget
-
-    def input_widgets(self) -> dict[str, QWidget]:
-        return {name: self.input_widget(name) for name in self._widgets}
-
-    def input_widgets_by_type(self, widget_type: type[QWidget]) -> list[QWidget]:
-        return [
-            widget for widget in self.input_widgets().values() if isinstance(widget, widget_type)
-        ]
-
-    def set_model(self, model: type[BaseModel], data: dict[str, Any] | None = None) -> None:
-        old_data = self.raw_data()
-        self.cleanup()
-        self._model = model
-        self._populate()
-        if data is None:
-            data = {key: value for key, value in old_data.items() if key in model.model_fields}
-        self.set_partial_data(data)
-        self.mark_clean()
-
-    def set_data(self, data: BaseModel | dict[str, Any]) -> None:
-        values = data.model_dump() if isinstance(data, BaseModel) else dict(data)
-        self.set_partial_data(values)
-
-    def set_partial_data(self, data: dict[str, Any]) -> None:
-        for name, value in data.items():
-            if name not in self._widgets:
-                continue
-            self._set_widget_value(name, value)
-        self._refresh_reference_units()
-        self.changed.emit()
-
-    def raw_data(self) -> dict[str, Any]:
-        return {name: self._read_widget_value(name) for name in self._widgets}
-
-    def get_data(self) -> dict[str, Any]:
-        return self.model_instance().model_dump()
-
-    def model_instance(self) -> BaseModel:
-        self._validate_domain_widgets()
-        return self._model.model_validate(self.raw_data())
-
-    def validate(self) -> bool:
-        try:
-            self.get_data()
-        except (ValidationError, ValueError):
-            self.validity_changed.emit(False)
-            return False
-        self.validity_changed.emit(True)
-        return True
-
-    def dirty_fields(self) -> set[str]:
-        current = self.raw_data()
-        fields = set(current) | set(self._baseline)
-        dirty = set()
-        for field in fields:
-            current_value = current.get(field)
-            baseline_value = self._baseline.get(field)
-            if current_value is None or baseline_value is None:
-                changed = current_value is not None or baseline_value is not None
-            elif isinstance(current_value, float) or isinstance(baseline_value, float):
-                changed = abs(float(current_value) - float(baseline_value)) >= 1e-9
-            else:
-                changed = current_value != baseline_value
-            if changed:
-                dirty.add(field)
-        return dirty
-
-    def mark_clean(self) -> None:
-        self._baseline = self.raw_data()
-
-    def reset_to_baseline(self) -> None:
-        self.set_partial_data(self._baseline)
-
-    def editable_data(self) -> dict[str, Any]:
-        return {
-            key: value
-            for key, value in self.get_data().items()
-            if key not in self._read_only_fields
-        }
-
-    def raw_editable_data(self) -> dict[str, Any]:
-        return {
-            key: value
-            for key, value in self.raw_data().items()
-            if key not in self._read_only_fields
-        }
-
-    def cleanup(self) -> None:
-        while self._layout.count():
-            item = self._layout.takeAt(0)
-            widget = item.widget()
-            if widget is not None:
-                widget.close()
-                widget.deleteLater()
-        self._widgets.clear()
-        self._field_configs.clear()
-
-    def closeEvent(self, event) -> None:  # noqa: N802
-        self.cleanup()
-        super().closeEvent(event)
-
-    def _populate(self) -> None:
-        for config in pydantic_model_input_configs(self._model):
-            name = config["name"]
-            info = self._model.model_fields[name]
-            widget = self._create_widget(name, info)
-            label_text = config["display_name"]
-            self._layout.addRow(label_text, widget)
-            label = self._layout.labelForField(widget)
-            if label is not None:
-                label.setProperty("_model_field_name", name)
-            if config.get("tooltip") and label is not None:
-                label.setToolTip(config["tooltip"])
-            widget.setEnabled(name not in self._read_only_fields)
-            self._widgets[name] = widget
-            self._field_configs[name] = config
-            self._set_widget_value(name, config["default"])
-            self._apply_field_metadata(name)
-            self._connect_widget(widget)
-
-        self._connect_device_signal_widgets()
-        self._connect_reference_unit_widgets()
-        self._refresh_reference_units()
-
-    def _create_widget(self, name: str, info: FieldInfo) -> QWidget:
-        annotation = info.annotation
-        args = get_args(annotation)
-        optional = NoneType in args
-        non_none_args = tuple(arg for arg in args if arg is not NoneType)
-        value_annotation = non_none_args[0] if len(non_none_args) == 1 else annotation
-
-        widget = self._create_value_widget(name, value_annotation)
-        numeric = value_annotation in (int, float) or any(
-            arg in (int, float) for arg in get_args(value_annotation)
-        )
-        if optional and (numeric or value_annotation is bool):
-            return OptionalValueWidget(widget, parent=self)
-        return widget
-
-    def _create_value_widget(self, name: str, annotation: Any) -> QWidget:
-        args = get_args(annotation)
-        if (
-            isinstance(annotation, type)
-            and issubclass(annotation, Signal)
-            or any(isinstance(arg, type) and issubclass(arg, Signal) for arg in args)
-        ):
-            return SignalComboBox(
-                parent=self,
-                client=self._client,
-                require_device=self._model_has_device_field(),
-                arg_name=name,
-            )
-        if (
-            isinstance(annotation, type)
-            and issubclass(annotation, DeviceBase)
-            or any(isinstance(arg, type) and issubclass(arg, DeviceBase) for arg in args)
-        ):
-            return DeviceComboBox(parent=self, client=self._client, arg_name=name)
-        if get_origin(annotation) is Literal:
-            widget = QComboBox(self)
-            widget.addItems([str(value) for value in get_args(annotation)])
-            return widget
-        if annotation is bool:
-            return QCheckBox(self)
-        if annotation is int:
-            spin_box = QSpinBox(self)
-            spin_box.setRange(-2147483647, 2147483647)
-            return spin_box
-        if annotation is float:
-            spin_box = BECSpinBox(self)
-            spin_box.setRange(-1_000_000_000, 1_000_000_000)
-            return spin_box
-        return QLineEdit(self)
-
-    def _apply_field_metadata(self, name: str) -> None:
-        config = self._field_configs[name]
-        field_widget = self._widgets[name]
-        input_widget = self.input_widget(name)
-
-        if config.get("precision") is not None:
-            apply_numeric_precision(input_widget, config)
-        if any(config.get(key) is not None for key in NUMERIC_BOUND_KEYS):
-            apply_numeric_limits(input_widget, config)
-
-        apply_unit_metadata(field_widget, config)
-        if input_widget is not field_widget:
-            apply_unit_metadata(input_widget, config)
-
-    def _connect_widget(self, widget: QWidget) -> None:
-        if isinstance(widget, OptionalValueWidget):
-            widget.value_changed.connect(lambda _value: self.changed.emit())
-            return
-        WidgetIO.connect_widget_change_signal(widget, lambda *_args: self.changed.emit())
-
-    def _connect_device_signal_widgets(self) -> None:
-        devices = [
-            widget for widget in self._widgets.values() if isinstance(widget, DeviceComboBox)
-        ]
-        signals = [
-            widget for widget in self._widgets.values() if isinstance(widget, SignalComboBox)
-        ]
-        if not devices or not signals:
-            return
-        device_widget = devices[0]
-        for signal_widget in signals:
-            device_widget.device_selected.connect(signal_widget.set_device)
-            device_widget.device_reset.connect(lambda w=signal_widget: w.set_device(None))
-            if device_widget.currentText().strip():
-                signal_widget.set_device(device_widget.currentText().strip())
-
-    def _connect_reference_unit_widgets(self) -> None:
-        for name, widget in self.input_widgets().items():
-            if not isinstance(widget, DeviceComboBox):
-                continue
-            widget.device_selected.connect(
-                lambda _device_name, field_name=name: self._update_reference_units(field_name)
-            )
-            widget.device_reset.connect(
-                lambda field_name=name: self._apply_reference_units(field_name, None)
-            )
-            widget.currentTextChanged.connect(
-                lambda text, field_name=name: self._handle_reference_device_text(field_name, text)
-            )
-
-    def _refresh_reference_units(self) -> None:
-        for name, widget in self.input_widgets().items():
-            if isinstance(widget, DeviceComboBox):
-                self._update_reference_units(name)
-
-    def _update_reference_units(self, source_name: str) -> None:
-        widget = self.input_widget(source_name)
-        if not isinstance(widget, DeviceComboBox) or not widget.is_valid_input:
-            self._apply_reference_units(source_name, None)
-            return
-        self._apply_reference_units(source_name, device_units(widget.get_current_device()))
-
-    def _apply_reference_units(self, source_name: str, units: str | None) -> None:
-        for field_name, config in self._field_configs.items():
-            if config.get("reference_units") != source_name:
-                continue
-            field_widget = self.field_widget(field_name)
-            input_widget = self.input_widget(field_name)
-            apply_unit_metadata(field_widget, config, units)
-            if input_widget is not field_widget:
-                apply_unit_metadata(input_widget, config, units)
-
-    def _handle_reference_device_text(self, source_name: str, device_name: str) -> None:
-        widget = self.input_widget(source_name)
-        if isinstance(widget, DeviceComboBox) and not widget.validate_device(device_name):
-            self._apply_reference_units(source_name, None)
-
-    def _validate_domain_widgets(self) -> None:
-        for widget in self._widgets.values():
-            if isinstance(widget, DeviceComboBox):
-                device = widget.currentText().strip()
-                if not device:
-                    raise ValueError("Device is required.")
-                if not widget.is_valid_input:
-                    raise ValueError(f"Device '{device}' is not available.")
-            if isinstance(widget, SignalComboBox):
-                signal = widget.get_signal_name().strip()
-                if signal and not widget.is_valid_input:
-                    raise ValueError(f"Signal '{signal}' is not available.")
-
-    def _read_widget_value(self, name: str) -> Any:
-        widget = self._widgets[name]
-        info = self._model.model_fields[name]
-        if isinstance(widget, OptionalValueWidget):
-            return widget.value()
-        if isinstance(widget, QLineEdit):
-            value = WidgetIO.get_value(widget)
-            return None if NoneType in get_args(info.annotation) and value == "" else value
-        if isinstance(widget, QComboBox) and get_origin(info.annotation) is Literal:
-            return WidgetIO.get_value(widget, as_string=True)
-        return WidgetIO.get_value(widget)
-
-    def _set_widget_value(self, name: str, value: Any) -> None:
-        widget = self._widgets[name]
-        if isinstance(widget, OptionalValueWidget):
-            widget.set_value(value)
-            return
-        if value is None:
-            if isinstance(widget, QLineEdit):
-                value = ""
-            elif isinstance(widget, QCheckBox):
-                value = False
-            elif isinstance(widget, (QSpinBox, QDoubleSpinBox)):
-                value = 0
-        WidgetIO.set_value(widget, value)
-
-    def _model_has_device_field(self) -> bool:
-        for field in self._model.model_fields.values():
-            annotation = field.annotation
-            args = get_args(annotation)
-            has_device = (
-                isinstance(annotation, type)
-                and issubclass(annotation, DeviceBase)
-                or any(isinstance(arg, type) and issubclass(arg, DeviceBase) for arg in args)
-            )
-            has_signal = (
-                isinstance(annotation, type)
-                and issubclass(annotation, Signal)
-                or any(isinstance(arg, type) and issubclass(arg, Signal) for arg in args)
-            )
-            if has_device and not has_signal:
-                return True
-        return False
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import json
-    import sys
-
-    from bec_lib.scan_args import ScanArgument
-    from pydantic import Field
-    from qtpy.QtWidgets import QApplication, QLabel, QPushButton, QTabWidget, QTextEdit, QVBoxLayout
-
-    from bec_widgets.utils.colors import apply_theme
-
-    class BasicScanConfig(BaseModel):
-        """Plain Pydantic fields without GUI metadata."""
-
-        sample_name: str
-        enabled: bool = True
-        repeats: int = 3
-
-    class LimitConfig(BaseModel):
-        """Normal Pydantic Field metadata."""
-
-        mode: Literal["monitor", "scan", "calibration"] = "scan"
-        low_limit: (
-            float | None
-        )  # example of the field without additional metadata, still works in form
-        high_limit: float | None = Field(
-            default=10.0,
-            title="High limit",
-            description="Optional upper allowed value.",
-            json_schema_extra={"precision": 4},
-        )
-        tolerance: float = Field(
-            default=0.1,
-            title="Tolerance",
-            description="Warning tolerance around configured limits.",
-            json_schema_extra={"precision": 4},
-        )
-
-    class ScanArgumentConfig(BaseModel):
-        """ScanArgument metadata applied through Field extras."""
-
-        settling_time: float = Field(
-            default=0.0,
-            **ScanArgument(
-                display_name="Settling time",
-                description="Time to wait after moving.",
-                units="s",
-                precision=3,
-                ge=0,
-            ).model_dump(),
-        )
-        frames: int = Field(
-            default=1,
-            **ScanArgument(
-                display_name="Frames", description="Number of frames per trigger.", ge=1
-            ).model_dump(),
-        )
-
-    class DeviceSignalLimitsConfig(BaseModel):
-        """Device, signal, and numeric fields whose units follow the selected device."""
-
-        model_config = {"arbitrary_types_allowed": True}
-
-        device: DeviceBase | str = Field(
-            default="",
-            **ScanArgument(display_name="Device", description="Positioner device.").model_dump(),
-        )
-        signal: Signal | str | None = Field(
-            default=None,
-            **ScanArgument(display_name="Signal", description="Device signal.").model_dump(),
-        )
-        low_limit: float | None = Field(
-            default=None,
-            **ScanArgument(
-                display_name="Low limit",
-                description="Optional lower limit.",
-                reference_units="device",
-                precision=4,
-            ).model_dump(),
-        )
-        high_limit: float | None = Field(
-            default=None,
-            **ScanArgument(
-                display_name="High limit",
-                description="Optional upper limit.",
-                reference_units="device",
-                precision=4,
-            ).model_dump(),
-        )
-
-    class DisplayConfig(BaseModel):
-        title: str | None = Field(
-            default=None, title="Title", description="Optional display title."
-        )
-        show_grid: bool = Field(default=True, title="Show grid")
-        refresh_interval: int = Field(
-            default=1000, title="Refresh interval", description="Refresh interval in milliseconds."
-        )
-
-    class DeviceAndSignalConfig(BaseModel):
-        model_config = {"arbitrary_types_allowed": True}
-
-        title: str | None = Field(
-            default=None, title="Title", description="Optional display title."
-        )
-        device: DeviceBase | str = Field(
-            default="", title="Device", description="BEC device selection."
-        )
-        signal: Signal | str | None = Field(
-            default=None,
-            title="Signal",
-            description="Signal selection scoped to the selected device.",
-        )
-        refresh_interval: int = Field(
-            default=1000, title="Refresh interval", description="Refresh interval in milliseconds."
-        )
-
-    class DeviceOnlyConfig(BaseModel):
-        model_config = {"arbitrary_types_allowed": True}
-
-        title: str | None = Field(
-            default=None, title="Title", description="Optional display title."
-        )
-        device: DeviceBase | str = Field(
-            default="", title="Device", description="BEC device selection."
-        )
-        refresh_interval: int = Field(
-            default=1000, title="Refresh interval", description="Refresh interval in milliseconds."
-        )
-
-    class SignalOnlyConfig(BaseModel):
-        model_config = {"arbitrary_types_allowed": True}
-
-        title: str | None = Field(
-            default=None, title="Title", description="Optional display title."
-        )
-        signal: Signal | str | None = Field(
-            default=None,
-            title="Signal",
-            description="Global BEC signal selection without a device field.",
-        )
-        refresh_interval: int = Field(
-            default=1000, title="Refresh interval", description="Refresh interval in milliseconds."
-        )
-
-    class ExampleWindow(QWidget):
-        def __init__(self) -> None:
-            super().__init__()
-            self.setWindowTitle("PydanticWidgetForm example")
-
-            self._tabs = QTabWidget(self)
-            self._output = QTextEdit(self)
-            self._output.setReadOnly(True)
-            self._output.setPlaceholderText("Validated form data appears here.")
-            self._forms: list[PydanticWidgetForm] = []
-
-            self._add_form("Basic", PydanticWidgetForm(BasicScanConfig))
-            self._add_form("Limits", PydanticWidgetForm(LimitConfig))
-            self._add_form("ScanArgument", PydanticWidgetForm(ScanArgumentConfig))
-            self._add_form("Display", PydanticWidgetForm(DisplayConfig))
-            self._add_form("Device + signal", PydanticWidgetForm(DeviceAndSignalConfig))
-            self._add_form("Device limits", PydanticWidgetForm(DeviceSignalLimitsConfig))
-            self._add_form("Device only", PydanticWidgetForm(DeviceOnlyConfig))
-            self._add_form("Signal only", PydanticWidgetForm(SignalOnlyConfig))
-
-            show_data = QPushButton("Show current tab data", self)
-            show_data.clicked.connect(self._show_current_data)
-
-            layout = QVBoxLayout(self)
-            layout.addWidget(QLabel("Generated forms from Pydantic models", self))
-            layout.addWidget(self._tabs)
-            layout.addWidget(show_data)
-            layout.addWidget(self._output)
-
-        def _add_form(self, title: str, form: PydanticWidgetForm) -> None:
-            form.changed.connect(lambda _form=form: self._on_form_changed(_form))
-            self._forms.append(form)
-            self._tabs.addTab(form, title)
-
-        def _show_current_data(self, _checked: bool = False, *, validate: bool = True) -> None:
-            form = self._forms[self._tabs.currentIndex()]
-            if validate:
-                try:
-                    data = form.get_data()
-                except (ValidationError, ValueError) as exc:
-                    self._output.setPlainText(str(exc))
-                    return
-                key = "data"
-            else:
-                data = form.raw_data()
-                key = "raw_data"
-            self._output.setPlainText(
-                json.dumps(
-                    {key: data, "dirty_fields": sorted(form.dirty_fields())}, indent=2, default=str
-                )
-            )
-
-        def _on_form_changed(self, form: PydanticWidgetForm) -> None:
-            if form is self._forms[self._tabs.currentIndex()]:
-                self._show_current_data(validate=False)
-
-    app = QApplication(sys.argv)
-    apply_theme("dark")
-    window = ExampleWindow()
-    window.show()
-    sys.exit(app.exec())

bec_widgets/utils/rpc_logging.py

@@ -1,16 +0,0 @@
-from __future__ import annotations
-
-
-def elapsed_seconds(start: float | int | None, stop: float) -> float | None:
-    if start is None:
-        return None
-    try:
-        return max(0.0, stop - float(start))
-    except (TypeError, ValueError):
-        return None
-
-
-def format_elapsed(elapsed: float | None) -> str:
-    if elapsed is None:
-        return "unknown"
-    return f"{elapsed:.3f}"

bec_widgets/utils/rpc_server.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import functools
-import time
 import traceback
 import types
 from contextlib import contextmanager
@@ -12,14 +11,13 @@ from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import
 from qtpy.QtCore import Qt, QTimer
-from qtpy.QtWidgets import QApplication, QWidget
+from qtpy.QtWidgets import QWidget
 from redis.exceptions import RedisError
 
 from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.utils.container_utils import WidgetContainerUtils
 from bec_widgets.utils.error_popups import ErrorPopupUtility
-from bec_widgets.utils.rpc_logging import elapsed_seconds, format_elapsed
 from bec_widgets.utils.rpc_register import RPCRegister
 from bec_widgets.utils.screen_utils import apply_window_geometry
 from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
@@ -117,107 +115,27 @@ class RPCServer:
         if request_id is None:
             logger.error("Received RPC instruction without request_id")
             return
-        method = msg.get("action")
-        parameter = msg.get("parameter", {})
-        args = parameter.get("args", [])
-        kwargs = parameter.get("kwargs", {})
-        target_gui_id = parameter.get("gui_id")
-        sent_at = metadata.get("sent_at")
-        deadline = metadata.get("deadline")
-        timeout = metadata.get("timeout")
-        received_at = time.time()
-        receive_latency = elapsed_seconds(sent_at, received_at)
-        stale_on_receive = deadline is not None and received_at > deadline
-        logger.info(
-            "GUI RPC server received request "
-            f"request_id={request_id} method={method} gui_id={self.gui_id} "
-            f"target_gui_id={target_gui_id} timeout={timeout} "
-            f"receive_latency_s={format_elapsed(receive_latency)} "
-            f"stale_on_receive={stale_on_receive}"
-        )
-        if stale_on_receive:
-            logger.warning(
-                "GUI RPC server received request after client timeout deadline "
-                f"request_id={request_id} method={method} gui_id={self.gui_id} "
-                f"target_gui_id={target_gui_id} timeout={timeout} "
-                f"receive_latency_s={format_elapsed(receive_latency)}"
-            )
         logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
-
-        # Shutdown must acknowledge before teardown starts. The generic RPC path
-        # below publishes successful responses through QTimer.singleShot(0);
-        # for system.shutdown that would race with the queued app quit and
-        # dispatcher shutdown scheduled by _shutdown_gui_server().
-        if method == "system.shutdown":
-            execution_start = time.perf_counter()
-            try:
-                self.run_system_rpc(method, args, kwargs)
-            except Exception:
-                execution_duration = time.perf_counter() - execution_start
-                content = traceback.format_exc()
-                logger.error(
-                    "GUI RPC server shutdown request failed "
-                    f"request_id={request_id} method={method} gui_id={self.gui_id} "
-                    f"execution_duration_s={execution_duration:.3f}\n{content}"
-                )
-                self.send_response(request_id, False, {"error": content})
-            else:
-                execution_duration = time.perf_counter() - execution_start
-                logger.info(
-                    "GUI RPC server acknowledged shutdown request "
-                    f"request_id={request_id} method={method} gui_id={self.gui_id} "
-                    f"execution_duration_s={execution_duration:.3f}"
-                )
-                self.send_response(request_id, True, {"result": None})
-            return
-
-        execution_start = time.perf_counter()
         with rpc_exception_hook(functools.partial(self.send_response, request_id, False)):
             try:
+                method = msg["action"]
+                args = msg["parameter"].get("args", [])
+                kwargs = msg["parameter"].get("kwargs", {})
                 if method.startswith("system."):
                     res = self.run_system_rpc(method, args, kwargs)
                 else:
-                    obj = self.get_object_from_config(parameter)
+                    obj = self.get_object_from_config(msg["parameter"])
                     res = self.run_rpc(obj, method, args, kwargs)
             except Exception:
-                execution_duration = time.perf_counter() - execution_start
                 content = traceback.format_exc()
-                logger.error(
-                    "GUI RPC server execution failed "
-                    f"request_id={request_id} method={method} gui_id={self.gui_id} "
-                    f"target_gui_id={target_gui_id} execution_duration_s={execution_duration:.3f}\n"
-                    f"{content}"
-                )
+                logger.error(f"Error while executing RPC instruction: {content}")
                 self.send_response(request_id, False, {"error": content})
             else:
-                execution_duration = time.perf_counter() - execution_start
-                response_stale = deadline is not None and time.time() > deadline
-                logger.info(
-                    "GUI RPC server executed request "
-                    f"request_id={request_id} method={method} gui_id={self.gui_id} "
-                    f"target_gui_id={target_gui_id} execution_duration_s={execution_duration:.3f} "
-                    f"response_after_client_deadline={response_stale}"
-                )
-                if response_stale:
-                    logger.warning(
-                        "GUI RPC server response is late for client timeout "
-                        f"request_id={request_id} method={method} gui_id={self.gui_id} "
-                        f"target_gui_id={target_gui_id} timeout={timeout} "
-                        f"execution_duration_s={execution_duration:.3f}"
-                    )
                 logger.debug(f"RPC instruction executed successfully: {res}")
                 self._rpc_singleshot_repeats[request_id] = SingleshotRPCRepeat()
                 QTimer.singleShot(0, lambda: self.serialize_result_and_send(request_id, res))
 
     def send_response(self, request_id: str, accepted: bool, msg: dict):
-        log_message = (
-            "GUI RPC server publishing response "
-            f"request_id={request_id} gui_id={self.gui_id} accepted={accepted}"
-        )
-        if accepted:
-            logger.info(log_message)
-        else:
-            logger.error(log_message)
         self.client.connector.set_and_publish(
             MessageEndpoints.gui_instruction_response(request_id),
             messages.RequestResponseMessage(accepted=accepted, message=msg),
@@ -318,23 +236,10 @@ class RPCServer:
     def run_system_rpc(self, method: str, args: list, kwargs: dict):
         if method == "system.launch_dock_area":
             return self._launch_dock_area(*args, **kwargs)
-        if method == "system.shutdown":
-            return self._shutdown_gui_server()
         if method == "system.list_capabilities":
-            return {"system.launch_dock_area": True, "system.shutdown": True}
+            return {"system.launch_dock_area": True}
         raise ValueError(f"Unknown system RPC method: {method}")
 
-    @staticmethod
-    def _shutdown_gui_server() -> None:
-        app = QApplication.instance()
-        if app is None:
-            return
-        gui_server = getattr(app, "gui_server", None)
-        if gui_server is not None and hasattr(gui_server, "request_shutdown"):
-            QTimer.singleShot(0, gui_server.request_shutdown)
-            return
-        QTimer.singleShot(0, app.quit)
-
     @staticmethod
     def _launch_dock_area(
         name: str | None = None,
@@ -392,14 +297,7 @@ class RPCServer:
                 res = self.serialize_object(res)
         except RegistryNotReadyError:
             try:
-                repeat = self._rpc_singleshot_repeats[request_id]
-                repeat += retry_delay
-                logger.warning(
-                    "GUI RPC result serialization delayed; retrying "
-                    f"request_id={request_id} retry_delay_ms={retry_delay} "
-                    f"accumulated_delay_ms={repeat.accumulated_delay} "
-                    f"max_delay_ms={repeat.max_delay}"
-                )
+                self._rpc_singleshot_repeats[request_id] += retry_delay
                 QTimer.singleShot(
                     retry_delay, lambda: self.serialize_result_and_send(request_id, res)
                 )
@@ -509,9 +407,8 @@ class RPCServer:
                 container_proxy = parent.gui_id
             else:
                 container_proxy = None
-        except Exception as e:
+        except Exception:
             container_proxy = None
-            logger.error(f"Error while serializing RPC result: {e}")
 
         if wait and not self.rpc_register.object_is_registered(connector):
             raise RegistryNotReadyError(f"Connector {connector} not registered yet")

bec_widgets/utils/scan_arg_metadata.py

@@ -1,155 +0,0 @@
-from __future__ import annotations
-
-import re
-from collections.abc import Mapping
-from typing import Any
-
-from bec_lib import bec_logger
-from qtpy.QtWidgets import QDoubleSpinBox, QSpinBox, QWidget
-
-logger = bec_logger.logger
-
-UNIT_TOOLTIP_PREFIXES = ("Units:", "Units from:")
-
-
-def format_display_name(name: str) -> str:
-    """Convert a raw argument name into a user-facing label."""
-    parts = re.split(r"(_|\d+)", name)
-    return " ".join(part.capitalize() for part in parts if part.isalnum()).strip()
-
-
-def resolve_tooltip(scan_argument: Mapping[str, Any]) -> str | None:
-    """Resolve explicit tooltip text, falling back to the description."""
-    return scan_argument.get("tooltip") or scan_argument.get("description")
-
-
-def ui_config_from_metadata(
-    name: str,
-    metadata: Mapping[str, Any],
-    *,
-    default: Any = None,
-    input_type: Any = None,
-    arg: bool = False,
-    display_name: str | None = None,
-) -> dict[str, Any]:
-    """Build the normalized scan-input item consumed by form widgets."""
-    return {
-        "arg": arg,
-        "name": name,
-        "type": input_type,
-        "display_name": display_name or metadata.get("display_name") or format_display_name(name),
-        "tooltip": resolve_tooltip(metadata),
-        "default": default,
-        "expert": metadata.get("expert", False),
-        "hidden": metadata.get("hidden", False),
-        "precision": metadata.get("precision"),
-        "units": metadata.get("units"),
-        "reference_units": metadata.get("reference_units"),
-        "reference_limits": metadata.get("reference_limits"),
-        "gt": metadata.get("gt"),
-        "ge": metadata.get("ge"),
-        "lt": metadata.get("lt"),
-        "le": metadata.get("le"),
-        "alternative_group": metadata.get("alternative_group"),
-    }
-
-
-def unit_tooltip(item: Mapping[str, Any], units: str | None = None) -> str | None:
-    """Build tooltip text from scan argument unit metadata."""
-    tooltip = item.get("tooltip")
-    reference_units = item.get("reference_units")
-    units = units or item.get("units")
-
-    tooltip_parts = [tooltip] if tooltip else []
-    if units:
-        tooltip_parts.append(f"Units: {units}")
-    elif reference_units:
-        tooltip_parts.append(f"Units from: {reference_units}")
-    if tooltip_parts:
-        return "\n".join(str(part) for part in tooltip_parts)
-    return None
-
-
-def strip_unit_tooltip(tooltip: str) -> str:
-    """Remove unit lines added by :func:`apply_unit_metadata`."""
-    return "\n".join(
-        line for line in tooltip.splitlines() if not line.startswith(UNIT_TOOLTIP_PREFIXES)
-    ).strip()
-
-
-def apply_unit_metadata(widget: QWidget, item: Mapping[str, Any], units: str | None = None) -> None:
-    """Apply unit tooltip text and numeric suffix metadata to a widget."""
-    units = units or item.get("units")
-    tooltip = unit_tooltip(item, units)
-    existing_tooltip = strip_unit_tooltip(widget.toolTip())
-    base_tooltip = item.get("tooltip")
-    if base_tooltip and existing_tooltip == base_tooltip:
-        existing_tooltip = ""
-
-    if tooltip:
-        widget.setToolTip(f"{existing_tooltip}\n{tooltip}" if existing_tooltip else tooltip)
-    else:
-        widget.setToolTip(existing_tooltip)
-
-    if hasattr(widget, "setSuffix"):
-        widget.setSuffix(f" {units}" if units else "")
-
-
-def device_units(device: object) -> str | None:
-    """Return engineering units from a BEC device object when available."""
-    egu = getattr(device, "egu", None)
-    if not callable(egu):
-        return None
-    try:
-        return egu()
-    except Exception:
-        logger.exception("Failed to fetch engineering units from device %s", device)
-        return None
-
-
-def apply_numeric_precision(widget: QWidget, item: Mapping[str, Any]) -> None:
-    """Apply decimal precision metadata to spinboxes supporting ``setDecimals``."""
-    if not hasattr(widget, "setDecimals"):
-        return
-
-    precision = item.get("precision")
-    if precision is None:
-        return
-
-    try:
-        widget.setDecimals(max(0, int(precision)))
-    except (TypeError, ValueError):
-        logger.warning(
-            "Ignoring invalid precision %r for parameter %s", precision, item.get("name")
-        )
-
-
-def apply_numeric_limits(widget: QWidget, item: Mapping[str, Any]) -> None:
-    """Apply ``gt/ge/lt/le`` numeric bounds to Qt spinboxes."""
-    if isinstance(widget, QSpinBox) and not isinstance(widget, QDoubleSpinBox):
-        minimum = -2147483647
-        maximum = 2147483647
-        if item.get("ge") is not None:
-            minimum = int(item["ge"])
-        if item.get("gt") is not None:
-            minimum = int(item["gt"]) + 1
-        if item.get("le") is not None:
-            maximum = int(item["le"])
-        if item.get("lt") is not None:
-            maximum = int(item["lt"]) - 1
-        widget.setRange(minimum, maximum)
-        return
-
-    if isinstance(widget, QDoubleSpinBox):
-        minimum = -float("inf")
-        maximum = float("inf")
-        step = 10 ** (-widget.decimals())
-        if item.get("ge") is not None:
-            minimum = float(item["ge"])
-        if item.get("gt") is not None:
-            minimum = float(item["gt"]) + step
-        if item.get("le") is not None:
-            maximum = float(item["le"])
-        if item.get("lt") is not None:
-            maximum = float(item["lt"]) - step
-        widget.setRange(minimum, maximum)

bec_widgets/utils/widget_io.py

@@ -99,45 +99,6 @@ class ComboBoxHandler(WidgetHandler):
         widget.currentIndexChanged.connect(lambda idx, w=widget: slot(w, self.get_value(w)))
 
 
-class DeviceComboBoxHandler(ComboBoxHandler):
-    """Handler for BEC device comboboxes."""
-
-    def get_value(self, widget, **kwargs) -> str:
-        return widget.currentText().strip()
-
-    def set_value(self, widget, value: str | None) -> None:
-        device = "" if value is None else str(value)
-        if not device:
-            widget.setCurrentText("")
-            return
-        widget.set_device(device)
-        if widget.currentText() != device:
-            widget.setCurrentText(device)
-
-    def connect_change_signal(self, widget, slot):
-        widget.currentTextChanged.connect(lambda text, w=widget: slot(w, text.strip()))
-
-
-class SignalComboBoxHandler(ComboBoxHandler):
-    """Handler for BEC signal comboboxes."""
-
-    def get_value(self, widget, **kwargs) -> str | None:
-        signal = widget.get_signal_name().strip()
-        return signal or None
-
-    def set_value(self, widget, value: str | None) -> None:
-        signal = "" if value is None else str(value)
-        if not signal:
-            widget.setCurrentText("")
-            return
-        widget.set_signal(signal)
-        if widget.currentText() != signal and widget.get_signal_name() != signal:
-            widget.setCurrentText(signal)
-
-    def connect_change_signal(self, widget, slot):
-        widget.currentTextChanged.connect(lambda _text, w=widget: slot(w, self.get_value(w)))
-
-
 class TableWidgetHandler(WidgetHandler):
     """Handler for QTableWidget widgets."""
 
@@ -321,18 +282,6 @@ class WidgetIO:
         Returns:
             handler_class: The handler class if found, otherwise None.
         """
-        if (
-            isinstance(widget, QComboBox)
-            and hasattr(widget, "set_signal")
-            and hasattr(widget, "get_signal_name")
-        ):
-            return SignalComboBoxHandler
-        if (
-            isinstance(widget, QComboBox)
-            and hasattr(widget, "set_device")
-            and hasattr(widget, "device_selected")
-        ):
-            return DeviceComboBoxHandler
         for base in type(widget).__mro__:
             if base in WidgetIO._handlers:
                 return WidgetIO._handlers[base]

bec_widgets/widgets/containers/dock_area/dock_area.py

@@ -385,11 +385,6 @@ class BECDockArea(DockAreaWidget):
             "bec_shell": (widget_icons["BECShell"], "Add BEC Shell", "BECShell"),
             "sbb_monitor": (widget_icons["SBBMonitor"], "Add SBB Monitor", "SBBMonitor"),
             "log_panel": (widget_icons["LogPanel"], "Add LogPanel", "LogPanel"),
-            "beamline_state_manager": (
-                widget_icons["BeamlineStateManager"],
-                "Add Beamline State Manager",
-                "BeamlineStateManager",
-            ),
         }
 
         # Create expandable menu actions (original behavior)

bec_widgets/widgets/containers/main_window/addons/notification_center/notification_banner.py

@@ -11,6 +11,7 @@ Intended for use in desktop applications to provide user feedback, warnings, and
 
 from __future__ import annotations
 
+import json
 import sys
 from datetime import datetime
 from enum import Enum
@@ -28,7 +29,7 @@ from qtpy.QtWidgets import QApplication, QFrame, QMainWindow, QScrollArea, QWidg
 
 from bec_widgets import SafeProperty, SafeSlot
 from bec_widgets.utils.bec_connector import BECConnector
-from bec_widgets.utils.colors import apply_theme, get_theme_name
+from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.widget_io import WidgetIO
 
 
@@ -257,8 +258,8 @@ class NotificationToast(QFrame):
     def _connect_to_theme_change(self):
         """Connect this toast to the global theme‑updated signal."""
         qapp = QApplication.instance()
-        if hasattr(qapp, "theme"):
-            qapp.theme.theme_changed.connect(self.apply_theme)
+        if hasattr(qapp, "theme_signal"):
+            qapp.theme_signal.theme_updated.connect(self.apply_theme)
 
     # helper methods -----------------------------------------------------
     def _current_inner_width(self) -> int:
@@ -353,9 +354,11 @@ class NotificationToast(QFrame):
         Args:
             theme(str | None): "light" or "dark". If None, auto-detects from QApplication.
         """
-        theme = str(theme or get_theme_name()).lower()
-        if theme not in {"light", "dark"}:
-            theme = "dark"
+        # determine effective theme
+        if theme is None:
+            app = QApplication.instance()
+            theme = getattr(getattr(app, "theme", None), "theme", "dark")
+        theme = theme.lower()
         self._theme = theme
         palette = DARK_PALETTE if theme == "dark" else LIGHT_PALETTE
 
@@ -400,18 +403,11 @@ class NotificationToast(QFrame):
             #NotificationToast QPushButton:hover {{ color: {btn_hover}; }}
             """)
         # traceback panel colours
-        if theme == "dark":
-            trace_bg = "#1e1e1e"
-            trace_fg = palette["body"]
-            trace_border = "rgba(255,255,255,48)"
-        else:
-            trace_bg = "#ffffff"
-            trace_fg = palette["body"]
-            trace_border = "rgba(15,23,42,54)"
+        trace_bg = "#1e1e1e" if theme == "dark" else "#f0f0f0"
         self.trace_view.setStyleSheet(f"""
             background:{trace_bg};
-            color:{trace_fg};
-            border: 1px solid {trace_border};
+            color:{palette['body']};
+            border:none;
             border-radius:8px;
             """)
 
@@ -442,8 +438,8 @@ class NotificationToast(QFrame):
             }}
             """)
 
-        self._accent_alpha = 6 if theme == "light" else 60
-        self._gradient_width_factor = 1.0 if theme == "light" else 0.70
+        # stronger accent wash in light mode, slightly stronger in dark too
+        self._accent_alpha = 110 if theme == "light" else 60
         self.update()
 
     ########################################
@@ -475,8 +471,6 @@ class NotificationToast(QFrame):
     # Event Filters
     ########################################
     def eventFilter(self, watched, event):
-        if not isinstance(event, QtCore.QEvent):
-            return False
         # timestamp label → toggle absolute time
         if watched is self.time_lbl:
             if event.type() == QtCore.QEvent.Enter and not self._showing_absolute:
@@ -525,9 +519,7 @@ class NotificationToast(QFrame):
         painter.fillPath(path, self._base_color)
 
         # accent gradient, fades to transparent
-        grad = QtGui.QLinearGradient(
-            0, 0, self.width() * getattr(self, "_gradient_width_factor", 0.70), 0
-        )
+        grad = QtGui.QLinearGradient(0, 0, self.width() * 0.7, 0)
         accent = QtGui.QColor(self._accent_color)
         if getattr(self, "_theme", "dark") == "light":
             accent = accent.darker(115)
@@ -551,7 +543,7 @@ class NotificationToast(QFrame):
 
     def close(self) -> None:
         self.closed.emit()
-        self.time_lbl.removeEventFilter(self)
+        QtWidgets.QApplication.instance().removeEventFilter(self)
         super().close()  # this will remove the widget from its parent
 
 
@@ -681,8 +673,8 @@ class NotificationCentre(QScrollArea):
     def _connect_to_theme_change(self):
         """Connect to the theme change signal."""
         qapp = QApplication.instance()
-        if hasattr(qapp, "theme"):
-            qapp.theme.theme_changed.connect(self.apply_theme)
+        if hasattr(qapp, "theme_signal"):
+            qapp.theme_signal.theme_updated.connect(self.apply_theme)
 
     #  public API
     def add_notification(
@@ -896,8 +888,6 @@ class NotificationCentre(QScrollArea):
         self.setFixedHeight(min(content_h, avail))
 
     def eventFilter(self, watched, event):
-        if not isinstance(event, QtCore.QEvent):
-            return False
         if watched is self.parent() and event.type() == QtCore.QEvent.Resize:
             self._adjust_height()
         return super().eventFilter(watched, event)

bec_widgets/widgets/containers/main_window/main_window.py

@@ -4,7 +4,7 @@ import os
 
 from bec_lib import bec_logger
 from bec_lib.endpoints import MessageEndpoints
-from qtpy.QtCore import QSize, Qt, QTimer
+from qtpy.QtCore import QEvent, QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QActionGroup, QIcon
 from qtpy.QtWidgets import (
     QApplication,
@@ -412,6 +412,11 @@ class BECMainWindow(BECWidget, QMainWindow):
         """
         apply_theme(theme)  # emits theme_updated and applies palette globally
 
+    def event(self, event):
+        if event.type() == QEvent.Type.StatusTip:
+            return True
+        return super().event(event)
+
     def _show_widget_hierarchy_dialog(self):
         if self._widget_hierarchy_dialog is None:
             dialog = WidgetHierarchyDialog(root_widget=None, parent=self)

bec_widgets/widgets/control/buttons/button_abort/button_abort.py

@@ -1,6 +1,3 @@
-from __future__ import annotations
-
-from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from qtpy.QtCore import Qt
 from qtpy.QtWidgets import QHBoxLayout, QPushButton, QToolButton, QWidget
@@ -8,8 +5,6 @@ from qtpy.QtWidgets import QHBoxLayout, QPushButton, QToolButton, QWidget
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
 
-logger = bec_logger.logger
-
 
 class AbortButton(BECWidget, QWidget):
     """A button that abort the scan."""
@@ -60,7 +55,7 @@ class AbortButton(BECWidget, QWidget):
             scan_id(str|None): The scan id to abort. If None, the current scan will be aborted.
         """
         if self.scan_id is not None:
-            logger.info(f"Aborting scan with scan_id: {self.scan_id}")
+            print(f"Aborting scan with scan_id: {self.scan_id}")
             self.queue.request_scan_abortion(scan_id=self.scan_id)
         else:
             self.queue.request_scan_abortion()

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_2d/positioner_box_2d.py

@@ -429,7 +429,7 @@ class PositionerBox2D(PositionerBoxBase):
 
     @SafeSlot()
     def on_stop(self):
-        self._stop_device([self.device_hor, self.device_ver])
+        self._stop_device(f"{self.device_hor} or {self.device_ver}")
 
     @SafeProperty(float)
     def step_size_hor(self):

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_base.py

@@ -1,10 +1,11 @@
+import uuid
 from abc import abstractmethod
-from typing import Callable, Sequence, TypedDict
+from typing import Callable, TypedDict
 
 from bec_lib.device import Positioner
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
-from bec_lib.messages import VariableMessage
+from bec_lib.messages import ScanQueueMessage
 from qtpy.QtWidgets import (
     QDialog,
     QDoubleSpinBox,
@@ -115,16 +116,17 @@ class PositionerBoxBase(BECWidget, QWidget):
         else:
             ui["units"].setVisible(False)
 
-    def _stop_device(self, device: str | Sequence[str]):
+    def _stop_device(self, device: str):
         """Stop call"""
-        devices = [device] if isinstance(device, str) else list(device)
-        devices = [dev for dev in devices if dev]
-        if not devices:
-            logger.warning("Stop requested without a valid device.")
-            return
-
-        msg = VariableMessage(value=devices)
-        self.client.connector.send(MessageEndpoints.stop_devices(), msg)
+        request_id = str(uuid.uuid4())
+        params = {"device": device, "rpc_id": request_id, "func": "stop", "args": [], "kwargs": {}}
+        msg = ScanQueueMessage(
+            scan_type="device_rpc",
+            parameter=params,
+            queue="emergency",
+            metadata={"RID": request_id, "response": False},
+        )
+        self.client.connector.send(MessageEndpoints.scan_queue_request(self.client.username), msg)
 
     # pylint: disable=unused-argument
     def _on_device_readback(

bec_widgets/widgets/control/device_input/device_combobox/device_combobox.py

@@ -9,7 +9,7 @@ from bec_lib.device import ComputedSignal, Device, Positioner, ReadoutPriority
 from bec_lib.device import Signal as BECSignal
 from bec_lib.logger import bec_logger
 from pydantic import Field, field_validator
-from qtpy.QtCore import QSize, QStringListModel, Signal, Slot
+from qtpy.QtCore import QSize, QStringListModel, Qt, Signal, Slot
 from qtpy.QtWidgets import QComboBox, QCompleter, QSizePolicy
 
 from bec_widgets.utils.bec_connector import ConnectionConfig
@@ -219,7 +219,9 @@ class DeviceComboBox(BECWidget, QComboBox):
         self._callback_id = self.bec_dispatcher.client.callbacks.register(
             EventType.DEVICE_UPDATE, self.on_device_update
         )
-        self.device_config_update.connect(self.update_devices_from_filters)
+        self.device_config_update.connect(
+            self.update_devices_from_filters, Qt.ConnectionType.QueuedConnection
+        )
         self.currentTextChanged.connect(self.check_validity)
         self.check_validity(self.currentText())
 
@@ -255,6 +257,9 @@ class DeviceComboBox(BECWidget, QComboBox):
     @SafeSlot()
     def update_devices_from_filters(self):
         """Refresh the available device list from current device/readout/signal filters."""
+        if getattr(self, "_destroyed", False):
+            return
+
         self.config.device_filter = [entry.value for entry in self.device_filter]
         self.config.readout_filter = [entry.value for entry in self.readout_filter]
         self.config.signal_class_filter = self.signal_class_filter
@@ -489,7 +494,7 @@ class DeviceComboBox(BECWidget, QComboBox):
             action: Device update action emitted by BEC.
             content: Device update payload. Currently unused.
         """
-        if self._callback_id is None or getattr(self, "_destroyed", False):
+        if getattr(self, "_destroyed", False):
             return
         if action in ["add", "remove", "reload"]:
             self.device_config_update.emit()
@@ -497,9 +502,8 @@ class DeviceComboBox(BECWidget, QComboBox):
     def cleanup(self):
         """Cleanup the widget."""
         if self._callback_id is not None:
-            callback_id = self._callback_id
+            self.bec_dispatcher.client.callbacks.remove(self._callback_id)
             self._callback_id = None
-            self.bec_dispatcher.client.callbacks.remove(callback_id)
         super().cleanup()
 
     def get_current_device(self) -> object:
@@ -603,10 +607,8 @@ class DeviceComboBox(BECWidget, QComboBox):
         return device.readout_priority in self.readout_filter
 
     def _update_validity_style(self, is_valid: bool) -> None:
-        if is_valid or not self.isEnabled():
-            self.setStyleSheet("")
-            return
-        self.setStyleSheet("QComboBox { border: 1px solid red; }")
+        border_color = "transparent" if is_valid or not self.isEnabled() else "red"
+        self.setStyleSheet(f"border: 1px solid {border_color};")
 
     def _filter_devices_by_signal_class(
         self, devices: list[Device | BECSignal | ComputedSignal | Positioner]

bec_widgets/widgets/control/device_input/signal_combobox/signal_combobox.py

@@ -77,6 +77,7 @@ class SignalComboBox(BECWidget, QComboBox):
 
     device_signal_changed = Signal(str)
     signal_reset = Signal()
+    device_config_update = Signal()
 
     def __init__(
         self,
@@ -138,7 +139,10 @@ class SignalComboBox(BECWidget, QComboBox):
             self.autocomplete = True
 
         self._device_update_register = self.bec_dispatcher.client.callbacks.register(
-            EventType.DEVICE_UPDATE, self.update_signals_from_filters
+            EventType.DEVICE_UPDATE, self.on_device_update
+        )
+        self.device_config_update.connect(
+            self.update_signals_from_filters, Qt.ConnectionType.QueuedConnection
         )
         self.currentTextChanged.connect(self.on_text_changed)
 
@@ -197,19 +201,17 @@ class SignalComboBox(BECWidget, QComboBox):
         self.update_signals_from_filters()
 
     @SafeSlot()
-    @SafeSlot(str, dict)
-    def update_signals_from_filters(self, action: str | None = None, content: dict | None = None):
+    @SafeSlot(dict, dict)
+    def update_signals_from_filters(
+        self, content: dict | None = None, metadata: dict | None = None
+    ):
         """Refresh available signals from the current device and filters.
 
         Args:
-            action: Optional BEC device update action. If provided, only device list changing
-                actions trigger a refresh.
             content: Optional callback payload from BEC device updates. Currently unused.
+            metadata: Optional callback metadata from BEC device updates. Currently unused.
         """
-        if self._device_update_register is None or getattr(self, "_destroyed", False):
-            return
-
-        if action is not None and action not in ["add", "remove", "reload"]:
+        if getattr(self, "_destroyed", False):
             return
 
         self.config.signal_filter = [kind.name for kind in self.signal_filter]
@@ -252,6 +254,13 @@ class SignalComboBox(BECWidget, QComboBox):
             ),
         )
 
+    def on_device_update(self, action: str, content: dict) -> None:
+        """Refresh filters when BEC reports device configuration changes."""
+        if getattr(self, "_destroyed", False):
+            return
+        if action in ["add", "remove", "reload"]:
+            self.device_config_update.emit()
+
     @Property(str)
     def device(self) -> str:
         """Selected device."""
@@ -468,7 +477,8 @@ class SignalComboBox(BECWidget, QComboBox):
             True if an enabled item was found and selected.
         """
         for index in range(self.count()):
-            if self._item_is_enabled(index):
+            item = self.model().item(index)
+            if item is not None and item.isEnabled():
                 self.setCurrentIndex(index)
                 return True
         return False
@@ -593,9 +603,8 @@ class SignalComboBox(BECWidget, QComboBox):
     def cleanup(self):
         """Cleanup the widget."""
         if self._device_update_register is not None:
-            callback_id = self._device_update_register
+            self.bec_dispatcher.client.callbacks.remove(self._device_update_register)
             self._device_update_register = None
-            self.bec_dispatcher.client.callbacks.remove(callback_id)
         super().cleanup()
 
     @staticmethod
@@ -625,10 +634,8 @@ class SignalComboBox(BECWidget, QComboBox):
         self.check_validity(self.currentText())
 
     def _update_validity_style(self, is_valid: bool) -> None:
-        if is_valid or not self.isEnabled():
-            self.setStyleSheet("")
-            return
-        self.setStyleSheet("QComboBox { border: 1px solid red; }")
+        border_color = "transparent" if is_valid or not self.isEnabled() else "red"
+        self.setStyleSheet(f"border: 1px solid {border_color};")
 
     def _replace_signal_items(self, items: list[str | tuple[str, dict]] | None = None):
         combo_items = self._signals if items is None else items
@@ -649,37 +656,15 @@ class SignalComboBox(BECWidget, QComboBox):
         if self._config_signals:
             index = offset + len(self._hinted_signals) + len(self._normal_signals)
             self.insertItem(index, "Config Signals")
-            self._set_item_enabled(index, False)
+            self.model().item(index).setEnabled(False)
         if self._normal_signals:
             index = offset + len(self._hinted_signals)
             self.insertItem(index, "Normal Signals")
-            self._set_item_enabled(index, False)
+            self.model().item(index).setEnabled(False)
         if self._hinted_signals:
             index = offset
             self.insertItem(index, "Hinted Signals")
-            self._set_item_enabled(index, False)
-
-    def _standard_item(self, index: int):
-        model = self.model()
-        item_getter = getattr(model, "item", None)
-        if callable(item_getter):
-            return item_getter(index)
-        return None
-
-    def _item_is_enabled(self, index: int) -> bool:
-        item = self._standard_item(index)
-        if item is not None:
-            return item.isEnabled()
-
-        model_index = self.model().index(index, self.modelColumn())
-        if not model_index.isValid():
-            return True
-        return bool(self.model().flags(model_index) & Qt.ItemFlag.ItemIsEnabled)
-
-    def _set_item_enabled(self, index: int, enabled: bool) -> None:
-        item = self._standard_item(index)
-        if item is not None:
-            item.setEnabled(enabled)
+            self.model().item(index).setEnabled(False)
 
     def _display_text_for_signal(self, signal: str) -> str | None:
         for entry in self._signals:

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -14,6 +14,7 @@ from qtpy.QtWidgets import (
     QLabel,
     QPushButton,
     QSizePolicy,
+    QSpacerItem,
     QVBoxLayout,
     QWidget,
 )
@@ -24,7 +25,6 @@ from bec_widgets.utils.colors import apply_theme, get_accent_colors
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.widgets.control.buttons.stop_button.stop_button import StopButton
 from bec_widgets.widgets.control.scan_control.scan_group_box import ScanGroupBox
-from bec_widgets.widgets.control.scan_control.scan_info_adapter import ScanInfoAdapter
 from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
 
 
@@ -95,7 +95,6 @@ class ScanControl(BECWidget, QWidget):
         self._hide_scan_control_buttons = False
         self._hide_metadata = False
         self._hide_scan_selection_combobox = False
-        self._scan_info_adapter = ScanInfoAdapter()
 
         # Create and set main layout
         self._init_UI()
@@ -185,17 +184,12 @@ class ScanControl(BECWidget, QWidget):
             MessageEndpoints.available_scans()
         ).resource
         if self.config.allowed_scans is None:
-            supported_scans = ["ScanBase", "SyncFlyScanBase", "AsyncFlyScanBase", "ScanBaseV4"]
-
-            def _is_scan_supported(scan_name):
-                scan_info = self.available_scans[scan_name]
-                return (
-                    scan_info.get("base_class") in supported_scans
-                    and self._scan_info_adapter.has_scan_ui_config(scan_info)
-                    and not scan_name.startswith("_")
-                )
-
-            allowed_scans = filter(_is_scan_supported, self.available_scans.keys())
+            supported_scans = ["ScanBase", "SyncFlyScanBase", "AsyncFlyScanBase"]
+            allowed_scans = [
+                scan_name
+                for scan_name, scan_info in self.available_scans.items()
+                if scan_info["base_class"] in supported_scans and len(scan_info["gui_config"]) > 0
+            ]
 
         else:
             allowed_scans = self.config.allowed_scans
@@ -382,14 +376,14 @@ class ScanControl(BECWidget, QWidget):
         self.reset_layout()
         selected_scan_info = self.available_scans.get(scan_name, {})
 
-        gui_config = self._scan_info_adapter.build_scan_ui_config(selected_scan_info)
-        arg_group = gui_config.get("arg_group", None)
-        kwarg_groups = gui_config.get("kwarg_groups", [])
+        gui_config = selected_scan_info.get("gui_config", {})
+        self.arg_group = gui_config.get("arg_group", None)
+        self.kwarg_groups = gui_config.get("kwarg_groups", None)
 
-        if arg_group and bool(arg_group.get("arg_inputs")):
-            self.add_arg_group(arg_group)
-        if kwarg_groups:
-            self.add_kwargs_boxes(kwarg_groups)
+        if bool(self.arg_group["arg_inputs"]):
+            self.add_arg_group(self.arg_group)
+        if len(self.kwarg_groups) > 0:
+            self.add_kwargs_boxes(self.kwarg_groups)
 
         self.update()
         self.adjustSize()
@@ -420,7 +414,6 @@ class ScanControl(BECWidget, QWidget):
         position = self.ARG_BOX_POSITION + (1 if self.arg_box is not None else 0)
         for group in groups:
             box = ScanGroupBox(box_type="kwargs", config=group)
-            box.reference_units_changed.connect(self._apply_reference_units_to_other_boxes)
             box.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)
             self.layout.insertWidget(position + len(self.kwarg_boxes), box)
             self.kwarg_boxes.append(box)
@@ -434,30 +427,11 @@ class ScanControl(BECWidget, QWidget):
         """
         self.arg_box = ScanGroupBox(box_type="args", config=group)
         self.arg_box.device_selected.connect(self.emit_device_selected)
-        self.arg_box.reference_units_changed.connect(self._apply_reference_units_to_other_boxes)
         self.arg_box.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)
         self.arg_box.hide_add_remove_buttons = self._hide_add_remove_buttons
         self.layout.insertWidget(self.ARG_BOX_POSITION, self.arg_box)
         self.arg_box.setVisible(not self._hide_arg_box)
 
-    def _scan_group_boxes(self) -> list[ScanGroupBox]:
-        boxes = []
-        if self.arg_box is not None:
-            boxes.append(self.arg_box)
-        boxes.extend(self.kwarg_boxes)
-        return boxes
-
-    def _apply_reference_units_to_other_boxes(
-        self, source_box: ScanGroupBox, reference_name: str, units: str | None
-    ) -> None:
-        """
-        Propagate device-derived units to scan fields that reference a device in another group.
-        """
-        for box in self._scan_group_boxes():
-            if box is source_box:
-                continue
-            box.apply_reference_units(reference_name, units)
-
     @SafeSlot(str)
     def emit_device_selected(self, dev_names):
         """

bec_widgets/widgets/control/scan_control/scan_group_box.py

@@ -20,12 +20,6 @@ from qtpy.QtWidgets import (
     QVBoxLayout,
 )
 
-from bec_widgets.utils.scan_arg_metadata import (
-    apply_numeric_limits,
-    apply_numeric_precision,
-    apply_unit_metadata,
-    device_units,
-)
 from bec_widgets.utils.widget_io import WidgetIO
 from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import (
     BECDeviceFilter,
@@ -180,7 +174,6 @@ class ScanGroupBox(QGroupBox):
     }
 
     device_selected = Signal(str)
-    reference_units_changed = Signal(object, str, object)
 
     def __init__(
         self,
@@ -216,8 +209,6 @@ class ScanGroupBox(QGroupBox):
 
         self.labels = []
         self.widgets = []
-        self._widget_configs = {}
-        self._column_labels = {}
         self.selected_devices = {}
 
         self.init_box(self.config)
@@ -256,7 +247,6 @@ class ScanGroupBox(QGroupBox):
             label = QLabel(text=display_name)
             self.layout.addWidget(label, row, column_index)
             self.labels.append(label)
-            self._column_labels[column_index] = label
 
     def add_input_widgets(self, group_inputs: dict, row) -> None:
         """
@@ -291,31 +281,20 @@ class ScanGroupBox(QGroupBox):
                 )
             else:
                 widget = widget_class(parent=self.parent(), arg_name=arg_name, default=default)
-            apply_numeric_precision(widget, item)
-            apply_numeric_limits(widget, item)
             if isinstance(widget, DeviceComboBox):
                 self.selected_devices[widget] = ""
                 widget.device_selected.connect(self.emit_device_selected)
-                widget.currentTextChanged.connect(
-                    lambda text, device_widget=widget: self._handle_device_text_changed(
-                        device_widget, text
-                    )
-                )
             if isinstance(widget, ScanLiteralsComboBox):
                 widget.set_literals(item["type"].get("Literal", []))
-            self._widget_configs[widget] = item
-            apply_unit_metadata(widget, item)
+            tooltip = item.get("tooltip", None)
+            if tooltip is not None:
+                widget.setToolTip(item["tooltip"])
             self.layout.addWidget(widget, row, column_index)
             self.widgets.append(widget)
 
     @Slot(str)
     def emit_device_selected(self, device_name):
-        sender = self.sender()
-        self.selected_devices[sender] = device_name.strip()
-        if isinstance(sender, DeviceComboBox):
-            units = device_units(sender.get_current_device())
-            self._update_reference_units(sender, units)
-            self._emit_reference_units_changed(sender, units)
+        self.selected_devices[self.sender()] = device_name.strip()
         selected_devices_str = " ".join(self.selected_devices.values())
         self.device_selected.emit(selected_devices_str)
 
@@ -342,7 +321,6 @@ class ScanGroupBox(QGroupBox):
         for widget in self.widgets[-len(self.inputs) :]:
             if isinstance(widget, DeviceComboBox):
                 self.selected_devices[widget] = ""
-            self._widget_configs.pop(widget, None)
             widget.close()
             widget.deleteLater()
         self.widgets = self.widgets[: -len(self.inputs)]
@@ -355,7 +333,6 @@ class ScanGroupBox(QGroupBox):
         for widget in list(self.widgets):
             if isinstance(widget, DeviceComboBox):
                 self.selected_devices.pop(widget, None)
-            self._widget_configs.pop(widget, None)
             widget.close()
             widget.deleteLater()
             self.layout.removeWidget(widget)
@@ -458,67 +435,3 @@ class ScanGroupBox(QGroupBox):
                 if widget.arg_name == key:
                     WidgetIO.set_value(widget, value)
                     break
-
-    def _refresh_column_label(self, column: int, item: dict) -> None:
-        if column not in self._column_labels:
-            return
-        self._column_labels[column].setText(item.get("display_name", item.get("name", None)))
-
-    def _widget_position(self, widget) -> tuple[int, int] | None:
-        for row in range(self.layout.rowCount()):
-            for column in range(self.layout.columnCount()):
-                item = self.layout.itemAtPosition(row, column)
-                if item is not None and item.widget() is widget:
-                    return row, column
-        return None
-
-    def _update_reference_units(self, device_widget: DeviceComboBox, units: str | None) -> None:
-        position = self._widget_position(device_widget)
-        if position is None:
-            return
-        source_row, _ = position
-        source_name = device_widget.arg_name
-
-        for widget in self.widgets:
-            item = self._widget_configs.get(widget, {})
-            if item.get("reference_units") != source_name:
-                continue
-            widget_position = self._widget_position(widget)
-            if widget_position is None:
-                continue
-            row, column = widget_position
-            if self.box_type == "args" and row != source_row:
-                continue
-            apply_unit_metadata(widget, item, units)
-            self._refresh_column_label(column, item)
-
-    def apply_reference_units(self, reference_name: str, units: str | None) -> None:
-        """
-        Apply units to widgets that reference an argument owned by another group box.
-
-        Cross-box references only have one widget row, so row scoping is intentionally handled by
-        the source group before this method is called.
-        """
-        for widget in self.widgets:
-            item = self._widget_configs.get(widget, {})
-            if item.get("reference_units") != reference_name:
-                continue
-            apply_unit_metadata(widget, item, units)
-            position = self._widget_position(widget)
-            if position is not None:
-                _, column = position
-                self._refresh_column_label(column, item)
-
-    def _emit_reference_units_changed(
-        self, device_widget: DeviceComboBox, units: str | None
-    ) -> None:
-        reference_name = getattr(device_widget, "arg_name", None)
-        if not reference_name:
-            return
-        self.reference_units_changed.emit(self, reference_name, units)
-
-    def _handle_device_text_changed(self, device_widget: DeviceComboBox, device_name: str) -> None:
-        if not device_widget.validate_device(device_name):
-            self.selected_devices[device_widget] = ""
-            self._update_reference_units(device_widget, None)
-            self._emit_reference_units_changed(device_widget, None)

bec_widgets/widgets/control/scan_control/scan_info_adapter.py

@@ -1,278 +0,0 @@
-"""Helpers for translating BEC scan metadata into ScanControl UI configuration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from bec_widgets.utils.scan_arg_metadata import format_display_name as format_scan_display_name
-from bec_widgets.utils.scan_arg_metadata import resolve_tooltip as resolve_scan_tooltip
-from bec_widgets.utils.scan_arg_metadata import ui_config_from_metadata
-
-AnnotationValue = str | dict[str, Any] | list[Any] | None
-ScanArgumentMetadata = dict[str, Any]
-SignatureEntry = dict[str, Any]
-ScanInputConfig = dict[str, Any]
-ScanInfo = dict[str, Any]
-ScanUIConfig = dict[str, Any]
-
-SUPPORTED_SCAN_INPUT_TYPES = {"device", "DeviceBase", "float", "int", "bool", "str"}
-
-
-class ScanInfoAdapter:
-    """Normalize available-scan payloads into the structure consumed by ``ScanControl``."""
-
-    @staticmethod
-    def has_scan_ui_config(scan_info: ScanInfo) -> bool:
-        """Check whether a scan exposes enough metadata to build a UI.
-
-        Args:
-            scan_info (ScanInfo): Available-scan payload for one scan.
-
-        Returns:
-            bool: ``True`` when a supported GUI metadata field is present.
-        """
-        if not (
-            scan_info.get("gui_visibility")
-            or scan_info.get("gui_config")
-            or scan_info.get("gui_visualization")
-            or scan_info.get("signature")
-        ):
-            return False
-
-        gui_config = ScanInfoAdapter().build_scan_ui_config(scan_info)
-        return not ScanInfoAdapter.unsupported_inputs(gui_config)
-
-    @staticmethod
-    def is_supported_input_type(input_type: AnnotationValue) -> bool:
-        """Return whether ``ScanGroupBox`` has a widget for this serialized type."""
-        return (
-            isinstance(input_type, str)
-            and input_type in SUPPORTED_SCAN_INPUT_TYPES
-            or isinstance(input_type, dict)
-            and "Literal" in input_type
-        )
-
-    @staticmethod
-    def unsupported_inputs(gui_config: ScanUIConfig) -> list[ScanInputConfig]:
-        """Return input configs that cannot be rendered by ``ScanGroupBox``."""
-        inputs = []
-        arg_group = gui_config.get("arg_group")
-        if arg_group:
-            inputs.extend(arg_group.get("inputs", []))
-        for group in gui_config.get("kwarg_groups", []):
-            inputs.extend(group.get("inputs", []))
-        return [
-            input_config
-            for input_config in inputs
-            if not ScanInfoAdapter.is_supported_input_type(input_config.get("type"))
-        ]
-
-    @staticmethod
-    def format_display_name(name: str) -> str:
-        """Convert a parameter name into a user-facing label.
-
-        Args:
-            name (str): Raw parameter name.
-
-        Returns:
-            str: Formatted display label such as ``Exp Time``.
-        """
-        return format_scan_display_name(name)
-
-    @staticmethod
-    def resolve_tooltip(scan_argument: ScanArgumentMetadata) -> str | None:
-        """Resolve the tooltip text from parsed ``ScanArgument`` metadata.
-
-        Args:
-            scan_argument (ScanArgumentMetadata): Parsed ``ScanArgument`` metadata.
-
-        Returns:
-            str | None: Explicit tooltip text if provided, otherwise the description fallback.
-        """
-        return resolve_scan_tooltip(scan_argument)
-
-    @staticmethod
-    def parse_annotation(
-        annotation: AnnotationValue,
-    ) -> tuple[AnnotationValue, ScanArgumentMetadata]:
-        """Extract the serialized base annotation and ``ScanArgument`` metadata.
-
-        Args:
-            annotation (AnnotationValue): Serialized annotation payload from BEC.
-
-        Returns:
-            tuple[AnnotationValue, ScanArgumentMetadata]: The unwrapped annotation and parsed
-            ``ScanArgument`` metadata.
-        """
-        scan_argument: ScanArgumentMetadata = {}
-        if isinstance(annotation, list):
-            annotation = next(
-                (entry for entry in annotation if entry != "NoneType"),
-                annotation[0] if annotation else "_empty",
-            )
-        if isinstance(annotation, dict) and "Annotated" in annotation:
-            annotated = annotation["Annotated"]
-            annotation = annotated.get("type", "_empty")
-            scan_argument = annotated.get("metadata", {}).get("ScanArgument", {}) or {}
-        return annotation, scan_argument
-
-    @staticmethod
-    def scan_arg_type_from_annotation(annotation: AnnotationValue) -> AnnotationValue:
-        """Normalize an annotation value to the widget type expected by ``ScanControl``.
-
-        Args:
-            annotation (AnnotationValue): Serialized or parsed annotation value.
-
-        Returns:
-            AnnotationValue: The normalized type identifier used by the widget layer.
-        """
-        if isinstance(annotation, dict):
-            return annotation
-        if annotation in ("_empty", None):
-            return "str"
-        return annotation
-
-    def scan_input_from_signature(
-        self, param: SignatureEntry, arg: bool = False
-    ) -> ScanInputConfig:
-        """Build one ScanControl input description from a signature entry.
-
-        Args:
-            param (SignatureEntry): Serialized signature entry.
-            arg (bool): Whether the parameter belongs to the positional arg bundle.
-
-        Returns:
-            ScanInputConfig: Normalized input configuration for ``ScanControl``.
-        """
-        annotation, scan_argument = self.parse_annotation(param.get("annotation"))
-        return self._build_scan_input(
-            name=param["name"],
-            annotation=annotation,
-            scan_argument=scan_argument,
-            arg=arg,
-            default=None if arg else param.get("default", None),
-        )
-
-    def scan_input_from_arg_input(
-        self, name: str, item_type: AnnotationValue, signature_by_name: dict[str, SignatureEntry]
-    ) -> ScanInputConfig:
-        """Build one arg-bundle input description from ``arg_input`` metadata.
-
-        Args:
-            name (str): Argument name from ``arg_input``.
-            item_type (AnnotationValue): Serialized argument type from ``arg_input``.
-            signature_by_name (dict[str, SignatureEntry]): Signature entries indexed by
-                parameter name.
-
-        Returns:
-            ScanInputConfig: Normalized input configuration for one arg-bundle field.
-        """
-        if name in signature_by_name:
-            scan_input = self.scan_input_from_signature(signature_by_name[name], arg=True)
-            scan_input["type"] = self.scan_arg_type_from_annotation(
-                self.parse_annotation(signature_by_name[name].get("annotation"))[0]
-            )
-        else:
-            annotation, scan_argument = self.parse_annotation(item_type)
-            scan_input = self._build_scan_input(
-                name=name,
-                annotation=annotation,
-                scan_argument=scan_argument,
-                arg=True,
-                default=None,
-            )
-        if scan_input["type"] in ("_empty", None):
-            scan_input["type"] = item_type
-        return scan_input
-
-    def _build_scan_input(
-        self,
-        name: str,
-        annotation: AnnotationValue,
-        scan_argument: ScanArgumentMetadata,
-        *,
-        arg: bool,
-        default: Any,
-    ) -> ScanInputConfig:
-        """Build one normalized ScanControl input configuration.
-
-        Args:
-            name (str): Parameter name.
-            annotation (AnnotationValue): Parsed annotation value.
-            scan_argument (ScanArgumentMetadata): Parsed ``ScanArgument`` metadata.
-            arg (bool): Whether the parameter belongs to the positional arg bundle.
-            default (Any): Default value for the parameter.
-
-        Returns:
-            ScanInputConfig: Normalized input configuration.
-        """
-        return ui_config_from_metadata(
-            name=name,
-            metadata=scan_argument,
-            input_type=self.scan_arg_type_from_annotation(annotation),
-            default=default,
-            arg=arg,
-        )
-
-    def build_scan_ui_config(self, scan_info: ScanInfo) -> ScanUIConfig:
-        """Normalize one available-scan entry into the widget UI configuration.
-
-        Args:
-            scan_info (ScanInfo): Available-scan payload for one scan.
-
-        Returns:
-            ScanUIConfig: Legacy group structure consumed by ``ScanControl`` and
-            ``ScanGroupBox``.
-        """
-        gui_visualization = (
-            scan_info.get("gui_visualization") or scan_info.get("gui_visibility") or {}
-        )
-        if not gui_visualization and scan_info.get("gui_config"):
-            return scan_info["gui_config"]
-
-        signature = scan_info.get("signature", [])
-        signature_by_name = {entry["name"]: entry for entry in signature}
-
-        arg_group = None
-        arg_input = scan_info.get("arg_input", {})
-        if isinstance(arg_input, dict) and arg_input:
-            bundle_size = scan_info.get("arg_bundle_size", {})
-            inputs = [
-                self.scan_input_from_arg_input(name, item_type, signature_by_name)
-                for name, item_type in arg_input.items()
-            ]
-            arg_group = {
-                "name": "Scan Arguments",
-                "bundle": bundle_size.get("bundle"),
-                "arg_inputs": arg_input,
-                "inputs": inputs,
-                "min": bundle_size.get("min"),
-                "max": bundle_size.get("max"),
-            }
-
-        kwarg_groups = []
-        arg_names = set(arg_input) if isinstance(arg_input, dict) else set()
-        visible_kwarg_names = set()
-        for group_name, input_names in gui_visualization.items():
-            inputs = []
-            for input_name in input_names:
-                if input_name in arg_names or input_name not in signature_by_name:
-                    continue
-                if input_name in visible_kwarg_names:
-                    continue
-                param = signature_by_name[input_name]
-                if param.get("kind") in ("VAR_POSITIONAL", "VAR_KEYWORD"):
-                    continue
-                scan_input = self.scan_input_from_signature(param)
-                if scan_input.get("hidden"):
-                    continue
-                inputs.append(scan_input)
-                visible_kwarg_names.add(input_name)
-            if inputs:
-                kwarg_groups.append({"name": group_name, "inputs": inputs})
-
-        return {
-            "scan_class_name": scan_info.get("class"),
-            "arg_group": arg_group,
-            "kwarg_groups": kwarg_groups,
-        }

bec_widgets/widgets/plots/image/image.py

@@ -907,7 +907,14 @@ class Image(ImageBase):
             async_signal_name=config.async_signal_name,
         )
 
-        self.subscriptions["main"].async_signal_name = None
+        config.async_signal_name = None
+        if target_device == self._config.device and target_entry == self._config.signal:
+            config.device = ""
+            config.signal = ""
+            config.source = None
+            config.monitor_type = None
+            self._signal_configs.pop("main", None)
+            self._set_connection_status("disconnected")
         self.async_update = False
         self._sync_device_selection()
 

bec_widgets/widgets/plots/image/image_base.py

@@ -460,7 +460,7 @@ class ImageBase(PlotBase):
                 self._color_bar = None
 
             def disable_autorange():
-                logger.info("Disabling autorange")
+                print("Disabling autorange")
                 self.setProperty("autorange", False)
 
             if style == "simple":
@@ -928,7 +928,7 @@ class ImageBase(PlotBase):
                 # if sync:
                 self._sync_colorbar_levels()
         self._sync_autorange_switch()
-        logger.info(f"Autorange set to {enabled}")
+        print(f"Autorange set to {enabled}")
 
     @SafeProperty(str)
     def autorange_mode(self) -> str:

bec_widgets/widgets/plots/waveform/waveform.py

@@ -2449,7 +2449,7 @@ class Waveform(PlotBase):
                 first_key = next(iter(info))
                 mem_bytes = info[first_key]["value"]["mem_size"]
             size_mb = mem_bytes / (1024 * 1024)
-            logger.info(f"Dataset size: {size_mb:.1f} MB")
+            print(f"Dataset size: {size_mb:.1f} MB")
         except Exception as exc:  # noqa: BLE001
             logger.error(f"Unable to evaluate dataset size: {exc}")
             return True

bec_widgets/widgets/progress/ring_progress_bar/ring.py

@@ -217,14 +217,14 @@ class Ring(BECWidget, QWidget):
 
         match mode:
             case "manual":
-                if self.config.mode == "manual":
+                if self.config.mode == "manual" and self.registered_slot is None:
                     return
                 if self.registered_slot is not None:
                     self.bec_dispatcher.disconnect_slot(*self.registered_slot)
                 self.config.mode = "manual"
                 self.registered_slot = None
             case "scan":
-                if self.config.mode == "scan":
+                if self.config.mode == "scan" and self.registered_slot is not None:
                     return
                 if self.registered_slot is not None:
                     self.bec_dispatcher.disconnect_slot(*self.registered_slot)
@@ -383,9 +383,9 @@ class Ring(BECWidget, QWidget):
         """
         current_RID = meta.get("RID", None)
         if current_RID != self.RID:
+            self.RID = current_RID
             self.set_min_max_values(0, msg.get("max_value", 100))
         self.set_value(msg.get("value", 0))
-        self.update()
 
     @SafeSlot(dict, dict)
     def on_device_readback(self, msg, meta):
@@ -404,7 +404,6 @@ class Ring(BECWidget, QWidget):
         if value is None:
             return
         self.set_value(value)
-        self.update()
 
     @SafeSlot(dict, dict)
     def on_device_progress(self, msg, meta):
@@ -424,7 +423,6 @@ class Ring(BECWidget, QWidget):
         if msg.get("done"):
             value = max_val
         self.set_value(value)
-        self.update()
 
     def paintEvent(self, event):
         if not self.progress_container:

bec_widgets/widgets/progress/ring_progress_bar/ring_progress_bar.py

@@ -103,7 +103,6 @@ class RingProgressContainerWidget(QWidget):
             self._hovered_ring = None
             self._last_hover_global_pos = None
             self._hover_tooltip.hide()
-        ring.cleanup()
         ring.close()
         ring.deleteLater()
         self.rings.pop(index)
@@ -373,7 +372,7 @@ class RingProgressContainerWidget(QWidget):
         self._hovered_ring = None
         self._last_hover_global_pos = None
         self._hover_tooltip.hide()
-        for ring in self.rings:
+        for ring in list(self.rings):
             ring.close()
             ring.deleteLater()
         self.rings = []

bec_widgets/widgets/progress/scan_progressbar/scan_progressbar.py

@@ -155,6 +155,7 @@ class ScanProgressBar(BECWidget, QWidget):
         self._progress_device = None
         self.task = None
         self.scan_number = None
+        self.progress_started.connect(lambda: print("Scan progress started"))
 
     def connect_to_queue(self):
         """

bec_widgets/widgets/services/beamline_states/beamline_state_manager.pyproject

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

bec_widgets/widgets/services/beamline_states/beamline_state_manager_plugin.py

@@ -1,57 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtWidgets import QWidget
-
-from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.services.beamline_states.beamline_state_pill import BeamlineStateManager
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='BeamlineStateManager' name='beamline_state_manager'>
-    </widget>
-</ui>
-"""
-
-
-class BeamlineStateManagerPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        if parent is None:
-            return QWidget()
-        t = BeamlineStateManager(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return "BEC Services"
-
-    def icon(self):
-        return designer_material_icon(BeamlineStateManager.ICON_NAME)
-
-    def includeFile(self):
-        return "beamline_state_manager"
-
-    def initialize(self, form_editor):
-        self._form_editor = form_editor
-
-    def isContainer(self):
-        return False
-
-    def isInitialized(self):
-        return self._form_editor is not None
-
-    def name(self):
-        return "BeamlineStateManager"
-
-    def toolTip(self):
-        return ""
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/widgets/services/beamline_states/dialogs.py

@@ -1,267 +0,0 @@
-from __future__ import annotations
-
-import slugify
-from bec_lib import bl_states
-from qtpy.QtWidgets import (
-    QCheckBox,
-    QComboBox,
-    QDialog,
-    QDialogButtonBox,
-    QFormLayout,
-    QGroupBox,
-    QHBoxLayout,
-    QLineEdit,
-    QMessageBox,
-    QPushButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.forms_from_types.pydantic_widget_form import PydanticWidgetForm
-from bec_widgets.utils.name_utils import pascal_to_snake
-from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
-
-BEAMLINE_STATE_STATUS_LABELS = {
-    "valid": "VALID",
-    "invalid": "INVALID",
-    "warning": "WARNING",
-    "unknown": "UNKNOWN",
-}
-
-SUPPORTED_BEAMLINE_STATES: tuple[type[bl_states.BeamlineState], ...] = (
-    bl_states.DeviceWithinLimitsState,
-    bl_states.ShutterState,
-)
-
-
-class AddBeamlineStateDialog(QDialog):
-    """Dialog for creating supported beamline state configurations."""
-
-    def __init__(self, parent: QWidget | None = None, client=None) -> None:
-        super().__init__(parent=parent)
-        self.setWindowTitle("Add Beamline State")
-        self._cleaned_up = False
-        self._client = client
-        self._config: bl_states.BeamlineStateConfig | None = None
-        self._auto_generated_name: str | None = None
-
-        self._type_combo = QComboBox(self)
-        for state_class in SUPPORTED_BEAMLINE_STATES:
-            self._type_combo.addItem(state_class.__name__, state_class)
-        self._type_combo.currentIndexChanged.connect(self._update_config_form)
-
-        self._form = QFormLayout()
-        self._form.addRow("State type", self._type_combo)
-        self._config_form_host = QVBoxLayout()
-        self._config_form: PydanticWidgetForm | None = None
-
-        self._buttons = QDialogButtonBox(
-            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel, parent=self
-        )
-        self._buttons.accepted.connect(self.accept)
-        self._buttons.rejected.connect(self.reject)
-
-        layout = QVBoxLayout(self)
-        layout.addLayout(self._form)
-        layout.addLayout(self._config_form_host)
-        layout.addWidget(self._buttons)
-        self.setLayout(layout)
-        self.setMinimumWidth(280)
-        self._update_config_form()
-        self._fit_height_to_contents()
-
-    def config(self) -> bl_states.BeamlineStateConfig:
-        state_class = self._selected_state_class()
-        config_class = state_class.CONFIG_CLASS
-        name = self._state_name()
-        data = self._config_form.get_data()
-        data["name"] = name
-        return config_class.model_validate(data)
-
-    def accept(self) -> None:
-        try:
-            self._config = self.config()
-        except Exception as exc:
-            QMessageBox.warning(self, "Invalid Beamline State", str(exc))
-            return
-        super().accept()
-
-    @property
-    def config_result(self) -> bl_states.BeamlineStateConfig:
-        if self._config is None:
-            raise RuntimeError("Beamline state dialog was not accepted with a valid config.")
-        return self._config
-
-    def cleanup(self) -> None:
-        if self._cleaned_up:
-            return
-        self._cleaned_up = True
-        if self._config_form is not None:
-            self._config_form.cleanup()
-            self._config_form.close()
-            self._config_form.deleteLater()
-
-    def closeEvent(self, event) -> None:  # noqa: N802
-        self.cleanup()
-        super().closeEvent(event)
-
-    @SafeSlot(str)
-    def _on_valid_device_selected(self, device: str) -> None:
-        if self._cleaned_up:
-            return
-        name_widget = self._config_form.input_widget("name")
-        current_name = name_widget.text().strip()
-        if current_name and current_name != self._auto_generated_name:
-            return
-        suffix = slugify.slugify(
-            pascal_to_snake(self._selected_state_class().__name__), separator="_"
-        )
-        generated_name = f"{slugify.slugify(device, separator='_')}_{suffix}"
-        self._auto_generated_name = generated_name
-        name_widget.setText(generated_name)
-
-    @SafeSlot(int)
-    def _update_config_form(self, _index: int = 0) -> None:
-        previous_data = self._config_form.raw_data() if self._config_form is not None else {}
-        if self._config_form is not None:
-            self._config_form_host.removeWidget(self._config_form)
-            self._config_form.cleanup()
-            self._config_form.setParent(None)
-            self._config_form.deleteLater()
-        config_class = self._selected_state_class().CONFIG_CLASS
-        data = {
-            key: value
-            for key, value in previous_data.items()
-            if key in config_class.model_fields and value is not None
-        }
-        self._config_form = PydanticWidgetForm(config_class, parent=self, client=self._client)
-        self._config_form.set_partial_data(data)
-        self._config_form_host.addWidget(self._config_form)
-        for device_widget in self._config_form.input_widgets_by_type(DeviceComboBox):
-            device_widget.device_selected.connect(self._on_valid_device_selected)
-        self._fit_height_to_contents()
-
-    def _fit_height_to_contents(self) -> None:
-        self.setMinimumHeight(0)
-        self.setMaximumHeight(16777215)
-        self.layout().activate()
-        self.adjustSize()
-        height = self.sizeHint().expandedTo(self.minimumSizeHint()).height()
-        self.setMinimumHeight(height)
-        self.setMaximumHeight(height)
-
-    def _selected_state_class(self) -> type[bl_states.BeamlineState]:
-        state_class = self._type_combo.currentData()
-        if state_class is None:
-            raise RuntimeError("No beamline state class selected.")
-        return state_class
-
-    def _state_name(self) -> str:
-        name_widget = self._config_form.input_widget("name")
-        raw_name = name_widget.text().strip()
-        if not raw_name:
-            raise ValueError("Name is required.")
-        name = slugify.slugify(raw_name, separator="_")
-        name_widget.setText(name)
-        return name
-
-
-class StatusFilterDialog(QDialog):
-    """Dialog for selecting visible beamline state statuses."""
-
-    def __init__(self, selected_statuses: set[str] | None, parent: QWidget | None = None) -> None:
-        super().__init__(parent=parent)
-        self.setWindowTitle("Filter Beamline State Status")
-        self._checkboxes: dict[str, QCheckBox] = {}
-
-        controls = QHBoxLayout()
-        select_all = QPushButton("Select all", self)
-        clear = QPushButton("Clear", self)
-        select_all.clicked.connect(lambda: self._set_all(True))
-        clear.clicked.connect(lambda: self._set_all(False))
-        controls.addWidget(select_all)
-        controls.addWidget(clear)
-        controls.addStretch(1)
-
-        list_layout = QVBoxLayout()
-        for status, label in BEAMLINE_STATE_STATUS_LABELS.items():
-            checkbox = QCheckBox(label, self)
-            checkbox.setChecked(selected_statuses is None or status in selected_statuses)
-            self._checkboxes[status] = checkbox
-            list_layout.addWidget(checkbox)
-        list_layout.addStretch(1)
-
-        box = QGroupBox("Displayed status", self)
-        box.setLayout(list_layout)
-
-        buttons = QDialogButtonBox(
-            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel, parent=self
-        )
-        buttons.accepted.connect(self.accept)
-        buttons.rejected.connect(self.reject)
-
-        layout = QVBoxLayout(self)
-        layout.addLayout(controls)
-        layout.addWidget(box)
-        layout.addWidget(buttons)
-        self.setLayout(layout)
-
-    def selected_statuses(self) -> set[str] | None:
-        selected = {status for status, checkbox in self._checkboxes.items() if checkbox.isChecked()}
-        if selected == set(self._checkboxes):
-            return None
-        return selected
-
-    def _set_all(self, checked: bool) -> None:
-        for checkbox in self._checkboxes.values():
-            checkbox.setChecked(checked)
-
-
-class DeviceFilterDialog(QDialog):
-    """Dialog for filtering beamline states by configured device."""
-
-    def __init__(
-        self,
-        devices: list[str],
-        selected_devices: set[str] | None,
-        device_filter_text: str,
-        parent: QWidget | None = None,
-    ) -> None:
-        super().__init__(parent=parent)
-        self.setWindowTitle("Filter Beamline State Devices")
-        self._checkboxes: dict[str, QCheckBox] = {}
-
-        self._device_text = QLineEdit(self)
-        self._device_text.setPlaceholderText("Device name or comma-separated names")
-        self._device_text.setText(device_filter_text)
-
-        list_layout = QVBoxLayout()
-        for device in devices:
-            checkbox = QCheckBox(device, self)
-            checkbox.setChecked(selected_devices is not None and device in selected_devices)
-            self._checkboxes[device] = checkbox
-            list_layout.addWidget(checkbox)
-        list_layout.addStretch(1)
-
-        box = QGroupBox("Known devices", self)
-        box.setLayout(list_layout)
-
-        buttons = QDialogButtonBox(
-            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel, parent=self
-        )
-        buttons.accepted.connect(self.accept)
-        buttons.rejected.connect(self.reject)
-
-        layout = QVBoxLayout(self)
-        layout.addWidget(self._device_text)
-        layout.addWidget(box)
-        layout.addWidget(buttons)
-        self.setLayout(layout)
-
-    def selected_devices(self) -> set[str] | None:
-        selected = {device for device, checkbox in self._checkboxes.items() if checkbox.isChecked()}
-        return selected or None
-
-    def filter_text(self) -> str:
-        return self._device_text.text().strip()

bec_widgets/widgets/services/beamline_states/register_beamline_state_manager.py

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

bec_widgets/widgets/utility/toggle/toggle.py

@@ -1,6 +1,6 @@
 import sys
 
-from qtpy.QtCore import Property, QEasingCurve, QEvent, QPointF, QPropertyAnimation, Qt, Signal
+from qtpy.QtCore import Property, QEasingCurve, QPointF, QPropertyAnimation, Qt, Signal
 from qtpy.QtGui import QColor, QPainter
 from qtpy.QtWidgets import QApplication, QWidget
 
@@ -41,22 +41,10 @@ class ToggleSwitch(QWidget):
         theme = getattr(QApplication.instance(), "theme", None)
         colors = theme.colors if theme else {}
 
-        self._active_track_color = self._theme_color(colors, "PRIMARY", QColor(33, 150, 243))
-        self._active_thumb_color = self._theme_color(colors, "ON_PRIMARY", QColor(255, 255, 255))
-        self._inactive_track_color = self._theme_color(colors, "SEPARATOR", QColor(200, 200, 200))
-        self._inactive_thumb_color = self._theme_color(colors, "ON_PRIMARY", QColor(255, 255, 255))
-        self._disabled_track_color = self._theme_color(colors, "DISABLED_BG", QColor(220, 220, 220))
-        self._disabled_thumb_color = self._theme_color(colors, "DISABLED_FG", QColor(150, 150, 150))
-        self._disabled_border_color = self._theme_color(
-            colors, "DISABLED_BORDER", QColor(170, 170, 170)
-        )
-        if hasattr(self, "_checked"):
-            self.update_colors()
-
-    @staticmethod
-    def _theme_color(colors: dict, key: str, fallback: QColor) -> QColor:
-        color = colors.get(key, fallback)
-        return color if isinstance(color, QColor) else QColor(color)
+        self._active_track_color = colors.get("PRIMARY", QColor(33, 150, 243))
+        self._active_thumb_color = colors.get("ON_PRIMARY", QColor(255, 255, 255))
+        self._inactive_track_color = colors.get("SEPARATOR", QColor(200, 200, 200))
+        self._inactive_thumb_color = colors.get("ON_PRIMARY", QColor(255, 255, 255))
 
     @Property(bool)
     def checked(self):
@@ -131,40 +119,29 @@ class ToggleSwitch(QWidget):
 
     def paintEvent(self, event):
         painter = QPainter(self)
-        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.setRenderHint(QPainter.Antialiasing)
 
         # Draw track
         painter.setBrush(self._track_color)
-        painter.setPen(self._disabled_border_color if not self.isEnabled() else Qt.PenStyle.NoPen)
+        painter.setPen(Qt.NoPen)
         painter.drawRoundedRect(
             0, 0, self.width(), self.height(), self.height() / 2, self.height() / 2
         )
 
         # Draw thumb
         painter.setBrush(self._thumb_color)
-        painter.setPen(Qt.PenStyle.NoPen)
         diameter = int(self.height() * 0.8)
         painter.drawEllipse(int(self._thumb_pos.x()), int(self._thumb_pos.y()), diameter, diameter)
 
     def mousePressEvent(self, event):
-        if self.isEnabled() and event.button() == Qt.MouseButton.LeftButton:
+        if event.button() == Qt.LeftButton:
             self.checked = not self.checked
 
     def update_colors(self):
-        if not self.isEnabled():
-            self._thumb_color = self._disabled_thumb_color
-            self._track_color = self._disabled_track_color
-            return
 
         self._thumb_color = self.active_thumb_color if self._checked else self.inactive_thumb_color
         self._track_color = self.active_track_color if self._checked else self.inactive_track_color
 
-    def changeEvent(self, event):
-        if event.type() == QEvent.Type.EnabledChange:
-            self.update_colors()
-            self.update()
-        super().changeEvent(event)
-
     def get_thumb_pos(self, checked):
         return QPointF(self.width() - self.height() + 3, 2) if checked else QPointF(3, 2)
 
@@ -190,7 +167,7 @@ class ToggleSwitch(QWidget):
 
 
 if __name__ == "__main__":  # pragma: no cover
-    from qtpy.QtWidgets import QHBoxLayout, QWidget
+    from qtpy.QtWidgets import QHBoxLayout, QVBoxLayout, QWidget
 
     from bec_widgets.utils.colors import apply_theme
     from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
@@ -200,12 +177,9 @@ if __name__ == "__main__":  # pragma: no cover
     widget = QWidget()
     layout = QHBoxLayout(widget)
     toggle = ToggleSwitch()
-    toggle_disabled = ToggleSwitch()
     dark_mode_btn = DarkModeButton()
     layout.addWidget(toggle)
-    layout.addWidget(toggle_disabled)
     layout.addWidget(dark_mode_btn)
-    toggle_disabled.setEnabled(False)
     window = QWidget()
     window.setLayout(layout)
     window.show()

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bec_widgets"
-version = "3.13.5"
+version = "3.11.1"
 description = "BEC Widgets"
 requires-python = ">=3.11"
 classifiers = [
@@ -24,7 +24,6 @@ dependencies = [
   "pydantic~=2.0",
   "pylsp-bec~=1.2",
   "pyqtgraph==0.13.7",
-  "python-slugify~=8.0",
   "qtconsole~=5.5, >=5.5.1",             # needed for jupyter console
   "qtmonaco~=0.8, >=0.8.1",
   "qtpy~=2.4",
@@ -65,15 +64,6 @@ qtermwidget = ["pyside6_qtermwidget"]
 
 
 
-
-
-
-
-
-
-
-
-
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

tests/end-2-end/conftest.py

@@ -45,7 +45,7 @@ def connected_client_gui_obj(qtbot, gui_id, bec_client_lib):
     """
     gui = BECGuiClient(gui_id=gui_id)
     try:
-        gui.show(wait=True)
+        gui.start(wait=True)
         qtbot.waitUntil(lambda: hasattr(gui, "bec"), timeout=5000)
         gui.bec.delete_all()  # ensure clean state
         qtbot.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)

tests/end-2-end/test_beamline_state_manager_e2e.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-import uuid
-
-import pytest
-from bec_lib.bl_states import DeviceWithinLimitsStateConfig
-
-from bec_widgets.widgets.services.beamline_states.beamline_state_pill import BeamlineStateManager
-
-# pylint: disable=protected-access
-
-
-def _delete_state_if_present(bec, state_name: str) -> None:
-    if hasattr(bec.beamline_states, state_name):
-        bec.beamline_states.delete(state_name)
-
-
-@pytest.mark.timeout(100)
-def test_beamline_state_manager_adds_updates_and_deletes_state_e2e(qtbot, bec_client_lib):
-    """
-    Verify the real BEC beamline-state flow is reflected by BeamlineStateManager.
-
-    This test requires the e2e BEC servers and is intended to be run with
-    ``--start-servers``.
-    """
-    bec = bec_client_lib
-    dev = bec.device_manager.devices
-    scans = bec.scans
-    state_name = f"samx_widget_limits_{uuid.uuid4().hex[:8]}"
-    config = DeviceWithinLimitsStateConfig(
-        name=state_name, device="samx", signal="samx", low_limit=0.0, high_limit=10.0, tolerance=1.0
-    )
-    manager = BeamlineStateManager(client=bec)
-    qtbot.addWidget(manager)
-    manager.show()
-    qtbot.waitExposed(manager)
-
-    _delete_state_if_present(bec, state_name)
-
-    try:
-        bec.beamline_states.add(config)
-
-        qtbot.waitUntil(lambda: hasattr(bec.beamline_states, state_name), timeout=10000)
-        qtbot.waitUntil(lambda: state_name in manager._state_pills, timeout=10000)
-
-        pill = manager._state_pills[state_name]
-        assert pill.state_name == state_name
-
-        scans.umv(dev.samx, 5, relative=False).wait()
-        qtbot.waitUntil(
-            lambda: getattr(bec.beamline_states, state_name).get()["status"] == "valid",
-            timeout=10000,
-        )
-        qtbot.waitUntil(lambda: pill._status == "valid", timeout=10000)
-        assert pill._status_label.text() == "VALID"
-        assert pill._detail_label.text() == "Device samx within limits"
-
-        scans.umv(dev.samx, 20, relative=False).wait()
-        qtbot.waitUntil(
-            lambda: getattr(bec.beamline_states, state_name).get()["status"] == "invalid",
-            timeout=10000,
-        )
-        qtbot.waitUntil(lambda: pill._status == "invalid", timeout=10000)
-        assert pill._status_label.text() == "INVALID"
-        assert pill._detail_label.text() == "Device samx out of limits"
-
-        bec.beamline_states.delete(state_name)
-        qtbot.waitUntil(lambda: not hasattr(bec.beamline_states, state_name), timeout=10000)
-        qtbot.waitUntil(lambda: state_name not in manager._state_pills, timeout=10000)
-
-    finally:
-        _delete_state_if_present(bec, state_name)
-        scans.umv(dev.samx, 0, relative=False).wait()

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -143,11 +143,11 @@ def test_rpc_gui_obj(connected_client_gui_obj: BECGuiClient, qtbot):
     qtbot.wait(500)
     gui.kill_server()
     assert not gui._gui_is_alive()
-    gui.show(wait=True)
+    gui.start(wait=True)
     assert gui._gui_is_alive()
-    # calling show multiple times should not change anything
-    gui.show(wait=True)
-    gui.show(wait=True)
+    # calling start multiple times should not change anything
+    gui.start(wait=True)
+    gui.start(wait=True)
 
     def wait_for_gui_started():
         return "bec" in gui.windows

tests/end-2-end/user_interaction/conftest.py

@@ -75,7 +75,7 @@ def connected_client_gui_obj(qtbot_scope_module, gui_id, bec_client_lib):
     """
     gui = BECGuiClient(gui_id=gui_id)
     try:
-        gui.show(wait=True)
+        gui.start(wait=True)
         qtbot_scope_module.waitUntil(lambda: hasattr(gui, "bec"), timeout=5000)
         gui.bec.delete_all()  # ensure clean state
         qtbot_scope_module.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)

tests/unit_tests/test_beamline_state_pill.py

@@ -1,702 +0,0 @@
-import shiboken6
-from bec_lib import bl_states
-from qtpy.QtCore import QCoreApplication, QEvent, Qt
-from qtpy.QtWidgets import QMessageBox, QStyleOptionViewItem
-
-from bec_widgets.utils.toolbars.toolbar import ModularToolBar
-from bec_widgets.utils.widget_io import WidgetIO
-from bec_widgets.widgets.services.beamline_states import beamline_state_pill as pill_module
-from bec_widgets.widgets.services.beamline_states.beamline_state_pill import (
-    BeamlineStateManager,
-    BeamlineStatePill,
-)
-from bec_widgets.widgets.services.beamline_states.dialogs import AddBeamlineStateDialog
-
-from .client_mocks import mocked_client
-from .conftest import create_widget
-
-
-def test_beamline_state_pill_updates_from_message(qtbot, mocked_client):
-    pill = create_widget(
-        qtbot, BeamlineStatePill, state_name="shutter_open", title="Shutter", client=mocked_client
-    )
-    pill.update_state({"name": "shutter_open", "status": "valid", "label": "Shutter is open."}, {})
-
-    assert pill._state_name == "shutter_open"
-    assert pill._name_label.text() == "Shutter"
-    assert pill._status_label.text() == "VALID"
-    assert pill._detail_label.text() == "Shutter is open."
-    assert not pill._icon_label.pixmap().isNull()
-    assert pill.toolTip() == "Shutter is open."
-
-
-def test_beamline_state_pill_ignores_other_states(qtbot, mocked_client):
-    pill = create_widget(
-        qtbot, BeamlineStatePill, state_name="shutter_open", title="Shutter", client=mocked_client
-    )
-    pill.update_state(
-        {"name": "other_state", "status": "invalid", "label": "Should be ignored."}, {}
-    )
-
-    assert pill._status_label.text() == "UNKNOWN"
-    assert pill.toolTip() == "No state information available."
-
-
-def test_beamline_state_pill_expands_and_emits_updated_limits(qtbot, mocked_client):
-    limits_pill = create_widget(
-        qtbot, BeamlineStatePill, state_name="limits", title="Limits", client=mocked_client
-    )
-    limits_pill.set_state_config(
-        {
-            "name": "limits",
-            "title": "Limits",
-            "state_type": "DeviceWithinLimitsState",
-            "parameters": {
-                "name": "limits",
-                "title": "Limits",
-                "device": "samx",
-                "signal": "samx",
-                "low_limit": 0.0,
-                "high_limit": 10.0,
-                "tolerance": 0.1,
-            },
-        }
-    )
-
-    assert limits_pill._settings.isHidden()
-    assert limits_pill._config_form is None
-    assert not limits_pill._update_button.isEnabled()
-    assert not limits_pill._revert_button.isEnabled()
-
-    qtbot.mouseClick(limits_pill._header, Qt.MouseButton.LeftButton)
-    assert limits_pill._config_form is not None
-    high_limit = limits_pill._config_form.input_widget("high_limit")
-    high_limit.setValue(20.0)
-
-    assert not limits_pill._settings.isHidden()
-    assert limits_pill._update_button.isEnabled()
-    assert limits_pill._revert_button.isEnabled()
-    assert (
-        limits_pill._config_form.field_widget("high_limit").property("beamlineStateDirty") is True
-    )
-    assert limits_pill._config_form.get_data()["device"] == "samx"
-    assert limits_pill.edited_config().high_limit == 20.0
-
-    with qtbot.waitSignal(limits_pill.update_requested) as signal:
-        limits_pill._update_button.click()
-
-    assert signal.args[0] == "limits"
-    assert isinstance(signal.args[1], bl_states.DeviceWithinLimitsState.CONFIG_CLASS)
-    assert signal.args[1].device == "samx"
-    assert signal.args[1].signal == "samx"
-    assert signal.args[1].low_limit == 0.0
-    assert signal.args[1].high_limit == 20.0
-    assert signal.args[1].tolerance == 0.1
-    assert not limits_pill._settings.isHidden()
-
-
-def test_beamline_state_pill_first_expand_uses_config_class_without_rebuild(
-    qtbot, mocked_client, monkeypatch
-):
-    limits_pill = create_widget(
-        qtbot, BeamlineStatePill, state_name="limits", title="Limits", client=mocked_client
-    )
-    set_model_calls = []
-    original_set_model = pill_module.PydanticWidgetForm.set_model
-
-    def set_model_spy(self, model, data=None):
-        set_model_calls.append(model)
-        return original_set_model(self, model, data=data)
-
-    monkeypatch.setattr(pill_module.PydanticWidgetForm, "set_model", set_model_spy)
-    limits_pill.set_state_config(
-        {
-            "name": "limits",
-            "title": "Limits",
-            "state_type": "DeviceWithinLimitsState",
-            "parameters": {
-                "device": "samx",
-                "signal": "samx",
-                "low_limit": 0.0,
-                "high_limit": 10.0,
-                "tolerance": 0.1,
-            },
-        }
-    )
-
-    limits_pill.set_expanded(True)
-    assert limits_pill._config_form is not None
-    assert set_model_calls == []
-
-
-def test_beamline_state_pill_reverts_changed_settings(qtbot, mocked_client):
-    limits_pill = create_widget(
-        qtbot, BeamlineStatePill, state_name="limits", title="Limits", client=mocked_client
-    )
-    limits_pill.set_state_config(
-        {
-            "name": "limits",
-            "title": "Limits",
-            "state_type": "DeviceWithinLimitsState",
-            "parameters": {
-                "device": "samx",
-                "signal": "samx",
-                "low_limit": 0.0,
-                "high_limit": 10.0,
-                "tolerance": 0.1,
-            },
-        }
-    )
-
-    limits_pill.set_expanded(True)
-    assert limits_pill._config_form is not None
-    low_limit = limits_pill._config_form.input_widget("low_limit")
-    low_limit.setValue(-5.0)
-
-    assert limits_pill._update_button.isEnabled()
-    assert limits_pill._config_form.field_widget("low_limit").property("beamlineStateDirty") is True
-
-    limits_pill._revert_button.click()
-
-    assert low_limit.value() == 0.0
-    assert not limits_pill._update_button.isEnabled()
-    assert not limits_pill._revert_button.isEnabled()
-    assert (
-        limits_pill._config_form.field_widget("low_limit").property("beamlineStateDirty") is False
-    )
-
-
-def test_beamline_state_pill_does_not_override_themed_input_controls(qtbot, mocked_client):
-    limits_pill = create_widget(
-        qtbot, BeamlineStatePill, state_name="limits", title="Limits", client=mocked_client
-    )
-    limits_pill.set_state_config(
-        {
-            "name": "limits",
-            "title": "Limits",
-            "state_type": "DeviceWithinLimitsState",
-            "parameters": {
-                "device": "samx",
-                "signal": "samx",
-                "low_limit": 0.0,
-                "high_limit": 10.0,
-                "tolerance": 0.1,
-            },
-        }
-    )
-    limits_pill.set_expanded(True)
-
-    stylesheet = limits_pill.styleSheet()
-
-    assert "QAbstractSpinBox" not in stylesheet
-    assert "QComboBox" not in stylesheet
-    assert "QCheckBox::indicator" not in stylesheet
-
-
-def test_beamline_state_manager_adds_and_removes_pills(qtbot, mocked_client):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    beamline_state_manager.update_available_states(
-        {
-            "states": [
-                {
-                    "name": "shutter_open",
-                    "title": "Shutter",
-                    "state_type": "ShutterState",
-                    "parameters": {},
-                },
-                {
-                    "name": "limits",
-                    "title": "Limits",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {},
-                },
-            ]
-        },
-        {},
-    )
-
-    assert sorted(beamline_state_manager._state_pills) == ["limits", "shutter_open"]
-    assert beamline_state_manager._model.rowCount() == 2
-    assert beamline_state_manager._state_pills["shutter_open"]._name_label.text() == "Shutter"
-    assert not beamline_state_manager._empty_label.isVisible()
-
-    beamline_state_manager.update_available_states(
-        {
-            "states": [
-                {
-                    "name": "limits",
-                    "title": "Limits",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {},
-                }
-            ]
-        },
-        {},
-    )
-
-    assert sorted(beamline_state_manager._state_pills) == ["limits"]
-    assert beamline_state_manager._model.rowCount() == 1
-
-
-def test_beamline_state_manager_ignores_unchanged_available_states(qtbot, mocked_client):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    content = {
-        "states": [
-            {
-                "name": "limits",
-                "title": "Limits",
-                "state_type": "DeviceWithinLimitsState",
-                "parameters": {
-                    "device": "samx",
-                    "signal": "samx",
-                    "low_limit": 0.0,
-                    "high_limit": 10.0,
-                    "tolerance": 0.1,
-                },
-            }
-        ]
-    }
-
-    beamline_state_manager.update_available_states(content, {})
-    pill = beamline_state_manager._state_pills["limits"]
-
-    beamline_state_manager.update_available_states(content, {})
-
-    assert beamline_state_manager._state_pills["limits"] is pill
-    assert pill._config_form is None
-
-
-def test_beamline_state_manager_adds_state_without_recreating_existing_pills(qtbot, mocked_client):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    limits_state = {
-        "name": "limits",
-        "title": "Limits",
-        "state_type": "DeviceWithinLimitsState",
-        "parameters": {
-            "device": "samx",
-            "signal": "samx",
-            "low_limit": 0.0,
-            "high_limit": 10.0,
-            "tolerance": 0.1,
-        },
-    }
-    shutter_state = {
-        "name": "shutter_open",
-        "title": "Shutter",
-        "state_type": "ShutterState",
-        "parameters": {},
-    }
-
-    beamline_state_manager.update_available_states({"states": [limits_state]}, {})
-    pill = beamline_state_manager._state_pills["limits"]
-    pill.set_expanded(True)
-    config_form = pill._config_form
-
-    beamline_state_manager.update_available_states({"states": [limits_state, shutter_state]}, {})
-
-    assert beamline_state_manager._state_pills["limits"] is pill
-    assert pill._config_form is config_form
-    assert pill.is_expanded()
-    assert sorted(beamline_state_manager._state_pills) == ["limits", "shutter_open"]
-
-
-def test_beamline_state_manager_uses_valid_horizontal_size_hints(qtbot, mocked_client):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    beamline_state_manager.update_available_states(
-        {
-            "states": [
-                {
-                    "name": "limits",
-                    "title": "Limits",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {
-                        "device": "samx",
-                        "signal": "samx",
-                        "low_limit": 0.0,
-                        "high_limit": 10.0,
-                        "tolerance": 0.1,
-                    },
-                }
-            ]
-        },
-        {},
-    )
-
-    index = beamline_state_manager._model.index_for_name("limits")
-    hint = beamline_state_manager._delegate.sizeHint(QStyleOptionViewItem(), index)
-
-    assert beamline_state_manager.minimumWidth() == 0
-    assert beamline_state_manager._view.minimumWidth() == 0
-    assert beamline_state_manager._view.horizontalScrollBarPolicy() == Qt.ScrollBarAlwaysOff
-    assert hint.width() > 0
-    assert hint.height() >= 58
-
-
-def test_beamline_state_manager_header_click_expands_pill_once(qtbot, mocked_client):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    beamline_state_manager.update_available_states(
-        {
-            "states": [
-                {
-                    "name": "limits",
-                    "title": "Limits",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {"device": "samx"},
-                }
-            ]
-        },
-        {},
-    )
-
-    pill = beamline_state_manager._state_pills["limits"]
-    assert pill._settings.isHidden()
-
-    qtbot.mouseClick(pill._header, Qt.MouseButton.LeftButton)
-
-    assert not pill._settings.isHidden()
-
-
-def test_beamline_state_manager_preserves_expanded_pill_on_refresh(qtbot, mocked_client):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    state = {
-        "name": "limits",
-        "title": "Limits",
-        "state_type": "DeviceWithinLimitsState",
-        "parameters": {"device": "samx", "high_limit": 10.0},
-    }
-    beamline_state_manager.update_available_states({"states": [state]}, {})
-
-    beamline_state_manager._state_pills["limits"].set_expanded(True)
-    beamline_state_manager.update_available_states({"states": [state]}, {})
-
-    assert beamline_state_manager._state_pills["limits"].is_expanded()
-    assert not beamline_state_manager._state_pills["limits"]._settings.isHidden()
-
-
-def test_beamline_state_manager_propagates_idle_card_background(qtbot, mocked_client):
-    idle_card_manager = create_widget(
-        qtbot, BeamlineStateManager, client=mocked_client, idle_card_background=True
-    )
-    idle_card_manager.update_available_states(
-        {
-            "states": [
-                {
-                    "name": "limits",
-                    "title": "Limits",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {"device": "samx"},
-                }
-            ]
-        },
-        {},
-    )
-
-    assert idle_card_manager._state_pills["limits"]._idle_card_background is True
-
-    idle_card_manager.idle_card_background = False
-
-    assert idle_card_manager._state_pills["limits"]._idle_card_background is False
-
-
-def test_beamline_state_manager_filters_status(qtbot, mocked_client):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    beamline_state_manager.update_available_states(
-        {
-            "states": [
-                {
-                    "name": "shutter_open",
-                    "title": "Shutter",
-                    "state_type": "ShutterState",
-                    "parameters": {"device": "samy"},
-                },
-                {
-                    "name": "limits",
-                    "title": "Limits",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {"device": "samx"},
-                },
-            ]
-        },
-        {},
-    )
-
-    assert isinstance(beamline_state_manager._toolbar, ModularToolBar)
-    assert not beamline_state_manager._toolbar.components.exists("refresh")
-
-    beamline_state_manager._state_pills["limits"].update_state(
-        {"name": "limits", "status": "valid", "label": "Within limits."}, {}
-    )
-    beamline_state_manager._state_pills["shutter_open"].update_state(
-        {"name": "shutter_open", "status": "invalid", "label": "Closed."}, {}
-    )
-    beamline_state_manager._selected_statuses = {"valid"}
-    beamline_state_manager._apply_filters()
-
-    assert not beamline_state_manager._hidden_summary.isHidden()
-    assert "1 state is hidden" in beamline_state_manager._hidden_summary.text()
-    assert not beamline_state_manager._view.isRowHidden(
-        beamline_state_manager._model.index_for_name("limits").row()
-    )
-    assert beamline_state_manager._view.isRowHidden(
-        beamline_state_manager._model.index_for_name("shutter_open").row()
-    )
-
-    beamline_state_manager._hidden_summary.click()
-
-    assert not beamline_state_manager._view.isRowHidden(
-        beamline_state_manager._model.index_for_name("shutter_open").row()
-    )
-    assert shiboken6.isValid(beamline_state_manager._state_pills["shutter_open"])
-
-    beamline_state_manager._hidden_summary.click()
-
-    assert beamline_state_manager._view.isRowHidden(
-        beamline_state_manager._model.index_for_name("shutter_open").row()
-    )
-    assert shiboken6.isValid(beamline_state_manager._state_pills["shutter_open"])
-
-
-def test_beamline_state_manager_status_filter_reacts_to_state_changes(qtbot, mocked_client):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    beamline_state_manager.update_available_states(
-        {
-            "states": [
-                {
-                    "name": "limits",
-                    "title": "Limits",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {"device": "samx"},
-                }
-            ]
-        },
-        {},
-    )
-
-    beamline_state_manager._selected_statuses = {"valid"}
-    beamline_state_manager._state_pills["limits"].update_state(
-        {"name": "limits", "status": "valid", "label": "Within limits."}, {}
-    )
-
-    assert beamline_state_manager._hidden_summary.isHidden()
-
-    beamline_state_manager._state_pills["limits"].update_state(
-        {"name": "limits", "status": "invalid", "label": "Out of limits."}, {}
-    )
-
-    assert not beamline_state_manager._hidden_summary.isHidden()
-    assert beamline_state_manager._view.isRowHidden(
-        beamline_state_manager._model.index_for_name("limits").row()
-    )
-
-
-def test_beamline_state_manager_filters_devices(qtbot, mocked_client, monkeypatch):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    beamline_state_manager.update_available_states(
-        {
-            "states": [
-                {
-                    "name": "samx_limits",
-                    "title": "samx",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {"device": "samx"},
-                },
-                {
-                    "name": "samy_limits",
-                    "title": "samy",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {"device": "samy"},
-                },
-            ]
-        },
-        {},
-    )
-
-    beamline_state_manager._device_filter_text = "samx"
-    beamline_state_manager._apply_filters()
-
-    assert not beamline_state_manager._hidden_summary.isHidden()
-    assert "1 state is hidden" in beamline_state_manager._hidden_summary.text()
-
-    captured = {}
-
-    class FakeDeviceFilterDialog:
-        def __init__(self, devices, selected_devices, device_filter_text, parent):
-            captured["devices"] = devices
-            captured["selected_devices"] = selected_devices
-            captured["device_filter_text"] = device_filter_text
-            captured["parent"] = parent
-
-        def exec(self):
-            return 0
-
-    monkeypatch.setattr(pill_module, "DeviceFilterDialog", FakeDeviceFilterDialog)
-
-    beamline_state_manager.open_device_filter_dialog()
-
-    assert captured["devices"] == ["samx", "samy"]
-    assert captured["device_filter_text"] == "samx"
-    assert captured["parent"] is beamline_state_manager
-
-
-def test_beamline_state_manager_updates_state_parameters(qtbot, mocked_client):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-    beamline_state_manager.update_available_states(
-        {
-            "states": [
-                {
-                    "name": "limits",
-                    "title": "Limits",
-                    "state_type": "DeviceWithinLimitsState",
-                    "parameters": {
-                        "device": "samx",
-                        "signal": "samx",
-                        "low_limit": 0.0,
-                        "high_limit": 10.0,
-                        "tolerance": 0.1,
-                    },
-                }
-            ]
-        },
-        {},
-    )
-
-    class StateClient:
-        def __init__(self):
-            self.parameters = None
-
-        def update_parameters(self, **kwargs):
-            self.parameters = kwargs
-
-    class StateManager:
-        def __init__(self):
-            self.limits = StateClient()
-
-    mocked_client.beamline_states = StateManager()
-    pill = beamline_state_manager._state_pills["limits"]
-    pill.set_expanded(True)
-    high_limit = pill._config_form.input_widget("high_limit")
-    high_limit.setValue(20.0)
-
-    assert pill._update_button.isEnabled()
-
-    beamline_state_manager._update_state_parameters("limits", pill.edited_config())
-
-    assert mocked_client.beamline_states.limits.parameters == {
-        "device": "samx",
-        "signal": "samx",
-        "low_limit": 0.0,
-        "high_limit": 20.0,
-        "tolerance": 0.1,
-    }
-    assert not pill._update_button.isEnabled()
-    assert pill._config_form.field_widget("high_limit").property("beamlineStateDirty") is False
-
-
-def test_beamline_state_manager_removes_state(qtbot, mocked_client, monkeypatch):
-    beamline_state_manager = create_widget(qtbot, BeamlineStateManager, client=mocked_client)
-
-    class StateManager:
-        def __init__(self):
-            self.deleted = None
-
-        def delete(self, state_name):
-            self.deleted = state_name
-
-    mocked_client.beamline_states = StateManager()
-    monkeypatch.setattr(
-        QMessageBox, "question", lambda *args, **kwargs: QMessageBox.StandardButton.Yes
-    )
-
-    beamline_state_manager._remove_state_requested("limits")
-
-    assert mocked_client.beamline_states.deleted == "limits"
-
-
-def test_add_beamline_state_dialog_uses_generated_widgets_and_normalizes_name(qtbot, mocked_client):
-    add_state_dialog = create_widget(qtbot, AddBeamlineStateDialog, client=mocked_client)
-    limits_index = add_state_dialog._type_combo.findText(bl_states.DeviceWithinLimitsState.__name__)
-    assert limits_index >= 0
-    add_state_dialog._type_combo.setCurrentIndex(limits_index)
-
-    assert add_state_dialog._config_form.model is bl_states.DeviceWithinLimitsState.CONFIG_CLASS
-
-    name = add_state_dialog._config_form.input_widget("name")
-    device = add_state_dialog._config_form.input_widget("device")
-    signal = add_state_dialog._config_form.input_widget("signal")
-    low_limit = add_state_dialog._config_form.field_widget("low_limit")
-    high_limit = add_state_dialog._config_form.field_widget("high_limit")
-
-    name.setText("samx-limits")
-    WidgetIO.set_value(device, "samx")
-    WidgetIO.set_value(signal, "samx")
-    low_limit.checkbox.setChecked(True)
-    high_limit.checkbox.setChecked(True)
-    high_limit.value_widget.setValue(15.0)
-
-    config = add_state_dialog.config()
-
-    assert config.name == "samx_limits"
-    assert config.device == "samx"
-    assert config.signal == "samx"
-    assert config.low_limit == 0.0
-    assert config.high_limit == 15.0
-
-
-def test_add_beamline_state_dialog_generates_name_only_after_valid_device_selection(
-    qtbot, mocked_client
-):
-    add_state_dialog = create_widget(qtbot, AddBeamlineStateDialog, client=mocked_client)
-    name = add_state_dialog._config_form.input_widget("name")
-    device = add_state_dialog._config_form.input_widget("device")
-
-    device.setCurrentText("s")
-
-    assert name.text() == ""
-
-    device.set_device("samx")
-
-    assert name.text() == "samx_device_within_limits_state"
-
-
-def test_add_beamline_state_dialog_switches_state_type_without_collapsing(qtbot, mocked_client):
-    add_state_dialog = create_widget(qtbot, AddBeamlineStateDialog, client=mocked_client)
-    initial_height = add_state_dialog.height()
-    limits_index = add_state_dialog._type_combo.findText("DeviceWithinLimitsState")
-    assert limits_index >= 0
-    shutter_index = add_state_dialog._type_combo.findText("ShutterState")
-    assert shutter_index >= 0
-
-    add_state_dialog._type_combo.setCurrentIndex(shutter_index)
-    qtbot.wait(0)
-
-    assert add_state_dialog._config_form.model is bl_states.DeviceStateConfig
-    assert add_state_dialog._config_form_host.count() == 1
-    assert not add_state_dialog._config_form.isHidden()
-    assert not add_state_dialog._buttons.isHidden()
-    assert add_state_dialog.sizeHint().height() > add_state_dialog._buttons.sizeHint().height()
-    assert add_state_dialog.minimumWidth() == 280
-    assert add_state_dialog.maximumWidth() > add_state_dialog.minimumWidth()
-    assert add_state_dialog.minimumHeight() == add_state_dialog.maximumHeight()
-
-    add_state_dialog._type_combo.setCurrentIndex(limits_index)
-    qtbot.wait(0)
-
-    assert add_state_dialog._config_form.model is bl_states.DeviceWithinLimitsState.CONFIG_CLASS
-    assert add_state_dialog.height() >= initial_height
-    assert add_state_dialog.minimumHeight() == add_state_dialog.maximumHeight()
-
-
-def test_add_beamline_state_dialog_cleanup_deletes_device_widgets(qtbot, mocked_client):
-    add_state_dialog = create_widget(qtbot, AddBeamlineStateDialog, client=mocked_client)
-    device = add_state_dialog._config_form.input_widget("device")
-    signal = add_state_dialog._config_form.input_widget("signal")
-
-    add_state_dialog.reject()
-    assert shiboken6.isValid(device)
-    assert shiboken6.isValid(signal)
-
-    add_state_dialog.cleanup()
-    QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
-
-    assert not shiboken6.isValid(device)
-    assert not shiboken6.isValid(signal)

tests/unit_tests/test_bec_connector.py

@@ -6,7 +6,6 @@ from qtpy.QtCore import QObject
 from qtpy.QtWidgets import QApplication, QWidget
 
 from bec_widgets.utils.bec_connector import BECConnector
-from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeProperty
 from bec_widgets.utils.error_popups import SafeSlot as Slot
 
@@ -16,9 +15,6 @@ from .client_mocks import mocked_client
 class BECConnectorQObject(BECConnector, QObject): ...
 
 
-class _CleanupBroadcastWidget(BECWidget, QWidget): ...
-
-
 @pytest.fixture
 def bec_connector(mocked_client):
     connector = BECConnectorQObject(client=mocked_client)
@@ -150,28 +146,6 @@ def test_bec_connector_change_object_name(bec_connector):
     assert not any(obj.objectName() == previous_name for obj in all_objects)
 
 
-def test_bec_widget_cleanup_broadcasts_after_children_are_unregistered(mocked_client, qtbot):
-    parent = _CleanupBroadcastWidget(client=mocked_client, object_name="cleanup_parent")
-    child = _CleanupBroadcastWidget(
-        parent=parent, client=mocked_client, object_name="cleanup_child"
-    )
-    qtbot.addWidget(parent)
-
-    observed_connections = []
-    parent.rpc_register.callbacks.append(
-        lambda connections: observed_connections.append(set(connections))
-    )
-
-    parent.close()
-
-    assert parent._destroyed is True
-    assert child.gui_id not in parent.rpc_register.list_all_connections()
-    assert all(
-        parent.gui_id in snapshot or child.gui_id not in snapshot
-        for snapshot in observed_connections
-    )
-
-
 def test_bec_connector_export_settings():
 
     class MyWidget(BECConnector, QWidget):

tests/unit_tests/test_bec_dispatcher.py

@@ -5,7 +5,7 @@ from unittest import mock
 
 import pytest
 from bec_lib import service_config
-from bec_lib.messages import GUIInstructionMessage, ScanMessage
+from bec_lib.messages import ScanMessage
 from bec_lib.serialization import MsgpackSerialization
 
 from bec_widgets.utils.bec_dispatcher import BECDispatcher, QtRedisConnector, QtThreadSafeCallback
@@ -213,49 +213,3 @@ def test_dispatcher_2_topic_same_cb_with_boundmethod(
 
     send_msg_event.set()
     qtbot.wait(10)
-
-
-def test_qt_redis_connector_logs_rpc_before_qt_callback(monkeypatch):
-    info_mock = mock.MagicMock()
-    warning_mock = mock.MagicMock()
-    monkeypatch.setattr("bec_widgets.utils.bec_dispatcher.logger.info", info_mock)
-    monkeypatch.setattr("bec_widgets.utils.bec_dispatcher.logger.warning", warning_mock)
-
-    def callback(_msg, _metadata):
-        pass
-
-    cb = QtThreadSafeCallback(callback)
-    connector = QtRedisConnector("localhost:1", mock.MagicMock())
-    rpc_msg = GUIInstructionMessage(
-        action="set_value",
-        parameter={"args": [1], "kwargs": {"source": "test"}, "gui_id": "ring"},
-        metadata={
-            "request_id": "dispatcher-request",
-            "receiver": "gui",
-            "object_name": "progressbar",
-            "timeout": 0.1,
-            "sent_at": 1.0,
-            "deadline": 1.1,
-        },
-    )
-
-    try:
-        connector._execute_callback(cb, {"data": rpc_msg}, {})
-
-        info_mock.assert_called_once()
-        info_message = info_mock.call_args.args[0]
-        assert "GUI RPC dispatcher received request before Qt callback emit" in info_message
-        assert "request_id=dispatcher-request" in info_message
-        assert "method=set_value" in info_message
-        assert "receiver=gui" in info_message
-        assert "target_gui_id=ring" in info_message
-        assert "object_name=progressbar" in info_message
-        assert "timeout=0.1" in info_message
-        assert "stale_on_dispatch=True" in info_message
-
-        warning_mock.assert_called_once()
-        warning_message = warning_mock.call_args.args[0]
-        assert "received request after client timeout deadline" in warning_message
-        assert "request_id=dispatcher-request" in warning_message
-    finally:
-        connector.shutdown()

tests/unit_tests/test_client_utils.py

@@ -1,19 +1,10 @@
-import signal
-import subprocess
 from contextlib import contextmanager
 from unittest import mock
 
 import pytest
 
 from bec_widgets.cli.client import BECDockArea
-from bec_widgets.cli.client_utils import (
-    GRACEFUL_SERVER_SHUTDOWN_RPC_TIMEOUT,
-    OUTPUT_READER_STOP_EVENT_ATTR,
-    BECGuiClient,
-    _join_process_output_thread,
-    _start_plot_process,
-)
-from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCResponseTimeoutError, rpc_timeout
+from bec_widgets.cli.client_utils import BECGuiClient, _start_plot_process
 
 
 @pytest.fixture
@@ -229,7 +220,7 @@ def test_client_utils_new_starts_server_when_not_alive():
         with mock.patch("bec_widgets.cli.client_utils.wait_for_server", _no_wait_for_server):
             with (
                 mock.patch.object(gui, "_check_if_server_is_alive", return_value=False),
-                mock.patch.object(gui, "show") as mock_start,
+                mock.patch.object(gui, "start") as mock_start,
             ):
                 gui.new(wait=False, startup_profile=None)
 
@@ -266,109 +257,3 @@ def test_client_utils_delete_falls_back_to_direct_close():
         gui.delete("dock")
 
     widget._run_rpc.assert_called_once_with("close")
-
-
-def test_client_utils_gui_client_set_rpc_timeout():
-    gui = BECGuiClient()
-    assert gui._rpc_timeout == 60
-
-    gui.set_rpc_timeout(10)
-    assert gui._rpc_timeout == 10
-
-
-def test_client_utils_kill_server_waits_for_process_before_joining_output_thread():
-    gui = BECGuiClient()
-    gui._client = mock.MagicMock()
-    gui._process = mock.MagicMock(pid=123, stdout=None, stderr=None)
-    gui._process.poll.return_value = None
-    order = []
-    gui._process.wait.side_effect = lambda timeout: order.append("wait")
-    gui._process_output_processing_thread = mock.MagicMock()
-    gui._process_output_processing_thread.join.side_effect = lambda timeout: order.append("join")
-    gui._process_output_processing_thread.is_alive.return_value = False
-
-    with (
-        mock.patch.object(gui, "_request_server_shutdown", return_value=False),
-        mock.patch("bec_widgets.cli.client_utils.os.getpgid", return_value=123),
-        mock.patch("bec_widgets.cli.client_utils.os.killpg") as killpg,
-    ):
-        gui.kill_server()
-
-    killpg.assert_called_once_with(123, signal.SIGTERM)
-    assert order == ["wait", "join"]
-    assert gui._process is None
-    assert gui._process_output_processing_thread is None
-
-
-def test_client_utils_kill_server_requests_graceful_shutdown_before_signal():
-    gui = BECGuiClient()
-    gui._client = mock.MagicMock()
-    process = mock.MagicMock(stdout=None, stderr=None)
-    process.poll.return_value = None
-    gui._process = process
-    gui._process_output_processing_thread = mock.MagicMock()
-    gui._process_output_processing_thread.is_alive.return_value = False
-    launcher = mock.MagicMock()
-
-    with (
-        mock.patch.object(
-            BECGuiClient, "launcher", new_callable=mock.PropertyMock
-        ) as launcher_prop,
-        mock.patch("bec_widgets.cli.client_utils.os.killpg") as killpg,
-    ):
-        launcher_prop.return_value = launcher
-        gui.kill_server()
-
-    launcher._run_rpc.assert_called_once_with(
-        "system.shutdown", wait_for_rpc_response=True, timeout=GRACEFUL_SERVER_SHUTDOWN_RPC_TIMEOUT
-    )
-    process.wait.assert_called_once_with(timeout=5)
-    killpg.assert_not_called()
-    assert gui._process is None
-    assert gui._process_output_processing_thread is None
-
-
-def test_client_utils_kill_server_kills_process_group_after_timeout():
-    gui = BECGuiClient()
-    gui._client = mock.MagicMock()
-    process = mock.MagicMock(pid=123, stdout=None, stderr=None, args=["bec-gui-server"])
-    process.poll.return_value = None
-    process.wait.side_effect = [subprocess.TimeoutExpired(cmd="bec-gui-server", timeout=10), None]
-    gui._process = process
-
-    with (
-        mock.patch.object(gui, "_request_server_shutdown", return_value=False),
-        mock.patch("bec_widgets.cli.client_utils.os.getpgid", return_value=123),
-        mock.patch("bec_widgets.cli.client_utils.os.killpg") as killpg,
-        mock.patch("bec_widgets.cli.client_utils.subprocess.run") as run,
-    ):
-        run.return_value.stdout = "PID PPID PGID STAT COMMAND\n123 1 123 S bec-gui-server"
-        gui.kill_server()
-
-    assert killpg.call_args_list == [mock.call(123, signal.SIGTERM), mock.call(123, signal.SIGKILL)]
-    assert process.wait.call_args_list == [mock.call(timeout=10), mock.call(timeout=10)]
-    run.assert_called_once_with(
-        ["ps", "-o", "pid,ppid,pgid,stat,command", "-g", "123"],
-        check=False,
-        capture_output=True,
-        text=True,
-        timeout=2,
-    )
-
-
-def test_join_process_output_thread_signals_reader_before_closing_streams():
-    process = mock.MagicMock(pid=123, args=["bec-gui-server"])
-    process.stdout = mock.MagicMock()
-    process.stderr = mock.MagicMock()
-    thread = mock.MagicMock()
-    stop_event = mock.MagicMock()
-    setattr(thread, OUTPUT_READER_STOP_EVENT_ATTR, stop_event)
-    thread.is_alive.side_effect = [True, False]
-    logger = mock.MagicMock()
-
-    _join_process_output_thread(process, thread, logger)
-
-    assert thread.join.call_args_list == [mock.call(timeout=2), mock.call(timeout=2)]
-    stop_event.set.assert_called_once_with()
-    process.stdout.close.assert_called_once_with()
-    process.stderr.close.assert_called_once_with()

tests/unit_tests/test_color_utils.py

@@ -2,11 +2,11 @@ import pyqtgraph as pg
 import pytest
 from pydantic import ValidationError
 from qtpy.QtGui import QColor
-from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+from qtpy.QtWidgets import QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_connector import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import Colors, apply_theme, get_theme_name, rgba, theme_color
+from bec_widgets.utils.colors import Colors, apply_theme
 from bec_widgets.widgets.plots.waveform.curve import CurveConfig
 from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
@@ -76,27 +76,10 @@ def test_hex_to_rgba():
         Colors.hex_to_rgba("#FF573")
 
 
-def test_get_theme_name_uses_application_theme():
-    app = QApplication.instance()
-    assert app.theme.theme == "light"
-    assert get_theme_name() == "light"
-
-
-def test_theme_color_uses_theme_color_method():
-    app = QApplication.instance()
-    fallback = QColor("#ffffff")
-    expected = app.theme.color("FG", fallback.name())
-    expected = expected if isinstance(expected, QColor) else QColor(str(expected))
-
-    assert theme_color(app.theme, "FG", fallback).name() == expected.name()
-
-
-def test_theme_color_returns_fallback_without_theme_color_method():
-    assert theme_color("light", "FG", QColor("#ffffff")).name() == "#ffffff"
-
-
-def test_qss_rgba_and_blend_helpers():
-    assert rgba(QColor("#010203"), 300) == "rgba(1, 2, 3, 255)"
+def test_rgba_to_hex():
+    assert Colors.rgba_to_hex(255, 87, 51, 255) == "#FF5733FF"
+    assert Colors.rgba_to_hex(255, 87, 51, 128) == "#FF573380"
+    assert Colors.rgba_to_hex(255, 87, 51) == "#FF5733FF"
 
 
 def test_canonical_colormap_name_case_insensitive():

tests/unit_tests/test_device_config_form_dialog.py

@@ -98,15 +98,11 @@ def test_waiting_display(update_dialog, qtbot):
         mock_spinner_stop.assert_called_once()
 
 
-def test_update_cycle(update_dialog):
+def test_update_cycle(update_dialog, qtbot):
     update = {"enabled": False, "readoutPriority": "baseline", "deviceTags": {"tag"}}
 
     def _mock_send(action="update", config=None, wait_for_response=True, timeout_s=None):
-        device = update_dialog.client.device_manager.devices["test_device"]
-        device._config = {**device._config, **config["test_device"]}  # type: ignore
-
-    update_dialog._q_threadpool = MagicMock()
-    update_dialog._q_threadpool.start.side_effect = lambda runnable: runnable.run()
+        update_dialog.client.device_manager.devices["test_device"]._config = config["test_device"]  # type: ignore
 
     update_dialog._config_helper.send_config_request = MagicMock(side_effect=_mock_send)
     for item in update_dialog._form.enumerate_form_widgets():
@@ -115,7 +111,9 @@ def test_update_cycle(update_dialog):
 
     assert update_dialog.updated_config() == update
     update_dialog.apply()
-    update_dialog._q_threadpool.start.assert_called_once()
+    qtbot.waitUntil(
+        lambda: update_dialog._config_helper.send_config_request.call_count == 1, timeout=100
+    )
 
     update_dialog._config_helper.send_config_request.assert_called_with(
         action="update", config={"test_device": update}, wait_for_response=False

tests/unit_tests/test_device_input_widgets.py

@@ -120,7 +120,7 @@ def test_device_input_combobox_disabled_invalid_has_neutral_border(device_input_
     assert "red" in device_input_combobox.styleSheet()
 
     device_input_combobox.setEnabled(False)
-    assert device_input_combobox.styleSheet() == ""
+    assert "transparent" in device_input_combobox.styleSheet()
 
     device_input_combobox.setEnabled(True)
     assert "red" in device_input_combobox.styleSheet()
@@ -139,23 +139,6 @@ def test_device_input_combobox_cleanup_unregisters_callback(qtbot, mocked_client
         assert widget._callback_id is None
 
 
-def test_device_input_combobox_cleanup_clears_callback_before_unregister(qtbot, mocked_client):
-    widget = DeviceComboBox(client=mocked_client)
-    qtbot.addWidget(widget)
-    callback_id = widget._callback_id
-
-    def assert_callback_cleared(removed_callback_id):
-        assert removed_callback_id == callback_id
-        assert widget._callback_id is None
-
-    with mock.patch.object(
-        mocked_client.callbacks, "remove", side_effect=assert_callback_cleared
-    ) as remove_mock:
-        widget.cleanup()
-
-    remove_mock.assert_called_once_with(callback_id)
-
-
 def test_get_device_from_input_combobox_init(device_input_combobox):
     device_input_combobox.setCurrentIndex(0)
     device_text = device_input_combobox.currentText()

tests/unit_tests/test_device_signal_input.py

@@ -96,22 +96,6 @@ def test_signal_combobox_autocomplete(qtbot, mocked_client):
     assert text_changes[-1] == "manual_signal"
 
 
-def test_signal_combobox_group_headers_are_disabled(qtbot, mocked_client):
-    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
-
-    widget.set_device("samx")
-
-    assert widget.itemText(0) == "Hinted Signals"
-    assert widget.itemText(2) == "Normal Signals"
-    assert widget.itemText(4) == "Config Signals"
-    assert widget.model().item(0).isEnabled() is False
-    assert widget.model().item(2).isEnabled() is False
-    assert widget.model().item(4).isEnabled() is False
-
-    assert widget.set_to_first_enabled() is True
-    assert widget.currentText() == "samx (readback)"
-
-
 def test_signal_combobox_qproperties(device_signal_combobox):
     device_signal_combobox.include_config_signals = False
     device_signal_combobox.include_normal_signals = False
@@ -132,7 +116,7 @@ def test_signal_combobox_disabled_invalid_has_neutral_border(device_signal_combo
     assert "red" in device_signal_combobox.styleSheet()
 
     device_signal_combobox.setEnabled(False)
-    assert device_signal_combobox.styleSheet() == ""
+    assert "transparent" in device_signal_combobox.styleSheet()
 
     device_signal_combobox.setEnabled(True)
     assert "red" in device_signal_combobox.styleSheet()
@@ -212,50 +196,6 @@ def test_device_signal_input_base_cleanup(qtbot, mocked_client):
         assert widget._device_update_register is None
 
 
-def test_signal_combobox_cleanup_clears_callback_before_unregister(qtbot, mocked_client):
-    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
-    callback_id = widget._device_update_register
-
-    def assert_callback_cleared(removed_callback_id):
-        assert removed_callback_id == callback_id
-        assert widget._device_update_register is None
-
-    with mock.patch.object(
-        mocked_client.callbacks, "remove", side_effect=assert_callback_cleared
-    ) as remove_mock:
-        widget.cleanup()
-
-    remove_mock.assert_called_once_with(callback_id)
-
-
-def test_signal_combobox_cleanup_blocks_in_flight_device_update(qtbot, mocked_client):
-    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
-    callback_id = widget._device_update_register
-
-    def trigger_in_flight_update(_):
-        widget.update_signals_from_filters("reload", {})
-
-    with (
-        mock.patch.object(
-            mocked_client.callbacks, "remove", side_effect=trigger_in_flight_update
-        ) as remove_mock,
-        mock.patch.object(widget, "_set_signal_groups") as set_signal_groups,
-    ):
-        widget.cleanup()
-
-    remove_mock.assert_called_once_with(callback_id)
-    set_signal_groups.assert_not_called()
-
-
-def test_signal_combobox_device_update_ignores_update_action(qtbot, mocked_client):
-    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
-
-    with mock.patch.object(widget, "_set_signal_groups") as set_signal_groups:
-        widget.update_signals_from_filters("update", {})
-
-    set_signal_groups.assert_not_called()
-
-
 def test_signal_combobox_get_signal_name_with_item_data(qtbot, device_signal_combobox):
     """Test get_signal_name returns obj_name from item data when available."""
     device_signal_combobox.include_normal_signals = True

tests/unit_tests/test_dock_area.py

@@ -869,14 +869,7 @@ class TestToolbarFunctionality:
 
     def test_toolbar_utils_actions(self, advanced_dock_area):
         """Test utils toolbar actions trigger widget creation."""
-        utils_actions = [
-            "queue",
-            "terminal",
-            "status",
-            "progress_bar",
-            "sbb_monitor",
-            "beamline_state_manager",
-        ]
+        utils_actions = ["queue", "terminal", "status", "progress_bar", "sbb_monitor"]
 
         for action_name in utils_actions:
             with patch.object(advanced_dock_area, "new") as mock_new:
@@ -2435,7 +2428,6 @@ class TestFlatToolbarActions:
             "flat_terminal",
             "flat_bec_shell",
             "flat_sbb_monitor",
-            "flat_beamline_state_manager",
         ]
 
         for action_name in utils_actions:
@@ -2480,7 +2472,6 @@ class TestFlatToolbarActions:
             "flat_terminal": "BecConsole",
             "flat_bec_shell": "BECShell",
             "flat_sbb_monitor": "SBBMonitor",
-            "flat_beamline_state_manager": "BeamlineStateManager",
         }
 
         for action_name, widget_type in utils_action_mapping.items():

tests/unit_tests/test_generated_form_form.py

@@ -1,24 +1,10 @@
 from decimal import Decimal
-from unittest.mock import patch
 
 import pytest
-from bec_lib.device import Device, Signal
-from bec_lib.scan_args import ScanArgument
 from pydantic import BaseModel, Field
-from qtpy.QtWidgets import QCheckBox, QLabel, QLineEdit
 
 from bec_widgets.utils.forms_from_types.forms import PydanticModelForm, TypedForm
 from bec_widgets.utils.forms_from_types.items import FloatDecimalFormItem, IntFormItem, StrFormItem
-from bec_widgets.utils.forms_from_types.pydantic_widget_form import (
-    OptionalValueWidget,
-    PydanticWidgetForm,
-)
-from bec_widgets.utils.widget_io import WidgetIO
-from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
-from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
-from bec_widgets.widgets.utility.spinbox.decimal_spinbox import BECSpinBox
-
-from .client_mocks import mocked_client
 
 # pylint: disable=no-member
 # pylint: disable=missing-function-docstring
@@ -40,80 +26,6 @@ class ExampleSchema(BaseModel):
     decimal_dp_limits_nodefault: Decimal = Field(decimal_places=2, gt=1, le=34.5)
 
 
-class GeneratedBeamlineSchema(BaseModel):
-    name: str = Field(title="State name", description="Unique state identifier.")
-    title: str | None = Field(default=None, title="Display title", description="Visible title.")
-    device: Device | str = Field(title="Device", description="BEC device.")
-    signal: Signal | str | None = Field(
-        default=None, title="Signal", description="Optional device signal."
-    )
-    limit: float | None = Field(
-        default=None,
-        title="Limit",
-        description="Optional numeric limit.",
-        json_schema_extra={"precision": 6},
-    )
-    tolerance: float = Field(
-        default=0.1,
-        title="Tolerance",
-        description="Warning tolerance.",
-        json_schema_extra={"precision": 6},
-    )
-
-    model_config = {"arbitrary_types_allowed": True}
-
-
-class GeneratedPlainSchema(BaseModel):
-    sample_name: str
-
-
-class GeneratedDeviceOnlySchema(BaseModel):
-    device: Device | str = Field(default="", title="Device")
-
-    model_config = {"arbitrary_types_allowed": True}
-
-
-class GeneratedSignalOnlySchema(BaseModel):
-    signal: Signal | str | None = Field(default=None, title="Signal")
-
-    model_config = {"arbitrary_types_allowed": True}
-
-
-class GeneratedScanArgumentSchema(BaseModel):
-    device: Device | str = Field(
-        default="", **ScanArgument(display_name="Device", description="Device source.").model_dump()
-    )
-    signal: Signal | str | None = Field(
-        default=None,
-        **ScanArgument(display_name="Signal", description="Signal source.").model_dump(),
-    )
-    low_limit: float | None = Field(
-        default=None,
-        **ScanArgument(
-            display_name="Low limit",
-            description="Optional lower bound.",
-            reference_units="device",
-            precision=4,
-            ge=-5,
-            le=5,
-        ).model_dump(),
-    )
-    exposure: float = Field(
-        default=0.1,
-        **ScanArgument(
-            display_name="Exposure", tooltip="Camera exposure.", units="s", precision=3, gt=0
-        ).model_dump(),
-    )
-
-    model_config = {"arbitrary_types_allowed": True}
-
-
-class GeneratedRequiredNumericAndOptionalBoolSchema(BaseModel):
-    enabled: bool | None = None
-    retry_count: int
-    scale: float
-
-
 TEST_DICT = {
     "sample_name": "test name",
     "str_optional": "None",
@@ -162,146 +74,3 @@ def test_widget_set_data(model_widget: PydanticModelForm):
         "decimal_dp_limits_nodefault",
     ]:
         assert model_widget.widget_dict[key].getValue() == TEST_DICT[key]
-
-
-def test_pydantic_widget_form_uses_field_metadata_and_type_widgets(qtbot, mocked_client):
-    form = PydanticWidgetForm(GeneratedBeamlineSchema, client=mocked_client)
-    qtbot.addWidget(form)
-
-    assert isinstance(form.input_widget("name"), QLineEdit)
-    assert isinstance(form.input_widget("device"), DeviceComboBox)
-    assert isinstance(form.input_widget("signal"), SignalComboBox)
-    assert isinstance(form.field_widget("limit"), OptionalValueWidget)
-    assert isinstance(form.input_widget("limit"), BECSpinBox)
-    assert form.input_widgets_by_type(DeviceComboBox) == [form.input_widget("device")]
-    assert form.input_widgets_by_type(SignalComboBox) == [form.input_widget("signal")]
-
-    label = form.layout().labelForField(form.field_widget("device"))
-    assert isinstance(label, QLabel)
-    assert label.text() == "Device"
-    assert label.toolTip() == "BEC device."
-    assert form.field_widget("limit").toolTip() == "Optional numeric limit."
-
-
-def test_pydantic_widget_form_device_signal_variants(qtbot, mocked_client):
-    device_signal_form = PydanticWidgetForm(GeneratedBeamlineSchema, client=mocked_client)
-    device_only_form = PydanticWidgetForm(GeneratedDeviceOnlySchema, client=mocked_client)
-    signal_only_form = PydanticWidgetForm(GeneratedSignalOnlySchema, client=mocked_client)
-    qtbot.addWidget(device_signal_form)
-    qtbot.addWidget(device_only_form)
-    qtbot.addWidget(signal_only_form)
-
-    assert isinstance(device_signal_form.input_widget("device"), DeviceComboBox)
-    assert isinstance(device_signal_form.input_widget("signal"), SignalComboBox)
-    assert device_signal_form.input_widget("signal").require_device is True
-
-    assert isinstance(device_only_form.input_widget("device"), DeviceComboBox)
-    assert device_only_form.input_widgets_by_type(SignalComboBox) == []
-
-    assert isinstance(signal_only_form.input_widget("signal"), SignalComboBox)
-    assert signal_only_form.input_widget("signal").require_device is False
-    assert signal_only_form.input_widgets_by_type(DeviceComboBox) == []
-
-
-def test_pydantic_widget_form_plain_field_has_generated_label_and_no_tooltip(qtbot):
-    form = PydanticWidgetForm(GeneratedPlainSchema)
-    qtbot.addWidget(form)
-
-    label = form.layout().labelForField(form.field_widget("sample_name"))
-    assert isinstance(label, QLabel)
-    assert label.text() == "Sample name"
-    assert label.toolTip() == ""
-    assert form.field_widget("sample_name").toolTip() == ""
-
-
-def test_pydantic_widget_form_uses_scan_argument_metadata(qtbot, mocked_client):
-    form = PydanticWidgetForm(GeneratedScanArgumentSchema, client=mocked_client)
-    qtbot.addWidget(form)
-
-    low_limit = form.field_widget("low_limit")
-    low_limit_input = form.input_widget("low_limit")
-    exposure = form.input_widget("exposure")
-
-    low_limit_label = form.layout().labelForField(low_limit)
-    assert isinstance(low_limit_label, QLabel)
-    assert low_limit_label.text() == "Low limit"
-    assert low_limit.toolTip() == "Optional lower bound.\nUnits from: device"
-    assert low_limit_input.toolTip() == "Optional lower bound.\nUnits from: device"
-    assert low_limit_input.decimals() == 4
-    assert low_limit_input.minimum() == pytest.approx(-5)
-    assert low_limit_input.maximum() == pytest.approx(5)
-
-    assert form.field_widget("exposure").toolTip() == "Camera exposure.\nUnits: s"
-    assert exposure.toolTip() == "Camera exposure.\nUnits: s"
-    assert exposure.suffix() == " s"
-    assert exposure.decimals() == 3
-    assert exposure.minimum() == pytest.approx(0.001)
-
-    with patch.object(mocked_client.device_manager.devices.samx, "egu", return_value="mm"):
-        WidgetIO.set_value(form.input_widget("device"), "samx")
-
-    assert low_limit.toolTip() == "Optional lower bound.\nUnits: mm"
-    assert low_limit_input.toolTip() == "Optional lower bound.\nUnits: mm"
-    assert low_limit_input.suffix() == " mm"
-
-
-def test_pydantic_widget_form_cleans_up_on_close(qtbot):
-    form = PydanticWidgetForm(GeneratedPlainSchema)
-    qtbot.addWidget(form)
-
-    form.close()
-
-    assert form.widgets == {}
-    assert form.layout().count() == 0
-
-
-def test_pydantic_widget_form_round_trips_optional_numeric_and_dirty_state(qtbot, mocked_client):
-    form = PydanticWidgetForm(
-        GeneratedBeamlineSchema,
-        client=mocked_client,
-        data={"name": "state_1", "title": "State", "device": "samx", "signal": "samx"},
-    )
-    qtbot.addWidget(form)
-
-    assert form.get_data()["limit"] is None
-
-    limit = form.field_widget("limit")
-    limit.checkbox.setChecked(True)
-    form.input_widget("limit").setValue(5.0)
-
-    assert form.get_data()["limit"] == 5.0
-    assert form.model_instance().limit == 5.0
-    assert "limit" in form.dirty_fields()
-
-    form.reset_to_baseline()
-
-    assert form.get_data()["limit"] is None
-    assert form.dirty_fields() == set()
-
-
-def test_pydantic_widget_form_initializes_required_numeric_fields(qtbot):
-    form = PydanticWidgetForm(GeneratedRequiredNumericAndOptionalBoolSchema)
-    qtbot.addWidget(form)
-
-    assert form.raw_data()["retry_count"] == 0
-    assert form.raw_data()["scale"] == 0.0
-    assert form.model_instance().retry_count == 0
-    assert form.model_instance().scale == 0.0
-
-
-def test_pydantic_widget_form_preserves_optional_bool_none(qtbot):
-    form = PydanticWidgetForm(GeneratedRequiredNumericAndOptionalBoolSchema)
-    qtbot.addWidget(form)
-
-    enabled = form.field_widget("enabled")
-
-    assert isinstance(enabled, OptionalValueWidget)
-    assert isinstance(form.input_widget("enabled"), QCheckBox)
-    assert form.raw_data()["enabled"] is None
-    assert form.model_instance().enabled is None
-
-    enabled.checkbox.setChecked(True)
-    form.input_widget("enabled").setChecked(True)
-
-    assert form.raw_data()["enabled"] is True
-    assert form.model_instance().enabled is True

tests/unit_tests/test_image_view_next_gen.py

@@ -464,6 +464,10 @@ def test_disconnect_clears_async_state(qtbot, mocked_client, monkeypatch):
 
     assert view.subscriptions["main"].async_signal_name is None
     assert view.async_update is False
+    assert view.device == ""
+    assert view.signal == ""
+    assert view.subscriptions["main"].source is None
+    assert view.subscriptions["main"].monitor_type is None
 
 
 ##############################################

tests/unit_tests/test_launch_window.py

@@ -4,9 +4,7 @@ import os
 from unittest import mock
 
 import pytest
-from qtpy.QtCore import QObject
 from qtpy.QtGui import QFontMetrics
-from qtpy.QtWidgets import QWidget
 
 import bec_widgets
 from bec_widgets.applications.launch_window import START_EMPTY_PROFILE_OPTION, LaunchWindow
@@ -18,28 +16,6 @@ from .client_mocks import mocked_client
 base_path = os.path.dirname(bec_widgets.__file__)
 
 
-def _launcher_child_connection(launcher: LaunchWindow, name: str) -> QObject:
-    connection = QObject(parent=launcher)
-    connection.gui_id = f"{launcher.gui_id}:{name}"
-    connection.setObjectName(name)
-    return connection
-
-
-def _top_level_connection(qtbot, name: str) -> QWidget:
-    connection = QWidget()
-    connection.gui_id = name
-    connection.setObjectName(name)
-    qtbot.addWidget(connection)
-    return connection
-
-
-def _unparented_connection(name: str) -> QObject:
-    connection = QObject()
-    connection.gui_id = name
-    connection.setObjectName(name)
-    return connection
-
-
 @pytest.fixture
 def bec_launch_window(qtbot, mocked_client):
     widget = LaunchWindow(client=mocked_client)
@@ -141,20 +117,20 @@ def test_open_dock_area_with_start_empty_option_calls_launch(bec_launch_window):
         (["launcher", "dock_area", "scan_progress_simple", "scan_progress_full"], False),
         (
             ["launcher", "dock_area", "scan_progress_simple", "scan_progress_full", "hover_widget"],
-            False,
+            True,
         ),
-        (["launcher", "external_window"], True),
     ],
 )
-def test_gui_server_turns_off_the_lights(bec_launch_window, qtbot, connection_names, hide):
+def test_gui_server_turns_off_the_lights(bec_launch_window, connection_names, hide):
     connections = {}
     for name in connection_names:
+        conn = mock.MagicMock()
         if name == "hover_widget":
-            conn = _unparented_connection("HoverWidget")
-        elif name == "external_window":
-            conn = _top_level_connection(qtbot, "external_window")
+            conn.parent.return_value = None
+            conn.objectName.return_value = "HoverWidget"
         else:
-            conn = _launcher_child_connection(bec_launch_window, name)
+            conn.parent.return_value = mock.MagicMock()
+            conn.objectName.return_value = bec_launch_window.objectName()
         connections[name] = conn
     with (
         mock.patch.object(bec_launch_window, "show") as mock_show,
@@ -177,23 +153,6 @@ def test_gui_server_turns_off_the_lights(bec_launch_window, qtbot, connection_na
             mock_set_quit_on_last_window_closed.assert_called_once_with(True)
 
 
-def test_launcher_detects_external_main_window(bec_launch_window, qtbot):
-    connection = _top_level_connection(qtbot, "BECMainWindowNoRPC")
-
-    assert bec_launch_window._has_external_window({"window": connection})
-
-
-def test_launcher_logs_unparented_non_window_connection_once(bec_launch_window):
-    connection = _unparented_connection("HoverWidget")
-
-    with mock.patch("bec_widgets.applications.launch_window.logger.warning") as mock_warning:
-        bec_launch_window._turn_off_the_lights({"window": connection})
-        bec_launch_window._turn_off_the_lights({"window": connection})
-
-    mock_warning.assert_called_once()
-    assert "HoverWidget" in mock_warning.call_args.args[0]
-
-
 @pytest.mark.parametrize(
     "connection_names, close_called",
     [
@@ -204,12 +163,11 @@ def test_launcher_logs_unparented_non_window_connection_once(bec_launch_window):
         (["launcher", "dock_area", "scan_progress_simple", "scan_progress_full"], True),
         (
             ["launcher", "dock_area", "scan_progress_simple", "scan_progress_full", "hover_widget"],
-            True,
+            False,
         ),
-        (["launcher", "external_window"], False),
     ],
 )
-def test_launch_window_closes(bec_launch_window, qtbot, connection_names, close_called):
+def test_launch_window_closes(bec_launch_window, connection_names, close_called):
     """
     Test that the close event is handled correctly based on the connections.
     If there are no connections or only the launcher connection, the window should close.
@@ -217,12 +175,13 @@ def test_launch_window_closes(bec_launch_window, qtbot, connection_names, close_
     """
     connections = {}
     for name in connection_names:
+        conn = mock.MagicMock()
         if name == "hover_widget":
-            conn = _unparented_connection("HoverWidget")
-        elif name == "external_window":
-            conn = _top_level_connection(qtbot, "external_window")
+            conn.parent.return_value = None
+            conn.objectName.return_value = "HoverWidget"
         else:
-            conn = _launcher_child_connection(bec_launch_window, name)
+            conn.parent.return_value = mock.MagicMock()
+            conn.objectName.return_value = bec_launch_window.objectName()
         connections[name] = conn
     close_event = mock.MagicMock()
     with mock.patch.object(

tests/unit_tests/test_main_widnow.py

@@ -69,6 +69,11 @@ def test_display_app_id_connected(bec_main_window):
         assert bec_main_window._app_id_label.text() == "App ID: gui_123"
 
 
+def test_event_consumes_status_tip(bec_main_window):
+    status_tip_event = QEvent(QEvent.Type.StatusTip)
+    assert bec_main_window.event(status_tip_event) is True
+
+
 def test_get_launcher_from_qapp_returns_none_when_absent(bec_main_window):
     with patch.object(
         QApplication, "instance", return_value=SimpleNamespace(topLevelWidgets=lambda: [])

tests/unit_tests/test_name_utils.py

@@ -1,13 +0,0 @@
-from bec_widgets.utils.name_utils import pascal_to_snake, sanitize_namespace
-
-
-def test_pascal_to_snake():
-    assert pascal_to_snake("DeviceWithinLimitsState") == "device_within_limits_state"
-    assert pascal_to_snake("BECStatusWidget") == "bec_status_widget"
-
-
-def test_sanitize_namespace():
-    assert sanitize_namespace("scan 1 / user") == "scan_1_user"
-    assert sanitize_namespace(" beamline.state-1 ") == "beamline.state-1"
-    assert sanitize_namespace("   ") is None
-    assert sanitize_namespace(None) is None

tests/unit_tests/test_notifications.py

@@ -40,23 +40,11 @@ def test_apply_theme_updates_colours(qtbot, toast):
     """apply_theme("light") should inject LIGHT palette colours into stylesheets."""
     toast.apply_theme("light")
     assert LIGHT_PALETTE["title"] in toast._title_lbl.styleSheet()
-    assert "border: 1px solid" in toast.trace_view.styleSheet()
-    assert "border:none" not in toast.trace_view.styleSheet()
 
     toast.apply_theme("dark")
     assert DARK_PALETTE["title"] in toast._title_lbl.styleSheet()
 
 
-def test_toast_updates_from_qapp_theme_changed_signal(qtbot, toast):
-    app = QtWidgets.QApplication.instance()
-    assert hasattr(app, "theme")
-
-    app.theme.theme_changed.emit("light")
-    qtbot.wait(10)
-
-    assert LIGHT_PALETTE["title"] in toast._title_lbl.styleSheet()
-
-
 def test_expired_signal(qtbot, toast):
     """Toast must emit expired once its lifetime finishes."""
     with qtbot.waitSignal(toast.expired, timeout=1000):
@@ -263,20 +251,6 @@ def test_theme_propagation(qtbot, centre):
     assert LIGHT_PALETTE["title"] in toast._title_lbl.styleSheet()
 
 
-def test_centre_updates_from_qapp_theme_changed_signal(qtbot, centre):
-    toast = _post(centre, SeverityKind.INFO)
-    centre.apply_theme("dark")
-
-    app = QtWidgets.QApplication.instance()
-    assert hasattr(app, "theme")
-
-    app.theme.theme_changed.emit("light")
-    qtbot.wait(10)
-
-    assert centre._theme == "light"
-    assert LIGHT_PALETTE["title"] in toast._title_lbl.styleSheet()
-
-
 # ------------------------------------------------------------------------
 # NotificationIndicator tests
 # ------------------------------------------------------------------------

tests/unit_tests/test_positioner_box.py

@@ -2,7 +2,7 @@ from unittest import mock
 
 import pytest
 from bec_lib.endpoints import MessageEndpoints
-from bec_lib.messages import VariableMessage
+from bec_lib.messages import ScanQueueMessage
 from qtpy.QtCore import Qt, QTimer
 from qtpy.QtGui import QValidator
 from qtpy.QtWidgets import QPushButton
@@ -34,11 +34,15 @@ class PositionerWithoutPrecision(Positioner):
 def positioner_box(qtbot, mocked_client):
     """Fixture for PositionerBox widget"""
     with mock.patch(
-        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.PositionerBoxBase._check_device_is_valid",
-        return_value=True,
-    ):
-        db = create_widget(qtbot, PositionerBox, device="samx", client=mocked_client)
-        yield db
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.uuid.uuid4"
+    ) as mock_uuid:
+        mock_uuid.return_value = "fake_uuid"
+        with mock.patch(
+            "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.PositionerBoxBase._check_device_is_valid",
+            return_value=True,
+        ):
+            db = create_widget(qtbot, PositionerBox, device="samx", client=mocked_client)
+            yield db
 
 
 def test_positioner_box(positioner_box):
@@ -85,8 +89,16 @@ def test_positioner_box_on_stop(positioner_box):
     """Test on stop button"""
     with mock.patch.object(positioner_box.client.connector, "send") as mock_send:
         positioner_box.on_stop()
-        msg = VariableMessage(value=["samx"])
-        mock_send.assert_called_once_with(MessageEndpoints.stop_devices(), msg)
+        params = {"device": "samx", "rpc_id": "fake_uuid", "func": "stop", "args": [], "kwargs": {}}
+        msg = ScanQueueMessage(
+            scan_type="device_rpc",
+            parameter=params,
+            queue="emergency",
+            metadata={"RID": "fake_uuid", "response": False},
+        )
+        mock_send.assert_called_once_with(
+            MessageEndpoints.scan_queue_request(positioner_box.client.username), msg
+        )
 
 
 def test_positioner_box_setpoint_change(positioner_box):
@@ -127,15 +139,19 @@ def test_positioner_control_line(qtbot, mocked_client):
     Inherits from PositionerBox, but the layout is changed. Check dimensions only
     """
     with mock.patch(
-        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box.PositionerBox._check_device_is_valid",
-        return_value=True,
-    ):
-        db = PositionerControlLine(device="samx", client=mocked_client)
-        qtbot.addWidget(db)
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.uuid.uuid4"
+    ) as mock_uuid:
+        mock_uuid.return_value = "fake_uuid"
+        with mock.patch(
+            "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box.PositionerBox._check_device_is_valid",
+            return_value=True,
+        ):
+            db = PositionerControlLine(device="samx", client=mocked_client)
+            qtbot.addWidget(db)
 
-        assert db.ui.device_box.height() == db.height()
-        assert db.ui.device_box.height() >= db.dimensions[0]
-        assert db.ui.device_box.width() == 600
+            assert db.ui.device_box.height() == db.height()
+            assert db.ui.device_box.height() >= db.dimensions[0]
+            assert db.ui.device_box.width() == 600
 
 
 def test_positioner_box_open_dialog_selection(qtbot, positioner_box):

tests/unit_tests/test_positioner_box_2d.py

@@ -1,8 +1,6 @@
 from unittest import mock
 
 import pytest
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.messages import VariableMessage
 
 from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox2D
 
@@ -14,13 +12,17 @@ from .conftest import create_widget
 def positioner_box_2d(qtbot, mocked_client):
     """Fixture for PositionerBox widget"""
     with mock.patch(
-        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.PositionerBoxBase._check_device_is_valid",
-        return_value=True,
-    ):
-        db = create_widget(
-            qtbot, PositionerBox2D, device_hor="samx", device_ver="samy", client=mocked_client
-        )
-        yield db
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.uuid.uuid4"
+    ) as mock_uuid:
+        mock_uuid.return_value = "fake_uuid"
+        with mock.patch(
+            "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_base.PositionerBoxBase._check_device_is_valid",
+            return_value=True,
+        ):
+            db = create_widget(
+                qtbot, PositionerBox2D, device_hor="samx", device_ver="samy", client=mocked_client
+            )
+            yield db
 
 
 def test_positioner_box_2d(positioner_box_2d):
@@ -80,14 +82,6 @@ def test_positioner_box_setpoint_changes(positioner_box_2d: PositionerBox2D):
         mock_move.assert_called_once_with(100, relative=False)
 
 
-def test_positioner_box_2d_on_stop(positioner_box_2d: PositionerBox2D):
-    """Stop button sends both positioners to the immediate stop endpoint."""
-    with mock.patch.object(positioner_box_2d.client.connector, "send") as mock_send:
-        positioner_box_2d.on_stop()
-        msg = VariableMessage(value=["samx", "samy"])
-        mock_send.assert_called_once_with(MessageEndpoints.stop_devices(), msg)
-
-
 def _hor_buttons(widget: PositionerBox2D):
     return [
         widget.ui.tweak_increase_hor,

tests/unit_tests/test_rpc_base.py

@@ -3,12 +3,10 @@ from unittest.mock import MagicMock
 import pytest
 from bec_lib.device import DeviceBaseWithConfig, Signal
 
-from bec_widgets.cli.rpc import rpc_base as rpc_base_module
 from bec_widgets.cli.rpc.rpc_base import (
     DeletedWidgetError,
     RPCBase,
     RPCReference,
-    RPCResponseTimeoutError,
     _transform_args_kwargs,
 )
 
@@ -53,33 +51,3 @@ def test_transform_args_kwargs():
     )
     assert args == ("full name", "short name", "string_arg", "full name")
     assert kwargs == {"a": "full name", "b": "short name", "c": "string_arg", "d": "full name"}
-
-
-def test_run_rpc_logs_response_timeout(monkeypatch):
-    rpc = RPCBase(gui_id="progress_widget", object_name="progressbar")
-    rpc._rpc_timeout = 0
-    rpc._client = MagicMock()
-
-    info_mock = MagicMock()
-    error_mock = MagicMock()
-    monkeypatch.setattr(rpc_base_module.logger, "info", info_mock)
-    monkeypatch.setattr(rpc_base_module.logger, "error", error_mock)
-
-    with pytest.raises(RPCResponseTimeoutError):
-        rpc._run_rpc("set_value", 42, precision=2, timeout=0)
-
-    publish_msg = rpc._client.connector.set_and_publish.call_args.args[1]
-    assert publish_msg.metadata["method"] == "set_value"
-    assert publish_msg.metadata["target_gui_id"] == "progress_widget"
-    assert publish_msg.metadata["object_name"] == "progressbar"
-    assert publish_msg.metadata["timeout"] == 0
-    assert publish_msg.metadata["deadline"] == publish_msg.metadata["sent_at"]
-    assert info_mock.call_count == 1
-    info_message = info_mock.call_args.args[0]
-    error_mock.assert_called_once()
-    error_message = error_mock.call_args.args[0]
-    assert "GUI RPC response timeout" in error_message
-    assert "method=set_value" in error_message
-    assert "target_gui_id=progress_widget" in error_message
-    assert "object_name=progressbar" in error_message
-    assert "timeout=0" in error_message

tests/unit_tests/test_rpc_server.py

@@ -1,13 +1,11 @@
 import argparse
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import pytest
 from bec_lib.service_config import ServiceConfig
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.applications import companion_app as companion_app_module
 from bec_widgets.applications.companion_app import GUIServer
-from bec_widgets.utils import rpc_server as rpc_server_module
 from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.utils.rpc_server import RegistryNotReadyError, RPCServer, SingleshotRPCRepeat
 
@@ -60,68 +58,6 @@ def test_gui_server_get_service_config(gui_server):
     assert gui_server._get_service_config().config == ServiceConfig().config
 
 
-def test_gui_server_signal_shutdown_closes_widgets_and_quits_app(gui_server):
-    widget = MagicMock()
-    gui_server.app = MagicMock()
-    gui_server.app.topLevelWidgets.return_value = [widget]
-
-    gui_server.request_shutdown()
-
-    widget.close.assert_called_once()
-    gui_server.app.quit.assert_called_once()
-
-
-def test_gui_server_shutdown_is_idempotent(gui_server):
-    gui_server.launcher_window = MagicMock()
-    gui_server.dispatcher = MagicMock()
-
-    with (
-        patch.object(companion_app_module.shiboken6, "isValid", return_value=True),
-        patch.object(companion_app_module.pylsp_server, "is_running", return_value=False),
-    ):
-        gui_server.shutdown()
-        gui_server.shutdown()
-
-    gui_server.launcher_window.close.assert_called_once()
-    gui_server.launcher_window.deleteLater.assert_called_once()
-    gui_server.dispatcher.stop_cli_server.assert_called_once()
-    gui_server.dispatcher.disconnect_all.assert_called_once()
-
-
-def test_rpc_server_system_capabilities_include_shutdown(rpc_server):
-    assert rpc_server.run_system_rpc("system.list_capabilities", [], {}) == {
-        "system.launch_dock_area": True,
-        "system.shutdown": True,
-    }
-
-
-def test_rpc_server_system_shutdown_requests_gui_server_shutdown(rpc_server, qapp):
-    gui_server = MagicMock()
-    qapp.gui_server = gui_server
-
-    rpc_server.run_system_rpc("system.shutdown", [], {})
-    qapp.processEvents()
-
-    gui_server.request_shutdown.assert_called_once()
-    del qapp.gui_server
-
-
-def test_on_rpc_update_system_shutdown_sends_response_before_return(rpc_server):
-    order = []
-    rpc_server.run_system_rpc = MagicMock(side_effect=lambda *_args: order.append("shutdown"))
-    rpc_server.send_response = MagicMock(side_effect=lambda *_args: order.append("response"))
-    rpc_server.serialize_result_and_send = MagicMock()
-
-    rpc_server.on_rpc_update(
-        {"action": "system.shutdown", "parameter": {"args": [], "kwargs": {}}},
-        {"request_id": "shutdown-request", "sent_at": 1.0, "deadline": 10.0, "timeout": 2},
-    )
-
-    assert order == ["shutdown", "response"]
-    rpc_server.send_response.assert_called_once_with("shutdown-request", True, {"result": None})
-    rpc_server.serialize_result_and_send.assert_not_called()
-
-
 def test_singleshot_rpc_repeat_raises_on_repeated_singleshot(rpc_server):
     """
     Test that a singleshot RPC method raises an error when called multiple times.
@@ -155,34 +91,22 @@ def test_serialize_result_and_send_with_singleshot_retry(rpc_server, qtbot, dumm
         # Third call succeeds
         return {"gui_id": dummy.gui_id, "success": True}
 
-    warning_mock = MagicMock()
-
     # Patch serialize_object to control when it raises RegistryNotReadyError
     with patch.object(rpc_server, "serialize_object", side_effect=serialize_side_effect):
         with patch.object(rpc_server, "send_response") as mock_send_response:
-            with patch.object(rpc_server_module.logger, "warning", warning_mock):
-                # Start the serialization process
-                rpc_server._rpc_singleshot_repeats[request_id] = SingleshotRPCRepeat()
-                rpc_server.serialize_result_and_send(request_id, dummy)
+            # Start the serialization process
+            rpc_server._rpc_singleshot_repeats[request_id] = SingleshotRPCRepeat()
+            rpc_server.serialize_result_and_send(request_id, dummy)
 
-                # Verify that serialize_object was called 3 times
-                qtbot.waitUntil(lambda: call_count >= 3, timeout=5000)
+            # Verify that serialize_object was called 3 times
+            qtbot.waitUntil(lambda: call_count >= 3, timeout=5000)
 
-                # Verify that send_response was called with success
-                mock_send_response.assert_called_once()
-                args = mock_send_response.call_args[0]
-                assert args[0] == request_id
-                assert args[1] is True  # accepted=True
-                assert "result" in args[2]
-
-    assert warning_mock.call_count == 2
-    warning_logs = "\n".join(call.args[0] for call in warning_mock.call_args_list)
-    assert "result serialization delayed; retrying" in warning_logs
-    assert "request_id=test_request_123" in warning_logs
-    assert "retry_delay_ms=100" in warning_logs
-    assert "accumulated_delay_ms=100" in warning_logs
-    assert "accumulated_delay_ms=200" in warning_logs
-    assert "max_delay_ms=2000" in warning_logs
+            # Verify that send_response was called with success
+            mock_send_response.assert_called_once()
+            args = mock_send_response.call_args[0]
+            assert args[0] == request_id
+            assert args[1] is True  # accepted=True
+            assert "result" in args[2]
 
 
 def test_serialize_result_and_send_max_delay_exceeded(rpc_server, qtbot, dummy_widget):
@@ -216,56 +140,6 @@ def test_serialize_result_and_send_max_delay_exceeded(rpc_server, qtbot, dummy_w
             assert "Max delay exceeded" in args[2]["error"]
 
 
-def test_send_response_logs_publish_status(rpc_server, monkeypatch):
-    info_mock = MagicMock()
-    error_mock = MagicMock()
-    monkeypatch.setattr(rpc_server_module.logger, "info", info_mock)
-    monkeypatch.setattr(rpc_server_module.logger, "error", error_mock)
-
-    with patch.object(rpc_server.client.connector, "set_and_publish") as publish_mock:
-        rpc_server.send_response("request-ok", True, {"result": None})
-        rpc_server.send_response("request-failed", False, {"error": "bad"})
-
-    assert publish_mock.call_count == 2
-    assert "request_id=request-ok" in info_mock.call_args.args[0]
-    assert "accepted=True" in info_mock.call_args.args[0]
-    assert "request_id=request-failed" in error_mock.call_args.args[0]
-    assert "accepted=False" in error_mock.call_args.args[0]
-
-
-def test_on_rpc_update_logs_late_client_deadline(rpc_server, monkeypatch):
-    info_mock = MagicMock()
-    warning_mock = MagicMock()
-    monkeypatch.setattr(rpc_server_module.logger, "info", info_mock)
-    monkeypatch.setattr(rpc_server_module.logger, "warning", warning_mock)
-
-    rpc_server.rpc_register.get_rpc_by_id = MagicMock()
-    rpc_server.run_rpc = MagicMock(return_value=None)
-    rpc_server.serialize_result_and_send = MagicMock()
-
-    rpc_server.on_rpc_update(
-        {
-            "action": "set_value",
-            "parameter": {"args": [1], "kwargs": {"source": "test"}, "gui_id": "ring"},
-        },
-        {"request_id": "late-request", "timeout": 0.1, "sent_at": 1.0, "deadline": 1.1},
-    )
-
-    received_log = info_mock.call_args_list[0].args[0]
-    executed_log = info_mock.call_args_list[1].args[0]
-    warning_logs = "\n".join(call.args[0] for call in warning_mock.call_args_list)
-
-    assert "GUI RPC server received request" in received_log
-    assert "request_id=late-request" in received_log
-    assert "method=set_value" in received_log
-    assert "target_gui_id=ring" in received_log
-    assert "timeout=0.1" in received_log
-    assert "stale_on_receive=True" in received_log
-    assert "response_after_client_deadline=True" in executed_log
-    assert "received request after client timeout deadline" in warning_logs
-    assert "response is late for client timeout" in warning_logs
-
-
 def test_run_rpc_delegates_to_rpc_content_class(rpc_server):
     class Content:
         USER_ACCESS = ["foo", "mode", "mode.setter"]

tests/unit_tests/test_scan_arg_metadata.py

@@ -1,85 +0,0 @@
-import pytest
-from qtpy.QtWidgets import QDoubleSpinBox, QSpinBox
-
-from bec_widgets.utils.scan_arg_metadata import (
-    apply_numeric_limits,
-    apply_numeric_precision,
-    apply_unit_metadata,
-    device_units,
-    ui_config_from_metadata,
-    unit_tooltip,
-)
-
-from .conftest import create_widget
-
-
-def test_unit_tooltip_and_cleanup(qtbot):
-    widget = create_widget(qtbot, QDoubleSpinBox)
-    item = {"tooltip": "Move start", "reference_units": "device"}
-
-    assert unit_tooltip(item) == "Move start\nUnits from: device"
-
-    apply_unit_metadata(widget, item)
-    assert widget.toolTip() == "Move start\nUnits from: device"
-    assert widget.suffix() == ""
-
-    apply_unit_metadata(widget, item, "mm")
-    assert widget.toolTip() == "Move start\nUnits: mm"
-    assert widget.suffix() == " mm"
-
-    apply_unit_metadata(widget, item, "deg")
-    assert widget.toolTip() == "Move start\nUnits: deg"
-    assert widget.suffix() == " deg"
-
-
-def test_numeric_precision_and_limits(qtbot):
-    float_widget = create_widget(qtbot, QDoubleSpinBox)
-    int_widget = create_widget(qtbot, QSpinBox)
-
-    apply_numeric_precision(float_widget, {"name": "position", "precision": 3})
-    apply_numeric_limits(float_widget, {"ge": -1.5, "lt": 2.0})
-    apply_numeric_limits(int_widget, {"gt": 2, "le": 8})
-
-    assert float_widget.decimals() == 3
-    assert float_widget.minimum() == pytest.approx(-1.5)
-    assert float_widget.maximum() == pytest.approx(1.999)
-    assert int_widget.minimum() == 3
-    assert int_widget.maximum() == 8
-
-
-def test_device_units_uses_egu():
-    class Device:
-        def egu(self):
-            return "mm"
-
-    assert device_units(Device()) == "mm"
-    assert device_units(object()) is None
-
-
-def test_ui_config_from_metadata_matches_scan_control_item_shape():
-    item = ui_config_from_metadata(
-        name="exp_time",
-        input_type="float",
-        default=0.1,
-        metadata={"tooltip": "Exposure", "units": "s", "precision": 3, "ge": 0},
-    )
-
-    assert item == {
-        "arg": False,
-        "name": "exp_time",
-        "type": "float",
-        "display_name": "Exp Time",
-        "tooltip": "Exposure",
-        "default": 0.1,
-        "expert": False,
-        "hidden": False,
-        "precision": 3,
-        "units": "s",
-        "reference_units": None,
-        "reference_limits": None,
-        "gt": None,
-        "ge": 0,
-        "lt": None,
-        "le": None,
-        "alternative_group": None,
-    }

tests/unit_tests/test_scan_control.py

@@ -11,7 +11,6 @@ from bec_widgets.utils.forms_from_types.items import StrFormItem
 from bec_widgets.utils.widget_io import WidgetIO
 from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.control.scan_control import ScanControl
-from bec_widgets.widgets.control.scan_control.scan_info_adapter import ScanInfoAdapter
 
 from .client_mocks import mocked_client
 
@@ -281,359 +280,6 @@ def test_populate_scans(scan_control, mocked_client):
     assert sorted(items) == sorted(expected_scans)
 
 
-def test_scan_control_uses_gui_visibility_and_signature(qtbot, mocked_client):
-    scan_info = {
-        "class": "AnnotatedScan",
-        "base_class": "ScanBase",
-        "arg_input": {
-            "device": "DeviceBase",
-            "start": {
-                "Annotated": {
-                    "type": "float",
-                    "metadata": {
-                        "ScanArgument": {
-                            "display_name": "Start Position",
-                            "description": "Start position",
-                            "tooltip": "Custom start tooltip",
-                            "expert": False,
-                            "alternative_group": None,
-                            "units": None,
-                            "reference_units": "device",
-                        }
-                    },
-                }
-            },
-            "stop": {
-                "Annotated": {
-                    "type": "float",
-                    "metadata": {
-                        "ScanArgument": {
-                            "display_name": None,
-                            "description": "Stop position",
-                            "tooltip": None,
-                            "expert": False,
-                            "alternative_group": None,
-                            "units": None,
-                            "reference_units": "device",
-                        }
-                    },
-                }
-            },
-        },
-        "arg_bundle_size": {"bundle": 3, "min": 1, "max": None},
-        "gui_visibility": {
-            "Movement Parameters": ["steps", "step_size"],
-            "Acquisition Parameters": ["exp_time", "relative"],
-        },
-        "required_kwargs": [],
-        "signature": [
-            {"name": "args", "kind": "VAR_POSITIONAL", "default": "_empty", "annotation": "_empty"},
-            {"name": "steps", "kind": "KEYWORD_ONLY", "default": 10, "annotation": "int"},
-            {
-                "name": "step_size",
-                "kind": "KEYWORD_ONLY",
-                "default": None,
-                "annotation": {
-                    "Annotated": {
-                        "type": "float",
-                        "metadata": {
-                            "ScanArgument": {
-                                "display_name": "Step Size Custom",
-                                "description": "Step size",
-                                "tooltip": "Custom step tooltip",
-                                "expert": False,
-                                "alternative_group": "scan_resolution",
-                                "units": "mm",
-                                "reference_units": None,
-                            }
-                        },
-                    }
-                },
-            },
-            {
-                "name": "exp_time",
-                "kind": "KEYWORD_ONLY",
-                "default": 0,
-                "annotation": {
-                    "Annotated": {
-                        "type": "float",
-                        "metadata": {
-                            "ScanArgument": {
-                                "display_name": None,
-                                "description": None,
-                                "tooltip": "Exposure time",
-                                "expert": False,
-                                "alternative_group": None,
-                                "units": "s",
-                                "reference_units": None,
-                            }
-                        },
-                    }
-                },
-            },
-            {"name": "relative", "kind": "KEYWORD_ONLY", "default": False, "annotation": "bool"},
-            {"name": "kwargs", "kind": "VAR_KEYWORD", "default": "_empty", "annotation": "_empty"},
-        ],
-    }
-    mocked_client.connector.set_and_publish(
-        MessageEndpoints.available_scans(),
-        AvailableResourceMessage(resource={"annotated_scan": scan_info}),
-    )
-
-    widget = ScanControl(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    widget.comboBox_scan_selection.setCurrentText("annotated_scan")
-
-    assert widget.comboBox_scan_selection.count() == 1
-    assert widget.arg_box.layout.itemAtPosition(0, 1).widget().text() == "Start Position"
-    assert "Custom start tooltip\nUnits from: device" in widget.arg_box.widgets[1].toolTip()
-    with patch.object(mocked_client.device_manager.devices.samx, "egu", return_value="mm"):
-        WidgetIO.set_value(widget.arg_box.widgets[0], "samx")
-    assert widget.arg_box.layout.itemAtPosition(0, 1).widget().text() == "Start Position"
-    assert widget.arg_box.widgets[1].suffix() == " mm"
-    assert "Custom start tooltip\nUnits: mm" in widget.arg_box.widgets[1].toolTip()
-    widget.arg_box.widgets[0].setCurrentText("not_a_device")
-    assert widget.arg_box.layout.itemAtPosition(0, 1).widget().text() == "Start Position"
-    assert widget.arg_box.widgets[1].suffix() == ""
-    assert "Custom start tooltip\nUnits from: device" in widget.arg_box.widgets[1].toolTip()
-    assert [box.title() for box in widget.kwarg_boxes] == [
-        "Movement Parameters",
-        "Acquisition Parameters",
-    ]
-    assert widget.kwarg_boxes[0].layout.itemAtPosition(0, 1).widget().text() == "Step Size Custom"
-    assert widget.kwarg_boxes[0].widgets[1].suffix() == " mm"
-    assert "Custom step tooltip\nUnits: mm" in widget.kwarg_boxes[0].widgets[1].toolTip()
-    assert widget.kwarg_boxes[1].layout.itemAtPosition(0, 0).widget().text() == "Exp Time"
-    assert "Exposure time\nUnits: s" in widget.kwarg_boxes[1].widgets[0].toolTip()
-
-
-def test_scan_info_adapter_skips_duplicate_visible_kwargs():
-    scan_info = {
-        "class": "DuplicateScan",
-        "base_class": "ScanBaseV4",
-        "arg_input": {},
-        "arg_bundle_size": {"bundle": 0, "min": None, "max": None},
-        "gui_visibility": {
-            "Scan Parameters": ["relative", "burst_at_each_point"],
-            "Acquisition Parameters": ["exp_time", "burst_at_each_point"],
-        },
-        "signature": [
-            {"name": "relative", "kind": "KEYWORD_ONLY", "default": False, "annotation": "bool"},
-            {
-                "name": "burst_at_each_point",
-                "kind": "KEYWORD_ONLY",
-                "default": 1,
-                "annotation": "int",
-            },
-            {"name": "exp_time", "kind": "KEYWORD_ONLY", "default": 0, "annotation": "float"},
-        ],
-    }
-
-    gui_config = ScanInfoAdapter().build_scan_ui_config(scan_info)
-    groups = {
-        group["name"]: [input_spec["name"] for input_spec in group["inputs"]]
-        for group in gui_config["kwarg_groups"]
-    }
-
-    assert groups == {
-        "Scan Parameters": ["relative", "burst_at_each_point"],
-        "Acquisition Parameters": ["exp_time"],
-    }
-
-
-def test_scan_info_adapter_rejects_unsupported_visible_inputs():
-    scan_info = {
-        "class": "UnsupportedScan",
-        "base_class": "ScanBaseV4",
-        "arg_input": {},
-        "arg_bundle_size": {"bundle": 0, "min": None, "max": None},
-        "gui_visibility": {"Regions": ["regions"]},
-        "signature": [
-            {
-                "name": "regions",
-                "kind": "KEYWORD_ONLY",
-                "default": "_empty",
-                "annotation": {
-                    "Generic": {
-                        "origin": "list",
-                        "args": [
-                            {"Generic": {"origin": "tuple", "args": ["float", "float", "int"]}}
-                        ],
-                    }
-                },
-            }
-        ],
-    }
-
-    gui_config = ScanInfoAdapter().build_scan_ui_config(scan_info)
-    unsupported_inputs = ScanInfoAdapter.unsupported_inputs(gui_config)
-
-    assert [input_spec["name"] for input_spec in unsupported_inputs] == ["regions"]
-    assert ScanInfoAdapter.has_scan_ui_config(scan_info) is False
-
-
-def test_scan_info_adapter_skips_hidden_visible_kwargs():
-    scan_info = {
-        "class": "HiddenScan",
-        "base_class": "ScanBaseV4",
-        "arg_input": {},
-        "arg_bundle_size": {"bundle": 0, "min": None, "max": None},
-        "gui_visibility": {"Acquisition": ["exp_time", "internal_token"]},
-        "signature": [
-            {"name": "exp_time", "kind": "KEYWORD_ONLY", "default": 0, "annotation": "float"},
-            {
-                "name": "internal_token",
-                "kind": "KEYWORD_ONLY",
-                "default": None,
-                "annotation": {
-                    "Annotated": {
-                        "type": "str",
-                        "metadata": {
-                            "ScanArgument": {"display_name": "Internal Token", "hidden": True}
-                        },
-                    }
-                },
-            },
-        ],
-    }
-
-    gui_config = ScanInfoAdapter().build_scan_ui_config(scan_info)
-
-    assert [input_spec["name"] for input_spec in gui_config["kwarg_groups"][0]["inputs"]] == [
-        "exp_time"
-    ]
-
-
-def test_scan_control_propagates_reference_units_across_kwarg_groups(qtbot, mocked_client):
-    scan_info = {
-        "class": "RoundScan",
-        "base_class": "ScanBaseV4",
-        "arg_input": {},
-        "arg_bundle_size": {"bundle": 0, "min": None, "max": None},
-        "gui_visibility": {
-            "Motors": ["motor_1", "motor_2"],
-            "Ring Parameters": ["inner_radius", "outer_radius", "center_1", "center_2"],
-        },
-        "required_kwargs": [],
-        "signature": [
-            {
-                "name": "motor_1",
-                "kind": "POSITIONAL_OR_KEYWORD",
-                "default": "_empty",
-                "annotation": "DeviceBase",
-            },
-            {
-                "name": "motor_2",
-                "kind": "POSITIONAL_OR_KEYWORD",
-                "default": "_empty",
-                "annotation": "DeviceBase",
-            },
-            {
-                "name": "inner_radius",
-                "kind": "POSITIONAL_OR_KEYWORD",
-                "default": "_empty",
-                "annotation": {
-                    "Annotated": {
-                        "type": "float",
-                        "metadata": {
-                            "ScanArgument": {
-                                "display_name": "Inner Radius",
-                                "units": None,
-                                "reference_units": "motor_1",
-                                "ge": 0,
-                            }
-                        },
-                    }
-                },
-            },
-            {
-                "name": "outer_radius",
-                "kind": "POSITIONAL_OR_KEYWORD",
-                "default": "_empty",
-                "annotation": {
-                    "Annotated": {
-                        "type": "float",
-                        "metadata": {
-                            "ScanArgument": {
-                                "display_name": "Outer Radius",
-                                "units": None,
-                                "reference_units": "motor_1",
-                                "ge": 0,
-                            }
-                        },
-                    }
-                },
-            },
-            {
-                "name": "center_1",
-                "kind": "KEYWORD_ONLY",
-                "default": 0,
-                "annotation": {
-                    "Annotated": {
-                        "type": "float",
-                        "metadata": {
-                            "ScanArgument": {
-                                "display_name": "Center Motor 1",
-                                "units": None,
-                                "reference_units": "motor_1",
-                            }
-                        },
-                    }
-                },
-            },
-            {
-                "name": "center_2",
-                "kind": "KEYWORD_ONLY",
-                "default": 0,
-                "annotation": {
-                    "Annotated": {
-                        "type": "float",
-                        "metadata": {
-                            "ScanArgument": {
-                                "display_name": "Center Motor 2",
-                                "units": None,
-                                "reference_units": "motor_2",
-                            }
-                        },
-                    }
-                },
-            },
-        ],
-    }
-    mocked_client.connector.set_and_publish(
-        MessageEndpoints.available_scans(),
-        AvailableResourceMessage(resource={"round_scan": scan_info}),
-    )
-
-    widget = ScanControl(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    widget.comboBox_scan_selection.setCurrentText("round_scan")
-
-    motor_box = widget.kwarg_boxes[0]
-    ring_box = widget.kwarg_boxes[1]
-
-    assert "Units from: motor_1" in ring_box.widgets[0].toolTip()
-    assert ring_box.widgets[0].suffix() == ""
-
-    with patch.object(mocked_client.device_manager.devices.samx, "egu", return_value="mm"):
-        WidgetIO.set_value(motor_box.widgets[0], "samx")
-
-    assert ring_box.widgets[0].suffix() == " mm"
-    assert ring_box.widgets[1].suffix() == " mm"
-    assert ring_box.widgets[2].suffix() == " mm"
-    assert ring_box.widgets[3].suffix() == ""
-    assert "Units: mm" in ring_box.widgets[0].toolTip()
-
-    motor_box.widgets[0].setCurrentText("not_a_device")
-
-    assert ring_box.widgets[0].suffix() == ""
-    assert ring_box.widgets[1].suffix() == ""
-    assert ring_box.widgets[2].suffix() == ""
-    assert "Units from: motor_1" in ring_box.widgets[0].toolTip()
-
-
 def test_current_scan(scan_control, mocked_client):
     current_scan = scan_control.current_scan
     wrong_scan = "error_scan"

tests/unit_tests/test_scan_control_group_box.py

@@ -67,28 +67,28 @@ def test_kwarg_box(qtbot):
     assert kwarg_box.widgets[0].__class__.__name__ == "ScanDoubleSpinBox"
     assert kwarg_box.widgets[0].arg_name == "exp_time"
     assert WidgetIO.get_value(kwarg_box.widgets[0]) == 0
-    assert "Exposure time in seconds" in kwarg_box.widgets[0].toolTip()
+    assert kwarg_box.widgets[0].toolTip() == "Exposure time in seconds"
 
     # Widget 1
     assert kwarg_box.widgets[1].__class__.__name__ == "ScanSpinBox"
     assert kwarg_box.widgets[1].arg_name == "num_points"
     assert WidgetIO.get_value(kwarg_box.widgets[1]) == 1
-    assert "Number of points" in kwarg_box.widgets[1].toolTip()
+    assert kwarg_box.widgets[1].toolTip() == "Number of points"
 
     # Widget 2
     assert kwarg_box.widgets[2].__class__.__name__ == "ScanCheckBox"
     assert kwarg_box.widgets[2].arg_name == "relative"
     assert WidgetIO.get_value(kwarg_box.widgets[2]) == False
     assert (
-        "If True, the motors will be moved relative to their current position"
-        in kwarg_box.widgets[2].toolTip()
+        kwarg_box.widgets[2].toolTip()
+        == "If True, the motors will be moved relative to their current position"
     )
 
     # Widget 3
     assert kwarg_box.widgets[3].__class__.__name__ == "ScanLineEdit"
     assert kwarg_box.widgets[3].arg_name == "scan_type"
     assert WidgetIO.get_value(kwarg_box.widgets[3]) == "line"
-    assert "Type of scan" in kwarg_box.widgets[3].toolTip()
+    assert kwarg_box.widgets[3].toolTip() == "Type of scan"
 
     parameters = kwarg_box.get_parameters()
     assert parameters == {"exp_time": 0, "num_points": 1, "relative": False, "scan_type": "line"}
@@ -146,92 +146,14 @@ def test_arg_box(qtbot):
     assert arg_box.widgets[0].__class__.__name__ == "ScanLineEdit"
     assert arg_box.widgets[0].arg_name == "device"
     assert WidgetIO.get_value(arg_box.widgets[0]) == "samx"
-    assert "Device to scan" in arg_box.widgets[0].toolTip()
+    assert arg_box.widgets[0].toolTip() == "Device to scan"
 
     # Widget 1
     assert arg_box.widgets[1].__class__.__name__ == "ScanDoubleSpinBox"
     assert arg_box.widgets[1].arg_name == "start"
     assert WidgetIO.get_value(arg_box.widgets[1]) == 0
-    assert "Start position" in arg_box.widgets[1].toolTip()
+    assert arg_box.widgets[1].toolTip() == "Start position"
 
     # Widget 2
     assert arg_box.widgets[2].__class__.__name__ == "ScanSpinBox"
     assert arg_box.widgets[2].arg_name
-
-
-def test_spinbox_limits_from_scan_info(qtbot):
-    group_input = {
-        "name": "Kwarg Test",
-        "inputs": [
-            {
-                "arg": False,
-                "name": "exp_time",
-                "type": "float",
-                "display_name": "Exp Time",
-                "tooltip": "Exposure time in seconds",
-                "default": 2.0,
-                "expert": False,
-                "precision": 3,
-                "gt": 1.5,
-                "ge": None,
-                "lt": 5.0,
-                "le": None,
-            },
-            {
-                "arg": False,
-                "name": "num_points",
-                "type": "int",
-                "display_name": "Num Points",
-                "tooltip": "Number of points",
-                "default": 4,
-                "expert": False,
-                "gt": None,
-                "ge": 3,
-                "lt": 9,
-                "le": None,
-            },
-            {
-                "arg": False,
-                "name": "settling_time",
-                "type": "float",
-                "display_name": "Settling Time",
-                "tooltip": "Settling time in seconds",
-                "default": 0.5,
-                "expert": False,
-                "gt": None,
-                "ge": 0.2,
-                "lt": None,
-                "le": 3.5,
-            },
-            {
-                "arg": False,
-                "name": "steps",
-                "type": "int",
-                "display_name": "Steps",
-                "tooltip": "Number of steps",
-                "default": 4,
-                "expert": False,
-                "gt": 0,
-                "ge": None,
-                "lt": None,
-                "le": 10,
-            },
-        ],
-    }
-
-    kwarg_box = ScanGroupBox(box_type="kwargs", config=group_input)
-
-    exp_time = kwarg_box.widgets[0]
-    num_points = kwarg_box.widgets[1]
-    settling_time = kwarg_box.widgets[2]
-    steps = kwarg_box.widgets[3]
-
-    assert exp_time.decimals() == 3
-    assert exp_time.minimum() == 1.501
-    assert exp_time.maximum() == 4.999
-    assert num_points.minimum() == 3
-    assert num_points.maximum() == 8
-    assert settling_time.minimum() == 0.2
-    assert settling_time.maximum() == 3.5
-    assert steps.minimum() == 1
-    assert steps.maximum() == 10

tests/unit_tests/test_toggle.py

@@ -36,26 +36,3 @@ def test_toggle_click(qtbot, toggle):
     qtbot.mouseClick(toggle, Qt.LeftButton)
     toggle.paintEvent(None)
     assert toggle.checked is not init_state
-
-
-def test_toggle_disabled_state_blocks_clicks_and_restores_colors(qtbot, toggle):
-    toggle.checked = True
-    assert toggle._track_color == toggle.active_track_color
-    assert toggle._thumb_color == toggle.active_thumb_color
-
-    toggle.setEnabled(False)
-
-    assert toggle._track_color == toggle._disabled_track_color
-    assert toggle._thumb_color == toggle._disabled_thumb_color
-
-    qtbot.mouseClick(toggle, Qt.LeftButton)
-
-    assert toggle.checked is True
-    assert toggle._track_color == toggle._disabled_track_color
-    assert toggle._thumb_color == toggle._disabled_thumb_color
-
-    toggle.setEnabled(True)
-
-    assert toggle.checked is True
-    assert toggle._track_color == toggle.active_track_color
-    assert toggle._thumb_color == toggle.active_thumb_color

tests/unit_tests/test_widget_io.py

@@ -16,12 +16,8 @@ from qtpy.QtWidgets import (
 )
 
 from bec_widgets.utils.widget_io import WidgetHierarchy, WidgetIO, WidgetTreeNode
-from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
-from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
 from bec_widgets.widgets.utility.toggle.toggle import ToggleSwitch
 
-from .client_mocks import mocked_client
-
 
 @pytest.fixture(scope="function")
 def example_widget(qtbot):
@@ -200,58 +196,6 @@ def test_widget_io_signal(qtbot, example_widget):
     assert changes[-1][1] == False
 
 
-def test_widget_io_device_combobox_handler(qtbot, mocked_client):
-    widget = DeviceComboBox(client=mocked_client)
-    qtbot.addWidget(widget)
-    changes = []
-
-    WidgetIO.connect_widget_change_signal(widget, lambda _widget, value: changes.append(value))
-    WidgetIO.set_value(widget, "samx")
-
-    assert WidgetIO.get_value(widget) == "samx"
-    assert changes[-1] == "samx"
-
-
-def test_widget_io_device_combobox_handler_accepts_subclasses(qtbot, mocked_client):
-    class PromotedDeviceComboBox(DeviceComboBox):
-        pass
-
-    widget = PromotedDeviceComboBox(client=mocked_client)
-    qtbot.addWidget(widget)
-
-    WidgetIO.set_value(widget, "samx")
-
-    assert WidgetIO.get_value(widget) == "samx"
-
-
-def test_widget_io_signal_combobox_handler(qtbot, mocked_client):
-    widget = SignalComboBox(client=mocked_client, require_device=True)
-    qtbot.addWidget(widget)
-    changes = []
-
-    widget.set_device("samx")
-    WidgetIO.connect_widget_change_signal(widget, lambda _widget, value: changes.append(value))
-    WidgetIO.set_value(widget, "samx")
-
-    assert WidgetIO.get_value(widget) == "samx"
-    widget.setCurrentText("")
-    widget.setCurrentText("samx")
-    assert changes[-1] == "samx"
-
-
-def test_widget_io_signal_combobox_handler_accepts_subclasses(qtbot, mocked_client):
-    class PromotedSignalComboBox(SignalComboBox):
-        pass
-
-    widget = PromotedSignalComboBox(client=mocked_client, require_device=True)
-    qtbot.addWidget(widget)
-    widget.set_device("samx")
-
-    WidgetIO.set_value(widget, "samx")
-
-    assert WidgetIO.get_value(widget) == "samx"
-
-
 def test_find_widgets(example_widget):
     # Test find_widgets by class type
     line_edits = WidgetIO.find_widgets(QLineEdit)