0.52.1

Automatically generated by python-semantic-release

.gitlab-ci.yml

@@ -7,12 +7,14 @@ variables:
   DOCKER_TLS_CERTDIR: ""
   BEC_CORE_BRANCH: "main"
   OPHYD_DEVICES_BRANCH: "main"
+  CHILD_PIPELINE_BRANCH: "main"
 
 workflow:
   rules:
     - if: $CI_PIPELINE_SOURCE == "schedule"
     - if: $CI_PIPELINE_SOURCE == "web"
     - if: $CI_PIPELINE_SOURCE == "pipeline"
+    - if: $CI_PIPELINE_SOURCE == "parent_pipeline"
     - if: $CI_PIPELINE_SOURCE == "merge_request_event"
     - if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
       when: never
@@ -30,6 +32,11 @@ stages:
   - End2End
   - Deploy
 
+before_script:
+  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then 
+    test -d bec_widgets || git clone --branch $CHILD_PIPELINE_BRANCH https://gitlab.psi.ch/bec/bec_widgets.git; cd bec_widgets;
+    fi
+
 formatter:
   stage: Formatter
   needs: []
@@ -37,6 +44,9 @@ formatter:
     - pip install black isort
     - isort --check --diff --line-length=100 --profile=black --multi-line=3 --trailing-comma ./
     - black --check --diff --color --line-length=100 ./
+  rules:
+    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
+
 pylint:
   stage: Formatter
   needs: []
@@ -53,6 +63,8 @@ pylint:
     paths:
       - ./pylint/
     expire_in: 1 week
+  rules:
+    - if: $CI_PROJECT_PATH == "bec/bec_widgets"    
 
 pylint-check:
   stage: Formatter
@@ -84,6 +96,8 @@ pylint-check:
     paths:
       - ./pylint/
     expire_in: 1 week
+  rules:
+    - if: $CI_PROJECT_PATH == "bec/bec_widgets"    
 
 tests:
   stage: test
@@ -164,6 +178,7 @@ end-2-end-conda:
     - if: '$CI_PIPELINE_SOURCE == "schedule"'
     - if: '$CI_PIPELINE_SOURCE == "web"'
     - if: '$CI_PIPELINE_SOURCE == "pipeline"'
+    - if: '$CI_PIPELINE_SOURCE == "parent_pipeline"'
     - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
     - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
 
@@ -195,7 +210,7 @@ semver:
 
   allow_failure: false
   rules:
-    - if: '$CI_COMMIT_REF_NAME == "main"'
+    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
 
 pages:
   stage: Deploy
@@ -206,6 +221,6 @@ pages:
     - if: '$CI_COMMIT_TAG != null'
       variables:
         TARGET_BRANCH: $CI_COMMIT_TAG
-    - if: '$CI_COMMIT_REF_NAME == "main"'
+    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
   script:
-    - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/bec-widgets/253243/
+    - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/bec_widgets/253243/

CHANGELOG.md

@@ -2,6 +2,89 @@
 
 <!--next-version-placeholder-->
 
+## v0.52.1 (2024-05-08)
+
+### Fix
+
+* **docstrings:** Docstrings formating fixed for sphinx to properly format readdocs ([`7f2f7cd`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7f2f7cd07a14876617cd83cedde8c281fdc52c3a))
+
+## v0.52.0 (2024-05-07)
+
+### Feature
+
+* **utils/layout_manager:** Added GridLayoutManager to extend functionalities of native QGridLayout ([`fcd6ef0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fcd6ef0975dc872f69c9d6fb2b8a1ad04a423aae))
+* **widget/dock:** BECDock and BECDock area for dockable windows ([`d8ff8af`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d8ff8afcd474660a6069bbdab05f10a65f221727))
+
+### Fix
+
+* **widgets/dock:** BECDockArea close overwrites the default pyqtgraph Container close + minor improvements ([`ceae979`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ceae979f375ecc33c5c97148f197655c1ca57b6c))
+
+## v0.51.0 (2024-05-07)
+
+### Feature
+
+* **utils:** Added plugin helper to find and load ([`5ece269`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5ece269adb0e9b0c2a468f1dfbaa6212e86d3561))
+
+## v0.50.2 (2024-04-30)
+
+### Fix
+
+* 'disconnect_slot' has to be symmetric with 'connect_slot' regarding QtThreadSafeCallback ([`0dfcaa4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0dfcaa4b708948af0a40ec7cf34d03ff1e96ffac))
+
+## v0.50.1 (2024-04-29)
+
+### Fix
+
+* **cli:** BECFigure takes the port to connect to redis from the current BECClient, supporting plugins ([`57cb136`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/57cb136a098e87a452414bf44e627edb562f6799))
+
+## v0.50.0 (2024-04-29)
+
+### Feature
+
+* **plots:** Universal cleanup and remove also for children items ([`381d713`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/381d713837bb9217c58ba1d8b89691aa35c9f5ec))
+* **rpc/rpc_register:** Singleton rpc register for all rpc connections for session ([`a898e7e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a898e7e4f14e9ae854703dddbd1eb8c50cb640ff))
+
+### Fix
+
+* **widgets/figure:** Access pattern changed for getting widgets by coordinates for rpc ([`13c018a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/13c018a79704a7497c140df57179d294e43ecffa))
+* **plots:** Cleanup policy reviewed for children items ([`8f20a0b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/8f20a0b3b1b5dd117b36b45645717190b9ee9cbf))
+* **rpc/client_utils:** Getoutput more transparent + error handling ([`6b6a6b2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/6b6a6b2249f24d3d02bd5fcd7ef1c63ed794c304))
+* **rpc_register:** Thread lock for listign all connections ([`2ca3267`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/2ca32675ec3f00137e2140259db51f6e5aa7bb71))
+
+## v0.49.1 (2024-04-26)
+
+### Fix
+
+* **widgets/editor:** Qscintilla editor removed ([`ab85374`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ab8537483da6c87cb9a0b0f01706208c964f292d))
+
+## v0.49.0 (2024-04-24)
+
+### Feature
+
+* **rpc/client_utils:** Timeout for rpc response ([`6500a00`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/6500a00682a2a7ca535a138bd9496ed8470856a8))
+
+### Fix
+
+* **rpc/client_utils:** Close clean up policy for BECFigure ([`9602085`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9602085f82cbc983f89b5bfe48bf35f08438fa87))
+
+## v0.48.0 (2024-04-24)
+
+### Feature
+
+* **cli:** Added auto updates plugin support ([`6238693`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/6238693ffb44b47a56b969bc4129f2af7a2c04fe))
+
+## v0.47.0 (2024-04-23)
+
+### Feature
+
+* **utils/thread_checker:** Util class to check the thread leakage for closeEvent in qt ([`71cb80d`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/71cb80d544c5f4ef499379a431ce0c17907c7ce8))
+
+## v0.46.7 (2024-04-21)
+
+### Fix
+
+* **plot/image:** Monitors are now validated with current bec session ([`67a99a1`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/67a99a1a19c261f9a1f09635f274cd9fbfe53639))
+
 ## v0.46.6 (2024-04-19)
 
 ### Fix

README.md

