bec-widgets 0.57.1__py3-none-any.whl → 0.57.3__py3-none-any.whl

docs/user/getting_started/auto_updates.md

@@ -0,0 +1,82 @@
+(user.auto_updates)=
+# Auto updates
+BEC Widgets provides a simple way to update the entire GUI configuration based on events. These events can be of different types, such as a new scan being started or completed, a button being pressed, a device reporting an error or the existence of a specific metadata key. This allows the users to streamline the experience of the GUI and to focus on the data and the analysis, rather than on the GUI itself.
+
+The default auto update only takes control over a single `BECFigure` widget, which is automatically added to the GUI instance. The update instance is accessible via the `bec.gui.auto_updates` object. The user can disable / enable the auto updates by setting the `enabled` attribute of the `bec.gui.auto_updates` object, e.g. 
+
+```python
+bec.gui.auto_updates.enabled = False
+```
+
+Without further customization, the auto update will automatically update the `BECFigure` widget based on the currently performed scan. The behaviour is determined by the `handler` method of the `AutoUpdate` class: 
+
+````{dropdown} Auto Updates Handler
+:icon: code-square
+:animate: fade-in-slide-down
+:open: 
+```{literalinclude} ../../../bec_widgets/cli/auto_updates.py
+:pyobject: AutoUpdates.handler
+```
+````
+
+As shown, the default handler switches between different scan names and updates the `BECFigure` widget accordingly. If the scan is a line scan, the `simple_line_scan` update method is executed. 
+
+````{dropdown} Auto Updates Simple Line Scan
+:icon: code-square
+:animate: fade-in-slide-down
+:open: 
+```{literalinclude} ../../../bec_widgets/cli/auto_updates.py
+:pyobject: AutoUpdates.simple_line_scan
+```
+````
+
+As it can be seen from the above snippet, the update method gets the default figure by calling the `get_default_figure` method. If the figure is not found, maybe because the user has deleted or closed it, no update is performed. If the figure is found, the scan info is used to extract the first reported device for the x axis and the first device of the monitored devices for the y axis. The y axis can also be set by the user using the `selected_device` attribute:
+
+```python
+bec.gui.auto_updates.selected_device = 'bpm4i'
+```
+
+
+````{dropdown} Auto Updates Code
+:icon: code-square
+:animate: fade-in-slide-down
+```{literalinclude} ../../../bec_widgets/cli/auto_updates.py
+```
+````
+
+## Custom Auto Updates
+The beamline can customize their default behaviour through customized auto update classes. This can be achieved by modifying the class located in the beamline plugin repository: `<beamline_plugin>/bec_widgets/auto_updates.py`. The class should inherit from the `AutoUpdates` class and overwrite the `handler` method. 
+
+```python
+from bec_widgets.cli.auto_updates import AutoUpdates, ScanInfo
+
+
+class PlotUpdate(AutoUpdates):
+    create_default_dock = True
+    enabled = True
+
+    # def simple_line_scan(self, info: ScanInfo) -> None:
+    #     """
+    #     Simple line scan.
+    #     """
+    #     fig = self.get_default_figure()
+    #     if not fig:
+    #         return
+    #     dev_x = info.scan_report_devices[0]
+    #     dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
+    #     if not dev_y:
+    #         return
+    #     fig.clear_all()
+    #     plt = fig.plot(x_name=dev_x, y_name=dev_y)
+    #     plt.set(title=f"Custom Plot {info.scan_number}", x_label=dev_x, y_label=dev_y)
+
+    def handler(self, info: ScanInfo) -> None:
+        # EXAMPLES:
+        # if info.scan_name == "line_scan" and info.scan_report_devices:
+        #     self.simple_line_scan(info)
+        #     return
+        # if info.scan_name == "grid_scan" and info.scan_report_devices:
+        #     self.run_grid_scan_update(info)
+        #     return
+        super().handler(info)
+```

docs/user/getting_started/getting_started.md

@@ -9,5 +9,6 @@ hidden: true
 ---
 
 installation/