@@ -6,14 +6,14 @@ BEC Widgets is a GUI framework designed for interaction with [BEC (Beamline Expe
 Use the package manager [pip](https://pip.pypa.io/en/stable/) to install BEC Widgets:
 
 ```bash
-pip install bec-widgets
+pip install bec_widgets
 ```
 
 For development purposes, you can clone the repository and install the package locally in editable mode:
 
 ```bash
 git clone https://gitlab.psi.ch/bec/bec-widgets
-cd bec-widgets
+cd bec_widgets
 pip install -e .[dev]
 ```
 
@@ -22,12 +22,12 @@ BEC Widgets currently supports both PyQt5 and PyQt6. By default, PyQt6 is instal
 To select a specific Python Qt distribution, install the package with an additional tag:
 
 ```bash
-pip install bec-widgets[pyqt6]
+pip install bec_widgets[pyqt6]
 ```
 or 
 
 ```bash
-pip install bec-widgets[pyqt5]
+pip install bec_widgets[pyqt5]
 ```
 ## Documentation
 

bec_widgets/cli/__init__.py

@@ -1 +1,2 @@
-from .client import BECFigure
+from .auto_updates import AutoUpdates, ScanInfo
+from .client import BECDockArea, BECFigure

bec_widgets/cli/auto_updates.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from .client import BECFigure
+
+
+class ScanInfo(BaseModel):
+    scan_id: str
+    scan_number: int
+    scan_name: str
+    scan_report_devices: list
+    monitored_devices: list
+    status: str
+
+
+class AutoUpdates:
+    def __init__(self, figure: BECFigure, enabled: bool = True):
+        self.enabled = enabled
+        self.figure = figure
+
+    @staticmethod
+    def get_scan_info(msg) -> ScanInfo:
+        """
+        Update the script with the given data.
+        """
+        info = msg.info
+        status = msg.status
+        scan_id = msg.scan_id
+        scan_number = info.get("scan_number", 0)
+        scan_name = info.get("scan_name", "Unknown")
+        scan_report_devices = info.get("scan_report_devices", [])
+        monitored_devices = info.get("readout_priority", {}).get("monitored", [])
+        monitored_devices = [dev for dev in monitored_devices if dev not in scan_report_devices]
+        return ScanInfo(
+            scan_id=scan_id,
+            scan_number=scan_number,
+            scan_name=scan_name,
+            scan_report_devices=scan_report_devices,
+            monitored_devices=monitored_devices,
+            status=status,
+        )
+
+    def run(self, msg):
+        """
+        Run the update function if enabled.
+        """
+        if not self.enabled:
+            return
+        if msg.status != "open":
+            return
+        info = self.get_scan_info(msg)
+        self.handler(info)
+
+    @staticmethod
+    def get_selected_device(monitored_devices, selected_device):
+        """
+        Get the selected device for the plot. If no device is selected, the first
+        device in the monitored devices list is selected.
+        """
+        if selected_device:
+            return selected_device
+        if len(monitored_devices) > 0:
+            sel_device = monitored_devices[0]
+            return sel_device
+        return None
+
+    def handler(self, info: ScanInfo) -> None:
+        """
+        Default update function.
+        """
+        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.simple_grid_scan(info)
+            return
+        if info.scan_report_devices:
+            self.best_effort(info)
+            return
+
+    def simple_line_scan(self, info: ScanInfo) -> None:
+        """
+        Simple line scan.
+        """
+        dev_x = info.scan_report_devices[0]
+        dev_y = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
+        if not dev_y:
+            return
+        self.figure.clear_all()
+        plt = self.figure.plot(dev_x, dev_y)
+        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
+
+    def simple_grid_scan(self, info: ScanInfo) -> None:
+        """
+        Simple grid scan.
+        """
+        dev_x = info.scan_report_devices[0]
+        dev_y = info.scan_report_devices[1]
+        dev_z = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
+        self.figure.clear_all()
+        plt = self.figure.plot(dev_x, dev_y, dev_z, label=f"Scan {info.scan_number}")
+        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
+
+    def best_effort(self, info: ScanInfo) -> None:
+        """
+        Best effort scan.
+        """
+        dev_x = info.scan_report_devices[0]
+        dev_y = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
+        if not dev_y:
+            return
+        self.figure.clear_all()
+        plt = self.figure.plot(dev_x, dev_y, label=f"Scan {info.scan_number}")
+        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)

bec_widgets/cli/client_utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+import importlib.metadata as imd
 import os
 import select
 import subprocess
@@ -11,16 +12,17 @@ import uuid
 from functools import wraps
 from typing import TYPE_CHECKING
 
-from bec_lib import MessageEndpoints, messages
+from bec_lib import MessageEndpoints, ServiceConfig, messages
 from bec_lib.connector import MessageObject
 from bec_lib.device import DeviceBase
 from qtpy.QtCore import QCoreApplication
 
 import bec_widgets.cli.client as client
+from bec_widgets.cli.auto_updates import AutoUpdates
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 if TYPE_CHECKING:
-    from bec_widgets.cli.client import BECFigure
+    from bec_widgets.cli.client import BECDockArea, BECFigure
 
 
 def rpc_call(func):
@@ -54,68 +56,22 @@ def rpc_call(func):
     return wrapper
 
 
-def get_selected_device(monitored_devices, selected_device):
-    """
-    Get the selected device for the plot. If no device is selected, the first
-    device in the monitored devices list is selected.
-    """
-    if selected_device:
-        return selected_device
-    if len(monitored_devices) > 0:
-        sel_device = monitored_devices[0]
-        return sel_device
-    return None
-
-
-def update_script(figure: BECFigure, msg):
-    """
-    Update the script with the given data.
-    """
-    info = msg.info
-    status = msg.status
-    scan_id = msg.scan_id
-    scan_number = info.get("scan_number", 0)
-    scan_name = info.get("scan_name", "Unknown")
-    scan_report_devices = info.get("scan_report_devices", [])
-    monitored_devices = info.get("readout_priority", {}).get("monitored", [])
-    monitored_devices = [dev for dev in monitored_devices if dev not in scan_report_devices]
-
-    if scan_name == "line_scan" and scan_report_devices:
-        dev_x = scan_report_devices[0]
-        dev_y = get_selected_device(monitored_devices, figure.selected_device)
-        print(f"Selected device: {dev_y}")
-        if not dev_y:
-            return
-        figure.clear_all()
-        plt = figure.plot(dev_x, dev_y)
-        plt.set(title=f"Scan {scan_number}", x_label=dev_x, y_label=dev_y)
-    elif scan_name == "grid_scan" and scan_report_devices:
-        print(f"Scan {scan_number} is running")
-        dev_x = scan_report_devices[0]
-        dev_y = scan_report_devices[1]
-        dev_z = get_selected_device(monitored_devices, figure.selected_device)
-        figure.clear_all()
-        plt = figure.plot(dev_x, dev_y, dev_z, label=f"Scan {scan_number}")
-        plt.set(title=f"Scan {scan_number}", x_label=dev_x, y_label=dev_y)
-    elif scan_report_devices:
-        dev_x = scan_report_devices[0]
-        dev_y = get_selected_device(monitored_devices, figure.selected_device)
-        if not dev_y:
-            return
-        figure.clear_all()
-        plt = figure.plot(dev_x, dev_y, label=f"Scan {scan_number}")
-        plt.set(title=f"Scan {scan_number}", x_label=dev_x, y_label=dev_y)
-
-
-class BECFigureClientMixin:
+class BECGuiClientMixin:
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._process = None
-        self.update_script = update_script
+        self.update_script = self._get_update_script()
         self._target_endpoint = MessageEndpoints.scan_status()
         self._selected_device = None
         self.stderr_output = []
 
+    def _get_update_script(self) -> AutoUpdates:
+        eps = imd.entry_points(group="bec.widgets.auto_updates")
+        for ep in eps:
+            if ep.name == "plugin_widgets_update":
+                return ep.load()(figure=self)
+        return None
+
     @property
     def selected_device(self):
         """
@@ -138,7 +94,7 @@ class BECFigureClientMixin:
         )
 
     @staticmethod
-    def _handle_msg_update(msg: MessageObject, parent: BECFigureClientMixin) -> None:
+    def _handle_msg_update(msg: MessageObject, parent: BECGuiClientMixin) -> None:
         if parent.update_script is not None:
             # pylint: disable=protected-access
             parent._update_script_msg_parser(msg.value)
@@ -147,8 +103,7 @@ class BECFigureClientMixin:
         if isinstance(msg, messages.ScanStatusMessage):
             if not self.gui_is_alive():
                 return
-            if msg.status == "open":
-                self.update_script(self, msg)
+            self.update_script.run(msg)
 
     def show(self) -> None:
         """
@@ -166,7 +121,10 @@ class BECFigureClientMixin:
         """
         if self._process is None:
             return
-        self._run_rpc("close", (), wait_for_rpc_response=False)
+        if self.gui_is_alive():
+            self._run_rpc("close", (), wait_for_rpc_response=True)
+        else:
+            self._run_rpc("close", (), wait_for_rpc_response=False)
         self._process.terminate()
         self._process_output_processing_thread.join()
         self._process = None
@@ -178,10 +136,22 @@ class BECFigureClientMixin:
         """
         self._start_update_script()
         # pylint: disable=subprocess-run-check
+        config = self._client._service_config.redis
         monitor_module = importlib.import_module("bec_widgets.cli.server")
         monitor_path = monitor_module.__file__
+        gui_class = self.__class__.__name__
 
-        command = [sys.executable, "-u", monitor_path, "--id", self._gui_id]
+        command = [
+            sys.executable,
+            "-u",
+            monitor_path,
+            "--id",
+            self._gui_id,
+            "--config",
+            config,
+            "--gui_class",
+            gui_class,
+        ]
         self._process = subprocess.Popen(
             command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
         )
@@ -199,17 +169,33 @@ class BECFigureClientMixin:
         self.stderr_output.clear()
 
     def _get_output(self) -> str:
-        os.set_blocking(self._process.stdout.fileno(), False)
-        os.set_blocking(self._process.stderr.fileno(), False)
-        while self._process.poll() is None:
-            readylist, _, _ = select.select([self._process.stdout, self._process.stderr], [], [], 1)
-            if self._process.stdout in readylist:
-                # print("*"*10, self._process.stdout.read(1024), flush=True, end="")
-                self._process.stdout.read(1024)
-            if self._process.stderr in readylist:
-                # print("!"*10, self._process.stderr.read(1024), flush=True, end="", file=sys.stderr)
-                print(self._process.stderr.read(1024), flush=True, end="", file=sys.stderr)
-                self.stderr_output.append(self._process.stderr.read(1024))
+        try:
+            os.set_blocking(self._process.stdout.fileno(), False)
+            os.set_blocking(self._process.stderr.fileno(), False)
+            while self._process.poll() is None:
+                readylist, _, _ = select.select(
+                    [self._process.stdout, self._process.stderr], [], [], 1
+                )
+                if self._process.stdout in readylist:
+                    output = self._process.stdout.read(1024)
+                    if output:
+                        print(output, end="")
+                if self._process.stderr in readylist:
+                    error_output = self._process.stderr.read(1024)
+                    if error_output:
+                        print(error_output, end="", file=sys.stderr)
+                        self.stderr_output.append(error_output)
+        except Exception as e:
+            print(f"Error reading process output: {str(e)}")
+
+
+class RPCResponseTimeoutError(Exception):
+    """Exception raised when an RPC response is not received within the expected time."""
+
+    def __init__(self, request_id, timeout):
+        super().__init__(
+            f"RPC response not received within {timeout} seconds for request ID {request_id}"
+        )
 
 
 class RPCBase:
@@ -257,7 +243,7 @@ class RPCBase:
             parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
             metadata={"request_id": request_id},
         )
-        # print(f"RPCBase: {rpc_msg}")
+
         # pylint: disable=protected-access
         receiver = self._root._gui_id
         self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
@@ -292,16 +278,29 @@ class RPCBase:
             return cls(parent=self, **msg_result)
         return msg_result
 
-    def _wait_for_response(self, request_id):
+    def _wait_for_response(self, request_id: str, timeout: int = 5):
         """
         Wait for the response from the server.
+
+        Args:
+            request_id(str): The request ID.
+            timeout(int): The timeout in seconds.
+
+        Returns:
+            The response from the server.
         """
+        start_time = time.time()
         response = None
-        while response is None and self.gui_is_alive():
+
+        while response is None and self.gui_is_alive() and (time.time() - start_time) < timeout:
             response = self._client.connector.get(
                 MessageEndpoints.gui_instruction_response(request_id)
             )
             QCoreApplication.processEvents()  # keep UI responsive (and execute signals/slots)
+            time.sleep(0.1)
+        if response is None and (time.time() - start_time) >= timeout:
+            raise RPCResponseTimeoutError(request_id, timeout)
+
         return response
 
     def gui_is_alive(self):

bec_widgets/cli/generate_cli.py

@@ -22,7 +22,7 @@ else:
 class ClientGenerator:
     def __init__(self):
         self.header = """# This file was automatically generated by generate_cli.py\n
-from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
+from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECGuiClientMixin
 from typing import Literal, Optional, overload"""
 
         self.content = ""
@@ -41,6 +41,7 @@ from typing import Literal, Optional, overload"""
     def generate_content_for_class(self, cls):
         """
         Generate the content for the class.
+
         Args:
             cls: The class for which to generate the content.
         """
@@ -53,9 +54,9 @@ from typing import Literal, Optional, overload"""
         # from {module} import {class_name}"""
 
         # Generate the content
-        if cls.__name__ == "BECFigure":
+        if cls.__name__ == "BECDockArea":
             self.content += f"""
-class {class_name}(RPCBase, BECFigureClientMixin):"""
+class {class_name}(RPCBase, BECGuiClientMixin):"""
         else:
             self.content += f"""
 class {class_name}(RPCBase):"""
@@ -108,6 +109,7 @@ if __name__ == "__main__":  # pragma: no cover
     import os
 
     from bec_widgets.utils import BECConnector
+    from bec_widgets.widgets.dock import BECDock, BECDockArea
     from bec_widgets.widgets.figure import BECFigure
     from bec_widgets.widgets.plots import BECImageShow, BECMotorMap, BECPlotBase, BECWaveform
     from bec_widgets.widgets.plots.image import BECImageItem
@@ -124,6 +126,8 @@ if __name__ == "__main__":  # pragma: no cover
         BECConnector,
         BECImageItem,
         BECMotorMap,
+        BECDock,
+        BECDockArea,
     ]
     generator = ClientGenerator()
     generator.generate_client(clss)

bec_widgets/cli/rpc_register.py

@@ -0,0 +1,80 @@
+from threading import Lock
+from weakref import WeakValueDictionary
+
+from qtpy.QtCore import QObject
+
+
+class RPCRegister:
+    """
+    A singleton class that keeps track of all the RPC objects registered in the system for CLI usage.
+    """
+
+    _instance = None
+    _initialized = False
+    _lock = Lock()
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(RPCRegister, cls).__new__(cls)
+            cls._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self._rpc_register = WeakValueDictionary()
+        self._initialized = True
+
+    def add_rpc(self, rpc: QObject):
+        """
+        Add an RPC object to the register.
+
+        Args:
+            rpc(QObject): The RPC object to be added to the register.
+        """
+        if not hasattr(rpc, "gui_id"):
+            raise ValueError("RPC object must have a 'gui_id' attribute.")
+        self._rpc_register[rpc.gui_id] = rpc
+
+    def remove_rpc(self, rpc: str):
+        """
+        Remove an RPC object from the register.
+
+        Args:
+            rpc(str): The RPC object to be removed from the register.
+        """
+        if not hasattr(rpc, "gui_id"):
+            raise ValueError(f"RPC object {rpc} must have a 'gui_id' attribute.")
+        self._rpc_register.pop(rpc.gui_id, None)
+
+    def get_rpc_by_id(self, gui_id: str) -> QObject:
+        """
+        Get an RPC object by its ID.
+
+        Args:
+            gui_id(str): The ID of the RPC object to be retrieved.
+
+        Returns:
+            QObject: The RPC object with the given ID.
+        """
+        rpc_object = self._rpc_register.get(gui_id, None)
+        return rpc_object
+
+    def list_all_connections(self) -> dict:
+        """
+        List all the registered RPC objects.
+
+        Returns:
+            dict: A dictionary containing all the registered RPC objects.
+        """
+        with self._lock:
+            connections = dict(self._rpc_register)
+        return connections
+
+    @classmethod
+    def reset_singleton(cls):
+        """
+        Reset the singleton instance.
+        """
+        cls._instance = None
+        cls._initialized = False

bec_widgets/cli/rpc_wigdet_handler.py

@@ -0,0 +1,27 @@
+from bec_widgets.utils import BECConnector
+from bec_widgets.widgets.figure import BECFigure
+
+
+class RPCWidgetHandler:
+    """Handler class for creating widgets from RPC messages."""
+
+    widget_classes = {
+        "BECFigure": BECFigure,
+    }
+
+    @staticmethod
+    def create_widget(widget_type, **kwargs) -> BECConnector:
+        """
+        Create a widget from an RPC message.
+
+        Args:
+            widget_type(str): The type of the widget.
+            **kwargs: The keyword arguments for the widget.
+
+        Returns:
+            widget(BECConnector): The created widget.
+        """
+        widget_class = RPCWidgetHandler.widget_classes.get(widget_type)
+        if widget_class:
+            return widget_class(**kwargs)
+        raise ValueError(f"Unknown widget type: {widget_type}")

bec_widgets/cli/server.py

@@ -1,10 +1,15 @@
 import inspect
+import threading
+import time
+from typing import Literal, Union
 
 from bec_lib import MessageEndpoints, messages
 from qtpy.QtCore import QTimer
 
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.widgets.dock.dock_area import BECDockArea
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.plots import BECCurve, BECImageShow, BECWaveform
 
@@ -12,12 +17,21 @@ from bec_widgets.widgets.plots import BECCurve, BECImageShow, BECWaveform
 class BECWidgetsCLIServer:
     WIDGETS = [BECWaveform, BECFigure, BECCurve, BECImageShow]
 
-    def __init__(self, gui_id: str = None, dispatcher: BECDispatcher = None, client=None) -> None:
-        self.dispatcher = BECDispatcher() if dispatcher is None else dispatcher
+    def __init__(
+        self,
+        gui_id: str = None,
+        dispatcher: BECDispatcher = None,
+        client=None,
+        config=None,
+        gui_class: Union["BECFigure", "BECDockArea"] = BECFigure,
+    ) -> None:
+        self.dispatcher = BECDispatcher(config=config) if dispatcher is None else dispatcher
         self.client = self.dispatcher.client if client is None else client
         self.client.start()
         self.gui_id = gui_id
-        self.fig = BECFigure(gui_id=self.gui_id)
+        self.gui = gui_class(gui_id=self.gui_id)
+        self.rpc_register = RPCRegister()
+        self.rpc_register.add_rpc(self.gui)
 
         self.dispatcher.connect_slot(
             self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
@@ -27,15 +41,15 @@ class BECWidgetsCLIServer:
         self._shutdown_event = False
         self._heartbeat_timer = QTimer()
         self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
-        self._heartbeat_timer.start(1000)  # Emit heartbeat every 1 seconds
+        self._heartbeat_timer.start(200)  # Emit heartbeat every 1 seconds
 
     def on_rpc_update(self, msg: dict, metadata: dict):
         request_id = metadata.get("request_id")
         try:
+            obj = self.get_object_from_config(msg["parameter"])
             method = msg["action"]
             args = msg["parameter"].get("args", [])
             kwargs = msg["parameter"].get("kwargs", {})
-            obj = self.get_object_from_config(msg["parameter"])
             res = self.run_rpc(obj, method, args, kwargs)
         except Exception as e:
             print(e)
@@ -52,20 +66,10 @@ class BECWidgetsCLIServer:
 
     def get_object_from_config(self, config: dict):
         gui_id = config.get("gui_id")
-        # check if the object is the figure
-        if gui_id == self.fig.gui_id:
-            return self.fig
-        # check if the object is a widget
-        if gui_id in self.fig._widgets:
-            obj = self.fig._widgets[config["gui_id"]]
-            return obj
-        if self.fig._widgets:
-            for widget in self.fig._widgets.values():
-                item = widget.find_widget_by_id(gui_id)
-                if item:
-                    return item
-
-        raise ValueError(f"Object with gui_id {gui_id} not found")
+        obj = self.rpc_register.get_rpc_by_id(gui_id)
+        if obj is None:
+            raise ValueError(f"Object with gui_id {gui_id} not found")
+        return obj
 
     def run_rpc(self, obj, method, args, kwargs):
         method_obj = getattr(obj, method)
@@ -104,33 +108,59 @@ class BECWidgetsCLIServer:
                 messages.StatusMessage(name=self.gui_id, status=1, info={}),
                 expire=10,
             )
-        print("Heartbeat emitted")
 
-    def shutdown(self):
+    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
         self._shutdown_event = True
         self._heartbeat_timer.stop()
+        self.client.shutdown()
 
 
 if __name__ == "__main__":  # pragma: no cover
     import argparse
+    import os
     import sys
 
+    from qtpy.QtCore import QSize
+    from qtpy.QtGui import QIcon
     from qtpy.QtWidgets import QApplication, QMainWindow
 
     app = QApplication(sys.argv)
     app.setApplicationName("BEC Figure")
+    current_path = os.path.dirname(__file__)
+    icon = QIcon()
+    icon.addFile(os.path.join(current_path, "bec_widgets_icon.png"), size=QSize(48, 48))
+    app.setWindowIcon(icon)
+
     win = QMainWindow()
+    win.setWindowTitle("BEC Widgets")
 
     parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
     parser.add_argument("--id", type=str, help="The id of the server")
+    parser.add_argument(
+        "--gui_class",
+        type=str,
+        help="Name of the gui class to be rendered. Possible values: \n- BECFigure\n- BECDockArea",
+    )
+    parser.add_argument("--config", type=str, help="Config to connect to redis.")
 
     args = parser.parse_args()
 
-    server = BECWidgetsCLIServer(gui_id=args.id)
-    # server = BECWidgetsCLIServer(gui_id="test")
+    if args.gui_class == "BECFigure":
+        gui_class = BECFigure
+    elif args.gui_class == "BECDockArea":
+        gui_class = BECDockArea
+    else:
+        print(
+            "Please specify a valid gui_class to run. Use -h for help."
+            "\n Starting with default gui_class BECFigure."
+        )
+        gui_class = BECFigure
 
-    fig = server.fig
-    win.setCentralWidget(fig)
+    server = BECWidgetsCLIServer(gui_id=args.id, config=args.config, gui_class=gui_class)
+
+    gui = server.gui
+    win.setCentralWidget(gui)
+    win.resize(800, 600)
     win.show()
 
     app.aboutToQuit.connect(server.shutdown)

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -2,13 +2,17 @@ import os
 
 import numpy as np
 import pyqtgraph as pg
-from pyqtgraph.Qt import uic
+from pyqtgraph.Qt import QtWidgets, uic
 from qtconsole.inprocess import QtInProcessKernelManager
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from qtpy.QtCore import QSize
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.widgets import BECFigure
+from bec_widgets.widgets.dock.dock_area import BECDockArea
 
 
 class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
@@ -43,13 +47,24 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.safe_close = False
         # self.figure.clean_signal.connect(self.confirm_close)
 
+        self.register = RPCRegister()
+        self.register.add_rpc(self.figure)
+
         # console push
         self.console.kernel_manager.kernel.shell.push(
             {
                 "fig": self.figure,
+                "register": self.register,
+                "dock": self.dock,
                 "w1": self.w1,
                 "w2": self.w2,
                 "w3": self.w3,
+                "d1": self.d1,
+                "d2": self.d2,
+                "d3": self.d3,
+                "b2a": self.button_2_a,
+                "b2b": self.button_2_b,
+                "b2c": self.button_2_c,
                 "bec": self.figure.client,
                 "scans": self.figure.client.scans,
                 "dev": self.figure.client.device_manager.devices,
@@ -62,9 +77,16 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.figure = BECFigure(parent=self, gui_id="remote")  # Create a new BECDeviceMonitor
         self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout
 
+        self.dock_layout = QVBoxLayout(self.dock_placeholder)
+        self.dock = BECDockArea(gui_id="remote")
+        self.dock_layout.addWidget(self.dock)
+
         # add stuff to figure
         self._init_figure()
 
+        # init dock for testing
+        self._init_dock()
+
         self.console_layout = QVBoxLayout(self.widget_console)
         self.console = JupyterConsoleWidget()
         self.console_layout.addWidget(self.console)
@@ -86,6 +108,36 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.w1.add_curve_scan("samx", "samy", "bpm3a", pen_style="dash")
         self.c1 = self.w1.get_config()
 
+    def _init_dock(self):
+        self.button_1 = QtWidgets.QPushButton("Button 1 ")
+        self.button_2_a = QtWidgets.QPushButton("Button to be added at place 0,0 in d3")
+        self.button_2_b = QtWidgets.QPushButton("button after without postions specified")
+        self.button_2_c = QtWidgets.QPushButton("button super late")
+        self.button_3 = QtWidgets.QPushButton("Button above Figure ")
+        self.label_1 = QtWidgets.QLabel("some scan info label with useful information")
+
+        self.label_2 = QtWidgets.QLabel("label which is added separately")
+        self.label_3 = QtWidgets.QLabel("Label above figure")
+
+        self.d1 = self.dock.add_dock(widget=self.button_1, position="left")
+        self.d1.addWidget(self.label_2)
+        self.d2 = self.dock.add_dock(widget=self.label_1, position="right")
+        self.d3 = self.dock.add_dock(name="figure")
+        self.fig_dock3 = BECFigure()
+        self.fig_dock3.plot("samx", "bpm4d")
+        self.d3.add_widget(self.label_3)
+        self.d3.add_widget(self.button_3)
+        self.d3.add_widget(self.fig_dock3)
+
+        self.dock.save_state()
+
+    def closeEvent(self, event):
+        """Override to handle things when main window is closed."""
+        self.dock.cleanup()
+        self.figure.clear_all()
+        self.figure.client.shutdown()
+        super().closeEvent(event)
+
 
 if __name__ == "__main__":  # pragma: no cover
     import sys
@@ -96,7 +148,12 @@ if __name__ == "__main__":  # pragma: no cover
 
     app = QApplication(sys.argv)
     app.setApplicationName("Jupyter Console")
+    app.setApplicationDisplayName("Jupyter Console")
+    icon = QIcon()
+    icon.addFile("terminal_icon.png", size=QSize(48, 48))
+    app.setWindowIcon(icon)
     win = JupyterConsoleWindow()
     win.show()
 
+    app.aboutToQuit.connect(win.close)
     sys.exit(app.exec_())

bec_widgets/examples/jupyter_console/jupyter_console_window.ui

@@ -13,13 +13,37 @@
   <property name="windowTitle">
    <string>Plotting Console</string>
   </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
+  <layout class="QVBoxLayout" name="verticalLayout_4">
    <item>
     <widget class="QSplitter" name="splitter">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
-     <widget class="QWidget" name="glw" native="true"/>
+     <widget class="QTabWidget" name="tabWidget">
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="QWidget" name="tab_1">
+       <attribute name="title">
+        <string>BECDock</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="verticalLayout">
+        <item>
+         <widget class="QWidget" name="dock_placeholder" native="true"/>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="tab_2">
+       <attribute name="title">
+        <string>BECFigure</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="verticalLayout_3">
+        <item>
+         <widget class="QWidget" name="glw" native="true"/>
+        </item>
+       </layout>
+      </widget>
+     </widget>
      <widget class="QWidget" name="widget_console" native="true"/>
     </widget>
    </item>

bec_widgets/utils/__init__.py

@@ -2,7 +2,9 @@ from .bec_connector import BECConnector, ConnectionConfig
 from .bec_dispatcher import BECDispatcher
 from .bec_table import BECTable
 from .colors import Colors
+from .container_utils import WidgetContainerUtils
 from .crosshair import Crosshair
 from .entry_validator import EntryValidator
+from .layout_manager import GridLayoutManager
 from .rpc_decorator import register_rpc_methods, rpc_public
 from .validator_delegate import DoubleValidationDelegate

bec_widgets/utils/bec_connector.py

@@ -7,6 +7,7 @@ from typing import Optional, Type
 from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import Slot as pyqtSlot
 
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 
@@ -31,7 +32,7 @@ class ConnectionConfig(BaseModel):
 class BECConnector:
     """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
 
-    USER_ACCESS = ["config_dict"]
+    USER_ACCESS = ["config_dict", "get_all_rpc"]
 
     def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
         # BEC related connections
@@ -54,10 +55,30 @@ class BECConnector:
         else:
             self.gui_id = self.config.gui_id
 
+        # register widget to rpc register
+        self.rpc_register = RPCRegister()
+        self.rpc_register.add_rpc(self)
+
+    def get_all_rpc(self) -> dict:
+        """Get all registered RPC objects."""
+        all_connections = self.rpc_register.list_all_connections()
+        return dict(all_connections)
+
+    @property
+    def rpc_id(self) -> str:
+        """Get the RPC ID of the widget."""
+        return self.gui_id
+
+    @rpc_id.setter
+    def rpc_id(self, rpc_id: str) -> None:
+        """Set the RPC ID of the widget."""
+        self.gui_id = rpc_id
+
     @property
     def config_dict(self) -> dict:
         """
         Get the configuration of the widget.
+
         Returns:
             dict: The configuration of the widget.
         """
@@ -67,6 +88,7 @@ class BECConnector:
     def config_dict(self, config: BaseModel) -> None:
         """
         Get the configuration of the widget.
+
         Returns:
             dict: The configuration of the widget.
         """
@@ -76,6 +98,7 @@ class BECConnector:
     def set_gui_id(self, gui_id: str) -> None:
         """
         Set the GUI ID for the widget.
+
         Args:
             gui_id(str): GUI ID
         """
@@ -96,6 +119,7 @@ class BECConnector:
 
     def update_client(self, client) -> None:
         """Update the client and device manager from BEC and create object for BEC shortcuts.
+
         Args:
             client: BEC client
         """
@@ -106,6 +130,7 @@ class BECConnector:
     def on_config_update(self, config: ConnectionConfig | dict) -> None:
         """
         Update the configuration for the widget.
+
         Args:
             config(ConnectionConfig): Configuration settings.
         """
@@ -118,8 +143,10 @@ class BECConnector:
     def get_config(self, dict_output: bool = True) -> dict | BaseModel:
         """
         Get the configuration of the widget.
+
         Args:
             dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
+
         Returns:
             dict: The configuration of the plot widget.
         """
@@ -127,3 +154,15 @@ class BECConnector:
             return self.config.model_dump()
         else:
             return self.config
+
+    def cleanup(self):
+        """Cleanup the widget."""
+        self.rpc_register.remove_rpc(self)
+        all_connections = self.rpc_register.list_all_connections()
+        if len(all_connections) == 0:
+            print("No more connections. Shutting down GUI BEC client.")
+            self.client.shutdown()
+
+    # def closeEvent(self, event):
+    #     self.cleanup()
+    #     super().closeEvent(event)

bec_widgets/utils/bec_dispatcher.py

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, Union
 
 import redis
-from bec_lib import BECClient
+from bec_lib import BECClient, ServiceConfig
 from bec_lib.redis_connector import MessageObject, RedisConnector
 from qtpy.QtCore import QObject
 from qtpy.QtCore import Signal as pyqtSignal
@@ -71,13 +71,13 @@ class BECDispatcher:
     _instance = None
     _initialized = False
 
-    def __new__(cls, client=None, *args, **kwargs):
+    def __new__(cls, client=None, config: str = None, *args, **kwargs):
         if cls._instance is None:
             cls._instance = super(BECDispatcher, cls).__new__(cls)
             cls._initialized = False
         return cls._instance
 
-    def __init__(self, client=None):
+    def __init__(self, client=None, config: str = None):
         if self._initialized:
             return
 
@@ -85,7 +85,14 @@ class BECDispatcher:
         self.client = client
 
         if self.client is None:
-            self.client = BECClient(connector_cls=QtRedisConnector, forced=True)
+            if config is not None:
+                host, port = config.split(":")
+                redis_config = {"host": host, "port": port}
+                self.client = BECClient(
+                    config=ServiceConfig(redis=redis_config), connector_cls=QtRedisConnector
+                )  # , forced=True)
+            else:
+                self.client = BECClient(connector_cls=QtRedisConnector)  # , forced=True)
         else:
             if self.client.started:
                 # have to reinitialize client to use proper connector
@@ -122,7 +129,15 @@ class BECDispatcher:
         self._slots[slot].update(set(topics_str))
 
     def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
-        self.client.connector.unregister(topics, cb=slot)
+        # find the right slot to disconnect from ;
+        # slot callbacks are wrapped in QtThreadSafeCallback objects,
+        # but the slot we receive here is the original callable
+        for connected_slot in self._slots:
+            if connected_slot.cb == slot:
+                break
+        else:
+            return
+        self.client.connector.unregister(topics, cb=connected_slot)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
         self._slots[slot].difference_update(set(topics_str))
         if not self._slots[slot]:

bec_widgets/utils/bec_table.py

@@ -8,6 +8,7 @@ class BECTable(QTableWidget):
     def keyPressEvent(self, event) -> None:
         """
         Delete selected rows with backspace or delete key
+
         Args:
             event: keyPressEvent
         """

bec_widgets/utils/container_utils.py

@@ -0,0 +1,48 @@
+import itertools
+from typing import Type
+
+from qtpy.QtWidgets import QWidget
+
+
+class WidgetContainerUtils:
+
+    @staticmethod
+    def generate_unique_widget_id(container: dict, prefix: str = "widget") -> str:
+        """
+        Generate a unique widget ID.
+
+        Args:
+            container(dict): The container of widgets.
+            prefix(str): The prefix of the widget ID.
+
+        Returns:
+            widget_id(str): The unique widget ID.
+        """
+        existing_ids = set(container.keys())
+        for i in itertools.count(1):
+            widget_id = f"{prefix}_{i}"
+            if widget_id not in existing_ids:
+                return widget_id
+
+    @staticmethod
+    def find_first_widget_by_class(
+        container: dict, widget_class: Type[QWidget], can_fail: bool = True
+    ) -> QWidget | None:
+        """
+        Find the first widget of a given class in the figure.
+
+        Args:
+            container(dict): The container of widgets.
+            widget_class(Type): The class of the widget to find.
+            can_fail(bool): If True, the method will return None if no widget is found. If False, it will raise an error.
+
+        Returns:
+            widget: The widget of the given class.
+        """
+        for widget_id, widget in container.items():
+            if isinstance(widget, widget_class):
+                return widget
+        if can_fail:
+            return None
+        else:
+            raise ValueError(f"No widget of class {widget_class} found.")

bec_widgets/utils/crosshair.py

@@ -17,6 +17,7 @@ class Crosshair(QObject):
     def __init__(self, plot_item: pg.PlotItem, precision: int = None, parent=None):
         """
         Crosshair for 1D and 2D plots.
+
         Args:
             plot_item (pyqtgraph.PlotItem): The plot item to which the crosshair will be attached.
             precision (int, optional): Number of decimal places to round the coordinates to. Defaults to None.

bec_widgets/utils/ctrl_c.py

@@ -1,39 +0,0 @@
-# TODO haven't found yet how to deal with QAbstractSocket in qtpy
-# import signal
-# import socket
-# from PyQt5.QtNetwork import QAbstractSocket
-#
-#
-# def setup(app):
-#     app.signalwatchdog = SignalWatchdog()  # need to store to keep socket pair alive
-#     signal.signal(signal.SIGINT, make_quit_handler(app))
-#
-#
-# def make_quit_handler(app):
-#     def handler(*args):
-#         print()  # make ^C appear on its own line
-#         app.quit()
-#
-#     return handler
-#
-#
-# class SignalWatchdog(QAbstractSocket):
-#     def __init__(self):
-#         """
-#         Propagates system signals from Python to QEventLoop
-#         adapted from https://stackoverflow.com/a/65802260/655404
-#         """
-#         super().__init__(QAbstractSocket.SctpSocket, None)
-#
-#         self.writer, self.reader = writer, reader = socket.socketpair()
-#         writer.setblocking(False)
-#
-#         fd_writer = writer.fileno()
-#         fd_reader = reader.fileno()
-#
-#         signal.set_wakeup_fd(fd_writer)  # Python hook
-#         self.setSocketDescriptor(fd_reader)  # Qt hook
-#
-#         self.readyRead.connect(
-#             lambda: None
-#         )  # dummy function call that lets the Python interpreter run

bec_widgets/utils/entry_validator.py

@@ -3,6 +3,16 @@ class EntryValidator:
         self.devices = devices
 
     def validate_signal(self, name: str, entry: str = None) -> str:
+        """
+        Validate a signal entry for a given device. If the entry is not provided, the first signal entry will be used from the device hints.
+
+        Args:
+            name(str): Device name
+            entry(str): Signal entry
+
+        Returns:
+            str: Signal entry
+        """
         if name not in self.devices:
             raise ValueError(f"Device '{name}' not found in current BEC session")
 
@@ -15,3 +25,18 @@ class EntryValidator:
             raise ValueError(f"Entry '{entry}' not found in device '{name}' signals")
 
         return entry
+
+    def validate_monitor(self, monitor: str) -> str:
+        """
+        Validate a monitor entry for a given device.
+
+        Args:
+            monitor(str): Monitor entry
+
+        Returns:
+            str: Monitor entry
+        """
+        if monitor not in self.devices:
+            raise ValueError(f"Device '{monitor}' not found in current BEC session")
+
+        return monitor

bec_widgets/utils/layout_manager.py

@@ -0,0 +1,121 @@
+from collections import OrderedDict
+from typing import Literal
+
+from qtpy.QtWidgets import QGridLayout, QWidget
+
+
+class GridLayoutManager:
+    """
+    GridLayoutManager class is used to manage widgets in a QGridLayout and extend its functionality.
+
+    The GridLayoutManager class provides methods to add, move, and check the position of widgets in a QGridLayout.
+    It also provides a method to get the positions of all widgets in the layout.
+
+    Args:
+        layout(QGridLayout): The layout to manage.
+    """
+
+    def __init__(self, layout: QGridLayout):
+        self.layout = layout
+
+    def is_position_occupied(self, row: int, col: int) -> bool:
+        """
+        Check if the position in the layout is occupied by a widget.
+
+        Args:
+            row(int): The row to check.
+            col(int): The column to check.
+
+        Returns:
+            bool: True if the position is occupied, False otherwise.
+        """
+        for i in range(self.layout.count()):
+            widget_row, widget_col, _, _ = self.layout.getItemPosition(i)
+            if widget_row == row and widget_col == col:
+                return True
+        return False
+
+    def shift_widgets(
+        self,
+        direction: Literal["down", "up", "left", "right"] = "down",
+        start_row: int = 0,
+        start_col: int = 0,
+    ):
+        """
+        Shift widgets in the layout in the specified direction starting from the specified position.
+
+        Args:
+            direction(str): The direction to shift the widgets. Can be "down", "up", "left", or "right".
+            start_row(int): The row to start shifting from. Default is 0.
+            start_col(int): The column to start shifting from. Default is 0.
+        """
+        for i in reversed(range(self.layout.count())):
+            widget_item = self.layout.itemAt(i)
+            widget = widget_item.widget()
+            row, col, rowspan, colspan = self.layout.getItemPosition(i)
+            if direction == "down" and row >= start_row:
+                self.layout.addWidget(widget, row + 1, col, rowspan, colspan)
+            elif direction == "up" and row > start_row:
+                self.layout.addWidget(widget, row - 1, col, rowspan, colspan)
+            elif direction == "right" and col >= start_col:
+                self.layout.addWidget(widget, row, col + 1, rowspan, colspan)
+            elif direction == "left" and col > start_col:
+                self.layout.addWidget(widget, row, col - 1, rowspan, colspan)
+
+    def move_widget(self, widget: QWidget, new_row: int, new_col: int):
+        """
+        Move a widget to a new position in the layout.
+
+        Args:
+            widget(QWidget): The widget to move.
+            new_row(int): The new row to move the widget to.
+            new_col(int): The new column to move the widget to.
+        """
+        self.layout.removeWidget(widget)
+        self.layout.addWidget(widget, new_row, new_col)
+
+    def add_widget(
+        self,
+        widget: QWidget,
+        row=None,
+        col=0,
+        rowspan=1,
+        colspan=1,
+        shift: Literal["down", "up", "left", "right"] = "down",
+    ):
+        """
+        Add a widget to the layout at the specified position.
+
+        Args:
+            widget(QWidget): The widget to add.
+            row(int): The row to add the widget to. If None, the widget will be added to the next available row.
+            col(int): The column to add the widget to. Default is 0.
+            rowspan(int): The number of rows the widget will span. Default is 1.
+            colspan(int): The number of columns the widget will span. Default is 1.
+            shift(str): The direction to shift the widgets if the position is occupied. Can be "down", "up", "left", or "right".
+        """
+        if row is None:
+            row = self.layout.rowCount()
+        if self.is_position_occupied(row, col):
+            self.shift_widgets(shift, start_row=row)
+        self.layout.addWidget(widget, row, col, rowspan, colspan)
+
+    def get_widgets_positions(self) -> dict:
+        """
+        Get the positions of all widgets in the layout.
+        Returns:
+            dict: A dictionary with the positions of the widgets in the layout.
+
+        """
+        positions = []
+        for i in range(self.layout.count()):
+            widget_item = self.layout.itemAt(i)
+            widget = widget_item.widget()
+            if widget:
+                position = self.layout.getItemPosition(i)
+                positions.append((position, widget))
+        positions.sort(key=lambda x: (x[0][0], x[0][1], x[0][2], x[0][3]))
+        ordered_positions = OrderedDict()
+        for pos, widget in positions:
+            ordered_positions[pos] = widget
+        return ordered_positions

bec_widgets/utils/plugin_utils.py

@@ -0,0 +1,40 @@
+import inspect
+
+from bec_lib.plugin_helper import _get_available_plugins
+
+from bec_widgets.utils import BECConnector
+
+
+def get_plugin_widgets() -> dict[str, BECConnector]:
+    """
+    Get all available widgets from the plugin directory. Widgets are classes that inherit from BECConnector.
+    The plugins are provided through python plugins and specified in the respective pyproject.toml file using
+    the following key:
+
+        [project.entry-points."bec.widgets.user_widgets"]
+        plugin_widgets = "path.to.plugin.module"
+
+    e.g.
+        [project.entry-points."bec.widgets.user_widgets"]
+        plugin_widgets = "pxiii_bec.bec_widgets.widgets"
+
+        assuming that the widgets module for the package pxiii_bec is located at pxiii_bec/bec_widgets/widgets and
+        contains the widgets to be loaded within the pxiii_bec/bec_widgets/widgets/__init__.py file.
+
+    Returns:
+        dict[str, BECConnector]: A dictionary of widget names and their respective classes.
+    """
+    modules = _get_available_plugins("bec.widgets.user_widgets")
+    loaded_plugins = {}
+    print(modules)
+    for module in modules:
+        mods = inspect.getmembers(module, predicate=_filter_plugins)
+        for name, mod_cls in mods:
+            if name in loaded_plugins:
+                print(f"Duplicated widgets plugin {name}.")
+            loaded_plugins[name] = mod_cls
+    return loaded_plugins
+
+
+def _filter_plugins(obj):
+    return inspect.isclass(obj) and issubclass(obj, BECConnector)

bec_widgets/utils/thread_checker.py

@@ -0,0 +1,37 @@
+import threading
+
+
+class ThreadTracker:
+    def __init__(self, exclude_names=None):
+        self.exclude_names = exclude_names if exclude_names else []
+        self.initial_threads = self._capture_threads()
+
+    def _capture_threads(self):
+        return set(
+            th
+            for th in threading.enumerate()
+            if not any(ex_name in th.name for ex_name in self.exclude_names)
+            and th is not threading.main_thread()
+        )
+
+    def _thread_info(self, threads):
+        return ", \n".join(f"{th.name}(ID: {th.ident})" for th in threads)
+
+    def check_unfinished_threads(self):
+        current_threads = self._capture_threads()
+        additional_threads = current_threads - self.initial_threads
+        closed_threads = self.initial_threads - current_threads
+        if additional_threads:
+            raise Exception(
+                f"###### Initial threads ######:\n {self._thread_info(self.initial_threads)}\n"
+                f"###### Current threads ######:\n {self._thread_info(current_threads)}\n"
+                f"###### Closed threads ######:\n {self._thread_info(closed_threads)}\n"
+                f"###### Unfinished threads ######:\n {self._thread_info(additional_threads)}"
+            )
+        else:
+            print(
+                "All threads properly closed.\n"
+                f"###### Initial threads ######:\n {self._thread_info(self.initial_threads)}\n"
+                f"###### Current threads ######:\n {self._thread_info(current_threads)}\n"
+                f"###### Closed threads ######:\n {self._thread_info(closed_threads)}"
+            )

bec_widgets/utils/widget_io.py

@@ -114,6 +114,7 @@ class WidgetIO:
     def get_value(widget, ignore_errors=False):
         """
         Retrieve value from the widget instance.
+
         Args:
             widget: Widget instance.
             ignore_errors(bool, optional): Whether to ignore if no handler is found.
@@ -129,6 +130,7 @@ class WidgetIO:
     def set_value(widget, value, ignore_errors=False):
         """
         Set a value on the widget instance.
+
         Args:
             widget: Widget instance.
             value: Value to set.
@@ -155,6 +157,7 @@ class WidgetHierarchy:
     ) -> None:
         """
         Print the widget hierarchy to the console.
+
         Args:
             widget: Widget to print the hierarchy of
             indent(int, optional): Level of indentation.
@@ -196,6 +199,7 @@ class WidgetHierarchy:
     ) -> dict:
         """
         Export the widget hierarchy to a dictionary.
+
         Args:
             widget: Widget to print the hierarchy of.
             config(dict,optional): Dictionary to export the hierarchy to.
@@ -245,6 +249,7 @@ class WidgetHierarchy:
     def import_config_from_dict(widget, config: dict, set_values: bool = False) -> None:
         """
         Import the widget hierarchy from a dictionary.
+
         Args:
             widget: Widget to import the hierarchy to.
             config:

bec_widgets/utils/yaml_dialog.py

@@ -9,6 +9,7 @@ from qtpy.QtWidgets import QFileDialog
 def load_yaml(instance) -> Union[dict, None]:
     """
     Load YAML file from disk.
+
     Args:
         instance: Instance of the calling widget.
 
@@ -40,6 +41,7 @@ def load_yaml(instance) -> Union[dict, None]:
 def save_yaml(instance, config: dict) -> None:
     """
     Save YAML file to disk.
+
     Args:
         instance: Instance of the calling widget.
         config: Configuration data to be saved.

bec_widgets/validation/monitor_config_validator.py

@@ -8,7 +8,7 @@ class Signal(BaseModel):
     """
     Represents a signal in a plot configuration.
 
-    Attributes:
+    Args:
         name (str): The name of the signal.
         entry (Optional[str]): The entry point of the signal, optional.
     """
@@ -21,6 +21,7 @@ class Signal(BaseModel):
     def validate_fields(cls, values):
         """Validate the fields of the model.
         First validate the 'name' field, then validate the 'entry' field.