-command_line_introduction/
+quick_start/
+auto_updates/
 ```

docs/user/getting_started/{command_line_introduction.md → quick_start.md}

@@ -1,34 +1,53 @@
 (user.command_line_introduction)=
-# Command Line Introduction
-In order to use BEC Widgets as a plotting tool for BEC, it needs to be [installed](#user.installation) in the same python environment as the BECIpythonClient. If that is the case, it will automatically launch a GUI and assign the control of the GUI to the `gui` object in the client. The GUI backend will also be automatically connect to the BEC server, giving access to all information on the server and allowing the user to visualize the data in real-time.
+# Quick start
+In order to use BEC Widgets as a plotting tool for BEC, it needs to be [installed](#user.installation) in the same Python environment as the BEC IPython client (please refer to the [BEC documentation](https://bec.readthedocs.io/en/latest/user/command_line_interface.html#start-up) for more details). Upon startup, the client will automatically launch a GUI and store it as a `bec.gui` object in the client. The GUI backend will also be automatically connect to the BEC server, giving access to all information on the server and allowing the user to visualize the data in real-time.
 
 ## BECDockArea
-The `gui` object represents the top level of hierarchy in BEC Widgets. It is a [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) based on the [pyqtgraph.dockarea](https://pyqtgraph.readthedocs.io/en/latest/api_reference/dockarea.html). The GUI can be further composed of multiple [`BECDock`](/api_reference/_autosummary/bec_widgets.cli.client.BECDock)s that can be detached and attached to the main area. These docks allow users to freely arrange and customize the widgets they add to the gui, giving them the necessary freedom to design the user interface they desire.
+The `bec.gui` object is your entry point to BEC Widgets. It is a [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) instance that can be composed of multiple [`BECDock`](/api_reference/_autosummary/bec_widgets.cli.client.BECDock)s that can be attached / detached to the main area. These docks allow users to freely arrange and customize the widgets they add to the gui, providing a flexible and customizable interface to visualize data. 
 
 ## Widgets
-Widgets are the building blocks of the BEC Widgets framework. They are the visual components that allow users to interact with the data and control the behavior of the application. Each dock can contain multiple widgets, although we recommend using a direct mapping of a single widget to a dock. We currently support two type of widgets:
-- [`BECFigure`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure): A widget that can be used to visualize data from BEC. It is automatically connected to the BEC server and can be used to plot data from BEC.
-- [`SpiralProgressBar`](/api_reference/_autosummary/bec_widgets.cli.client.SpiralProgressBar): A custom widget that can be used to show progress in a spiral shape.
+Widgets are the building blocks of the BEC Widgets framework. They are the visual components that allow users to interact with the data and control the behavior of the application. Each dock can contain multiple widgets, albeit we recommend for most use cases a single widget per dock. BEC Widgets provides a set of core widgets (cf. [widgets](#user.widgets)). More widgets can be added by the users, and we invite you to explore the [developer documentation](developer.widgets) to learn how to create custom widgets.
+For the introduction given here, we will focus on the `BECFigure` widget, as it is the most commonly used widget for visualizing data from BEC. The same access pattern can be used for all other widgets.
 
 **BECFigure**
-The [`BECFigure`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure) widget is one of the core widgets developed for BEC and designed to be flexible and can be used to visualize different types of data. It can be used to visualize [1D Waveform](user.widgets.waveform_1d), [2D Scatter Plot](user.widgets.scatter_2d), [Motor Position Map](user.widgets.motor_map) and 2D image data. As mentioned before, starting the BECIPythonClient will automatically launch a `gui` with a single dock area and a BECFigure widget attached to it. This widget is accessible via the `fig` object from the client directly. We also provide two methods [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot), [`image()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.image) and [`motor_map()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.motor_map) as shortcuts to add a plot, image or motor map to the BECFigure.
+
+The [`BECFigure`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure) widget is one of the core widgets developed for BEC and can be used to visualize different plot types, such as [1D waveforms](user.widgets.waveform_1d), [2D scatter plots](user.widgets.scatter_2d), [position maps](user.widgets.motor_map) and [2D images](user.widgets.image_2d). 
+If BEC Widgets is installed, the default behaviour of BEC is to automatically add a BECFigure Widget to the existing GUI instance. This widget is directly accessible via the `fig` object from the client. Moreover, a best-effort attempt is made to automatically determine the best plot type based on the currently performed scan. This behaviour can be changed or disabled by the user. For more details, please refer to the [auto update](user.auto_updates) section.
+
+<!-- We also provide two methods [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot), [`image()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.image) and [`motor_map()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.motor_map) as shortcuts to add a plot, image or motor map to the BECFigure. -->
 
 **Waveform Plot** 
+
  The [`BECWaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform) is a widget that can be used to visualize 1D waveform data, i.e. to plot data of a monitor against a motor position. The method [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot) of BECFigure adds a BECWaveForm widget to the figure, and returns the plot object. 
 
 ```python
-plt = fig.add_plot('samx', 'bpm4i')
+plt = fig.plot(x_name='samx', y_name='bpm4i')
+```
+Here, we create a new plot with a subscription to the devices `samx` and `bpm4i` and assign the plot to the object `plt`. We can now use this object to further customize the plot, e.g. changing the title ([`set_title()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_title)), axis labels ([`set_x_label()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_x_label)) or limits ([`set_x_lim()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_x_lim)). We invite you to explore the API of the BECWaveForm in the [documentation](user.widgets.waveform_1d) or directly in the command line.
+
+To plot custom data, i.e. data that is not directly available through a scan in BEC, we can use the same method, but provide the data directly to the plot. 
+
+```python
+plt = fig.plot([1,2,3,4], [1,4,9,16])
+# or 
+plt = fig.plot(x=[1,2,3,4], y=[1,4,9,16])
+# or 
+plt = fig.plot(x=np.array([1,2,3,4]), y=np.array([1,4,9,16]))
+# or 
+plt = fig.plot(np.random.rand(10,2))
 ```
-Here, we assign the plot to the object `plt`. We can now use this object to further customize the plot, e.g. changing the title ([`set_title()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_title)), axis labels ([`set_x_label()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_x_label)) or limits ([`set_x_lim()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_x_lim)). We invite you to explore the API of the BECWaveForm in the [documentation](user.widgets.waveform_1d) or directly in the command line.
 
 **Scatter Plot**