+
         Args:
             values (dict): The values to be validated."""
         devices = MonitorConfigValidator.devices

bec_widgets/widgets/__init__.py

@@ -1,4 +1,4 @@
-from .editor import BECEditor
+from .dock import BECDock, BECDockArea
 from .figure import BECFigure, FigureConfig
 from .monitor import BECMonitor
 from .motor_control import (

bec_widgets/widgets/dock/__init__.py

@@ -0,0 +1,2 @@
+from .dock import BECDock
+from .dock_area import BECDockArea

bec_widgets/widgets/dock/dock.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, Optional
+
+from pydantic import Field
+from pyqtgraph.dockarea import Dock
+
+from bec_widgets.cli.rpc_wigdet_handler import RPCWidgetHandler
+from bec_widgets.utils import BECConnector, ConnectionConfig, GridLayoutManager
+
+if TYPE_CHECKING:
+    from qtpy.QtWidgets import QWidget
+
+    from bec_widgets.widgets import BECDockArea
+
+
+class DockConfig(ConnectionConfig):
+    widgets: dict[str, ConnectionConfig] = Field({}, description="The widgets in the dock.")
+    position: Literal["bottom", "top", "left", "right", "above", "below"] = Field(
+        "bottom", description="The position of the dock."
+    )
+    parent_dock_area: Optional[str] = Field(
+        None, description="The GUI ID of parent dock area of the dock."
+    )
+
+
+class BECDock(BECConnector, Dock):
+    USER_ACCESS = [
+        "rpc_id",
+        "widget_list",
+        "show_title_bar",
+        "hide_title_bar",
+        "get_widgets_positions",
+        "set_title",
+        "add_widget_bec",
+        "list_eligible_widgets",
+        "move_widget",
+        "remove_widget",
+        "remove",
+        "attach",
+        "detach",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        parent_dock_area: BECDockArea | None = None,
+        config: DockConfig | None = None,
+        name: str | None = None,
+        client=None,
+        gui_id: str | None = None,
+        **kwargs,
+    ) -> None:
+        if config is None:
+            config = DockConfig(
+                widget_class=self.__class__.__name__, parent_dock_area=parent_dock_area.gui_id
+            )
+        else:
+            if isinstance(config, dict):
+                config = DockConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        Dock.__init__(self, name=name, **kwargs)
+
+        self.parent_dock_area = parent_dock_area
+
+        # Layout Manager
+        self.layout_manager = GridLayoutManager(self.layout)
+
+    def dropEvent(self, event):
+        source = event.source()
+        old_area = source.area
+        self.setOrientation("horizontal", force=True)
+        super().dropEvent(event)
+        if old_area in self.parent_dock_area.tempAreas and old_area != self.parent_dock_area:
+            self.parent_dock_area.removeTempArea(old_area)
+
+    def float(self):
+        """
+        Float the dock.
+        Overwrites the default pyqtgraph dock float.
+        """
+
+        # need to check if the dock is temporary and if it is the only dock in the area
+        # fixes bug in pyqtgraph detaching
+        if self.area.temporary == True and len(self.area.docks) <= 1:
+            return
+        elif self.area.temporary == True and len(self.area.docks) > 1:
+            self.area.docks.pop(self.name(), None)
+            super().float()
+        else:
+            super().float()
+
+    @property
+    def widget_list(self) -> list:
+        """
+        Get the widgets in the dock.
+
+        Returns:
+            widgets(list): The widgets in the dock.
+        """
+        return self.widgets
+
+    @widget_list.setter
+    def widget_list(self, value: list):
+        self.widgets = value
+
+    def hide_title_bar(self):
+        """
+        Hide the title bar of the dock.
+        """
+        # self.hideTitleBar() #TODO pyqtgraph looks bugged ATM, doing my implementation
+        self.label.hide()
+        self.labelHidden = True
+
+    def show_title_bar(self):
+        """
+        Hide the title bar of the dock.
+        """
+        # self.showTitleBar() #TODO pyqtgraph looks bugged ATM, doing my implementation
+        self.label.show()
+        self.labelHidden = False
+
+    def set_title(self, title: str):
+        """
+        Set the title of the dock.
+
+        Args:
+            title(str): The title of the dock.
+        """
+        self.parent_dock_area.docks[title] = self.parent_dock_area.docks.pop(self.name())
+        self.setTitle(title)
+
+    def get_widgets_positions(self) -> dict:
+        """
+        Get the positions of the widgets in the dock.
+
+        Returns:
+            dict: The positions of the widgets in the dock as dict -> {(row, col, rowspan, colspan):widget}
+        """
+        return self.layout_manager.get_widgets_positions()
+
+    def list_eligible_widgets(
+        self,
+    ) -> list:  # TODO can be moved to some util mixin like container class for rpc widgets
+        """
+        List all widgets that can be added to the dock.
+
+        Returns:
+            list: The list of eligible widgets.
+        """
+        return list(RPCWidgetHandler.widget_classes.keys())
+
+    def add_widget_bec(
+        self,
+        widget_type: str,
+        row=None,
+        col=0,
+        rowspan=1,
+        colspan=1,
+        shift: Literal["down", "up", "left", "right"] = "down",
+    ):
+        """
+        Add a widget to the dock.
+
+        Args:
+            widget_type(str): The widget to add. Only BEC RPC widgets from RPCWidgetHandler are allowed.
+            row(int): The row to add the widget to. If None, the widget will be added to the next available row.
+            col(int): The column to add the widget to.
+            rowspan(int): The number of rows the widget should span.
+            colspan(int): The number of columns the widget should span.
+            shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
+        """
+        if row is None:
+            row = self.layout.rowCount()
+
+        if self.layout_manager.is_position_occupied(row, col):
+            self.layout_manager.shift_widgets(shift, start_row=row)
+
+        widget = RPCWidgetHandler.create_widget(widget_type)
+        self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+
+        return widget
+
+    def add_widget(
+        self,
+        widget: QWidget,
+        row=None,
+        col=0,
+        rowspan=1,
+        colspan=1,
+        shift: Literal["down", "up", "left", "right"] = "down",
+    ):
+        """
+        Add a widget to the dock.
+
+        Args:
+            widget(QWidget): The widget to add.
+            row(int): The row to add the widget to. If None, the widget will be added to the next available row.
+            col(int): The column to add the widget to.
+            rowspan(int): The number of rows the widget should span.
+            colspan(int): The number of columns the widget should span.
+            shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
+        """
+        if row is None:
+            row = self.layout.rowCount()
+
+        if self.layout_manager.is_position_occupied(row, col):
+            self.layout_manager.shift_widgets(shift, start_row=row)
+
+        self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+
+    def move_widget(self, widget: QWidget, new_row: int, new_col: int):
+        """
+        Move a widget to a new position in the layout.
+
+        Args:
+            widget(QWidget): The widget to move.
+            new_row(int): The new row to move the widget to.
+            new_col(int): The new column to move the widget to.
+        """
+        self.layout_manager.move_widget(widget, new_row, new_col)
+
+    def attach(self):
+        """
+        Attach the dock to the parent dock area.
+        """
+        self.parent_dock_area.removeTempArea(self.area)
+
+    def detach(self):
+        """
+        Detach the dock from the parent dock area.
+        """
+        self.float()
+
+    def remove_widget(self, widget_rpc_id: str):
+        """
+        Remove a widget from the dock.
+
+        Args:
+            widget_rpc_id(str): The ID of the widget to remove.
+        """
+        widget = self.rpc_register.get_rpc_by_id(widget_rpc_id)
+        self.layout.removeWidget(widget)
+        widget.close()
+
+    def remove(self):
+        """
+        Remove the dock from the parent dock area.
+        """
+        # self.cleanup()
+        self.parent_dock_area.remove_dock(self.name())
+
+    def cleanup(self):
+        """
+        Clean up the dock, including all its widgets.
+        """
+        for widget in self.widgets:
+            if hasattr(widget, "cleanup"):
+                widget.cleanup()
+        super().cleanup()
+
+    def close(self):
+        """
+        Close the dock area and cleanup.
+        Has to be implemented to overwrite pyqtgraph event accept in Container close.
+        """
+        self.cleanup()
+        super().close()

bec_widgets/widgets/dock/dock_area.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+from weakref import WeakValueDictionary
+
+from pydantic import Field
+from pyqtgraph.dockarea.DockArea import DockArea
+from qtpy.QtCore import Qt
+from qtpy.QtGui import QPainter, QPaintEvent
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import BECConnector, ConnectionConfig, WidgetContainerUtils
+
+from .dock import BECDock, DockConfig
+
+
+class DockAreaConfig(ConnectionConfig):
+    docks: dict[str, DockConfig] = Field({}, description="The docks in the dock area.")
+
+
+class BECDockArea(BECConnector, DockArea):
+    USER_ACCESS = [
+        "panels",
+        "save_state",
+        "remove_dock",
+        "restore_state",
+        "add_dock",
+        "clear_all",
+        "detach_dock",
+        "attach_all",
+        "get_all_rpc",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        config: DockAreaConfig | None = None,
+        client=None,
+        gui_id: str = None,
+    ) -> None:
+        if config is None:
+            config = DockAreaConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = DockAreaConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        DockArea.__init__(self, parent=parent)
+
+        self._instructions_visible = True
+
+    def paintEvent(self, event: QPaintEvent):
+        super().paintEvent(event)
+        if self._instructions_visible:
+            painter = QPainter(self)
+            painter.drawText(self.rect(), Qt.AlignCenter, "Add docks using 'add_dock' method")
+
+    @property
+    def panels(self) -> dict:
+        """
+        Get the docks in the dock area.
+        Returns:
+            dock_dict(dict): The docks in the dock area.
+        """
+        return dict(self.docks)
+
+    @panels.setter
+    def panels(self, value: dict):
+
+        self.docks = WeakValueDictionary(value)
+
+    def restore_state(
+        self,
+        state: dict = None,
+        missing: Literal["ignore", "error"] = "ignore",
+        extra="bottom",
+    ):
+        """
+        Restore the state of the dock area. If no state is provided, the last state is restored.
+
+        Args:
+            state(dict): The state to restore.
+            missing(Literal['ignore','error']): What to do if a dock is missing.
+            extra(str): Extra docks that are in the dockarea but that are not mentioned in state will be added to the bottom of the dockarea, unless otherwise specified by the extra argument.
+        """
+        if state is None:
+            state = self._last_state
+        self.restoreState(state, missing=missing, extra=extra)
+
+    def save_state(self) -> dict:
+        """
+        Save the state of the dock area.
+
+        Returns:
+            dict: The state of the dock area.
+        """
+        self._last_state = self.saveState()
+        return self._last_state
+
+    def remove_dock(self, name: str):
+        """
+        Remove a dock by name and ensure it is properly closed and cleaned up.
+
+        Args:
+            name(str): The name of the dock to remove.
+        """
+        dock = self.docks.pop(name, None)
+        if dock:
+            dock.close()
+            if len(self.docks) <= 1:
+                for dock in self.docks.values():
+                    dock.hide_title_bar()
+
+        else:
+            raise ValueError(f"Dock with name {name} does not exist.")
+
+    def add_dock(
+        self,
+        name: str = None,
+        position: Literal["bottom", "top", "left", "right", "above", "below"] = None,
+        relative_to: BECDock | None = None,
+        closable: bool = False,
+        prefix: str = "dock",
+        widget: str | QWidget | None = None,
+        row: int = None,
+        col: int = 0,
+        rowspan: int = 1,
+        colspan: int = 1,
+    ) -> BECDock:
+        """
+        Add a dock to the dock area. Dock has QGridLayout as layout manager by default.
+
+        Args:
+            name(str): The name of the dock to be displayed and for further references. Has to be unique.
+            position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
+            relative_to(BECDock): The dock to which the new dock should be added relative to.
+            closable(bool): Whether the dock is closable.
+            prefix(str): The prefix for the dock name if no name is provided.
+            widget(str|QWidget|None): The widget to be added to the dock. While using RPC, only BEC RPC widgets from RPCWidgetHandler are allowed.
+            row(int): The row of the added widget.
+            col(int): The column of the added widget.
+            rowspan(int): The rowspan of the added widget.
+            colspan(int): The colspan of the added widget.
+
+        Returns:
+            BECDock: The created dock.
+        """
+        if name is None:
+            name = WidgetContainerUtils.generate_unique_widget_id(
+                container=self.docks, prefix=prefix
+            )
+
+        if name in set(self.docks.keys()):
+            raise ValueError(f"Dock with name {name} already exists.")
+
+        if position is None:
+            position = "bottom"
+
+        dock = BECDock(name=name, parent_dock_area=self, closable=closable)
+        dock.config.position = position
+        self.config.docks[name] = dock.config
+
+        self.addDock(dock=dock, position=position, relativeTo=relative_to)
+
+        if len(self.docks) <= 1:
+            dock.hide_title_bar()
+        elif len(self.docks) > 1:
+            for dock in self.docks.values():
+                dock.show_title_bar()
+
+        if widget is not None and isinstance(widget, str):
+            dock.add_widget_bec(
+                widget_type=widget, row=row, col=col, rowspan=rowspan, colspan=colspan
+            )
+        elif widget is not None and isinstance(widget, QWidget):
+            dock.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+        if self._instructions_visible:
+            self._instructions_visible = False
+            self.update()
+        return dock
+
+    def detach_dock(self, dock_name: str) -> BECDock:
+        """
+        Undock a dock from the dock area.
+
+        Args:
+            dock_name(str): The dock to undock.
+
+        Returns:
+            BECDock: The undocked dock.
+        """
+        dock = self.docks[dock_name]
+        self.floatDock(dock)
+        return dock
+
+    def attach_all(self):
+        """
+        Return all floating docks to the dock area.
+        """
+        while self.tempAreas:
+            for temp_area in self.tempAreas:
+                self.removeTempArea(temp_area)
+
+    def clear_all(self):
+        """
+        Close all docks and remove all temp areas.
+        """
+        self.attach_all()
+        for dock in dict(self.docks).values():
+            dock.remove()
+
+    def cleanup(self):
+        """
+        Cleanup the dock area.
+        """
+        self.clear_all()
+        super().cleanup()
+
+    def close(self):
+        """
+        Close the dock area and cleanup.
+        Has to be implemented to overwrite pyqtgraph event accept in Container close.
+        """
+        self.cleanup()
+        super().close()

bec_widgets/widgets/editor/__init__.py

@@ -1 +0,0 @@
-from .editor import BECEditor

bec_widgets/widgets/editor/editor.py

@@ -1,407 +0,0 @@
-import subprocess
-
-import qdarktheme
-from jedi import Script
-from jedi.api import Completion
-from qtconsole.manager import QtKernelManager
-from qtconsole.rich_jupyter_widget import RichJupyterWidget
-
-# pylint: disable=no-name-in-module
-from qtpy.Qsci import QsciAPIs, QsciLexerPython, QsciScintilla
-from qtpy.QtCore import Qt, QThread, Signal
-from qtpy.QtGui import QColor, QFont
-from qtpy.QtWidgets import QApplication, QFileDialog, QSplitter, QTextEdit, QVBoxLayout, QWidget
-
-from bec_widgets.widgets.toolbar import ModularToolBar
-
-
-class AutoCompleter(QThread):
-    """Initializes the AutoCompleter thread for handling autocompletion and signature help.
-
-    Args:
-        file_path (str): The path to the file for which autocompletion is required.
-        api (QsciAPIs): The QScintilla API instance used for managing autocompletions.
-        enable_docstring (bool, optional): Flag to determine if docstrings should be included in the signatures.
-    """
-
-    def __init__(self, file_path: str, api: QsciAPIs, enable_docstring: bool = False):
-        super().__init__(None)
-        self.file_path = file_path
-        self.script: Script = None
-        self.api: QsciAPIs = api
-        self.completions: list[Completion] = None
-        self.line = 0
-        self.index = 0
-        self.text = ""
-
-        # TODO so far disabled, quite buggy, docstring extraction has to be generalised
-        self.enable_docstring = enable_docstring
-
-    def update_script(self, text: str):
-        """Updates the script for Jedi completion based on the current editor text.
-
-        Args:
-            text (str): The current text of the editor.
-        """
-        if self.script is None or self.script.path != text:
-            self.script = Script(text, path=self.file_path)
-
-    def run(self):
-        """Runs the thread for generating autocompletions. Overrides QThread.run."""
-        self.update_script(self.text)
-        try:
-            self.completions = self.script.complete(self.line, self.index)
-            self.load_autocomplete(self.completions)
-        except Exception as err:
-            print(err)
-        self.finished.emit()
-
-    def get_function_signature(self, line: int, index: int, text: str) -> str:
-        """Fetches the function signature for a given position in the text.
-
-        Args:
-            line (int): The line number in the editor.
-            index (int): The index (column number) in the line.
-            text (str): The current text of the editor.
-
-        Returns:
-            str: A string containing the function signature or an empty string if not available.
-        """
-        self.update_script(text)
-        try:
-            signatures = self.script.get_signatures(line, index)
-            if signatures and self.enable_docstring is True:
-                full_docstring = signatures[0].docstring(raw=True)
-                compact_docstring = self.get_compact_docstring(full_docstring)
-                return compact_docstring
-            if signatures and self.enable_docstring is False:
-                return signatures[0].to_string()
-        except Exception as err:
-            print(f"Signature Error:{err}")
-        return ""
-
-    def load_autocomplete(self, completions: list):
-        """Loads the autocomplete suggestions into the QScintilla API.
-
-        Args:
-            completions (list[Completion]): A list of Completion objects to be added to the API.
-        """
-        self.api.clear()
-        for i in completions:
-            self.api.add(i.name)
-        self.api.prepare()
-
-    def get_completions(self, line: int, index: int, text: str):
-        """Starts the autocompletion process for a given position in the text.
-
-        Args:
-            line (int): The line number in the editor.
-            index (int): The index (column number) in the line.
-            text (str): The current text of the editor.
-        """
-        self.line = line
-        self.index = index
-        self.text = text
-        self.start()
-
-    def get_compact_docstring(self, full_docstring):
-        """Generates a compact version of a function's docstring.
-
-        Args:
-            full_docstring (str): The full docstring of a function.
-
-        Returns:
-            str: A compact version of the docstring.
-        """
-        lines = full_docstring.split("\n")
-        # TODO make it also for different docstring styles, now it is only for numpy style
-        cutoff_indices = [
-            i
-            for i, line in enumerate(lines)
-            if line.strip().lower() in ["parameters", "returns", "examples", "see also", "warnings"]
-        ]
-
-        if cutoff_indices:
-            lines = lines[: cutoff_indices[0]]
-
-        compact_docstring = "\n".join(lines).strip()
-        return compact_docstring
-
-
-class ScriptRunnerThread(QThread):
-    """Initializes the thread for running a Python script.
-
-    Args:
-        script (str): The script to be executed.
-    """
-
-    outputSignal = Signal(str)
-
-    def __init__(self, script):
-        super().__init__()
-        self.script = script
-
-    def run(self):
-        """Executes the script in a subprocess and emits output through a signal. Overrides QThread.run."""
-        process = subprocess.Popen(
-            ["python", "-u", "-c", self.script],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            bufsize=1,
-            universal_newlines=True,
-            text=True,
-        )
-
-        while True:
-            output = process.stdout.readline()
-            if output == "" and process.poll() is not None:
-                break
-            if output:
-                self.outputSignal.emit(output)
-        error = process.communicate()[1]
-        if error:
-            self.outputSignal.emit(error)
-
-
-class BECEditor(QWidget):
-    """Initializes the BEC Editor widget.
-
-    Args:
-        toolbar_enabled (bool, optional): Determines if the toolbar should be enabled. Defaults to True.
-    """
-
-    def __init__(
-        self, toolbar_enabled=True, jupyter_terminal_enabled=False, docstring_tooltip=False
-    ):
-        super().__init__()
-
-        self.script_runner_thread = None
-        self.file_path = None
-        self.docstring_tooltip = docstring_tooltip
-        self.jupyter_terminal_enabled = jupyter_terminal_enabled
-        # TODO just temporary solution, could be extended to other languages
-        self.is_python_file = True
-
-        # Initialize the editor and terminal
-        self.editor = QsciScintilla()
-        if self.jupyter_terminal_enabled:
-            self.terminal = self.make_jupyter_widget_with_kernel()
-        else:
-            self.terminal = QTextEdit()
-            self.terminal.setReadOnly(True)
-
-        # Layout
-        self.layout = QVBoxLayout()
-
-        # Initialize and add the toolbar if enabled
-        if toolbar_enabled:
-            self.toolbar = ModularToolBar(self)
-            self.layout.addWidget(self.toolbar)
-
-        # Initialize the splitter
-        self.splitter = QSplitter(Qt.Orientation.Vertical, self)
-        self.splitter.addWidget(self.editor)
-        self.splitter.addWidget(self.terminal)
-        self.splitter.setSizes([400, 200])
-
-        # Add Splitter to layout
-        self.layout.addWidget(self.splitter)
-        self.setLayout(self.layout)
-
-        self.setup_editor()
-
-    def setup_editor(self):
-        """Sets up the editor with necessary configurations like lexer, auto indentation, and line numbers."""
-        # Set the lexer for Python
-        self.lexer = QsciLexerPython()
-        self.editor.setLexer(self.lexer)
-
-        # Enable auto indentation and competition within the editor
-        self.editor.setAutoIndent(True)
-        self.editor.setIndentationsUseTabs(False)
-        self.editor.setIndentationWidth(4)
-        self.editor.setAutoCompletionSource(QsciScintilla.AutoCompletionSource.AcsAll)
-        self.editor.setAutoCompletionThreshold(1)
-
-        # Autocomplete for python file
-        # Connect cursor position change signal for autocompletion
-        self.editor.cursorPositionChanged.connect(self.on_cursor_position_changed)
-
-        # if self.is_python_file: #TODO can be changed depending on supported languages
-        self.__api = QsciAPIs(self.lexer)
-        self.auto_completer = AutoCompleter(
-            self.editor.text(), self.__api, enable_docstring=self.docstring_tooltip
-        )
-        self.auto_completer.finished.connect(self.loaded_autocomplete)
-
-        # Enable line numbers in the margin
-        self.editor.setMarginType(0, QsciScintilla.MarginType.NumberMargin)
-        self.editor.setMarginWidth(0, "0000")  # Adjust the width as needed
-
-        # Additional UI elements like menu for load/save can be added here
-        self.set_editor_style()
-
-    @staticmethod
-    def make_jupyter_widget_with_kernel() -> object:
-        """Start a kernel, connect to it, and create a RichJupyterWidget to use it"""
-        kernel_manager = QtKernelManager(kernel_name="python3")
-        kernel_manager.start_kernel()
-
-        kernel_client = kernel_manager.client()
-        kernel_client.start_channels()
-
-        jupyter_widget = RichJupyterWidget()
-        jupyter_widget.set_default_style("linux")
-        jupyter_widget.kernel_manager = kernel_manager
-        jupyter_widget.kernel_client = kernel_client
-        return jupyter_widget
-
-    def show_call_tip(self, position):
-        """Shows a call tip at the given position in the editor.
-
-        Args:
-            position (int): The position in the editor where the call tip should be shown.
-        """
-        line, index = self.editor.lineIndexFromPosition(position)
-        signature = self.auto_completer.get_function_signature(line + 1, index, self.editor.text())
-        if signature:
-            self.editor.showUserList(1, [signature])
-
-    def on_cursor_position_changed(self, line, index):
-        """Handles the event of cursor position change in the editor.
-
-        Args:
-            line (int): The current line number where the cursor is.
-            index (int): The current column index where the cursor is.
-        """
-        # if self.is_python_file: #TODO can be changed depending on supported languages
-        # Get completions
-        self.auto_completer.get_completions(line + 1, index, self.editor.text())
-        self.editor.autoCompleteFromAPIs()
-
-        # Show call tip - signature
-        position = self.editor.positionFromLineIndex(line, index)
-        self.show_call_tip(position)
-
-    def loaded_autocomplete(self):
-        """Placeholder method for actions after autocompletion data is loaded."""
-
-    def set_editor_style(self):
-        """Sets the style and color scheme for the editor."""
-        # Dracula Theme Colors
-        background_color = QColor("#282a36")
-        text_color = QColor("#f8f8f2")
-        keyword_color = QColor("#8be9fd")
-        string_color = QColor("#f1fa8c")
-        comment_color = QColor("#6272a4")
-        class_function_color = QColor("#50fa7b")
-
-        # Set Font
-        font = QFont()
-        font.setFamily("Consolas")
-        font.setPointSize(10)
-        self.editor.setFont(font)
-        self.editor.setMarginsFont(font)
-
-        # Set Editor Colors
-        self.editor.setMarginsBackgroundColor(background_color)
-        self.editor.setMarginsForegroundColor(text_color)
-        self.editor.setCaretForegroundColor(text_color)
-        self.editor.setCaretLineBackgroundColor(QColor("#44475a"))
-        self.editor.setPaper(background_color)  # Set the background color for the entire paper
-        self.editor.setColor(text_color)
-
-        # Set editor
-        # Syntax Highlighting Colors
-        lexer = self.editor.lexer()
-        if lexer:
-            lexer.setDefaultPaper(background_color)  # Set the background color for the text area
-            lexer.setDefaultColor(text_color)
-            lexer.setColor(keyword_color, QsciLexerPython.Keyword)
-            lexer.setColor(string_color, QsciLexerPython.DoubleQuotedString)
-            lexer.setColor(string_color, QsciLexerPython.SingleQuotedString)
-            lexer.setColor(comment_color, QsciLexerPython.Comment)
-            lexer.setColor(class_function_color, QsciLexerPython.ClassName)
-            lexer.setColor(class_function_color, QsciLexerPython.FunctionMethodName)
-
-        # Set the style for all text to have a transparent background
-        # TODO find better way how to do it!
-        for style in range(
-            128
-        ):  # QsciScintilla supports 128 styles by default, this set all to transparent background
-            self.lexer.setPaper(background_color, style)
-
-    def run_script(self):
-        """Runs the current script in the editor."""
-        if self.jupyter_terminal_enabled:
-            script = self.editor.text()
-            self.terminal.execute(script)
-
-        else:
-            script = self.editor.text()
-            self.script_runner_thread = ScriptRunnerThread(script)
-            self.script_runner_thread.outputSignal.connect(self.update_terminal)
-            self.script_runner_thread.start()
-
-    def update_terminal(self, text):
-        """Updates the terminal with new text.
-
-        Args:
-            text (str): The text to be appended to the terminal.
-        """
-        self.terminal.append(text)
-
-    def enable_docstring_tooltip(self):
-        """Enables the docstring tooltip."""
-        self.docstring_tooltip = True
-        self.auto_completer.enable_docstring = True
-
-    def open_file(self):
-        """Opens a file dialog for selecting and opening a Python file in the editor."""
-        options = QFileDialog.Options()
-        options |= QFileDialog.DontUseNativeDialog
-        file_path, _ = QFileDialog.getOpenFileName(
-            self, "Open file", "", "Python files (*.py);;All Files (*)", options=options
-        )
-
-        if not file_path:
-            return
-        try:
-            with open(file_path, "r") as file:
-                text = file.read()
-            self.editor.setText(text)
-        except FileNotFoundError:
-            print(f"The file {file_path} was not found.")
-        except Exception as e:
-            print(f"An error occurred while opening the file {file_path}: {e}")
-
-    def save_file(self):
-        """Opens a save file dialog for saving the current script in the editor."""
-        options = QFileDialog.Options()
-        options |= QFileDialog.DontUseNativeDialog
-        file_path, _ = QFileDialog.getSaveFileName(
-            self, "Save file", "", "Python files (*.py);;All Files (*)", options=options
-        )
-
-        if not file_path:
-            return
-        try:
-            if not file_path.endswith(".py"):
-                file_path += ".py"
-
-            with open(file_path, "w") as file:
-                text = self.editor.text()
-                file.write(text)
-                print(f"File saved to {file_path}")
-        except Exception as e:
-            print(f"An error occurred while saving the file to {file_path}: {e}")
-
-
-if __name__ == "__main__":  # pragma: no cover
-    app = QApplication([])
-    qdarktheme.setup_theme("auto")
-
-    mainWin = BECEditor(jupyter_terminal_enabled=True)
-
-    mainWin.show()
-    app.exec()

bec_widgets/widgets/figure/figure.py

@@ -1,27 +1,25 @@
 # pylint: disable = no-name-in-module,missing-module-docstring
 from __future__ import annotations
 
-import itertools
-import os
+import uuid
 from collections import defaultdict
-from typing import Literal, Optional, Type
+from typing import Literal, Optional
 
 import numpy as np
 import pyqtgraph as pg
 import qdarktheme
 from pydantic import Field
-from pyqtgraph.Qt import uic
 from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
+from qtpy.QtWidgets import QWidget
 
-from bec_widgets.utils import BECConnector, BECDispatcher, ConnectionConfig
+from bec_widgets.utils import BECConnector, ConnectionConfig, WidgetContainerUtils
 from bec_widgets.widgets.plots import (
     BECImageShow,
     BECMotorMap,
     BECPlotBase,
     BECWaveform,
+    SubplotConfig,
     Waveform1DConfig,
-    WidgetConfig,
 )
 from bec_widgets.widgets.plots.image import ImageConfig
 from bec_widgets.widgets.plots.motor_map import MotorMapConfig
@@ -33,7 +31,7 @@ class FigureConfig(ConnectionConfig):
     theme: Literal["dark", "light"] = Field("dark", description="The theme of the figure widget.")
     num_cols: int = Field(1, description="The number of columns in the figure widget.")
     num_rows: int = Field(1, description="The number of rows in the figure widget.")
-    widgets: dict[str, WidgetConfig] = Field(
+    widgets: dict[str, SubplotConfig] = Field(
         {}, description="The list of widgets to be added to the figure widget."
     )
 
@@ -43,7 +41,7 @@ class WidgetHandler:
 
     def __init__(self):
         self.widget_factory = {
-            "PlotBase": (BECPlotBase, WidgetConfig),
+            "PlotBase": (BECPlotBase, SubplotConfig),
             "Waveform1D": (BECWaveform, Waveform1DConfig),
             "ImShow": (BECImageShow, ImageConfig),
             "MotorMap": (BECMotorMap, MotorMapConfig),
@@ -97,6 +95,7 @@ class WidgetHandler:
 
 class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     USER_ACCESS = [
+        "rpc_id",
         "config_dict",
         "axes",
         "widgets",
@@ -110,6 +109,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         "change_layout",
         "change_theme",
         "clear_all",
+        "get_all_rpc",
+        "widget_list",
     ]
 
     clean_signal = pyqtSignal()
@@ -138,8 +139,21 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         # Container to keep track of the grid
         self.grid = []
 
+    def __getitem__(self, key: tuple | str):
+        if isinstance(key, tuple) and len(key) == 2:
+            return self.axes(*key)
+        elif isinstance(key, str):
+            widget = self._widgets.get(key)
+            if widget is None:
+                raise KeyError(f"No widget with ID {key}")
+            return self._widgets.get(key)
+        else:
+            raise TypeError(
+                "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
+            )
+
     @property
-    def axes(self) -> list[BECPlotBase]:
+    def widget_list(self) -> list[BECPlotBase]:
         """
         Access all widget in BECFigure as a list
         Returns:
@@ -148,16 +162,31 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         axes = [value for value in self._widgets.values() if isinstance(value, BECPlotBase)]
         return axes
 
-    @axes.setter
-    def axes(self, value: list[BECPlotBase]):
+    @widget_list.setter
+    def widget_list(self, value: list[BECPlotBase]):
+        """
+        Access all widget in BECFigure as a list
+        Returns:
+            list[BECPlotBase]: List of all widgets in the figure.
+        """
         self._axes = value
 
     @property
     def widgets(self) -> dict:
+        """
+        All widgets within the figure with gui ids as keys.
+        Returns:
+            dict: All widgets within the figure.
+        """
         return self._widgets
 
     @widgets.setter
     def widgets(self, value: dict):
+        """
+        All widgets within the figure with gui ids as keys.
+        Returns:
+            dict: All widgets within the figure.
+        """
         self._widgets = value
 
     def add_plot(
@@ -181,6 +210,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     ) -> BECWaveform:
         """
         Add a Waveform1D plot to the figure at the specified position.
+
         Args:
             widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
             row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
@@ -188,7 +218,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             config(dict): Additional configuration for the widget.
             **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
         """
-        widget_id = self._generate_unique_widget_id()
+        widget_id = str(uuid.uuid4())
         waveform = self.add_widget(
             widget_type="Waveform1D",
             widget_id=widget_id,
@@ -260,6 +290,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     ) -> BECWaveform:
         """
         Add a 1D waveform plot to the figure. Always access the first waveform widget in the figure.
+
         Args:
             x_name(str): The name of the device for the x-axis.
             y_name(str): The name of the device for the y-axis.
@@ -278,7 +309,9 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         Returns:
             BECWaveform: The waveform plot widget.
         """
-        waveform = self._find_first_widget_by_class(BECWaveform, can_fail=True)
+        waveform = WidgetContainerUtils.find_first_widget_by_class(
+            self._widgets, BECWaveform, can_fail=True
+        )
         if waveform is not None:
             if axis_kwargs:
                 waveform.set(**axis_kwargs)
@@ -344,6 +377,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     ) -> BECImageShow:
         """
         Add an image to the figure. Always access the first image widget in the figure.
+
         Args:
             monitor(str): The name of the monitor to display.
             color_bar(Literal["simple","full"]): The type of color bar to display.
@@ -355,7 +389,9 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         Returns:
             BECImageShow: The image widget.
         """
-        image = self._find_first_widget_by_class(BECImageShow, can_fail=True)
+        image = WidgetContainerUtils.find_first_widget_by_class(
+            self._widgets, BECImageShow, can_fail=True
+        )
         if image is not None:
             if axis_kwargs:
                 image.set(**axis_kwargs)
@@ -395,6 +431,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     ) -> BECImageShow:
         """
         Add an image to the figure at the specified position.
+
         Args:
             monitor(str): The name of the monitor to display.
             color_bar(Literal["simple","full"]): The type of color bar to display.
@@ -410,7 +447,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             BECImageShow: The image widget.
         """
 
-        widget_id = self._generate_unique_widget_id()
+        widget_id = str(uuid.uuid4())
         if config is None:
             config = ImageConfig(
                 widget_class="BECImageShow",
@@ -449,6 +486,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     def motor_map(self, motor_x: str = None, motor_y: str = None, **axis_kwargs) -> BECMotorMap:
         """
         Add a motor map to the figure. Always access the first motor map widget in the figure.
+
         Args:
             motor_x(str): The name of the motor for the X axis.
             motor_y(str): The name of the motor for the Y axis.
@@ -457,7 +495,9 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         Returns:
             BECMotorMap: The motor map widget.
         """
-        motor_map = self._find_first_widget_by_class(BECMotorMap, can_fail=True)
+        motor_map = WidgetContainerUtils.find_first_widget_by_class(
+            self._widgets, BECMotorMap, can_fail=True
+        )
         if motor_map is not None:
             if axis_kwargs:
                 motor_map.set(**axis_kwargs)
@@ -491,7 +531,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         Returns:
             BECMotorMap: The motor map widget.
         """
-        widget_id = self._generate_unique_widget_id()
+        widget_id = str(uuid.uuid4())
         if config is None:
             config = MotorMapConfig(
                 widget_class="BECMotorMap",
@@ -523,6 +563,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     ) -> BECPlotBase:
         """
         Add a widget to the figure at the specified position.
+
         Args:
             widget_type(Literal["PlotBase","Waveform1D"]): The type of the widget to add.
             widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
@@ -532,7 +573,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
         """
         if not widget_id:
-            widget_id = self._generate_unique_widget_id()
+            widget_id = str(uuid.uuid4())
         if widget_id in self._widgets:
             raise ValueError(f"Widget with ID '{widget_id}' already exists.")
 
@@ -585,6 +626,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     ) -> None:
         """
         Remove a widget from the figure. Can be removed by its unique identifier or by its coordinates.
+
         Args:
             row(int): The row coordinate of the widget to remove.
             col(int): The column coordinate of the widget to remove.
@@ -603,6 +645,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     def change_theme(self, theme: Literal["dark", "light"]) -> None:
         """
         Change the theme of the figure widget.
+
         Args:
             theme(Literal["dark","light"]): The theme to set for the figure widget.
         """
@@ -610,33 +653,15 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         self.setBackground("k" if theme == "dark" else "w")
         self.config.theme = theme
 
-    def _find_first_widget_by_class(
-        self, widget_class: Type[BECPlotBase], can_fail: bool = True
-    ) -> BECPlotBase | None:
-        """
-        Find the first widget of a given class in the figure.
-        Args:
-            widget_class(Type[BECPlotBase]): The class of the widget to find.
-            can_fail(bool): If True, the method will return None if no widget is found. If False, it will raise an error.
-        Returns:
-            BECPlotBase: The widget of the given class.
-        """
-        for widget_id, widget in self._widgets.items():
-            if isinstance(widget, widget_class):
-                return widget
-        if can_fail:
-            return None
-        else:
-            raise ValueError(f"No widget of class {widget_class} found.")
-
     def _remove_by_coordinates(self, row: int, col: int) -> None:
         """
         Remove a widget from the figure by its coordinates.
+
         Args:
             row(int): The row coordinate of the widget to remove.
             col(int): The column coordinate of the widget to remove.
         """
-        widget = self._get_widget_by_coordinates(row, col)
+        widget = self.axes(row, col)
         if widget:
             widget_id = widget.config.gui_id
             if widget_id in self._widgets:
@@ -645,6 +670,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     def _remove_by_id(self, widget_id: str) -> None:
         """
         Remove a widget from the figure by its unique identifier.
+
         Args:
             widget_id(str): The unique identifier of the widget to remove.
         """
@@ -656,26 +682,13 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             self._reindex_grid()
             if widget_id in self.config.widgets:
                 self.config.widgets.pop(widget_id)
-            print(f"Removed widget {widget_id}.")
         else:
             raise ValueError(f"Widget with ID '{widget_id}' does not exist.")
 
-    def __getitem__(self, key: tuple | str):
-        if isinstance(key, tuple) and len(key) == 2:
-            return self._get_widget_by_coordinates(*key)
-        elif isinstance(key, str):
-            widget = self._widgets.get(key)
-            if widget is None:
-                raise KeyError(f"No widget with ID {key}")
-            return self._widgets.get(key)
-        else:
-            raise TypeError(
-                "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
-            )
-
-    def _get_widget_by_coordinates(self, row: int, col: int) -> BECPlotBase:
+    def axes(self, row: int, col: int) -> BECPlotBase:
         """
         Get widget by its coordinates in the figure.
+
         Args:
             row(int): the row coordinate
             col(int): the column coordinate
@@ -695,17 +708,10 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             row += 1
         return row, col
 
-    def _generate_unique_widget_id(self):
-        """Generate a unique widget ID."""
-        existing_ids = set(self._widgets.keys())
-        for i in itertools.count(1):
-            widget_id = f"widget_{i}"
-            if widget_id not in existing_ids:
-                return widget_id
-
     def _change_grid(self, widget_id: str, row: int, col: int):
         """
         Change the grid to reflect the new position of the widget.
+
         Args:
             widget_id(str): The unique identifier of the widget.
             row(int): The new row coordinate of the widget in the figure.
@@ -720,7 +726,6 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
     def _reindex_grid(self):
         """Reindex the grid to remove empty rows and columns."""
-        print(f"old grid: {self.grid}")
         new_grid = []
         for row in self.grid:
             new_row = [widget for widget in row if widget is not None]
@@ -787,12 +792,16 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
     def clear_all(self):
         """Clear all widgets from the figure and reset to default state"""
-        # for widget in self._widgets.values():
-        #     widget.cleanup()
-        self.clear()
+        for widget in list(self._widgets.values()):
+            widget.remove()
+        # self.clear()
         self._widgets = defaultdict(dict)
         self.grid = []
         theme = self.config.theme
         self.config = FigureConfig(
             widget_class=self.__class__.__name__, gui_id=self.gui_id, theme=theme
         )
+
+    def cleanup(self):
+        self.clear_all()
+        super().cleanup()

bec_widgets/widgets/plots/__init__.py

@@ -1,4 +1,4 @@
 from .image import BECImageItem, BECImageShow, ImageItemConfig
 from .motor_map import BECMotorMap, MotorMapConfig
-from .plot_base import AxisConfig, BECPlotBase, WidgetConfig
+from .plot_base import AxisConfig, BECPlotBase, SubplotConfig
 from .waveform import BECCurve, BECWaveform, Waveform1DConfig

bec_widgets/widgets/plots/image.py

@@ -12,9 +12,9 @@ from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.utils import BECConnector, ConnectionConfig
+from bec_widgets.utils import BECConnector, ConnectionConfig, EntryValidator
 
-from .plot_base import BECPlotBase, WidgetConfig
+from .plot_base import BECPlotBase, SubplotConfig
 
 
 class ProcessingConfig(BaseModel):
@@ -50,7 +50,7 @@ class ImageItemConfig(ConnectionConfig):
     )
 
 
-class ImageConfig(WidgetConfig):
+class ImageConfig(SubplotConfig):
     images: dict[str, ImageItemConfig] = Field(
         {},
         description="The configuration of the images. The key is the name of the image (source).",
@@ -59,6 +59,7 @@ class ImageConfig(WidgetConfig):
 
 class BECImageItem(BECConnector, pg.ImageItem):
     USER_ACCESS = [
+        "rpc_id",
         "config_dict",
         "set",
         "set_fft",
@@ -111,8 +112,10 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set(self, **kwargs):
         """
         Set the properties of the image.
+
         Args:
             **kwargs: Keyword arguments for the properties to be set.
+
         Possible properties:
             - downsample
             - color_map
@@ -144,6 +147,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_fft(self, enable: bool = False):
         """
         Set the FFT of the image.
+
         Args:
             enable(bool): Whether to perform FFT on the monitor data.
         """
@@ -152,6 +156,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_log(self, enable: bool = False):
         """
         Set the log of the image.
+
         Args:
             enable(bool): Whether to perform log on the monitor data.
         """
@@ -162,6 +167,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_rotation(self, deg_90: int = 0):
         """
         Set the rotation of the image.
+
         Args:
             deg_90(int): The rotation angle of the monitor data before displaying.
         """
@@ -170,6 +176,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_transpose(self, enable: bool = False):
         """
         Set the transpose of the image.
+
         Args:
             enable(bool): Whether to transpose the image.
         """
@@ -178,6 +185,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_opacity(self, opacity: float = 1.0):
         """
         Set the opacity of the image.
+
         Args:
             opacity(float): The opacity of the image.
         """
@@ -187,6 +195,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_autorange(self, autorange: bool = False):
         """
         Set the autorange of the color bar.
+
         Args:
             autorange(bool): Whether to autorange the color bar.
         """
@@ -197,6 +206,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_color_map(self, cmap: str = "magma"):
         """
         Set the color map of the image.
+
         Args:
             cmap(str): The color map of the image.
         """
@@ -211,6 +221,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_auto_downsample(self, auto: bool = True):
         """
         Set the auto downsample of the image.
+
         Args:
             auto(bool): Whether to downsample the image.
         """
@@ -220,6 +231,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_monitor(self, monitor: str):
         """
         Set the monitor of the image.
+
         Args:
             monitor(str): The name of the monitor.
         """
@@ -228,6 +240,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     def set_vrange(self, vmin: float = None, vmax: float = None, vrange: tuple[int, int] = None):
         """
         Set the range of the color bar.
+
         Args:
             vmin(float): Minimum value of the color bar.
             vmax(float): Maximum value of the color bar.
@@ -257,6 +270,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
     ):
         """
         Add color bar to the layout.
+
         Args:
             style(Literal["simple,full"]): The style of the color bar.
             vrange(tuple[int,int]): The range of the color bar.
@@ -290,6 +304,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
 
 class BECImageShow(BECPlotBase):
     USER_ACCESS = [
+        "rpc_id",
         "config_dict",
         "add_image_by_config",
         "get_image_config",
@@ -335,7 +350,9 @@ class BECImageShow(BECPlotBase):
         super().__init__(
             parent=parent, parent_figure=parent_figure, config=config, client=client, gui_id=gui_id
         )
-
+        # Get bec shortcuts dev, scans, queue, scan_storage, dap
+        self.get_bec_shortcuts()
+        self.entry_validator = EntryValidator(self.dev)
         self._images = defaultdict(dict)
         self.apply_config(self.config)
         self.processor = ImageProcessor()
@@ -356,23 +373,10 @@ class BECImageShow(BECPlotBase):
 
         thread.start()
 
-    def find_widget_by_id(self, item_id: str) -> BECImageItem:
-        """
-        Find the widget by its gui_id.
-        Args:
-            item_id(str): The gui_id of the widget.
-
-        Returns:
-            BECImageItem: The widget with the given gui_id.
-        """
-        for source, images in self._images.items():
-            for monitor, image_item in images.items():
-                if image_item.gui_id == item_id:
-                    return image_item
-
     def find_image_by_monitor(self, item_id: str) -> BECImageItem:
         """
         Find the widget by its gui_id.
+
         Args:
             item_id(str): The gui_id of the widget.
 
@@ -388,11 +392,12 @@ class BECImageShow(BECPlotBase):
                     if result is not None:
                         return result
 
-    def apply_config(self, config: dict | WidgetConfig):
+    def apply_config(self, config: dict | SubplotConfig):
         """
         Apply the configuration to the 1D waveform widget.
+
         Args:
-            config(dict|WidgetConfig): Configuration settings.
+            config(dict|SubplotConfig): Configuration settings.
             replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
         """
         if isinstance(config, dict):
@@ -426,6 +431,7 @@ class BECImageShow(BECPlotBase):
     def add_image_by_config(self, config: ImageItemConfig | dict) -> BECImageItem:
         """
         Add an image to the widget by configuration.
+
         Args:
             config(ImageItemConfig|dict): The configuration of the image.
 
@@ -442,6 +448,7 @@ class BECImageShow(BECPlotBase):
     def get_image_config(self, image_id, dict_output: bool = True) -> ImageItemConfig | dict:
         """
         Get the configuration of the image.
+
         Args:
             image_id(str): The ID of the image.
             dict_output(bool): Whether to return the configuration as a dictionary. Defaults to True.
@@ -483,6 +490,7 @@ class BECImageShow(BECPlotBase):
     def get_image_dict(self) -> dict[str, dict[str, BECImageItem]]:
         """
         Get all images.
+
         Returns:
             dict[str, dict[str, BECImageItem]]: The dictionary of images.
         """
@@ -507,6 +515,8 @@ class BECImageShow(BECPlotBase):
                 f"Monitor with ID '{monitor}' already exists in widget '{self.gui_id}'."
             )
 