+
 The [`BECWaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveForm) widget can also be used to visualize 2D scatter plots. More details on setting up the scatter plot are available in the widget documentation of the [scatter plot](user.widgets.scatter_2d).
 
 **Motor Map**
+
 The [`BECMotorMap`](/api_reference/_autosummary/bec_widgets.cli.client.BECMotorMap) widget can be used to visualize the position of motors. It's focused on tracking and visualizing the position of motors, crucial for precise alignment and movement tracking during scans. More details on setting up the motor map are available in the widget documentation of the [motor map](user.widgets.motor_map).
 
 **Image Plot**
-The [`BECImageItem`](/api_reference/_autosummary/bec_widgets.cli.client.BECImageItem) widget can be used to visualize 2D image data for example a camera. More details on setting up the image plot are available in the widget documentation of the [image plot](user.widgets.image)
+
+The [`BECImageItem`](/api_reference/_autosummary/bec_widgets.cli.client.BECImageItem) widget can be used to visualize 2D image data for example a camera. More details on setting up the image plot are available in the widget documentation of the [image plot](user.widgets.image).
 
 ### Useful Commands
 We recommend users to explore the API of the widgets by themselves since we assume that the user interface is supposed to be intuitive and self-explanatory. We appreciate feedback from user in order to constantly improve the experience and allow easy access to the gui, widgets and their functionality. We recommend checking the [API documentation](user.api_reference), but also by using BEC Widgets, exploring the available functions and check their dockstrings.
@@ -43,32 +62,32 @@ gui.panels # returns a dictionary of all docks in the gui
 gui.add_dock() # adds a new dock to the gui
 
 dock = gui.panels['dock_2']
-dock.add_widget_bec('BECFigure') # adds a new widget of BECFigure to the dock
+dock.add_widget('BECFigure') # adds a new widget of BECFigure to the dock
 dock.widget_list # returns a list of all widgets in the dock
 
 figure = dock.widget_list[0] # assigns the created BECFigure to figure
-plt = figure.add_plot('samx', 'bpm4i') # adds a BECWaveForm plot to the figure
+plt = figure.plot(x_name='samx', y_name='bpm4i') # adds a BECWaveForm plot to the figure
 plt.curves # returns a list of all curves in the plot
 ```
 
-We note that commands can also be chained. For example, `gui.add_dock().add_widget_bec('BECFigure')` will add a new dock to the gui and add a new widget of `BECFigure` to the dock. 
+We note that commands can also be chained. For example, `gui.add_dock().add_widget('BECFigure')` will add a new dock to the gui and add a new widget of `BECFigure` to the dock. 
 
 ## Composing a larger GUI
 The example given above introduces BEC Widgets with its different components, and provides an overview of how to interact with the widgets. Nevertheless, another power aspect of BEC Widgets lies in the ability to compose a larger GUI with multiple docks and widgets. This section aims to provide a tutorial like guide on how to compose a more complex GUI that (A) live-plots a 1D waveform, (B) plots data from a camera, and (C) tracks the positions of two motors.
 Let's assume BEC was just started and the `gui` object is available in the client. A single dock is already attached together with a BEC Figure. Let's add the 1D waveform to this dock, change the color of the line to white and add the title *1D Waveform* to the plot.
 
 ```python
-plt = fig.add_plot('samx', 'bpm4i')
+plt = fig.plot(x_name='samx', y_name='bpm4i')
 plt.curves[0].set_color(color="white")
 plt.set_title('1D Waveform')
 ```
 
 Next, we add 2 new docks to the gui, one to plot the data of a camera and one to track the positions of two motors. 
 ```ipython
-cam_widget= gui.add_dock(name="cam_dock").add_widget_bec('BECFigure').image("eiger")
-motor_widget = gui.add_dock(name="mot_dock").add_widget_bec('BECFigure').motor_map("samx", "samy")
+cam_widget= gui.add_dock(name="cam_dock").add_widget('BECFigure').image("eiger")
+motor_widget = gui.add_dock(name="mot_dock").add_widget('BECFigure').motor_map("samx", "samy")
 ```
-Note, we chain commands here which is possible since the `add_dock` and `add_widget_bec` methods return the dock and the widget respectively. We can now further customize the widgets by changing the title, axis labels, etc.
+Note, we chain commands here which is possible since the `add_dock` and `add_widget` methods return the dock and the widget respectively. We can now further customize the widgets by changing the title, axis labels, etc.
 
 ```python
 cam_widget.set_title("Camera Image Eiger")
@@ -78,7 +97,7 @@ As a final step, we can now add also a SpiralProgressBar to a new dock, and perf
 As you see in the example below, all docks are arranged below each other. This is the default behavior of the `add_dock` method. However, the docks can be freely arranged by drag and drop as desired by the user. We invite you to explore this by yourself following the example in the video, and build your custom GUI with BEC Widgets.
 
 ```python
-prog_bar = gui.add_dock(name="prog_dock").add_widget_bec('SpiralProgressBar')
+prog_bar = gui.add_dock(name="prog_dock").add_widget('SpiralProgressBar')
 prog_bar.set_line_widths(15)
 scans.grid_scan(dev.samy, -2, 2, 10, dev.samx, -5, 5, 10, exp_time=0.1, relative=False)
 ```

docs/user/widgets/spiral_progress_bar.md

@@ -1,6 +1,12 @@
 (user.widgets.spiral_progress_bar)=
 # [Spiral Progress Bar](/api_reference/_autosummary/bec_widgets.cli.client.SpiralProgressBar)
-**Purpose** The Spiral Progress Bar widget is a circular progress bar that can be used to visualize the progress of a task. The widget is designed to be used in applications where the progress of a task is represented as a percentage. The Spiral Progress Bar widget is a part of the BEC Widgets library and can be controlled directly using its API, or hooked up to the progress of a device readback or scan.
+
+**Purpose:**
+
+The Spiral Progress Bar widget is a circular progress bar that can be used to visualize the progress of a task. The
+widget is designed to be used in applications where the progress of a task is represented as a percentage. The Spiral
+Progress Bar widget is a part of the BEC Widgets library and can be controlled directly using its API, or hooked up to
+the progress of a device readback or scan.
 
 **Key Features:**
 
@@ -11,11 +17,38 @@
 **Example of Use:**
 ![SpiralProgressBar](./progress_bar.gif)
 
-**Code example**
-The following code snipped demonstrates how to create a 2D scatter plot using BEC Widgets within BEC.
+**Code example:**
+
+The following code snipped demonstrates how to create a `SpiralProgressBar` using BEC Widgets within BEC.
 ```python
 # adds a new dock with a spiral progress bar
 progress = gui.add_dock().add_widget("SpiralProgressBar")
 # customize the size of the ring
 progress.set_line_width(20)
-```
+```
+
+By default, the Spiral Progress Bar widget will display a single ring. To add more rings, use the add_ring method:
+
+```python
+# adds a new dock with a spiral progress bar
+progress.add_ring()
+```
+
+To access rings and specify their properties, you can use `progress.rings` with an index specifying the ring index (
+starting from 0):
+
+```python
+progress.rings[0].set_line_width(20)  # set the width of the first ring
+progress.rings[1].set_line_width(10)  # set the width of the second ring
+```
+
+By default, the `SpiralProgressBar` widget is set with `progress.enable_auto_update(True)`, which will automatically
+update the bars in the widget. To manually set updates for each progress bar, use the set_update method. Note that
+manually updating a ring will disable the automatic update for the whole widget:
+
+```python
+progress.rings[0].set_update("scan")  # set the update of the first ring to be an overall scan progress
+progress.rings[1].set_update("device",
+                             "samx")  # set the update of the second ring to be a device readback (in this case, samx)
+```
+

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "0.57.1"
+version = "0.57.3"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -31,6 +31,7 @@ dev = [
     "pytest",
     "pytest-random-order",
     "pytest-timeout",
+    "pytest-xvfb",
     "coverage",
     "pytest-qt",
     "isort",

tests/end-2-end/conftest.py

@@ -1,40 +1,55 @@
+import random
+import time
+from contextlib import contextmanager
+
 import pytest
+from bec_lib.endpoints import MessageEndpoints
 
+from bec_widgets.cli.client_utils import _start_plot_process
 from bec_widgets.cli.rpc_register import RPCRegister
-from bec_widgets.cli.server import BECWidgetsCLIServer
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.widgets import BECDockArea, BECFigure
 
 
+# make threads check in autouse, **will be executed at the end**; better than
+# having it in fixtures for each test, since it prevents from needing to
+# 'manually' shutdown bec_client_lib (for example) to make it happy, whereas
+# whereas in fact bec_client_lib makes its on cleanup
 @pytest.fixture(autouse=True)
-def rpc_register():
-    yield RPCRegister()
-    RPCRegister.reset_singleton()
+def threads_check_fixture(threads_check):
+    return
+
+
+@pytest.fixture
+def gui_id():
+    return f"figure_{random.randint(0,100)}"  # make a new gui id each time, to ensure no 'gui is alive' zombie key can perturbate
+
+
+@contextmanager
+def plot_server(gui_id, klass, client_lib):
+    dispatcher = BECDispatcher(client=client_lib)  # Has to init singleton with fixture client
+    process, output_thread = _start_plot_process(
+        gui_id, klass, client_lib._client._service_config.redis
+    )
+    try:
+        while client_lib._client.connector.get(MessageEndpoints.gui_heartbeat(gui_id)) is None:
+            time.sleep(0.3)
+        yield gui_id
+    finally:
+        process.terminate()
+        process.wait()
+        output_thread.join()
+        dispatcher.disconnect_all()
+        dispatcher.reset_singleton()
 
 
 @pytest.fixture
-def rpc_server_figure(qtbot, bec_client_lib, threads_check):
-    dispatcher = BECDispatcher(client=bec_client_lib)  # Has to init singleton with fixture client
-    server = BECWidgetsCLIServer(gui_id="figure", gui_class=BECFigure)
-    qtbot.addWidget(server.gui)
-    qtbot.waitExposed(server.gui)
-    qtbot.wait(1000)  # 1s long to wait until gui is ready
-    yield server
-    dispatcher.disconnect_all()
-    server.client.shutdown()
-    server.shutdown()
-    dispatcher.reset_singleton()
+def rpc_server_figure(gui_id, bec_client_lib):
+    with plot_server(gui_id, BECFigure, bec_client_lib) as server:
+        yield server
 
 
 @pytest.fixture
-def rpc_server_dock(qtbot, bec_client_lib, threads_check):
-    dispatcher = BECDispatcher(client=bec_client_lib)  # Has to init singleton with fixture client
-    server = BECWidgetsCLIServer(gui_id="figure", gui_class=BECDockArea)
-    qtbot.addWidget(server.gui)
-    qtbot.waitExposed(server.gui)
-    qtbot.wait(1000)  # 1s long to wait until gui is ready
-    yield server
-    dispatcher.disconnect_all()
-    server.client.shutdown()
-    server.shutdown()
-    dispatcher.reset_singleton()
+def rpc_server_dock(gui_id, bec_client_lib):
+    with plot_server(gui_id, BECDockArea, bec_client_lib) as server:
+        yield server

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -1,3 +1,5 @@
+import time
+
 import numpy as np
 import pytest
 from bec_lib.client import BECClient
@@ -8,24 +10,10 @@ from bec_widgets.cli.client import BECDockArea, BECFigure, BECImageShow, BECMoto
 from bec_widgets.utils import Colors
 
 
-@pytest.fixture(name="bec_client")
-def cli_bec_client(rpc_server_dock):
-    """
-    Fixture to create a BECClient instance that is independent of the GUI.
-    """
-    # pylint: disable=protected-access
-    cli_client = BECClient(forced=True, config=rpc_server_dock.client._service_config)
-    cli_client.start()
-    yield cli_client
-    cli_client.shutdown()
-
-
-def test_rpc_add_dock_with_figure_e2e(rpc_server_dock, qtbot):
-    dock = BECDockArea(rpc_server_dock.gui_id)
-    dock_server = rpc_server_dock.gui
-
+def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
     # BEC client shortcuts
-    client = rpc_server_dock.client
+    dock = BECDockArea(rpc_server_dock)
+    client = bec_client_lib
     dev = client.device_manager.devices
     scans = client.scans
     queue = client.queue
@@ -35,17 +23,18 @@ def test_rpc_add_dock_with_figure_e2e(rpc_server_dock, qtbot):
     d1 = dock.add_dock("dock_1")
     d2 = dock.add_dock("dock_2")
 
-    assert len(dock_server.docks) == 3
-
+    dock_config = dock.config_dict
+    assert len(dock_config["docks"]) == 3
     # Add 3 figures with some widgets
     fig0 = d0.add_widget("BECFigure")
     fig1 = d1.add_widget("BECFigure")
     fig2 = d2.add_widget("BECFigure")
 
-    assert len(dock_server.docks) == 3
-    assert len(dock_server.docks["dock_0"].widgets) == 1
-    assert len(dock_server.docks["dock_1"].widgets) == 1
-    assert len(dock_server.docks["dock_2"].widgets) == 1
+    dock_config = dock.config_dict
+    assert len(dock_config["docks"]) == 3
+    assert len(dock_config["docks"]["dock_0"]["widgets"]) == 1
+    assert len(dock_config["docks"]["dock_1"]["widgets"]) == 1
+    assert len(dock_config["docks"]["dock_2"]["widgets"]) == 1
 
     assert fig1.__class__.__name__ == "BECFigure"
     assert fig1.__class__ == BECFigure
@@ -98,7 +87,7 @@ def test_rpc_add_dock_with_figure_e2e(rpc_server_dock, qtbot):
 
     # wait for scan to finish
     while not status.status == "COMPLETED":
-        qtbot.wait(200)
+        time.sleep(0.2)
 
     # plot
     plt_last_scan_data = queue.scan_storage.storage[-1].data
@@ -110,7 +99,7 @@ def test_rpc_add_dock_with_figure_e2e(rpc_server_dock, qtbot):
     last_image_device = client.connector.get_last(MessageEndpoints.device_monitor("eiger"))[
         "data"
     ].data
-    qtbot.wait(500)
+    time.sleep(0.5)
     last_image_plot = im.images[0].get_data()
     np.testing.assert_equal(last_image_device, last_image_plot)
 
@@ -129,40 +118,41 @@ def test_rpc_add_dock_with_figure_e2e(rpc_server_dock, qtbot):
     )
 
 
-def test_dock_manipulations_e2e(rpc_server_dock, qtbot):
-    dock = BECDockArea(rpc_server_dock.gui_id)
-    dock_server = rpc_server_dock.gui
+def test_dock_manipulations_e2e(rpc_server_dock):
+    dock = BECDockArea(rpc_server_dock)
 
     d0 = dock.add_dock("dock_0")
     d1 = dock.add_dock("dock_1")
     d2 = dock.add_dock("dock_2")
-    assert len(dock_server.docks) == 3
+    dock_config = dock.config_dict
+    assert len(dock_config["docks"]) == 3
 
     d0.detach()
     dock.detach_dock("dock_2")
-    assert len(dock_server.docks) == 3
-    assert len(dock_server.tempAreas) == 2
+    dock_config = dock.config_dict
+    assert len(dock_config["docks"]) == 3
+    assert len(dock.temp_areas) == 2
 
     d0.attach()
-    assert len(dock_server.docks) == 3
-    assert len(dock_server.tempAreas) == 1
+    dock_config = dock.config_dict
+    assert len(dock_config["docks"]) == 3
+    assert len(dock.temp_areas) == 1
 
     d2.remove()
-    qtbot.wait(200)
+    dock_config = dock.config_dict
+    assert len(dock_config["docks"]) == 2
 
-    assert len(dock_server.docks) == 2
-    docks_list = list(dict(dock_server.docks).keys())
-    assert ["dock_0", "dock_1"] == docks_list
+    assert ["dock_0", "dock_1"] == list(dock_config["docks"])
 
     dock.clear_all()
 
-    assert len(dock_server.docks) == 0
-    assert len(dock_server.tempAreas) == 0
+    dock_config = dock.config_dict
+    assert len(dock_config["docks"]) == 0
+    assert len(dock.temp_areas) == 0
 
 
 def test_spiral_bar(rpc_server_dock):
-    dock = BECDockArea(rpc_server_dock.gui_id)
-    dock_server = rpc_server_dock.gui
+    dock = BECDockArea(rpc_server_dock)
 
     d0 = dock.add_dock(name="dock_0")
 
@@ -173,49 +163,46 @@ def test_spiral_bar(rpc_server_dock):
     bar.set_colors_from_map("viridis")
     bar.set_value([10, 20, 30, 40, 50])
 
-    bar_server = dock_server.docks["dock_0"].widgets[0]
+    bar_config = bar.config_dict
 
-    expected_colors = Colors.golden_angle_color("viridis", 5, "RGB")
-    bar_colors = [ring.color.getRgb() for ring in bar_server.rings]
-    bar_values = [ring.config.value for ring in bar_server.rings]
+    expected_colors = [list(color) for color in Colors.golden_angle_color("viridis", 5, "RGB")]
+    bar_colors = [ring.config_dict["color"] for ring in bar.rings]
+    bar_values = [ring.config_dict["value"] for ring in bar.rings]
+    assert bar_config["num_bars"] == 5
     assert bar_values == [10, 20, 30, 40, 50]
     assert bar_colors == expected_colors
 
 
-def test_spiral_bar_scan_update(rpc_server_dock, qtbot):
-    dock = BECDockArea(rpc_server_dock.gui_id)
-    dock_server = rpc_server_dock.gui
+def test_spiral_bar_scan_update(bec_client_lib, rpc_server_dock):
+    dock = BECDockArea(rpc_server_dock)
 
     d0 = dock.add_dock("dock_0")
 
-    d0.add_widget("SpiralProgressBar")
+    bar = d0.add_widget("SpiralProgressBar")
 
-    client = rpc_server_dock.client
+    client = bec_client_lib
     dev = client.device_manager.devices
+    dev.samx.tolerance.set(0)
+    dev.samy.tolerance.set(0)
     scans = client.scans
 
     status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
+    status.wait()
 
-    while not status.status == "COMPLETED":
-        qtbot.wait(200)
-
-    qtbot.wait(200)
-    bar_server = dock_server.docks["dock_0"].widgets[0]
-    assert bar_server.config.num_bars == 1
-    np.testing.assert_allclose(bar_server.rings[0].config.value, 10, atol=0.1)
-    np.testing.assert_allclose(bar_server.rings[0].config.min_value, 0, atol=0.1)
-    np.testing.assert_allclose(bar_server.rings[0].config.max_value, 10, atol=0.1)
+    bar_config = bar.config_dict
+    assert bar_config["num_bars"] == 1
+    assert bar_config["rings"][0]["value"] == 10
+    assert bar_config["rings"][0]["min_value"] == 0
+    assert bar_config["rings"][0]["max_value"] == 10
 
     status = scans.grid_scan(dev.samx, -5, 5, 4, dev.samy, -10, 10, 4, relative=True, exp_time=0.1)
+    status.wait()
 
-    while not status.status == "COMPLETED":
-        qtbot.wait(200)
-
-    qtbot.wait(200)
-    assert bar_server.config.num_bars == 1
-    np.testing.assert_allclose(bar_server.rings[0].config.value, 16, atol=0.1)
-    np.testing.assert_allclose(bar_server.rings[0].config.min_value, 0, atol=0.1)
-    np.testing.assert_allclose(bar_server.rings[0].config.max_value, 16, atol=0.1)
+    bar_config = bar.config_dict
+    assert bar_config["num_bars"] == 1
+    assert bar_config["rings"][0]["value"] == 16
+    assert bar_config["rings"][0]["min_value"] == 0
+    assert bar_config["rings"][0]["max_value"] == 16
 
     init_samx = dev.samx.read()["samx"]["value"]
     init_samy = dev.samy.read()["samy"]["value"]
@@ -226,23 +213,20 @@ def test_spiral_bar_scan_update(rpc_server_dock, qtbot):
     dev.samy.velocity.put(5)
 
     status = scans.umv(dev.samx, 5, dev.samy, 10, relative=True)
+    status.wait()
 
-    while not status.status == "COMPLETED":
-        qtbot.wait(200)
-
-    qtbot.wait(200)
-    assert bar_server.config.num_bars == 2
-    np.testing.assert_allclose(bar_server.rings[0].config.value, final_samx, atol=0.1)
-    np.testing.assert_allclose(bar_server.rings[1].config.value, final_samy, atol=0.1)
-    np.testing.assert_allclose(bar_server.rings[0].config.min_value, init_samx, atol=0.1)
-    np.testing.assert_allclose(bar_server.rings[1].config.min_value, init_samy, atol=0.1)
-    np.testing.assert_allclose(bar_server.rings[0].config.max_value, final_samx, atol=0.1)
-    np.testing.assert_allclose(bar_server.rings[1].config.max_value, final_samy, atol=0.1)
+    bar_config = bar.config_dict
+    assert bar_config["num_bars"] == 2
+    assert bar_config["rings"][0]["value"] == final_samx
+    assert bar_config["rings"][1]["value"] == final_samy
+    assert bar_config["rings"][0]["min_value"] == init_samx
+    assert bar_config["rings"][0]["max_value"] == final_samx
+    assert bar_config["rings"][1]["min_value"] == init_samy
+    assert bar_config["rings"][1]["max_value"] == final_samy
 
 
-def test_auto_update(rpc_server_dock, bec_client, qtbot):
-    dock = BECDockArea(rpc_server_dock.gui_id)
-    dock._client = bec_client
+def test_auto_update(bec_client_lib, rpc_server_dock):
+    dock = BECDockArea(rpc_server_dock)
 
     AutoUpdates.enabled = True
     AutoUpdates.create_default_dock = True
@@ -253,16 +237,13 @@ def test_auto_update(rpc_server_dock, bec_client, qtbot):
     # we need to start the update script manually; normally this is done when the GUI is started
     dock._start_update_script()
 
-    client = bec_client
+    client = bec_client_lib
     dev = client.device_manager.devices
     scans = client.scans
     queue = client.queue
 
     status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-
-    # wait for scan to finish
-    while not status.status == "COMPLETED":
-        qtbot.wait(200)
+    status.wait()
 
     last_scan_data = queue.scan_storage.storage[-1].data
 
@@ -278,10 +259,7 @@ def test_auto_update(rpc_server_dock, bec_client, qtbot):
     status = scans.grid_scan(
         dev.samx, -10, 10, 5, dev.samy, -5, 5, 5, exp_time=0.05, relative=False
     )
-
-    # wait for scan to finish
-    while not status.status == "COMPLETED":
-        qtbot.wait(200)
+    status.wait()
 
     plt = dock.auto_updates.get_default_figure()
     widgets = plt.widget_list