+        monitor = self.entry_validator.validate_monitor(monitor)
+
         image_config = ImageItemConfig(
             widget_class="BECImageItem",
             parent_id=self.gui_id,
@@ -582,6 +592,7 @@ class BECImageShow(BECPlotBase):
         """
         Set the range of the color bar.
         If name is not specified, then set vrange for all images.
+
         Args:
             vmin(float): Minimum value of the color bar.
             vmax(float): Maximum value of the color bar.
@@ -593,6 +604,7 @@ class BECImageShow(BECPlotBase):
         """
         Set the color map of the image.
         If name is not specified, then set color map for all images.
+
         Args:
             cmap(str): The color map of the image.
             name(str): The name of the image. If None, apply to all images.
@@ -602,6 +614,7 @@ class BECImageShow(BECPlotBase):
     def set_autorange(self, enable: bool = False, name: str = None):
         """
         Set the autoscale of the image.
+
         Args:
             enable(bool): Whether to autoscale the color bar.
             name(str): The name of the image. If None, apply to all images.
@@ -612,6 +625,7 @@ class BECImageShow(BECPlotBase):
         """
         Set the monitor of the image.
         If name is not specified, then set monitor for all images.
+
         Args:
             monitor(str): The name of the monitor.
             name(str): The name of the image. If None, apply to all images.
@@ -622,6 +636,7 @@ class BECImageShow(BECPlotBase):
         """
         Set the post processing of the image.
         If name is not specified, then set post processing for all images.
+
         Args:
             name(str): The name of the image. If None, apply to all images.
             **kwargs: Keyword arguments for the properties to be set.
@@ -636,6 +651,7 @@ class BECImageShow(BECPlotBase):
     def set_image_properties(self, name: str = None, **kwargs):
         """
         Set the properties of the image.
+
         Args:
             name(str): The name of the image. If None, apply to all images.
             **kwargs: Keyword arguments for the properties to be set.
@@ -656,6 +672,7 @@ class BECImageShow(BECPlotBase):
         """
         Set the FFT of the image.
         If name is not specified, then set FFT for all images.
+
         Args:
             enable(bool): Whether to perform FFT on the monitor data.
             name(str): The name of the image. If None, apply to all images.
@@ -666,6 +683,7 @@ class BECImageShow(BECPlotBase):
         """
         Set the log of the image.
         If name is not specified, then set log for all images.
+
         Args:
             enable(bool): Whether to perform log on the monitor data.
             name(str): The name of the image. If None, apply to all images.
@@ -676,6 +694,7 @@ class BECImageShow(BECPlotBase):
         """
         Set the rotation of the image.
         If name is not specified, then set rotation for all images.
+
         Args:
             deg_90(int): The rotation angle of the monitor data before displaying.
             name(str): The name of the image. If None, apply to all images.
@@ -686,6 +705,7 @@ class BECImageShow(BECPlotBase):
         """
         Set the transpose of the image.
         If name is not specified, then set transpose for all images.
+
         Args:
             enable(bool): Whether to transpose the monitor data before displaying.
             name(str): The name of the image. If None, apply to all images.
@@ -695,6 +715,7 @@ class BECImageShow(BECPlotBase):
     def toggle_threading(self, use_threading: bool):
         """
         Toggle threading for the widgets postprocessing and updating.
+
         Args:
             use_threading(bool): Whether to use threading.
         """
@@ -706,6 +727,7 @@ class BECImageShow(BECPlotBase):
     def on_image_update(self, msg: dict):
         """
         Update the image of the device monitor from bec.
+
         Args:
             msg(dict): The message from bec.
         """
@@ -715,10 +737,8 @@ class BECImageShow(BECPlotBase):
         processing_config = image_to_update.config.processing
         self.processor.set_config(processing_config)
         if self.use_threading:
-            print("using threaded version")
             self._create_thread_worker(device, data)
         else:
-            print("using NON-threaded version")
             data = self.processor.process_image(data)
             self.update_image(device, data)
 
@@ -726,6 +746,7 @@ class BECImageShow(BECPlotBase):
     def update_image(self, device: str, data: np.ndarray):
         """
         Update the image of the device monitor.
+
         Args:
             device(str): The name of the device.
             data(np.ndarray): The data to be updated.
@@ -736,6 +757,7 @@ class BECImageShow(BECPlotBase):
     def _connect_device_monitor(self, monitor: str):
         """
         Connect to the device monitor.
+
         Args:
             monitor(str): The name of the monitor.
         """
@@ -770,6 +792,7 @@ class BECImageShow(BECPlotBase):
     def _check_image_id(self, val: Any, dict_to_check: dict) -> bool:
         """
         Check if val is in the values of the dict_to_check or in the values of the nested dictionaries.
+
         Args:
             val(Any): Value to check.
             dict_to_check(dict): Dictionary to check.
@@ -785,18 +808,35 @@ class BECImageShow(BECPlotBase):
                     return True
         return False
 
+    def _validate_monitor(self, monitor: str, validate_bec: bool = True):
+        """
+        Validate the monitor name.
+
+        Args:
+            monitor(str): The name of the monitor.
+            validate_bec(bool): Whether to validate the monitor name with BEC.
+
+        Returns:
+            bool: True if the monitor name is valid, False otherwise.
+        """
+        if not monitor or monitor == "":
+            return False
+        if validate_bec:
+            return monitor in self.dev
+        return True
+
     def cleanup(self):
         """
         Clean up the widget.
         """
-        print(f"Cleaning up {self.gui_id}")
-        # for monitor in self._images["device_monitor"]:
-        #     self.bec_dispatcher.disconnect_slot(
-        #         self.on_image_update, MessageEndpoints.device_monitor(monitor)
-        #     )
-        # if self.thread is not None and self.thread.isRunning():
-        #     self.thread.quit()
-        #     self.thread.wait()
+        for monitor in self._images["device_monitor"]:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(monitor)
+            )
+        for image in self.images:
+            image.cleanup()
+
+        super().cleanup()
 
 
 class ImageProcessor:
@@ -812,6 +852,7 @@ class ImageProcessor:
     def set_config(self, config: ProcessingConfig):
         """
         Set the configuration of the processor.
+
         Args:
             config(ProcessingConfig): The configuration of the processor.
         """
@@ -820,6 +861,7 @@ class ImageProcessor:
     def FFT(self, data: np.ndarray) -> np.ndarray:
         """
         Perform FFT on the data.
+
         Args:
             data(np.ndarray): The data to be processed.
 
@@ -831,6 +873,7 @@ class ImageProcessor:
     def rotation(self, data: np.ndarray, rotate_90: int) -> np.ndarray:
         """
         Rotate the data by 90 degrees n times.
+
         Args:
             data(np.ndarray): The data to be processed.
             rotate_90(int): The number of 90 degree rotations.
@@ -843,6 +886,7 @@ class ImageProcessor:
     def transpose(self, data: np.ndarray) -> np.ndarray:
         """
         Transpose the data.
+
         Args:
             data(np.ndarray): The data to be processed.
 
@@ -854,6 +898,7 @@ class ImageProcessor:
     def log(self, data: np.ndarray) -> np.ndarray:
         """
         Perform log on the data.
+
         Args:
             data(np.ndarray): The data to be processed.
 
@@ -872,6 +917,7 @@ class ImageProcessor:
     def process_image(self, data: np.ndarray) -> np.ndarray:
         """
         Process the data according to the configuration.
+
         Args:
             data(np.ndarray): The data to be processed.
 
@@ -908,6 +954,7 @@ class ProcessorWorker(QObject):
     def process_image(self, device: str, image: np.ndarray):
         """
         Process the image data.
+
         Args:
             device(str): The name of the device.
             image(np.ndarray): The image data.

bec_widgets/widgets/plots/motor_map.py

@@ -13,11 +13,11 @@ from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils import EntryValidator
-from bec_widgets.widgets.plots.plot_base import BECPlotBase, WidgetConfig
+from bec_widgets.widgets.plots.plot_base import BECPlotBase, SubplotConfig
 from bec_widgets.widgets.plots.waveform import Signal, SignalData
 
 
-class MotorMapConfig(WidgetConfig):
+class MotorMapConfig(SubplotConfig):
     signals: Optional[Signal] = Field(None, description="Signals of the motor map")
     color_map: Optional[str] = Field(
         "Greys", description="Color scheme of the motor position gradient."
@@ -102,6 +102,7 @@ class BECMotorMap(BECPlotBase):
     ) -> None:
         """
         Change the active motors for the plot.
+
         Args:
             motor_x(str): Motor name for the X axis.
             motor_y(str): Motor name for the Y axis.
@@ -145,6 +146,7 @@ class BECMotorMap(BECPlotBase):
     def set_max_points(self, max_points: int) -> None:
         """
         Set the maximum number of points to display.
+
         Args:
             max_points(int): Maximum number of points to display.
         """
@@ -153,6 +155,7 @@ class BECMotorMap(BECPlotBase):
     def set_precision(self, precision: int) -> None:
         """
         Set the decimal precision of the motor position.
+
         Args:
             precision(int): Decimal precision of the motor position.
         """
@@ -161,6 +164,7 @@ class BECMotorMap(BECPlotBase):
     def set_num_dim_points(self, num_dim_points: int) -> None:
         """
         Set the number of dim points for the motor map.
+
         Args:
             num_dim_points(int): Number of dim points.
         """
@@ -169,6 +173,7 @@ class BECMotorMap(BECPlotBase):
     def set_background_value(self, background_value: int) -> None:
         """
         Set the background value of the motor map.
+
         Args:
             background_value(int): Background value of the motor map.
         """
@@ -177,19 +182,24 @@ class BECMotorMap(BECPlotBase):
     def set_scatter_size(self, scatter_size: int) -> None:
         """
         Set the scatter size of the motor map plot.
+
         Args:
             scatter_size(int): Size of the scatter points.
         """
         self.config.scatter_size = scatter_size
 
-    def _connect_motor_to_slots(self):
-        """Connect motors to slots."""
+    def _disconnect_current_motors(self):
+        """Disconnect the current motors from the slots."""
         if self.motor_x is not None and self.motor_y is not None:
-            old_endpoints = [
+            endpoints = [
                 MessageEndpoints.device_readback(self.motor_x),
                 MessageEndpoints.device_readback(self.motor_y),
             ]
-            self.bec_dispatcher.disconnect_slot(self.on_device_readback, old_endpoints)
+            self.bec_dispatcher.disconnect_slot(self.on_device_readback, endpoints)
+
+    def _connect_motor_to_slots(self):
+        """Connect motors to slots."""
+        self._disconnect_current_motors()
 
         self.motor_x = self.config.signals.x.name
         self.motor_y = self.config.signals.y.name
@@ -243,6 +253,7 @@ class BECMotorMap(BECPlotBase):
     def _add_coordinantes_crosshair(self, x: float, y: float) -> None:
         """
         Add crosshair to the plot to highlight the current position.
+
         Args:
             x(float): X coordinate.
             y(float): Y coordinate.
@@ -270,6 +281,7 @@ class BECMotorMap(BECPlotBase):
     def _make_limit_map(self, limits_x: list, limits_y: list) -> pg.ImageItem:
         """
         Create a limit map for the motor map plot.
+
         Args:
             limits_x(list): Motor limits for the x axis.
             limits_y(list): Motor limits for the y axis.
@@ -299,10 +311,12 @@ class BECMotorMap(BECPlotBase):
     def _get_motor_init_position(self, name: str, entry: str, precision: int) -> float:
         """
         Get the motor initial position from the config.
+
         Args:
             name(str): Motor name.
             entry(str): Motor entry.
             precision(int): Decimal precision of the motor position.
+
         Returns:
             float: Motor initial position.
         """
@@ -319,12 +333,14 @@ class BECMotorMap(BECPlotBase):
     ) -> tuple[str, str]:
         """
         Validate the signal name and entry.
+
         Args:
             x_name(str): Name of the x signal.
             y_name(str): Name of the y signal.
             x_entry(str|None): Entry of the x signal.
             y_entry(str|None): Entry of the y signal.
             validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+
         Returns:
             tuple[str,str]: Validated x and y entries.
         """
@@ -339,6 +355,7 @@ class BECMotorMap(BECPlotBase):
     def _get_motor_limit(self, motor: str) -> Union[list | None]:  # TODO check if works correctly
         """
         Get the motor limit from the config.
+
         Args:
             motor(str): Motor name.
 
@@ -400,6 +417,7 @@ class BECMotorMap(BECPlotBase):
     def on_device_readback(self, msg: dict) -> None:
         """
         Update the motor map plot with the new motor position.
+
         Args:
             msg(dict): Message from the device readback.
         """
@@ -418,18 +436,7 @@ class BECMotorMap(BECPlotBase):
 
         self.update_signal.emit()
 
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    import pyqtgraph as pg
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    glw = pg.GraphicsLayoutWidget()
-    motor_map = BECMotorMap()
-    motor_map.change_motors("samx", "samy")
-    glw.addItem(motor_map)
-    widget = glw
-    widget.show()
-    sys.exit(app.exec_())
+    def cleanup(self):
+        """Cleanup the widget."""
+        self._disconnect_current_motors()
+        super().cleanup()

bec_widgets/widgets/plots/plot_base.py

@@ -22,7 +22,7 @@ class AxisConfig(BaseModel):
     y_grid: bool = Field(False, description="Show grid on the y-axis.")
 
 
-class WidgetConfig(ConnectionConfig):
+class SubplotConfig(ConnectionConfig):
     parent_id: Optional[str] = Field(None, description="The parent figure of the plot.")
 
     # Coordinates in the figure
@@ -56,12 +56,12 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
         self,
         parent: Optional[QWidget] = None,  # TODO decide if needed for this class
         parent_figure=None,
-        config: Optional[WidgetConfig] = None,
+        config: Optional[SubplotConfig] = None,
         client=None,
         gui_id: Optional[str] = None,
     ):
         if config is None:
-            config = WidgetConfig(widget_class=self.__class__.__name__)
+            config = SubplotConfig(widget_class=self.__class__.__name__)
         super().__init__(client=client, config=config, gui_id=gui_id)
         pg.GraphicsLayout.__init__(self, parent)
 
@@ -73,8 +73,10 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def set(self, **kwargs) -> None:
         """
         Set the properties of the plot widget.
+
         Args:
             **kwargs: Keyword arguments for the properties to be set.
+
         Possible properties:
             - title: str
             - x_label: str
@@ -117,6 +119,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def set_title(self, title: str):
         """
         Set the title of the plot widget.
+
         Args:
             title(str): Title of the plot widget.
         """
@@ -126,6 +129,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def set_x_label(self, label: str):
         """
         Set the label of the x-axis.
+
         Args:
             label(str): Label of the x-axis.
         """
@@ -135,6 +139,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def set_y_label(self, label: str):
         """
         Set the label of the y-axis.
+
         Args:
             label(str): Label of the y-axis.
         """
@@ -144,6 +149,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def set_x_scale(self, scale: Literal["linear", "log"] = "linear"):
         """
         Set the scale of the x-axis.
+
         Args:
             scale(Literal["linear", "log"]): Scale of the x-axis.
         """
@@ -153,6 +159,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def set_y_scale(self, scale: Literal["linear", "log"] = "linear"):
         """
         Set the scale of the y-axis.
+
         Args:
             scale(Literal["linear", "log"]): Scale of the y-axis.
         """
@@ -208,6 +215,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def set_grid(self, x: bool = False, y: bool = False):
         """
         Set the grid of the plot widget.
+
         Args:
             x(bool): Show grid on the x-axis.
             y(bool): Show grid on the y-axis.
@@ -223,6 +231,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def lock_aspect_ratio(self, lock):
         """
         Lock aspect ratio.
+
         Args:
             lock(bool): True to lock, False to unlock.
         """
@@ -231,6 +240,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def plot(self, data_x: list | np.ndarray, data_y: list | np.ndarray, **kwargs):
         """
         Plot custom data on the plot widget. These data are not saved in config.
+
         Args:
             data_x(list|np.ndarray): x-axis data
             data_y(list|np.ndarray): y-axis data
@@ -243,7 +253,9 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def remove(self):
         """Remove the plot widget from the figure."""
         if self.figure is not None:
+            self.cleanup()
             self.figure.remove(widget_id=self.gui_id)
 
     def cleanup(self):
         """Cleanup the plot widget."""
+        super().cleanup()

bec_widgets/widgets/plots/waveform.py

@@ -15,7 +15,7 @@ from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils import BECConnector, Colors, ConnectionConfig, EntryValidator
-from bec_widgets.widgets.plots.plot_base import BECPlotBase, WidgetConfig
+from bec_widgets.widgets.plots.plot_base import BECPlotBase, SubplotConfig
 
 
 class SignalData(BaseModel):
@@ -53,7 +53,7 @@ class CurveConfig(ConnectionConfig):
     colormap: Optional[str] = Field("plasma", description="The colormap of the curves z gradient.")
 
 
-class Waveform1DConfig(WidgetConfig):
+class Waveform1DConfig(SubplotConfig):
     color_palette: Literal["plasma", "viridis", "inferno", "magma"] = Field(
         "plasma", description="The color palette of the figure widget."
     )  # TODO can be extended to all colormaps from current pyqtgraph session
@@ -64,6 +64,8 @@ class Waveform1DConfig(WidgetConfig):
 
 class BECCurve(BECConnector, pg.PlotDataItem):
     USER_ACCESS = [
+        "remove",
+        "rpc_id",
         "config_dict",
         "set",
         "set_data",
@@ -82,6 +84,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         name: Optional[str] = None,
         config: Optional[CurveConfig] = None,
         gui_id: Optional[str] = None,
+        parent_item: Optional[pg.PlotItem] = None,
         **kwargs,
     ):
         if config is None:
@@ -93,6 +96,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         super().__init__(config=config, gui_id=gui_id)
         pg.PlotDataItem.__init__(self, name=name)
 
+        self.parent_item = parent_item
         self.apply_config()
         if kwargs:
             self.set(**kwargs)
@@ -125,8 +129,10 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     def set(self, **kwargs):
         """
         Set the properties of the curve.
+
         Args:
             **kwargs: Keyword arguments for the properties to be set.
+
         Possible properties:
             - color: str
             - symbol: str
@@ -155,6 +161,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     def set_color(self, color: str, symbol_color: Optional[str] = None):
         """
         Change the color of the curve.
+
         Args:
             color(str): Color of the curve.
             symbol_color(str, optional): Color of the symbol. Defaults to None.
@@ -166,6 +173,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     def set_symbol(self, symbol: str):
         """
         Change the symbol of the curve.
+
         Args:
             symbol(str): Symbol of the curve.
         """
@@ -175,6 +183,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     def set_symbol_color(self, symbol_color: str):
         """
         Change the symbol color of the curve.
+
         Args:
             symbol_color(str): Color of the symbol.
         """
@@ -184,6 +193,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     def set_symbol_size(self, symbol_size: int):
         """
         Change the symbol size of the curve.
+
         Args:
             symbol_size(int): Size of the symbol.
         """
@@ -193,6 +203,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     def set_pen_width(self, pen_width: int):
         """
         Change the pen width of the curve.
+
         Args:
             pen_width(int): Width of the pen.
         """
@@ -202,6 +213,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     def set_pen_style(self, pen_style: Literal["solid", "dash", "dot", "dashdot"]):
         """
         Change the pen style of the curve.
+
         Args:
             pen_style(Literal["solid", "dash", "dot", "dashdot"]): Style of the pen.
         """
@@ -211,6 +223,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     def set_colormap(self, colormap: str):
         """
         Set the colormap for the scatter plot z gradient.
+
         Args:
             colormap(str): Colormap for the scatter plot.
         """
@@ -225,9 +238,15 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         x_data, y_data = self.getData()
         return x_data, y_data
 
+    def remove(self):
+        """Remove the curve from the plot."""
+        self.parent_item.removeItem(self)
+        self.cleanup()
+
 
 class BECWaveform(BECPlotBase):
     USER_ACCESS = [
+        "rpc_id",
         "config_dict",
         "add_curve_scan",
         "add_curve_custom",
@@ -286,24 +305,12 @@ class BECWaveform(BECPlotBase):
         self.add_legend()
         self.apply_config(self.config)
 
-    def find_widget_by_id(self, item_id: str) -> BECCurve:
-        """
-        Find the curve by its ID.
-        Args:
-            item_id(str): ID of the curve.
-
-        Returns:
-            BECCurve: The curve object.
-        """
-        for curve in self.plot_item.curves:
-            if curve.gui_id == item_id:
-                return curve
-
-    def apply_config(self, config: dict | WidgetConfig, replot_last_scan: bool = False):
+    def apply_config(self, config: dict | SubplotConfig, replot_last_scan: bool = False):
         """
         Apply the configuration to the 1D waveform widget.
+
         Args:
-            config(dict|WidgetConfig): Configuration settings.
+            config(dict|SubplotConfig): Configuration settings.
             replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
         """
         if isinstance(config, dict):
@@ -342,8 +349,10 @@ class BECWaveform(BECPlotBase):
     def add_curve_by_config(self, curve_config: CurveConfig | dict) -> BECCurve:
         """
         Add a curve to the plot widget by its configuration.
+
         Args:
             curve_config(CurveConfig|dict): Configuration of the curve to be added.
+
         Returns:
             BECCurve: The curve object.
         """
@@ -357,8 +366,10 @@ class BECWaveform(BECPlotBase):
     def get_curve_config(self, curve_id: str, dict_output: bool = True) -> CurveConfig | dict:
         """
         Get the configuration of a curve by its ID.
+
         Args:
             curve_id(str): ID of the curve.
+
         Returns:
             CurveConfig|dict: Configuration of the curve.
         """
@@ -385,8 +396,10 @@ class BECWaveform(BECPlotBase):
     def get_curve(self, identifier) -> BECCurve:
         """
         Get the curve by its index or ID.
+
         Args:
             identifier(int|str): Identifier of the curve. Can be either an integer (index) or a string (curve_id).
+
         Returns:
             BECCurve: The curve object.
         """
@@ -410,6 +423,7 @@ class BECWaveform(BECPlotBase):
     ) -> BECCurve:
         """
         Add a custom data curve to the plot widget.
+
         Args:
             x(list|np.ndarray): X data of the curve.
             y(list|np.ndarray): Y data of the curve.
@@ -460,15 +474,17 @@ class BECWaveform(BECPlotBase):
     ) -> BECCurve:
         """
         Add a curve object to the plot widget.
+
         Args:
             name(str): ID of the curve.
             source(str): Source of the curve.
             config(CurveConfig): Configuration of the curve.
             data(tuple[list|np.ndarray,list|np.ndarray], optional): Data (x,y) to be plotted. Defaults to None.
+
         Returns:
             BECCurve: The curve object.
         """
-        curve = BECCurve(config=config, name=name)
+        curve = BECCurve(config=config, name=name, parent_item=self.plot_item)
         self._curves_data[source][name] = curve
         self.plot_item.addItem(curve)
         self.config.curves[name] = curve.config
@@ -492,6 +508,7 @@ class BECWaveform(BECPlotBase):
     ) -> BECCurve:
         """
         Add a curve to the plot widget from the scan segment.
+
         Args:
             x_name(str): Name of the x signal.
             x_entry(str): Entry of the x signal.
@@ -562,6 +579,7 @@ class BECWaveform(BECPlotBase):
     ) -> tuple[str, str, str | None]:
         """
         Validate the signal name and entry.
+
         Args:
             x_name(str): Name of the x signal.
             y_name(str): Name of the y signal.
@@ -570,6 +588,7 @@ class BECWaveform(BECPlotBase):
             y_entry(str|None): Entry of the y signal.
             z_entry(str|None): Entry of the z signal.
             validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+
         Returns:
             tuple[str,str,str|None]: Validated x, y, z entries.
         """
@@ -587,6 +606,7 @@ class BECWaveform(BECPlotBase):
     def _check_curve_id(self, val: Any, dict_to_check: dict) -> bool:
         """
         Check if val is in the values of the dict_to_check or in the values of the nested dictionaries.
+
         Args:
             val(Any): Value to check.
             dict_to_check(dict): Dictionary to check.
@@ -605,6 +625,7 @@ class BECWaveform(BECPlotBase):
     def remove_curve(self, *identifiers):
         """
         Remove a curve from the plot widget.
+
         Args:
             *identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
         """
@@ -621,6 +642,7 @@ class BECWaveform(BECPlotBase):
     def _remove_curve_by_id(self, curve_id):
         """
         Remove a curve by its ID from the plot widget.
+
         Args:
             curve_id(str): ID of the curve to be removed.
         """
@@ -637,6 +659,7 @@ class BECWaveform(BECPlotBase):
     def _remove_curve_by_order(self, N):
         """
         Remove a curve by its order from the plot widget.
+
         Args:
             N(int): Order of the curve to be removed.
         """
@@ -682,6 +705,7 @@ class BECWaveform(BECPlotBase):
     def _update_scan_curves(self, data: ScanData):
         """
         Update the scan curves with the data from the scan segment.
+
         Args:
             data(ScanData): Data from the scan segment.
         """
@@ -716,6 +740,7 @@ class BECWaveform(BECPlotBase):
     def _make_z_gradient(self, data_z: list | np.ndarray, colormap: str) -> list | None:
         """
         Make a gradient color for the z values.
+
         Args:
             data_z(list|np.ndarray): Z values.
             colormap(str): Colormap for the gradient color.
@@ -738,6 +763,7 @@ class BECWaveform(BECPlotBase):
         """
         Update the scan curves with the data from the scan storage.
         Provide only one of scan_id or scan_index.
+
         Args:
             scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
             scan_index(int, optional): Index of the scan to be updated. Defaults to None.
@@ -757,8 +783,10 @@ class BECWaveform(BECPlotBase):
     def get_all_data(self, output: Literal["dict", "pandas"] = "dict") -> dict | pd.DataFrame:
         """
         Extract all curve data into a dictionary or a pandas DataFrame.
+
         Args:
             output (Literal["dict", "pandas"]): Format of the output data.
+
         Returns:
             dict | pd.DataFrame: Data of all curves in the specified format.
         """
@@ -796,3 +824,6 @@ class BECWaveform(BECPlotBase):
     def cleanup(self):
         """Cleanup the widget connection from BECDispatcher."""
         self.bec_dispatcher.disconnect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+        for curve in self.curves:
+            curve.cleanup()
+        super().cleanup()

bec_widgets/widgets/scan_control/scan_control.py

@@ -109,6 +109,7 @@ class ScanControl(QWidget):
     def add_horizontal_separator(self, layout) -> None:
         """
         Adds a horizontal separator to the given layout
+
         Args:
             layout: Layout to add the separator to
         """
@@ -142,6 +143,7 @@ class ScanControl(QWidget):
     def add_labels_to_layout(self, labels: list, grid_layout: QGridLayout) -> None:
         """
         Adds labels to the given grid layout as a separate row.
+
         Args:
             labels (list): List of label names to add.
             grid_layout (QGridLayout): The grid layout to which labels will be added.
@@ -157,6 +159,7 @@ class ScanControl(QWidget):
     ) -> None:  # TODO could be moved to BECTable
         """
         Adds labels to the given table widget as a header row.
+
         Args:
             labels(list): List of label names to add.
             table(QTableWidget): The table widget to which labels will be added.
@@ -166,7 +169,8 @@ class ScanControl(QWidget):
 
     def generate_args_input_fields(self, scan_info: dict) -> None:
         """
-        Generates input fields for args
+        Generates input fields for args.
+
         Args:
             scan_info(dict): Scan signature dictionary from BEC.
         """
@@ -188,6 +192,7 @@ class ScanControl(QWidget):
     def generate_kwargs_input_fields(self, scan_info: dict) -> None:
         """
         Generates input fields for kwargs
+
         Args:
             scan_info(dict): Scan signature dictionary from BEC.
         """
@@ -213,12 +218,13 @@ class ScanControl(QWidget):
     def generate_widgets_from_signature(self, items: list, signature: dict = None) -> list:
         """
         Generates widgets from the given list of items.
+
         Args:
             items(list): List of items to create widgets for.
             signature(dict, optional): Scan signature dictionary from BEC.
 
         Returns:
-
+            list: List of widgets created from the given items.
         """
         widgets = []  # Initialize an empty list to hold the widgets
 
@@ -333,6 +339,7 @@ class ScanControl(QWidget):
     def clear_and_delete_layout(self, layout: QLayout):
         """
         Clears and deletes the given layout and all its child widgets.
+
         Args:
             layout(QLayout): Layout to clear and delete
         """
@@ -383,6 +390,7 @@ class ScanControl(QWidget):
     def extract_args_from_table(self, table: QTableWidget) -> list:
         """
         Extracts the arguments from the given table widget.
+
         Args:
             table(QTableWidget): Table widget from which to extract the arguments
         """

bec_widgets/widgets/toolbar/toolbar.py

@@ -82,6 +82,7 @@ class RunScriptAction:
 
 class ModularToolBar(QToolBar):
     """Modular toolbar with optional automatic initialization.
+
     Args:
         parent (QWidget, optional): The parent widget of the toolbar. Defaults to None.
         auto_init (bool, optional): If True, automatically populates the toolbar based on the parent widget.

docs/developer/developer.md

@@ -13,8 +13,8 @@ To contribute to the development of BEC Widgets, start by setting up the develop
 
 1. **Clone the Repository**: 
 ```bash
-git clone https://gitlab.psi.ch/bec/bec-widgets
-cd bec-widgets
+git clone https://gitlab.psi.ch/bec/bec_widgets
+cd bec_widgets
 ```
 2. **Install in Editable Mode**:
 

docs/user/installation.md

@@ -14,7 +14,7 @@ Before installing BEC Widgets, please ensure the following requirements are met:
 Install BEC Widgets using the pip package manager. Open your terminal and execute:
 
 ```bash
-pip install bec-widgets
+pip install bec_widgets
 ```
 
 This command installs BEC Widgets along with its dependencies, including the default PyQt6.
@@ -26,13 +26,13 @@ BEC Widgets supports both PyQt5 and PyQt6. To install a specific version, use:
 For PyQt6:
 
 ```bash
-pip install bec-widgets[pyqt6]
+pip install bec_widgets[pyqt6]
 ```
 
 For PyQt5:
 
 ```bash
-pip install bec-widgets[pyqt5]
+pip install bec_widgets[pyqt5]
 ```
 
 **Troubleshooting**

setup.py

@@ -1,11 +1,10 @@
 # pylint: disable= missing-module-docstring
 from setuptools import find_packages, setup
 
-__version__ = "0.46.6"
+__version__ = "0.52.1"
 
 # Default to PyQt6 if no other Qt binding is installed
-QT_DEPENDENCY = "PyQt6>=6.0"
-QSCINTILLA_DEPENDENCY = "PyQt6-QScintilla"
+QT_DEPENDENCY = "PyQt6>=6.7"
 
 # pylint: disable=unused-import
 try:
@@ -14,7 +13,6 @@ except ImportError:
     pass
 else:
     QT_DEPENDENCY = "PyQt5>=5.9"
-    QSCINTILLA_DEPENDENCY = "QScintilla"
 
 if __name__ == "__main__":
     setup(
@@ -22,7 +20,6 @@ if __name__ == "__main__":
             "pydantic",
             "qtconsole",
             QT_DEPENDENCY,
-            QSCINTILLA_DEPENDENCY,
             "jedi",
             "qtpy",
             "pyqtgraph",
@@ -41,12 +38,19 @@ if __name__ == "__main__":
                 "pytest-qt",
                 "black",
                 "isort",
+                "fakeredis",
             ],
             "pyqt5": ["PyQt5>=5.9"],
-            "pyqt6": ["PyQt6>=6.0"],
+            "pyqt6": ["PyQt6>=6.7"],
         },
         version=__version__,
         packages=find_packages(),
         include_package_data=True,
-        package_data={"": ["*.ui", "*.yaml"]},
+        package_data={
+            "": [
+                "*.ui",
+                "*.yaml",
+                "*.png",
+            ]
+        },
     )

tests/end-2-end/conftest.py

@@ -0,0 +1,40 @@
+import pytest
+
+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
+
+
+@pytest.fixture(autouse=True)
+def rpc_register():
+    yield RPCRegister()
+    RPCRegister.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()
+
+
+@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()

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -0,0 +1,145 @@
+import numpy as np
+import pytest
+from bec_lib import MessageEndpoints
+
+from bec_widgets.cli.client import BECDockArea, BECFigure, BECImageShow, BECMotorMap, BECWaveform
+
+
+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
+
+    # BEC client shortcuts
+    client = rpc_server_dock.client
+    dev = client.device_manager.devices
+    scans = client.scans
+    queue = client.queue
+
+    # Create 3 docks
+    d0 = dock.add_dock("dock_0")
+    d1 = dock.add_dock("dock_1")
+    d2 = dock.add_dock("dock_2")
+
+    assert len(dock_server.docks) == 3
+
+    # Add 3 figures with some widgets
+    fig0 = d0.add_widget_bec("BECFigure")
+    fig1 = d1.add_widget_bec("BECFigure")
+    fig2 = d2.add_widget_bec("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
+
+    assert fig1.__class__.__name__ == "BECFigure"
+    assert fig1.__class__ == BECFigure
+    assert fig2.__class__.__name__ == "BECFigure"
+    assert fig2.__class__ == BECFigure
+
+    mm = fig0.motor_map("samx", "samy")
+    plt = fig1.plot("samx", "bpm4i")
+    im = fig2.image("eiger")
+
+    assert mm.__class__.__name__ == "BECMotorMap"
+    assert mm.__class__ == BECMotorMap
+    assert plt.__class__.__name__ == "BECWaveform"
+    assert plt.__class__ == BECWaveform
+    assert im.__class__.__name__ == "BECImageShow"
+    assert im.__class__ == BECImageShow
+
+    assert mm.config_dict["signals"] == {
+        "source": "device_readback",
+        "x": {
+            "name": "samx",
+            "entry": "samx",
+            "unit": None,
+            "modifier": None,
+            "limits": [-50.0, 50.0],
+        },
+        "y": {
+            "name": "samy",
+            "entry": "samy",
+            "unit": None,
+            "modifier": None,
+            "limits": [-50.0, 50.0],
+        },
+        "z": None,
+    }
+    assert plt.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+        "source": "scan_segment",
+        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
+        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
+        "z": None,
+    }
+    assert im.config_dict["images"]["eiger"]["monitor"] == "eiger"
+
+    # check initial position of motor map
+    initial_pos_x = dev.samx.read()["samx"]["value"]
+    initial_pos_y = dev.samy.read()["samy"]["value"]
+
+    # Try to make a scan
+    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)
+
+    # plot
+    plt_last_scan_data = queue.scan_storage.storage[-1].data
+    plt_data = plt.get_all_data()
+    assert plt_data["bpm4i-bpm4i"]["x"] == plt_last_scan_data["samx"]["samx"].val
+    assert plt_data["bpm4i-bpm4i"]["y"] == plt_last_scan_data["bpm4i"]["bpm4i"].val
+
+    # image
+    last_image_device = client.connector.get_last(MessageEndpoints.device_monitor("eiger"))[
+        "data"
+    ].data
+    qtbot.wait(500)
+    last_image_plot = im.images[0].get_data()
+    np.testing.assert_equal(last_image_device, last_image_plot)
+
+    # motor map
+    final_pos_x = dev.samx.read()["samx"]["value"]
+    final_pos_y = dev.samy.read()["samy"]["value"]
+
+    # check final coordinates of motor map
+    motor_map_data = mm.get_data()
+
+    np.testing.assert_equal(
+        [motor_map_data["x"][0], motor_map_data["y"][0]], [initial_pos_x, initial_pos_y]
+    )
+    np.testing.assert_equal(
+        [motor_map_data["x"][-1], motor_map_data["y"][-1]], [final_pos_x, final_pos_y]
+    )
+
+
+def test_dock_manipulations_e2e(rpc_server_dock, qtbot):
+    dock = BECDockArea(rpc_server_dock.gui_id)
+    dock_server = rpc_server_dock.gui
+
+    d0 = dock.add_dock("dock_0")
+    d1 = dock.add_dock("dock_1")
+    d2 = dock.add_dock("dock_2")
+    assert len(dock_server.docks) == 3
+
+    d0.detach()
+    dock.detach_dock("dock_2")
+    assert len(dock_server.docks) == 3
+    assert len(dock_server.tempAreas) == 2
+
+    d0.attach()
+    assert len(dock_server.docks) == 3
+    assert len(dock_server.tempAreas) == 1
+
+    d2.remove()
+    qtbot.wait(200)
+
+    assert len(dock_server.docks) == 2
+    docks_list = list(dict(dock_server.docks).keys())
+    assert ["dock_0", "dock_1"] == docks_list
+
+    dock.clear_all()
+
+    assert len(dock_server.docks) == 0
+    assert len(dock_server.tempAreas) == 0

tests/end-2-end/test_bec_figure_rpc_e2e.py

@@ -3,27 +3,11 @@ import pytest
 from bec_lib import MessageEndpoints
 
 from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
-from bec_widgets.cli.server import BECWidgetsCLIServer
-from bec_widgets.utils import BECDispatcher
 
 
-@pytest.fixture
-def rpc_server(qtbot, bec_client_lib, threads_check):
-    dispatcher = BECDispatcher(client=bec_client_lib)  # Has to init singleton with fixture client
-    server = BECWidgetsCLIServer(gui_id="id_test")
-    qtbot.addWidget(server.fig)
-    qtbot.waitExposed(server.fig)
-    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 test_rpc_waveform1d_custom_curve(rpc_server, qtbot):
-    fig = BECFigure(rpc_server.gui_id)
-    fig_server = rpc_server.fig
+def test_rpc_waveform1d_custom_curve(rpc_server_figure, qtbot):
+    fig = BECFigure(rpc_server_figure.gui_id)
+    fig_server = rpc_server_figure.gui
 
     ax = fig.add_plot()
     curve = ax.add_curve_custom([1, 2, 3], [1, 2, 3])
@@ -32,12 +16,12 @@ def test_rpc_waveform1d_custom_curve(rpc_server, qtbot):
     curve.set_color("blue")
 
     assert len(fig_server.widgets) == 1
-    assert len(fig_server.widgets["widget_1"].curves) == 1
+    assert len(fig_server.widgets[ax.rpc_id].curves) == 1
 
 
-def test_rpc_plotting_shortcuts_init_configs(rpc_server, qtbot):
-    fig = BECFigure(rpc_server.gui_id)
-    fig_server = rpc_server.fig
+def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
+    fig = BECFigure(rpc_server_figure.gui_id)
+    fig_server = rpc_server_figure.gui
 
     plt = fig.plot("samx", "bpm4i")
     im = fig.image("eiger")
@@ -91,15 +75,15 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server, qtbot):
     }
 
 
-def test_rpc_waveform_scan(rpc_server, qtbot):
-    fig = BECFigure(rpc_server.gui_id)
+def test_rpc_waveform_scan(rpc_server_figure, qtbot):
+    fig = BECFigure(rpc_server_figure.gui_id)
 
     # add 3 different curves to track
     plt = fig.plot("samx", "bpm4i")
     fig.plot("samx", "bpm3a")
     fig.plot("samx", "bpm4d")
 
-    client = rpc_server.client
+    client = rpc_server_figure.client
     dev = client.device_manager.devices
     scans = client.scans
     queue = client.queue
@@ -124,12 +108,12 @@ def test_rpc_waveform_scan(rpc_server, qtbot):
     assert plt_data["bpm4d-bpm4d"]["y"] == last_scan_data["bpm4d"]["bpm4d"].val
 
 
-def test_rpc_image(rpc_server, qtbot):
-    fig = BECFigure(rpc_server.gui_id)
+def test_rpc_image(rpc_server_figure, qtbot):
+    fig = BECFigure(rpc_server_figure.gui_id)
 
     im = fig.image("eiger")
 
-    client = rpc_server.client
+    client = rpc_server_figure.client
     dev = client.device_manager.devices
     scans = client.scans
 
@@ -149,13 +133,13 @@ def test_rpc_image(rpc_server, qtbot):
     np.testing.assert_equal(last_image_device, last_image_plot)
 
 
-def test_rpc_motor_map(rpc_server, qtbot):
-    fig = BECFigure(rpc_server.gui_id)
-    fig_server = rpc_server.fig
+def test_rpc_motor_map(rpc_server_figure, qtbot):
+    fig = BECFigure(rpc_server_figure.gui_id)
+    fig_server = rpc_server_figure.gui
 
     motor_map = fig.motor_map("samx", "samy")
 
-    client = rpc_server.client
+    client = rpc_server_figure.client
     dev = client.device_manager.devices
     scans = client.scans
 

tests/end-2-end/test_rpc_register_e2e.py

@@ -0,0 +1,50 @@
+import pytest
+
+from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
+
+
+def find_deepest_value(d: dict):
+    """
+    Recursively find the deepest value in a dictionary
+    Args:
+        d(dict): Dictionary to search
+
+    Returns:
+        The deepest value in the dictionary.
+    """
+    if isinstance(d, dict):
+        if d:
+            return find_deepest_value(next(iter(d.values())))
+    return d
+
+
+def test_rpc_register_list_connections(rpc_server_figure, rpc_register, qtbot):
+    fig = BECFigure(rpc_server_figure.gui_id)
+    fig_server = rpc_server_figure.gui
+
+    plt = fig.plot("samx", "bpm4i")
+    im = fig.image("eiger")
+    motor_map = fig.motor_map("samx", "samy")
+    plt_z = fig.add_plot("samx", "samy", "bpm4i")
+
+    all_connections = rpc_register.list_all_connections()
+
+    # Construct dict of all rpc items manually
+    all_subwidgets_expected = dict(fig_server.widgets)
+    curve_1D = find_deepest_value(fig_server.widgets[plt.rpc_id]._curves_data)
+    curve_2D = find_deepest_value(fig_server.widgets[plt_z.rpc_id]._curves_data)
+    curves_expected = {curve_1D.rpc_id: curve_1D, curve_2D.rpc_id: curve_2D}
+    fig_expected = {fig.rpc_id: fig_server}
+    image_item_expected = {
+        fig_server.widgets[im.rpc_id].images[0].rpc_id: fig_server.widgets[im.rpc_id].images[0]
+    }
+
+    all_connections_expected = {
+        **all_subwidgets_expected,
+        **curves_expected,
+        **fig_expected,
+        **image_item_expected,
+    }
+
+    assert len(all_connections) == 8
+    assert all_connections == all_connections_expected

tests/unit_tests/client_mocks.py

@@ -91,6 +91,7 @@ DEVICES = [
     FakeDevice("bpm4i"),
     FakeDevice("bpm3a"),
     FakeDevice("bpm3i"),
+    FakeDevice("eiger"),
 ]
 
 

tests/unit_tests/conftest.py

@@ -1,8 +1,15 @@
 import pytest
 
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
 
 
+@pytest.fixture(autouse=True)
+def rpc_register():
+    yield RPCRegister()
+    RPCRegister.reset_singleton()
+
+
 @pytest.fixture(autouse=True)
 def bec_dispatcher(threads_check):
     bec_dispatcher = bec_dispatcher_module.BECDispatcher()

tests/unit_tests/test_bec_dispatcher.py

@@ -1,4 +1,5 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+import threading
 import time
 from unittest import mock
 
@@ -13,8 +14,9 @@ from bec_widgets.utils.bec_dispatcher import QtRedisConnector
 
 
 @pytest.fixture
-def bec_dispatcher_w_connector(bec_dispatcher, topics_msg_list):
+def bec_dispatcher_w_connector(bec_dispatcher, topics_msg_list, send_msg_event):
     def pubsub_msg_generator():
+        send_msg_event.wait()
         for topic, msg in topics_msg_list:
             yield {"channel": topic.encode(), "pattern": None, "data": msg}
         while True:
@@ -33,6 +35,11 @@ def bec_dispatcher_w_connector(bec_dispatcher, topics_msg_list):
 dummy_msg = MsgpackSerialization.dumps(ScanMessage(point_id=0, scan_id="0", data={}))
 
 
+@pytest.fixture
+def send_msg_event():
+    return threading.Event()
+
+
 @pytest.mark.parametrize(
     "topics_msg_list",
     [
@@ -43,7 +50,7 @@ dummy_msg = MsgpackSerialization.dumps(ScanMessage(point_id=0, scan_id="0", data
         )
     ],
 )
-def test_dispatcher_disconnect_all(bec_dispatcher_w_connector, qtbot):
+def test_dispatcher_disconnect_all(bec_dispatcher_w_connector, qtbot, send_msg_event):
     bec_dispatcher = bec_dispatcher_w_connector
     cb1 = mock.Mock(spec=[])
     cb2 = mock.Mock(spec=[])
@@ -53,7 +60,81 @@ def test_dispatcher_disconnect_all(bec_dispatcher_w_connector, qtbot):
     bec_dispatcher.connect_slot(cb2, "topic2")
     bec_dispatcher.connect_slot(cb2, "topic3")
     assert len(bec_dispatcher.client.connector._topics_cb) == 3
+    send_msg_event.set()
+    qtbot.wait(10)
+    assert cb1.call_count == 2
+    assert cb2.call_count == 2
 
     bec_dispatcher.disconnect_all()
 
     assert len(bec_dispatcher.client.connector._topics_cb) == 0
+
+
+@pytest.mark.parametrize(
+    "topics_msg_list",
+    [
+        (
+            ("topic1", dummy_msg),
+            ("topic2", dummy_msg),
+        )
+    ],
+)
+def test_dispatcher_disconnect_one(bec_dispatcher_w_connector, qtbot, send_msg_event):
+    # test for BEC issue #276
+    bec_dispatcher = bec_dispatcher_w_connector
+    cb1 = mock.Mock(spec=[])
+    cb2 = mock.Mock(spec=[])
+
+    bec_dispatcher.connect_slot(cb1, "topic1")
+    bec_dispatcher.connect_slot(cb2, "topic2")
+    assert len(bec_dispatcher.client.connector._topics_cb) == 2
+    bec_dispatcher.disconnect_slot(cb1, "topic1")
+    assert len(bec_dispatcher.client.connector._topics_cb) == 1
+
+    send_msg_event.set()
+    qtbot.wait(10)
+    assert cb1.call_count == 0
+    cb2.assert_called_once()
+
+
+@pytest.mark.parametrize("topics_msg_list", [(("topic1", dummy_msg),)])
+def test_dispatcher_2_cb_same_topic(bec_dispatcher_w_connector, qtbot, send_msg_event):
+    # test for BEC issue #276
+    bec_dispatcher = bec_dispatcher_w_connector
+    cb1 = mock.Mock(spec=[])
+    cb2 = mock.Mock(spec=[])
+
+    bec_dispatcher.connect_slot(cb1, "topic1")
+    bec_dispatcher.connect_slot(cb2, "topic1")
+    assert len(bec_dispatcher.client.connector._topics_cb) == 1
+    bec_dispatcher.disconnect_slot(cb1, "topic1")
+
+    send_msg_event.set()
+    qtbot.wait(10)
+    assert cb1.call_count == 0
+    cb2.assert_called_once()
+
+
+@pytest.mark.parametrize(
+    "topics_msg_list",
+    [
+        (
+            ("topic1", dummy_msg),
+            ("topic2", dummy_msg),
+        )
+    ],
+)
+def test_dispatcher_2_topic_same_cb(bec_dispatcher_w_connector, qtbot, send_msg_event):
+    # test for BEC issue #276
+    bec_dispatcher = bec_dispatcher_w_connector
+    cb1 = mock.Mock(spec=[])
+
+    bec_dispatcher.connect_slot(cb1, "topic1")
+    bec_dispatcher.connect_slot(cb1, "topic2")
+    assert len(bec_dispatcher.client.connector._topics_cb) == 2
+    bec_dispatcher.disconnect_slot(cb1, "topic1")
+    assert len(bec_dispatcher.client.connector._topics_cb) == 1
+
+    send_msg_event.set()
+    qtbot.wait(10)
+    cb1.assert_called_once()

tests/unit_tests/test_bec_dock.py

@@ -0,0 +1,114 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+
+import pytest
+
+from bec_widgets.widgets import BECDock, BECDockArea
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def bec_dock_area(qtbot, mocked_client):
+    widget = BECDockArea(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+def test_bec_dock_area_init(bec_dock_area):
+    assert bec_dock_area is not None
+    assert bec_dock_area.client is not None
+    assert isinstance(bec_dock_area, BECDockArea)
+    assert bec_dock_area.config.widget_class == "BECDockArea"
+
+
+def test_bec_dock_area_add_remove_dock(bec_dock_area, qtbot):
+    initial_count = len(bec_dock_area.docks)
+
+    # Adding 3 docks
+    d0 = bec_dock_area.add_dock()
+    d1 = bec_dock_area.add_dock()
+    d2 = bec_dock_area.add_dock()
+
+    # Check if the docks were added
+    assert len(bec_dock_area.docks) == initial_count + 3
+    assert d0.name() in dict(bec_dock_area.docks)
+    assert d1.name() in dict(bec_dock_area.docks)
+    assert d2.name() in dict(bec_dock_area.docks)
+    assert bec_dock_area.docks[d0.name()].config.widget_class == "BECDock"
+    assert bec_dock_area.docks[d1.name()].config.widget_class == "BECDock"
+    assert bec_dock_area.docks[d2.name()].config.widget_class == "BECDock"
+
+    # Check panels API for getting docks to CLI
+    assert bec_dock_area.panels == dict(bec_dock_area.docks)
+
+    # Remove docks
+    d0_name = d0.name()
+    bec_dock_area.remove_dock(d0_name)  # TODO fix this, works in jupyter console
+    qtbot.wait(200)
+    d1.remove()
+    qtbot.wait(200)
+
+    assert len(bec_dock_area.docks) == initial_count + 1
+    assert d0.name() not in dict(bec_dock_area.docks)
+    assert d1.name() not in dict(bec_dock_area.docks)
+    assert d2.name() in dict(bec_dock_area.docks)
+
+
+def test_add_remove_bec_figure_to_dock(bec_dock_area):
+    d0 = bec_dock_area.add_dock()
+    fig = d0.add_widget_bec("BECFigure")
+    plt = fig.plot("samx", "bpm4i")
+    im = fig.image("eiger")
+    mm = fig.motor_map("samx", "samy")
+
+    assert len(bec_dock_area.docks) == 1
+    assert len(d0.widgets) == 1
+    assert len(d0.widget_list) == 1
+    assert len(fig.widgets) == 3
+
+    assert fig.config.widget_class == "BECFigure"
+    assert plt.config.widget_class == "BECWaveform"
+    assert im.config.widget_class == "BECImageShow"
+    assert mm.config.widget_class == "BECMotorMap"
+
+
+def test_dock_area_errors(bec_dock_area):
+    d0 = bec_dock_area.add_dock(name="dock_0")
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_dock_area.add_dock(name="dock_0")
+        assert "Dock with name  dock_0 already exists." in str(excinfo.value)
+
+
+def test_close_docks(bec_dock_area, qtbot):
+    d0 = bec_dock_area.add_dock(name="dock_0")
+    d1 = bec_dock_area.add_dock(name="dock_1")
+    d2 = bec_dock_area.add_dock(name="dock_2")
+
+    bec_dock_area.clear_all()
+    qtbot.wait(200)
+    assert len(bec_dock_area.docks) == 0
+
+
+def test_undock_and_dock_docks(bec_dock_area, qtbot):
+    d0 = bec_dock_area.add_dock(name="dock_0")
+    d1 = bec_dock_area.add_dock(name="dock_1")
+    d2 = bec_dock_area.add_dock(name="dock_4")
+    d3 = bec_dock_area.add_dock(name="dock_3")
+
+    d0.detach()
+    bec_dock_area.detach_dock("dock_1")
+    d2.detach()
+
+    assert len(bec_dock_area.docks) == 4
+    assert len(bec_dock_area.tempAreas) == 3
+
+    d0.attach()
+    assert len(bec_dock_area.docks) == 4
+    assert len(bec_dock_area.tempAreas) == 2
+
+    bec_dock_area.attach_all()
+    assert len(bec_dock_area.docks) == 4
+    assert len(bec_dock_area.tempAreas) == 0

tests/unit_tests/test_bec_figure.py

@@ -1,6 +1,4 @@
 # pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
-import os
-from unittest.mock import MagicMock
 
 import numpy as np
 import pytest
@@ -48,12 +46,12 @@ def test_bec_figure_add_remove_plot(bec_figure):
 
     # Check if the widgets were added
     assert len(bec_figure._widgets) == initial_count + 3
-    assert "widget_1" in bec_figure._widgets
-    assert "widget_2" in bec_figure._widgets
-    assert "widget_3" in bec_figure._widgets
-    assert bec_figure._widgets["widget_1"].config.widget_class == "BECWaveform"
-    assert bec_figure._widgets["widget_2"].config.widget_class == "BECWaveform"
-    assert bec_figure._widgets["widget_3"].config.widget_class == "BECPlotBase"
+    assert w0.gui_id in bec_figure._widgets
+    assert w1.gui_id in bec_figure._widgets
+    assert w2.gui_id in bec_figure._widgets
+    assert bec_figure._widgets[w0.gui_id].config.widget_class == "BECWaveform"
+    assert bec_figure._widgets[w1.gui_id].config.widget_class == "BECWaveform"
+    assert bec_figure._widgets[w2.gui_id].config.widget_class == "BECPlotBase"
 
     # Check accessing positions by the grid in figure
     assert bec_figure[0, 0] == w0
@@ -61,11 +59,11 @@ def test_bec_figure_add_remove_plot(bec_figure):
     assert bec_figure[2, 0] == w2
 
     # Removing 1 widget
-    bec_figure.remove(widget_id="widget_1")
+    bec_figure.remove(widget_id=w0.gui_id)
     assert len(bec_figure._widgets) == initial_count + 2
-    assert "widget_1" not in bec_figure._widgets
-    assert "widget_3" in bec_figure._widgets
-    assert bec_figure._widgets["widget_2"].config.widget_class == "BECWaveform"
+    assert w0.gui_id not in bec_figure._widgets
+    assert w2.gui_id in bec_figure._widgets
+    assert bec_figure._widgets[w1.gui_id].config.widget_class == "BECWaveform"
 
 
 def test_add_different_types_of_widgets(bec_figure):
@@ -121,20 +119,20 @@ def test_remove_plots(bec_figure):
 
     # remove by coordinates
     bec_figure[0, 0].remove()
-    assert "widget_1" not in bec_figure._widgets
+    assert w1.gui_id not in bec_figure._widgets
 
     # remove by widget_id
-    bec_figure.remove(widget_id="widget_2")
-    assert "widget_2" not in bec_figure._widgets
+    bec_figure.remove(widget_id=w2.gui_id)
+    assert w2.gui_id not in bec_figure._widgets
 
     # remove by widget object
     w3.remove()
-    assert "widget_3" not in bec_figure._widgets
+    assert w3.gui_id not in bec_figure._widgets
 
     # check the remaining widget 4
     assert bec_figure[0, 0] == w4
-    assert bec_figure["widget_4"] == w4
-    assert "widget_4" in bec_figure._widgets
+    assert bec_figure[w4.gui_id] == w4
+    assert w4.gui_id in bec_figure._widgets
     assert len(bec_figure._widgets) == 1
 
 
@@ -143,8 +141,8 @@ def test_remove_plots_by_coordinates_ints(bec_figure):
     w2 = bec_figure.add_plot(row=0, col=1)
 
     bec_figure.remove(0, 0)
-    assert "widget_1" not in bec_figure._widgets
-    assert "widget_2" in bec_figure._widgets
+    assert w1.gui_id not in bec_figure._widgets
+    assert w2.gui_id in bec_figure._widgets
     assert bec_figure[0, 0] == w2
     assert len(bec_figure._widgets) == 1
 
@@ -154,8 +152,8 @@ def test_remove_plots_by_coordinates_tuple(bec_figure):
     w2 = bec_figure.add_plot(row=0, col=1)
 
     bec_figure.remove(coordinates=(0, 0))
-    assert "widget_1" not in bec_figure._widgets
-    assert "widget_2" in bec_figure._widgets
+    assert w1.gui_id not in bec_figure._widgets
+    assert w2.gui_id in bec_figure._widgets
     assert bec_figure[0, 0] == w2
     assert len(bec_figure._widgets) == 1
 

tests/unit_tests/test_editor.py

@@ -1,170 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-
-import os
-import tempfile
-from unittest.mock import MagicMock, mock_open, patch
-
-import pytest
-from qtpy.Qsci import QsciScintilla
-from qtpy.QtWidgets import QTextEdit
-
-from bec_widgets.widgets.editor.editor import AutoCompleter, BECEditor
-
-
-@pytest.fixture(scope="function")
-def editor(qtbot, docstring_tooltip=False):
-    """Helper function to set up the BECEditor widget."""
-    widget = BECEditor(toolbar_enabled=True, docstring_tooltip=docstring_tooltip)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def find_action_by_text(toolbar, text):
-    """Helper function to find an action in the toolbar by its text."""
-    for action in toolbar.actions():
-        if action.text() == text:
-            return action
-    return None
-
-
-def test_bec_editor_initialization(editor):
-    """Test if the BECEditor widget is initialized correctly."""
-    assert isinstance(editor.editor, QsciScintilla)
-    assert isinstance(editor.terminal, QTextEdit)
-    assert isinstance(editor.auto_completer, AutoCompleter)
-
-
-@patch("bec_widgets.widgets.editor.editor.Script")  # Mock the Script class from jedi
-def test_autocompleter_suggestions(mock_script, editor, qtbot):
-    """Test if the autocompleter provides correct suggestions based on input."""
-    # Set up mock return values for the Script.complete method
-    mock_completion = MagicMock()
-    mock_completion.name = "mocked_method"
-    mock_script.return_value.complete.return_value = [mock_completion]
-
-    # Simulate user input in the editor
-    test_code = "print("
-    editor.editor.setText(test_code)
-    line, index = editor.editor.getCursorPosition()
-
-    # Trigger autocomplete
-    editor.auto_completer.get_completions(line, index, test_code)
-
-    # Use qtbot to wait for the completion thread
-    qtbot.waitUntil(lambda: editor.auto_completer.completions is not None, timeout=1000)
-
-    # Check if the expected completion is in the autocompleter's suggestions
-    suggested_methods = [completion.name for completion in editor.auto_completer.completions]
-    assert "mocked_method" in suggested_methods
-
-
-@patch("bec_widgets.widgets.editor.editor.Script")  # Mock the Script class from jedi
-@pytest.mark.parametrize(
-    "docstring_enabled, expected_signature",
-    [(True, "Mocked signature with docstring"), (False, "Mocked signature")],
-)
-def test_autocompleter_signature(mock_script, editor, docstring_enabled, expected_signature):
-    """Test if the autocompleter provides correct function signature based on docstring setting."""
-    # Set docstring mode based on parameter
-    editor.docstring_tooltip = docstring_enabled
-    editor.auto_completer.enable_docstring = docstring_enabled
-
-    # Set up mock return values for the Script.get_signatures method
-    mock_signature = MagicMock()
-    if docstring_enabled:
-        mock_signature.docstring.return_value = expected_signature
-    else:
-        mock_signature.to_string.return_value = expected_signature
-    mock_script.return_value.get_signatures.return_value = [mock_signature]
-
-    # Simulate user input that would trigger a signature request
-    test_code = "print("
-    editor.editor.setText(test_code)
-    line, index = editor.editor.getCursorPosition()
-
-    # Trigger signature request
-    signature = editor.auto_completer.get_function_signature(line, index, test_code)
-
-    # Check if the expected signature is returned
-    assert signature == expected_signature
-
-
-def test_open_file(editor):
-    """Test open_file method of BECEditor."""
-    # Create a temporary file with some content
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".py") as temp_file:
-        temp_file.write(b"test file content")
-
-    # Mock user selecting the file in the dialog
-    with patch("qtpy.QtWidgets.QFileDialog.getOpenFileName", return_value=(temp_file.name, "")):
-        with patch("builtins.open", new_callable=mock_open, read_data="test file content"):
-            editor.open_file()
-
-            # Verify if the editor's text is set to the file content
-            assert editor.editor.text() == "test file content"
-
-    # Clean up by removing the temporary file
-    os.remove(temp_file.name)
-
-
-def test_save_file(editor):
-    """Test save_file method of BECEditor."""
-    # Set some text in the editor
-    editor.editor.setText("test save content")
-
-    # Mock user selecting the file in the dialog
-    with patch(
-        "qtpy.QtWidgets.QFileDialog.getSaveFileName", return_value=("/path/to/save/file.py", "")
-    ):
-        with patch("builtins.open", new_callable=mock_open) as mock_file:
-            editor.save_file()
-
-            # Verify if the file was opened correctly for writing
-            mock_file.assert_called_with("/path/to/save/file.py", "w")
-
-            # Verify if the editor's text was written to the file
-            mock_file().write.assert_called_with("test save content")
-
-
-def test_open_file_through_toolbar(editor):
-    """Test the open_file method through the ModularToolBar."""
-    # Create a temporary file
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".py") as temp_file:
-        temp_file.write(b"test file content")
-
-    # Find the open file action in the toolbar
-    open_action = find_action_by_text(editor.toolbar, "Open File")
-    assert open_action is not None, "Open File action should be found"
-
-    # Mock the file dialog and built-in open function
-    with patch("qtpy.QtWidgets.QFileDialog.getOpenFileName", return_value=(temp_file.name, "")):
-        with patch("builtins.open", new_callable=mock_open, read_data="test file content"):
-            open_action.trigger()
-            # Verify if the editor's text is set to the file content
-            assert editor.editor.text() == "test file content"
-
-    # Clean up
-    os.remove(temp_file.name)
-
-
-def test_save_file_through_toolbar(editor):
-    """Test the save_file method through the ModularToolBar."""
-    # Set some text in the editor
-    editor.editor.setText("test save content")
-
-    # Find the save file action in the toolbar
-    save_action = find_action_by_text(editor.toolbar, "Save File")
-    assert save_action is not None, "Save File action should be found"
-
-    # Mock the file dialog and built-in open function
-    with patch(
-        "qtpy.QtWidgets.QFileDialog.getSaveFileName", return_value=("/path/to/save/file.py", "")
-    ):
-        with patch("builtins.open", new_callable=mock_open) as mock_file:
-            save_action.trigger()
-            # Verify if the file was opened correctly for writing
-            mock_file.assert_called_with("/path/to/save/file.py", "w")
-
-            # Verify if the editor's text was written to the file
-            mock_file().write.assert_called_with("test save content")

tests/unit_tests/test_generate_cli_client.py

@@ -40,7 +40,7 @@ def test_client_generator_with_black_formatting():
         '''\
         # This file was automatically generated by generate_cli.py
 
-        from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
+        from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECGuiClientMixin
         from typing import Literal, Optional, overload
 
         class MockBECWaveform1D(RPCBase):

tests/unit_tests/test_rpc_register.py

@@ -0,0 +1,52 @@
+from bec_widgets.cli.rpc_register import RPCRegister
+
+
+class FakeObject:
+    def __init__(self, gui_id):
+        self.gui_id = gui_id
+
+
+def test_add_connection(rpc_register):
+    obj1 = FakeObject("id1")
+    obj2 = FakeObject("id2")
+
+    rpc_register.add_rpc(obj1)
+    rpc_register.add_rpc(obj2)
+
+    all_connections = rpc_register.list_all_connections()
+
+    assert len(all_connections) == 2
+    assert all_connections["id1"] == obj1
+    assert all_connections["id2"] == obj2
+
+
+def test_remove_connection(rpc_register):
+
+    obj1 = FakeObject("id1")
+    obj2 = FakeObject("id2")
+
+    rpc_register.add_rpc(obj1)
+    rpc_register.add_rpc(obj2)
+
+    rpc_register.remove_rpc(obj1)
+
+    all_connections = rpc_register.list_all_connections()
+
+    assert len(all_connections) == 1
+    assert all_connections["id2"] == obj2
+
+
+def test_reset_singleton(rpc_register):
+    obj1 = FakeObject("id1")
+    obj2 = FakeObject("id2")
+
+    rpc_register.add_rpc(obj1)
+    rpc_register.add_rpc(obj2)
+
+    rpc_register.reset_singleton()
+    rpc_register = RPCRegister()
+
+    all_connections = rpc_register.list_all_connections()
+
+    assert len(all_connections) == 0
+    assert all_connections == {}

tests/unit_tests/test_waveform1d.py

@@ -141,7 +141,7 @@ def test_getting_curve(bec_figure):
     c1_expected_config = CurveConfig(
         widget_class="BECCurve",
         gui_id="test_curve",
-        parent_id="widget_1",
+        parent_id=w1.gui_id,
         label="bpm4i-bpm4i",
         color="#cc4778",
         symbol="o",