0.48.0

Automatically generated by python-semantic-release

.git_hooks/pre-commit

@@ -1,2 +1,3 @@
-black --line-length=100 $(git diff --cached --name-only --diff-filter=ACM -- '***.py')
-git add $(git diff --cached --name-only --diff-filter=ACM -- '***.py')
+black --line-length=100 $(git diff --cached --name-only --diff-filter=ACM -- '*.py')
+isort --line-length=100 --profile=black --multi-line=3 --trailing-comma $(git diff --cached --name-only --diff-filter=ACM -- '*.py')
+git add $(git diff --cached --name-only --diff-filter=ACM -- '*.py')

.gitlab-ci.yml

@@ -1,10 +1,22 @@
 # This file is a template, and might need editing before it works on your project.
 # Official language image. Look for the different tagged releases at:
 # https://hub.docker.com/r/library/python/tags/
-image: $CI_DOCKER_REGISTRY/python:3.9
+image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.10
 #commands to run in the Docker container before starting each job.
 variables:
   DOCKER_TLS_CERTDIR: ""
+  BEC_CORE_BRANCH: "main"
+  OPHYD_DEVICES_BRANCH: "main"
+
+workflow:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
+      when: never
+    - if: $CI_COMMIT_BRANCH
 
 include:
   - template: Security/Secret-Detection.gitlab-ci.yml
@@ -15,13 +27,15 @@ stages:
   - Formatter
   - test
   - AdditionalTests
+  - End2End
   - Deploy
 
 formatter:
   stage: Formatter
   needs: []
   script:
-    - pip install black
+    - pip install black isort
+    - isort --check --diff --line-length=100 --profile=black --multi-line=3 --trailing-comma ./
     - black --check --diff --color --line-length=100 ./
 pylint:
   stage: Formatter
@@ -77,10 +91,14 @@ tests:
   variables:
       QT_QPA_PLATFORM: "offscreen"
   script:
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
     - apt-get update
     - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-    - pip install .[dev]
-    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e .[dev]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
     - coverage report
     - coverage xml
   coverage: '/(?i)total.*? (100(?:\.0+)?\%|[1-9]?\d(?:\.\d+)?\%)$/'
@@ -91,35 +109,64 @@ tests:
         coverage_format: cobertura
         path: coverage.xml
 
-#tests-3.9-pyqt5: #todo enable when we decide what qt distributions we want to support
-#  extends: "tests"
-#  stage: AdditionalTests
-#  image: $CI_DOCKER_REGISTRY/python:3.9
-#  script:
-#    - apt-get update
-#    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-#    - pip install .[dev,pyqt5]
-#    - pytest -v --random-order ./tests
-
-tests-3.10:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DOCKER_REGISTRY/python:3.10
-  allow_failure: true
-
 
 tests-3.11:
   extends: "tests"
   stage: AdditionalTests
-  image: $CI_DOCKER_REGISTRY/python:3.11
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
   allow_failure: true
 
 tests-3.12:
   extends: "tests"
   stage: AdditionalTests
-  image: $CI_DOCKER_REGISTRY/python:3.12
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
   allow_failure: true
 
+end-2-end-conda:
+  stage: End2End
+  needs: []
+  image: continuumio/miniconda3
+  allow_failure: false
+  variables:
+    QT_QPA_PLATFORM: "offscreen"
+  script:
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - conda config --prepend channels conda-forge
+    - conda config --set channel_priority strict
+    - conda config --set always_yes yes --set changeps1 no
+    - conda create -q -n test-environment python=3.10
+    - conda init bash
+    - source ~/.bashrc
+    - conda activate test-environment
+
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+
+    - cd ./bec
+    - source ./bin/install_bec_dev.sh -t
+
+    - pip install -e ./bec_lib[dev]
+    - pip install -e ./bec_ipython_client[dev]
+    - cd ../
+    - pip install -e .[dev]
+    - cd ./tests/end-2-end
+    - pytest --start-servers --flush-redis --random-order
+
+  artifacts:
+    when: on_failure
+    paths:
+      - ./logs/*.log
+    expire_in: 1 week
+
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "schedule"'
+    - if: '$CI_PIPELINE_SOURCE == "web"'
+    - if: '$CI_PIPELINE_SOURCE == "pipeline"'
+    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
+    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
+
 
 semver:
   stage: Deploy
@@ -141,13 +188,14 @@ semver:
     - export REPOSITORY_USERNAME=__token__
     - export REPOSITORY_PASSWORD=$CI_PYPI_TOKEN
     - >
-      semantic-release publish -v DEBUG 
-      -D version_variable=./setup.py:__version__  
-      -D hvcs=gitlab 
+      semantic-release publish -v DEBUG
+      -D version_variable=./setup.py:__version__
+      -D hvcs=gitlab
+      -D branch=main
 
   allow_failure: false
   rules:
-    - if: '$CI_COMMIT_REF_NAME == "master"'
+    - if: '$CI_COMMIT_REF_NAME == "main"'
 
 pages:
   stage: Deploy
@@ -158,6 +206,6 @@ pages:
     - if: '$CI_COMMIT_TAG != null'
       variables:
         TARGET_BRANCH: $CI_COMMIT_TAG
-    - if: '$CI_COMMIT_REF_NAME == "master"'
+    - if: '$CI_COMMIT_REF_NAME == "main"'
   script:
     - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/bec-widgets/253243/

.pylintrc

@@ -52,7 +52,7 @@ persistent=yes
 
 # Minimum Python version to use for version dependent checks. Will default to
 # the version used to run pylint.
-py-version=3.9
+py-version=3.10
 
 # When enabled, pylint would attempt to guess common misconfiguration and emit
 # user-friendly hints instead of false-positive error messages.

.readthedocs.yaml

@@ -9,7 +9,7 @@ version: 2
 build:
   os: ubuntu-20.04
   tools:
-    python: "3.9"
+    python: "3.10"
 
 # Build documentation in the docs/ directory with Sphinx
 sphinx:

CHANGELOG.md

@@ -2,6 +2,175 @@
 
 <!--next-version-placeholder-->
 
+## 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
+
+* **cli:** Fixed support for devices as cli input ([`1111610`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1111610f3206c5c46db6b4bd1e8827f1a4cd9e3f))
+
+## v0.46.5 (2024-04-19)
+
+### Fix
+
+* **widgets/figure:** Individual cleanup disabled, making stuck rpc ([`ff52100`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ff52100e234debdfb5ccc0869352cfafde52ac93))
+* **plots/waveform:** Colormap is correctly passed from BECFigure ([`026c079`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/026c0792bee25723013fffe57ccff10d9b652913))
+
+## v0.46.4 (2024-04-16)
+
+### Fix
+
+* Renaming of bec_client to bec_ipython_client ([`4da625e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4da625e4398bdd937c2b788592f15f7530148292))
+* **plots/motor_map:** User can get data as dict from BECMotorMap ([`c12f2ce`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c12f2cee80b13137a2b70e2d121a079e20d124e2))
+* **plots/image:** User can get data as np.ndarray from BECImageItem ([`c2c583f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c2c583fce6f28981990c504dd065705124e40e44))
+* **rpc/server:** Server can accept client or dispatcher ([`ecdf0f1`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ecdf0f122b628ee378b80793d498cedafe50fbf8))
+
+## v0.46.3 (2024-04-11)
+
+### Fix
+
+* **test_fake_redis:** TestMessage fixed to pydantic BaseModel ([`0b86a00`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0b86a0009d9366b710294a3ab55cb9f4894472c0))
+* **plots/motor_map:** Removed single callback flag for connecting device_readback motors ([`49327a8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/49327a8dbde270c67bc0ce7c757fd4a3eae118b4))
+* **cli/client_utils:** Print_log is buffered; add output processing thread ([`285bf01`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/285bf0164b6deb91678f03ab2a190680b6d83a02))
+* Producer->connector ([`9def373`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9def3734afb361ac2d5cc933661766cdc440e09d))
+
+## v0.46.2 (2024-04-10)
+
+### Fix
+
+* **widget/plots:** Added "get_config" to all children of `BECConnector` to USER_ACCESS ([`ee617b7`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ee617b73a2fcad8194394182fcecb0dd4f583a8e))
+
+## v0.46.1 (2024-04-10)
+
+### Fix
+
+* **rpc/client:** Correct name for RPC class BECWaveform (instead of BECWaveform1D) ([`cf29035`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cf29035e283e55efa547cbac88e8b622190dfc4d))
+
+## v0.46.0 (2024-04-09)
+
+### Feature
+
+* **plot/waveform1d:** BECWaveform1D can show z data of scatter coded to different detector like BECMonitor2DScatter; BECWaveform1D name changed to BECWaveform ([`3d399ba`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3d399ba1f5d85bc67964febcf8921355f9f1c285))
+
+## v0.45.0 (2024-03-26)
+
+### Feature
+
+* **plots/bec_figure:** Motor Map integrated to BECFigure ([`b8519e8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b8519e8770f8ffc46a1255c18119fc7978ff1d39))
+* **plots/bec_motor_map:** BECMotorMap build on BECPlotBase ([`0f69c34`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0f69c346cd24b7afcd23f444525a170e062b0368))
+
+### Documentation
+
+* Added api reference; closes #123 ([`88014d2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/88014d24c1c272a6deea7436a6fa058bdb06fb57))
+
+## v0.44.5 (2024-03-25)
+
+### Fix
+
+* Circular imports ([`c5826f8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c5826f8887ed44d15d05c8ed0e337080b3146c5a))
+
+## v0.44.4 (2024-03-22)
+
+### Fix
+
+* **cli/server:** Thread heartbeat replaced with QTimer ([`e6b0657`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/e6b065767c8605aaef6ed6032ba893d3900b552c))
+* **cli/server:** Removed BECFigure.start(), the QApplication event loop is started by server.py ([`f3a96de`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f3a96dedd7ba49f9a1b713f6a5565f2b3dbb141e))
+
+## v0.44.3 (2024-03-21)
+
+### Fix
+
+* **cli:** Don't call user script if gui is not alive ([`a92aead`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a92aead7698fa98d6f7f582d030845d0b940ea2d))
+* **cli:** Added gui heartbeat ([`882cf55`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/882cf55fc5266a2cfb610702e834badff3ad0428))
+
+## v0.44.2 (2024-03-20)
+
+### Fix
+
+* **utils/bec_dispatcher:** Try/except to start client, to avoid crash when redis is not running ([`9ccd4ea`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9ccd4ea235be4c4332045b7a7f09d6cc6291f7ff))
+* **utils/bec_dispatcher:** Bec_dispatcher adjusted to the new BECClient; dropped support to inject bec_config.yaml, instead BECClient can be passed as arg ([`86416d5`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/86416d50cb850b42d312fe17fc46f0b4743dc940))
+
+## v0.44.1 (2024-03-19)
+
+### Fix
+
+* **examples/motor_compilation:** Motor_control_compilations.py do not have any hardcoded config anymore ([`14f901f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/14f901f1bea2ba7b79903c4743e37384e11533d3))
+
+## v0.44.0 (2024-03-18)
+
+### Feature
+
+* **cli:** Added update script to BECFigure ([`9049e0d`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9049e0d27fe9a3860e21ffc3b350eb69e567b71c))
+
+### Fix
+
+* **cli:** Removed hard-coded signal ([`203ae09`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/203ae0960688608fb609a742a23e5994bfe9805c))
+* **cli:** Fixed cleanup procedure ([`2d39c5e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/2d39c5e4d18bbb66a5f3340fce7f8944dd4ba19f))
+
+## v0.43.2 (2024-03-18)
+
+### Fix
+
+* **cli/server:** Added QApplications to enter separate QT event loop ensuring that QT objects are not deleted ([`d0f9bf1`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d0f9bf17339296a60301e5e6ffe602db369c6c7c))
+
+## v0.43.1 (2024-03-15)
+
+### Fix
+
+* **plots/image:** Same access pattern for image and image_item for setting up parameters, autorange of z scale disabled by default ([`b8d4e69`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b8d4e697ac2a5929a1374ce1778046efc3f8187a))
+* **widget/various:** Corrected USER_ACCESS methods for children widgets to include inherited methods to RPC ([`4664661`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4664661cfb4e8bd4a6adb71f2050b25d0b4f3d36))
+* **widgets/figure:** Added widgets can be accessed as a list (fig.axes) or as a dictionary (fig.widgets) ([`fcf918c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fcf918c48862d069b9fe69cbba7dbecbe7429790))
+
+## v0.43.0 (2024-03-14)
+
+### Feature
+
+* **plots/image:** Image processor can run in threaded or non-threaded version ([`4865b10`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4865b10ced6b321974e7b4b4db12786fe21fd916))
+* **plots/image:** Change stream processor to QThread with connector.get_last; cleanup method for BECFigure to kill all threads if App is closed during acquisition ([`7ffedd9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/7ffedd9cebb382fc22f24a6b0b46823db6378d89))
+* **plots/image:** Basic image visualisation, getting data are based on stream_connector (deprecated) ([`9ad0055`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9ad0055336dba50886504a616db6f9f63b23beb3))
+
+### Fix
+
+* **plots/waveform1d:** Curves_data access disabled ([`598479b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/598479bb555a6cd077d5a137052d91314e5af6b7))
+* **cli:** Find_widget_by_id for BECImageShow changed to be compatible with RPC logic ([`4ef6ae9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4ef6ae90f2afd5e2442465c11ce5165517cd4218))
+* **plots/image:** Access pattern for ImageItems in BECImageShow ([`3362fab`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3362fabed7ccd611b35f524c1970aeefbf3a9faf))
+* **cli:** Fix cli connector.send to set_and_publish for gui_instruction_response ([`4076698`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/407669853097b40e6fba7d43da001f083140ad74))
+
+## v0.42.1 (2024-03-10)
+
+### Fix
+
+* **various:** Repo cleanup, removed - [plot_app, one_plot, scan_plot, scan2d_plot, crosshair_example, qtplugins], tests adjusted ([`f3b3c2f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f3b3c2f526d66687b3cc596a5877921953dd0803))
+
+## v0.42.0 (2024-03-07)
+
+### Feature
+
+* **utils/bec_dispatcher:** BECDispatcher can register redis stream ([`4c0a7bb`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4c0a7bbec7abafc7d04a8aaf10dabd7e668fa908))
+
+## v0.41.4 (2024-03-07)
+
+### Fix
+
+* **utils/bec_dispatcher:** BECDispatcher can accept new EndpointInfo dataclass. ([`c319dac`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c319dacb24e64930af258a81484feeadcb1bc341))
+
 ## v0.41.3 (2024-03-01)
 
 ### Fix

bec_widgets/cli/__init__.py

@@ -0,0 +1,2 @@
+from .auto_updates import AutoUpdates, ScanInfo
+from .client import 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.py

@@ -1,10 +1,20 @@
 # This file was automatically generated by generate_cli.py
 
-from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
 from typing import Literal, Optional, overload
 
+from bec_widgets.cli.client_utils import BECFigureClientMixin, RPCBase, rpc_call
+
 
 class BECPlotBase(RPCBase):
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+
     @rpc_call
     def set(self, **kwargs) -> "None":
         """
@@ -101,7 +111,15 @@ class BECPlotBase(RPCBase):
         """
 
     @rpc_call
-    def plot_data(self, data_x: "list | np.ndarray", data_y: "list | np.ndarray", **kwargs):
+    def lock_aspect_ratio(self, lock):
+        """
+        Lock aspect ratio.
+        Args:
+            lock(bool): True to lock, False to unlock.
+        """
+
+    @rpc_call
+    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:
@@ -117,15 +135,27 @@ class BECPlotBase(RPCBase):
         """
 
 
-class BECWaveform1D(RPCBase):
+class BECWaveform(RPCBase):
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+
     @rpc_call
     def add_curve_scan(
         self,
         x_name: "str",
         y_name: "str",
+        z_name: "Optional[str]" = None,
         x_entry: "Optional[str]" = None,
         y_entry: "Optional[str]" = None,
+        z_entry: "Optional[str]" = None,
         color: "Optional[str]" = None,
+        color_map_z: "Optional[str]" = "plasma",
         label: "Optional[str]" = None,
         validate_bec: "bool" = True,
         **kwargs
@@ -137,7 +167,10 @@ class BECWaveform1D(RPCBase):
             x_entry(str): Entry of the x signal.
             y_name(str): Name of the y signal.
             y_entry(str): Entry of the y signal.
+            z_name(str): Name of the z signal.
+            z_entry(str): Entry of the z signal.
             color(str, optional): Color of the curve. Defaults to None.
+            color_map_z(str): The color map to use for the z-axis.
             label(str, optional): Label of the curve. Defaults to None.
             **kwargs: Additional keyword arguments for the curve configuration.
 
@@ -176,12 +209,12 @@ class BECWaveform1D(RPCBase):
         """
 
     @rpc_call
-    def scan_history(self, scan_index: "int" = None, scanID: "str" = None):
+    def scan_history(self, scan_index: "int" = None, scan_id: "str" = None):
         """
         Update the scan curves with the data from the scan storage.
-        Provide only one of scanID or scan_index.
+        Provide only one of scan_id or scan_index.
         Args:
-            scanID(str, optional): ScanID of the scan to be updated. Defaults to None.
+            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.
         """
 
@@ -194,15 +227,6 @@ class BECWaveform1D(RPCBase):
             list: List of curves.
         """
 
-    @property
-    @rpc_call
-    def curves_data(self) -> "dict":
-        """
-        Get the curves data of the plot widget as a dictionary
-        Returns:
-            dict: Dictionary of curves data.
-        """
-
     @rpc_call
     def get_curve(self, identifier) -> "BECCurve":
         """
@@ -242,17 +266,172 @@ class BECWaveform1D(RPCBase):
             dict | pd.DataFrame: Data of all curves in the specified format.
         """
 
+    @rpc_call
+    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
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+        """
+
+    @rpc_call
+    def set_title(self, title: "str"):
+        """
+        Set the title of the plot widget.
+        Args:
+            title(str): Title of the plot widget.
+        """
+
+    @rpc_call
+    def set_x_label(self, label: "str"):
+        """
+        Set the label of the x-axis.
+        Args:
+            label(str): Label of the x-axis.
+        """
+
+    @rpc_call
+    def set_y_label(self, label: "str"):
+        """
+        Set the label of the y-axis.
+        Args:
+            label(str): Label of the y-axis.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    def set_x_lim(self, *args) -> "None":
+        """
+        Set the limits of the x-axis. This method can accept either two separate arguments
+        for the minimum and maximum x-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_x_lim(x_min, x_max)
+            set_x_lim((x_min, x_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (x_min and x_max)
+                   or a single tuple with two integers.
+        """
+
+    @rpc_call
+    def set_y_lim(self, *args) -> "None":
+        """
+        Set the limits of the y-axis. This method can accept either two separate arguments
+        for the minimum and maximum y-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_y_lim(y_min, y_max)
+            set_y_lim((y_min, y_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (y_min and y_max)
+                   or a single tuple with two integers.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    def lock_aspect_ratio(self, lock):
+        """
+        Lock aspect ratio.
+        Args:
+            lock(bool): True to lock, False to unlock.
+        """
+
+    @rpc_call
+    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
+            **kwargs: Keyword arguments for the plot.
+        """
+
+    @rpc_call
+    def remove(self):
+        """
+        Remove the plot widget from the figure.
+        """
+
 
 class BECFigure(RPCBase, BECFigureClientMixin):
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @property
+    @rpc_call
+    def axes(self) -> "list[BECPlotBase]":
+        """
+        Access all widget in BECFigure as a list
+        Returns:
+            list[BECPlotBase]: List of all widgets in the figure.
+        """
+
+    @property
+    @rpc_call
+    def widgets(self) -> "dict":
+        """
+        None
+        """
+
     @rpc_call
     def add_plot(
         self,
-        widget_id: "str" = None,
+        x_name: "str" = None,
+        y_name: "str" = None,
+        z_name: "str" = None,
+        x_entry: "str" = None,
+        y_entry: "str" = None,
+        z_entry: "str" = None,
+        x: "list | np.ndarray" = None,
+        y: "list | np.ndarray" = None,
+        color: "Optional[str]" = None,
+        color_map_z: "Optional[str]" = "plasma",
+        label: "Optional[str]" = None,
+        validate: "bool" = True,
         row: "int" = None,
         col: "int" = None,
         config=None,
         **axis_kwargs
-    ) -> "BECWaveform1D":
+    ) -> "BECWaveform":
         """
         Add a Waveform1D plot to the figure at the specified position.
         Args:
@@ -263,6 +442,136 @@ class BECFigure(RPCBase, BECFigureClientMixin):
             **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
         """
 
+    @rpc_call
+    def add_image(
+        self,
+        monitor: "str" = None,
+        color_bar: "Literal['simple', 'full']" = "full",
+        color_map: "str" = "magma",
+        data: "np.ndarray" = None,
+        vrange: "tuple[float, float]" = None,
+        row: "int" = None,
+        col: "int" = None,
+        config=None,
+        **axis_kwargs
+    ) -> "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.
+            color_map(str): The color map to use for the image.
+            data(np.ndarray): Custom data to display.
+            vrange(tuple[float, float]): The range of values to display.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Additional configuration for the widget.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECImageShow: The image widget.
+        """
+
+    @rpc_call
+    def add_motor_map(
+        self,
+        motor_x: "str" = None,
+        motor_y: "str" = None,
+        row: "int" = None,
+        col: "int" = None,
+        config=None,
+        **axis_kwargs
+    ) -> "BECMotorMap":
+        """
+        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.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Additional configuration for the widget.
+            **axis_kwargs:
+
+        Returns:
+            BECMotorMap: The motor map widget.
+        """
+
+    @rpc_call
+    def plot(
+        self,
+        x_name: "str" = None,
+        y_name: "str" = None,
+        z_name: "str" = None,
+        x_entry: "str" = None,
+        y_entry: "str" = None,
+        z_entry: "str" = None,
+        x: "list | np.ndarray" = None,
+        y: "list | np.ndarray" = None,
+        color: "Optional[str]" = None,
+        color_map_z: "Optional[str]" = "plasma",
+        label: "Optional[str]" = None,
+        validate: "bool" = True,
+        **axis_kwargs
+    ) -> "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.
+            z_name(str): The name of the device for the z-axis.
+            x_entry(str): The name of the entry for the x-axis.
+            y_entry(str): The name of the entry for the y-axis.
+            z_entry(str): The name of the entry for the z-axis.
+            x(list | np.ndarray): Custom x data to plot.
+            y(list | np.ndarray): Custom y data to plot.
+            color(str): The color of the curve.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str): The label of the curve.
+            validate(bool): If True, validate the device names and entries.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECWaveform: The waveform plot widget.
+        """
+
+    @rpc_call
+    def image(
+        self,
+        monitor: "str" = None,
+        color_bar: "Literal['simple', 'full']" = "full",
+        color_map: "str" = "magma",
+        data: "np.ndarray" = None,
+        vrange: "tuple[float, float]" = None,
+        **axis_kwargs
+    ) -> "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.
+            color_map(str): The color map to use for the image.
+            data(np.ndarray): Custom data to display.
+            vrange(tuple[float, float]): The range of values to display.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECImageShow: The image widget.
+        """
+
+    @rpc_call
+    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.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECMotorMap: The motor map widget.
+        """
+
     @rpc_call
     def remove(
         self,
@@ -307,6 +616,15 @@ class BECFigure(RPCBase, BECFigureClientMixin):
 
 
 class BECCurve(RPCBase):
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+
     @rpc_call
     def set(self, **kwargs):
         """
@@ -337,6 +655,14 @@ class BECCurve(RPCBase):
             symbol_color(str, optional): Color of the symbol. Defaults to None.
         """
 
+    @rpc_call
+    def set_colormap(self, colormap: "str"):
+        """
+        Set the colormap for the scatter plot z gradient.
+        Args:
+            colormap(str): Colormap for the scatter plot.
+        """
+
     @rpc_call
     def set_symbol(self, symbol: "str"):
         """
@@ -384,3 +710,535 @@ class BECCurve(RPCBase):
         Returns:
             tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
         """
+
+
+class BECImageShow(RPCBase):
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    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.
+
+        Returns:
+            BECImageItem: The image object.
+        """
+
+    @rpc_call
+    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.
+
+        Returns:
+            ImageItemConfig|dict: The configuration of the image.
+        """
+
+    @rpc_call
+    def get_image_dict(self) -> "dict[str, dict[str, BECImageItem]]":
+        """
+        Get all images.
+        Returns:
+            dict[str, dict[str, BECImageItem]]: The dictionary of images.
+        """
+
+    @rpc_call
+    def add_monitor_image(
+        self,
+        monitor: "str",
+        color_map: "Optional[str]" = "magma",
+        color_bar: "Optional[Literal['simple', 'full']]" = "simple",
+        downsample: "Optional[bool]" = True,
+        opacity: "Optional[float]" = 1.0,
+        vrange: "Optional[tuple[int, int]]" = None,
+        **kwargs
+    ) -> "BECImageItem":
+        """
+        None
+        """
+
+    @rpc_call
+    def add_custom_image(
+        self,
+        name: "str",
+        data: "Optional[np.ndarray]" = None,
+        color_map: "Optional[str]" = "magma",
+        color_bar: "Optional[Literal['simple', 'full']]" = "simple",
+        downsample: "Optional[bool]" = True,
+        opacity: "Optional[float]" = 1.0,
+        vrange: "Optional[tuple[int, int]]" = None,
+        **kwargs
+    ):
+        """
+        None
+        """
+
+    @rpc_call
+    def set_vrange(self, vmin: "float", vmax: "float", name: "str" = None):
+        """
+        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.
+            name(str): The name of the image. If None, apply to all images.
+        """
+
+    @rpc_call
+    def set_color_map(self, cmap: "str", name: "str" = None):
+        """
+        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.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    def set_monitor(self, monitor: "str", name: "str" = None):
+        """
+        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.
+        """
+
+    @rpc_call
+    def set_processing(self, name: "str" = None, **kwargs):
+        """
+        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.
+        Possible properties:
+            - fft: bool
+            - log: bool
+            - rot: int
+            - transpose: bool
+        """
+
+    @rpc_call
+    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.
+        Possible properties:
+            - downsample: bool
+            - color_map: str
+            - monitor: str
+            - opacity: float
+            - vrange: tuple[int,int]
+            - fft: bool
+            - log: bool
+            - rot: int
+            - transpose: bool
+        """
+
+    @rpc_call
+    def set_fft(self, enable: "bool" = False, name: "str" = None):
+        """
+        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.
+        """
+
+    @rpc_call
+    def set_log(self, enable: "bool" = False, name: "str" = None):
+        """
+        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.
+        """
+
+    @rpc_call
+    def set_rotation(self, deg_90: "int" = 0, name: "str" = None):
+        """
+        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.
+        """
+
+    @rpc_call
+    def set_transpose(self, enable: "bool" = False, name: "str" = None):
+        """
+        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.
+        """
+
+    @rpc_call
+    def toggle_threading(self, use_threading: "bool"):
+        """
+        Toggle threading for the widgets postprocessing and updating.
+        Args:
+            use_threading(bool): Whether to use threading.
+        """
+
+    @rpc_call
+    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
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+        """
+
+    @rpc_call
+    def set_title(self, title: "str"):
+        """
+        Set the title of the plot widget.
+        Args:
+            title(str): Title of the plot widget.
+        """
+
+    @rpc_call
+    def set_x_label(self, label: "str"):
+        """
+        Set the label of the x-axis.
+        Args:
+            label(str): Label of the x-axis.
+        """
+
+    @rpc_call
+    def set_y_label(self, label: "str"):
+        """
+        Set the label of the y-axis.
+        Args:
+            label(str): Label of the y-axis.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    def set_x_lim(self, *args) -> "None":
+        """
+        Set the limits of the x-axis. This method can accept either two separate arguments
+        for the minimum and maximum x-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_x_lim(x_min, x_max)
+            set_x_lim((x_min, x_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (x_min and x_max)
+                   or a single tuple with two integers.
+        """
+
+    @rpc_call
+    def set_y_lim(self, *args) -> "None":
+        """
+        Set the limits of the y-axis. This method can accept either two separate arguments
+        for the minimum and maximum y-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_y_lim(y_min, y_max)
+            set_y_lim((y_min, y_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (y_min and y_max)
+                   or a single tuple with two integers.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    def lock_aspect_ratio(self, lock):
+        """
+        Lock aspect ratio.
+        Args:
+            lock(bool): True to lock, False to unlock.
+        """
+
+    @rpc_call
+    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
+            **kwargs: Keyword arguments for the plot.
+        """
+
+    @rpc_call
+    def remove(self):
+        """
+        Remove the plot widget from the figure.
+        """
+
+    @property
+    @rpc_call
+    def images(self) -> "list[BECImageItem]":
+        """
+        Get the list of images.
+        Returns:
+            list[BECImageItem]: The list of images.
+        """
+
+
+class BECConnector(RPCBase):
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+
+class BECImageItem(RPCBase):
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    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
+            - monitor
+            - opacity
+            - vrange
+            - fft
+            - log
+            - rot
+            - transpose
+        """
+
+    @rpc_call
+    def set_fft(self, enable: "bool" = False):
+        """
+        Set the FFT of the image.
+        Args:
+            enable(bool): Whether to perform FFT on the monitor data.
+        """
+
+    @rpc_call
+    def set_log(self, enable: "bool" = False):
+        """
+        Set the log of the image.
+        Args:
+            enable(bool): Whether to perform log on the monitor data.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    def set_transpose(self, enable: "bool" = False):
+        """
+        Set the transpose of the image.
+        Args:
+            enable(bool): Whether to transpose the image.
+        """
+
+    @rpc_call
+    def set_opacity(self, opacity: "float" = 1.0):
+        """
+        Set the opacity of the image.
+        Args:
+            opacity(float): The opacity of the image.
+        """
+
+    @rpc_call
+    def set_autorange(self, autorange: "bool" = False):
+        """
+        Set the autorange of the color bar.
+        Args:
+            autorange(bool): Whether to autorange the color bar.
+        """
+
+    @rpc_call
+    def set_color_map(self, cmap: "str" = "magma"):
+        """
+        Set the color map of the image.
+        Args:
+            cmap(str): The color map of the image.
+        """
+
+    @rpc_call
+    def set_auto_downsample(self, auto: "bool" = True):
+        """
+        Set the auto downsample of the image.
+        Args:
+            auto(bool): Whether to downsample the image.
+        """
+
+    @rpc_call
+    def set_monitor(self, monitor: "str"):
+        """
+        Set the monitor of the image.
+        Args:
+            monitor(str): The name of the monitor.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    def get_data(self) -> "np.ndarray":
+        """
+        Get the data of the image.
+        Returns:
+            np.ndarray: The data of the image.
+        """
+
+
+class BECMotorMap(RPCBase):
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    def change_motors(
+        self,
+        motor_x: "str",
+        motor_y: "str",
+        motor_x_entry: "str" = None,
+        motor_y_entry: "str" = None,
+        validate_bec: "bool" = True,
+    ) -> "None":
+        """
+        Change the active motors for the plot.
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            motor_x_entry(str): Motor entry for the X axis.
+            motor_y_entry(str): Motor entry for the Y axis.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        """
+
+    @rpc_call
+    def set_max_points(self, max_points: "int") -> "None":
+        """
+        Set the maximum number of points to display.
+        Args:
+            max_points(int): Maximum number of points to display.
+        """
+
+    @rpc_call
+    def set_precision(self, precision: "int") -> "None":
+        """
+        Set the decimal precision of the motor position.
+        Args:
+            precision(int): Decimal precision of the motor position.
+        """
+
+    @rpc_call
+    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.
+        """
+
+    @rpc_call
+    def set_background_value(self, background_value: "int") -> "None":
+        """
+        Set the background value of the motor map.
+        Args:
+            background_value(int): Background value of the motor map.
+        """
+
+    @rpc_call
+    def set_scatter_size(self, scatter_size: "int") -> "None":
+        """
+        Set the scatter size of the motor map plot.
+        Args:
+            scatter_size(int): Size of the scatter points.
+        """
+
+    @rpc_call
+    def get_data(self) -> "dict":
+        """
+        Get the data of the motor map.
+        Returns:
+            dict: Data of the motor map.
+        """

bec_widgets/cli/client_utils.py

@@ -1,14 +1,29 @@
+from __future__ import annotations
+
 import importlib
+import importlib.metadata as imd
+import os
 import select
 import subprocess
+import sys
+import threading
+import time
 import uuid
 from functools import wraps
+from typing import TYPE_CHECKING
 
 from bec_lib import MessageEndpoints, 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
+
 
 def rpc_call(func):
     """
@@ -23,6 +38,19 @@ def rpc_call(func):
 
     @wraps(func)
     def wrapper(self, *args, **kwargs):
+        # we could rely on a strict type check here, but this is more flexible
+        # moreover, it would anyway crash for objects...
+        out = []
+        for arg in args:
+            if hasattr(arg, "name"):
+                arg = arg.name
+            out.append(arg)
+        args = tuple(out)
+        for key, val in kwargs.items():
+            if hasattr(val, "name"):
+                kwargs[key] = val.name
+        if not self.gui_is_alive():
+            raise RuntimeError("GUI is not alive")
         return self._run_rpc(func.__name__, *args, **kwargs)
 
     return wrapper
@@ -32,6 +60,50 @@ class BECFigureClientMixin:
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._process = None
+        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):
+        """
+        Selected device for the plot.
+        """
+        return self._selected_device
+
+    @selected_device.setter
+    def selected_device(self, device: str | DeviceBase):
+        if isinstance(device, DeviceBase):
+            self._selected_device = device.name
+        elif isinstance(device, str):
+            self._selected_device = device
+        else:
+            raise ValueError("Device must be a string or a device object")
+
+    def _start_update_script(self) -> None:
+        self._client.connector.register(
+            self._target_endpoint, cb=self._handle_msg_update, parent=self
+        )
+
+    @staticmethod
+    def _handle_msg_update(msg: MessageObject, parent: BECFigureClientMixin) -> None:
+        if parent.update_script is not None:
+            # pylint: disable=protected-access
+            parent._update_script_msg_parser(msg.value)
+
+    def _update_script_msg_parser(self, msg: messages.BECMessage) -> None:
+        if isinstance(msg, messages.ScanStatusMessage):
+            if not self.gui_is_alive():
+                return
+            self.update_script.run(msg)
 
     def show(self) -> None:
         """
@@ -39,6 +111,9 @@ class BECFigureClientMixin:
         """
         if self._process is None or self._process.poll() is not None:
             self._start_plot_process()
+        while not self.gui_is_alive():
+            print("Waiting for GUI to start...")
+            time.sleep(1)
 
     def close(self) -> None:
         """
@@ -47,21 +122,26 @@ class BECFigureClientMixin:
         if self._process is None:
             return
         self._run_rpc("close", (), wait_for_rpc_response=False)
-        self._process.kill()
+        self._process.terminate()
+        self._process_output_processing_thread.join()
         self._process = None
+        self._client.shutdown()
 
     def _start_plot_process(self) -> None:
         """
         Start the plot in a new process.
         """
+        self._start_update_script()
         # pylint: disable=subprocess-run-check
         monitor_module = importlib.import_module("bec_widgets.cli.server")
         monitor_path = monitor_module.__file__
 
-        command = f"python {monitor_path} --id {self._gui_id}"
+        command = [sys.executable, "-u", monitor_path, "--id", self._gui_id]
         self._process = subprocess.Popen(
-            command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
         )
+        self._process_output_processing_thread = threading.Thread(target=self._get_output)
+        self._process_output_processing_thread.start()
 
     def print_log(self) -> None:
         """
@@ -69,22 +149,22 @@ class BECFigureClientMixin:
         """
         if self._process is None:
             return
-        print(self._get_stderr_output())
+        print("".join(self.stderr_output))
+        # Flush list
+        self.stderr_output.clear()
 
-    def _get_stderr_output(self) -> str:
-        stderr_output = []
-        while self._process.poll() is not None:
-            readylist, _, _ = select.select([self._process.stderr], [], [], 0.1)
-            if not readylist:
-                break
-            line = self._process.stderr.readline()
-            if not line:
-                break
-            stderr_output.append(line.decode("utf-8"))
-        return "".join(stderr_output)
-
-    def __del__(self) -> None:
-        self.close()
+    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))
 
 
 class RPCBase:
@@ -94,7 +174,12 @@ class RPCBase:
         self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())
         self._parent = parent
         super().__init__()
-        print(f"RPCBase: {self._gui_id}")
+        # print(f"RPCBase: {self._gui_id}")
+
+    def __repr__(self):
+        type_ = type(self)
+        qualname = type_.__qualname__
+        return f"<{qualname} object at {hex(id(self))}>"
 
     @property
     def _root(self):
@@ -104,7 +189,7 @@ class RPCBase:
         """
         parent = self
         # pylint: disable=protected-access
-        while not parent._parent is None:
+        while parent._parent is not None:
             parent = parent._parent
         return parent
 
@@ -127,10 +212,10 @@ class RPCBase:
             parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
             metadata={"request_id": request_id},
         )
-        print(f"RPCBase: {rpc_msg}")
+        # print(f"RPCBase: {rpc_msg}")
         # pylint: disable=protected-access
         receiver = self._root._gui_id
-        self._client.producer.send(MessageEndpoints.gui_instructions(receiver), rpc_msg)
+        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
 
         if not wait_for_rpc_response:
             return None
@@ -148,7 +233,9 @@ class RPCBase:
             return [self._create_widget_from_msg_result(res) for res in msg_result]
         if isinstance(msg_result, dict):
             if "__rpc__" not in msg_result:
-                return msg_result
+                return {
+                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
+                }
             cls = msg_result.pop("widget_class", None)
             msg_result.pop("__rpc__", None)
 
@@ -156,7 +243,7 @@ class RPCBase:
                 return msg_result
 
             cls = getattr(client, cls)
-            print(msg_result)
+            # print(msg_result)
             return cls(parent=self, **msg_result)
         return msg_result
 
@@ -165,8 +252,16 @@ class RPCBase:
         Wait for the response from the server.
         """
         response = None
-        while response is None:
-            response = self._client.producer.get(
+        while response is None and self.gui_is_alive():
+            response = self._client.connector.get(
                 MessageEndpoints.gui_instruction_response(request_id)
             )
+            QCoreApplication.processEvents()  # keep UI responsive (and execute signals/slots)
         return response
+
+    def gui_is_alive(self):
+        """
+        Check if the GUI is alive.
+        """
+        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
+        return heart is not None

bec_widgets/cli/generate_cli.py

@@ -1,9 +1,10 @@
 # pylint: disable=missing-module-docstring
 from __future__ import annotations
+
 import inspect
-import black
 import sys
 
+import black
 
 if sys.version_info >= (3, 11):
     from typing import get_overloads
@@ -103,16 +104,27 @@ class {class_name}(RPCBase):"""
             file.write(formatted_content)
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     import os
 
-    # Assuming ClientGenerator is defined in this script or imported correctly
+    from bec_widgets.utils import BECConnector
     from bec_widgets.widgets.figure import BECFigure
-    from bec_widgets.widgets.plots import BECPlotBase, BECWaveform1D, BECCurve
+    from bec_widgets.widgets.plots import BECImageShow, BECMotorMap, BECPlotBase, BECWaveform
+    from bec_widgets.widgets.plots.image import BECImageItem
+    from bec_widgets.widgets.plots.waveform import BECCurve
 
     current_path = os.path.dirname(__file__)
     client_path = os.path.join(current_path, "client.py")
-    clss = [BECPlotBase, BECWaveform1D, BECFigure, BECCurve]
+    clss = [
+        BECPlotBase,
+        BECWaveform,
+        BECFigure,
+        BECCurve,
+        BECImageShow,
+        BECConnector,
+        BECImageItem,
+        BECMotorMap,
+    ]
     generator = ClientGenerator()
     generator.generate_client(clss)
     generator.write(client_path)

bec_widgets/cli/server.py

@@ -1,51 +1,50 @@
 import inspect
 
 from bec_lib import MessageEndpoints, messages
+from qtpy.QtCore import QTimer
 
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.widgets.figure import BECFigure
-from bec_widgets.widgets.plots import BECCurve, BECWaveform1D
+from bec_widgets.widgets.plots import BECCurve, BECImageShow, BECWaveform
 
 
 class BECWidgetsCLIServer:
-    WIDGETS = [BECWaveform1D, BECFigure, BECCurve]
+    WIDGETS = [BECWaveform, BECFigure, BECCurve, BECImageShow]
 
-    def __init__(self, gui_id: str = None, dispatcher: BECDispatcher = None) -> None:
+    def __init__(self, gui_id: str = None, dispatcher: BECDispatcher = None, client=None) -> None:
         self.dispatcher = BECDispatcher() if dispatcher is None else dispatcher
-        self.client = self.dispatcher.client
+        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)
-        print(f"Server started with gui_id {self.gui_id}")
 
         self.dispatcher.connect_slot(
             self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
         )
 
-    def start(self):
-        """Start the figure window."""
-        self.fig.start()
-
-    @staticmethod
-    def _rpc_update_handler(msg, parent):
-        parent.on_rpc_update(msg.value)
+        # Setup QTimer for heartbeat
+        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
 
     def on_rpc_update(self, msg: dict, metadata: dict):
+        request_id = metadata.get("request_id")
         try:
             method = msg["action"]
             args = msg["parameter"].get("args", [])
             kwargs = msg["parameter"].get("kwargs", {})
-            request_id = metadata.get("request_id")
             obj = self.get_object_from_config(msg["parameter"])
             res = self.run_rpc(obj, method, args, kwargs)
-            self.send_response(request_id, True, {"result": res})
         except Exception as e:
             print(e)
             self.send_response(request_id, False, {"error": str(e)})
+        else:
+            self.send_response(request_id, True, {"result": res})
 
     def send_response(self, request_id: str, accepted: bool, msg: dict):
-        self.client.producer.set(
+        self.client.connector.set_and_publish(
             MessageEndpoints.gui_instruction_response(request_id),
             messages.RequestResponseMessage(accepted=accepted, message=msg),
             expire=60,
@@ -57,17 +56,14 @@ class BECWidgetsCLIServer:
         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"]]
+        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():
+        if self.fig._widgets:
+            for widget in self.fig._widgets.values():
                 item = widget.find_widget_by_id(gui_id)
                 if item:
                     return item
-                raise NotImplementedError(
-                    f"gui_id lookup for widget of type {widget.__class__.__name__} not implemented"
-                )
 
         raise ValueError(f"Object with gui_id {gui_id} not found")
 
@@ -85,6 +81,8 @@ class BECWidgetsCLIServer:
 
         if isinstance(res, list):
             res = [self.serialize_object(obj) for obj in res]
+        elif isinstance(res, dict):
+            res = {key: self.serialize_object(val) for key, val in res.items()}
         else:
             res = self.serialize_object(res)
         return res
@@ -99,9 +97,29 @@ class BECWidgetsCLIServer:
             }
         return obj
 
+    def emit_heartbeat(self):
+        if self._shutdown_event is False:
+            self.client.connector.set(
+                MessageEndpoints.gui_heartbeat(self.gui_id),
+                messages.StatusMessage(name=self.gui_id, status=1, info={}),
+                expire=10,
+            )
+        print("Heartbeat emitted")
 
-if __name__ == "__main__":
+    def shutdown(self):
+        self._shutdown_event = True
+        self._heartbeat_timer.stop()
+
+
+if __name__ == "__main__":  # pragma: no cover
     import argparse
+    import sys
+
+    from qtpy.QtWidgets import QApplication, QMainWindow
+
+    app = QApplication(sys.argv)
+    app.setApplicationName("BEC Figure")
+    win = QMainWindow()
 
     parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
     parser.add_argument("--id", type=str, help="The id of the server")
@@ -110,4 +128,10 @@ if __name__ == "__main__":
 
     server = BECWidgetsCLIServer(gui_id=args.id)
     # server = BECWidgetsCLIServer(gui_id="test")
-    server.start()
+
+    fig = server.fig
+    win.setCentralWidget(fig)
+    win.show()
+
+    app.aboutToQuit.connect(server.shutdown)
+    sys.exit(app.exec())

bec_widgets/examples/__init__.py

@@ -2,8 +2,8 @@ from .motor_movement import (
     MotorControlApp,
     MotorControlMap,
     MotorControlPanel,
-    MotorControlPanelRelative,
     MotorControlPanelAbsolute,
+    MotorControlPanelRelative,
     MotorCoordinateTable,
     MotorThread,
 )

bec_widgets/examples/crosshair_example/crosshair_example.py

@@ -1,168 +0,0 @@
-import numpy as np
-import pyqtgraph as pg
-from qtpy.QtWidgets import (
-    QApplication,
-    QVBoxLayout,
-    QLabel,
-    QWidget,
-    QHBoxLayout,
-    QTableWidget,
-    QTableWidgetItem,
-    QSpinBox,
-)
-from pyqtgraph import mkPen
-from pyqtgraph.Qt import QtCore
-from bec_widgets.utils import Crosshair
-
-
-class ExampleApp(QWidget):
-    def __init__(self):
-        super().__init__()
-
-        # Layout
-        self.layout = QHBoxLayout()
-        self.setLayout(self.layout)
-
-        ##########################
-        # 1D Plot
-        ##########################
-
-        # PlotWidget
-        self.plot_widget_1d = pg.PlotWidget(title="1D PlotWidget with multiple curves")
-        self.plot_item_1d = self.plot_widget_1d.getPlotItem()
-        self.plot_item_1d.setLogMode(True, True)
-
-        # 1D Datasets
-        self.x_data = np.linspace(0, 10, 1000)
-
-        def gauss(x, mu, sigma):
-            return (1 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)
-
-        # same convention as in line_plot.py
-        self.y_value_list = [
-            gauss(self.x_data, 1, 1),
-            gauss(self.x_data, 1.5, 3),
-            abs(np.sin(self.x_data)),
-            abs(np.cos(self.x_data)),
-            abs(np.sin(2 * self.x_data)),
-        ]  # List of y-values for multiple curves
-
-        self.curve_names = ["Gauss(1,1)", "Gauss(1.5,3)", "Abs(Sine)", "Abs(Cosine)", "Abs(Sine2x)"]
-        self.curves = []
-
-        ##########################
-        # 2D Plot
-        ##########################
-        self.plot_widget_2d = pg.PlotWidget(title="2D plot with crosshair and ROI square")
-        self.data_2D = np.random.random((100, 200))
-        self.plot_item_2d = self.plot_widget_2d.getPlotItem()
-        self.image_item = pg.ImageItem(self.data_2D)
-        self.plot_item_2d.addItem(self.image_item)
-
-        ##########################
-        # Table
-        ##########################
-        self.table = QTableWidget(len(self.curve_names), 2)
-        self.table.setHorizontalHeaderLabels(["(X, Y) - Moved", "(X, Y) - Clicked"])
-        self.table.setVerticalHeaderLabels(self.curve_names)
-        self.table.resizeColumnsToContents()
-
-        ##########################
-        # Spinbox for N curves
-        ##########################
-        self.spin_box = QSpinBox()
-        self.spin_box.setMinimum(0)
-        self.spin_box.setMaximum(len(self.y_value_list))
-        self.spin_box.setValue(2)
-        self.spin_box.valueChanged.connect(lambda: self.update_curves(self.spin_box.value()))
-
-        ##########################
-        # Adding widgets to layout
-        ##########################
-
-        ##### left side #####
-        self.column1 = QVBoxLayout()
-        self.layout.addLayout(self.column1)
-
-        # SpinBox
-        self.spin_row = QHBoxLayout()
-        self.column1.addLayout(self.spin_row)
-        self.spin_row.addWidget(QLabel("Number of curves:"))
-        self.spin_row.addWidget(self.spin_box)
-
-        # label
-        self.clicked_label_1d = QLabel("Clicked Coordinates (1D):")
-        self.column1.addWidget(self.clicked_label_1d)
-
-        # table
-        self.column1.addWidget(self.table)
-
-        # 1D plot
-        self.column1.addWidget(self.plot_widget_1d)
-
-        ##### left side #####
-        self.column2 = QVBoxLayout()
-        self.layout.addLayout(self.column2)
-
-        # labels
-        self.clicked_label_2d = QLabel("Clicked Coordinates (2D):")
-        self.moved_label_2d = QLabel("Moved Coordinates (2D):")
-        self.column2.addWidget(self.clicked_label_2d)
-        self.column2.addWidget(self.moved_label_2d)
-
-        # 2D plot
-        self.column2.addWidget(self.plot_widget_2d)
-
-        self.update_curves(2)  # just Gaussian curves
-
-    def hook_crosshair(self):
-        self.crosshair_1d = Crosshair(self.plot_item_1d, precision=10)
-        self.crosshair_1d.coordinatesChanged1D.connect(
-            lambda x, y: self.update_table(self.table, x, y, column=0)
-        )
-        self.crosshair_1d.coordinatesClicked1D.connect(
-            lambda x, y: self.update_table(self.table, x, y, column=1)
-        )
-        # 2D
-        self.crosshair_2d = Crosshair(self.plot_item_2d)
-        self.crosshair_2d.coordinatesChanged2D.connect(
-            lambda x, y: self.moved_label_2d.setText(f"Mouse Moved Coordinates (2D): x={x}, y={y}")
-        )
-        self.crosshair_2d.coordinatesClicked2D.connect(
-            lambda x, y: self.clicked_label_2d.setText(f"Clicked Coordinates (2D): x={x}, y={y}")
-        )
-
-    def update_table(self, table_widget, x, y_values, column):
-        """Update the table with the new coordinates"""
-        for i, y in enumerate(y_values):
-            table_widget.setItem(i, column, QTableWidgetItem(f"({x}, {y})"))
-            table_widget.resizeColumnsToContents()
-
-    def update_curves(self, num_curves):
-        """Update the number of curves"""
-
-        self.plot_item_1d.clear()
-
-        # Curves
-        color_list = ["#384c6b", "#e28a2b", "#5E3023", "#e41a1c", "#984e83", "#4daf4a"]
-        self.plot_item_1d.addLegend()
-        self.curves = []
-
-        y_value_list = self.y_value_list[:num_curves]
-
-        for ii, y_value in enumerate(y_value_list):
-            pen = mkPen(color=color_list[ii], width=2, style=QtCore.Qt.DashLine)
-            curve = pg.PlotDataItem(
-                self.x_data, y_value, pen=pen, skipFiniteCheck=True, name=self.curve_names[ii]
-            )
-            self.plot_item_1d.addItem(curve)
-            self.curves.append(curve)
-
-        self.hook_crosshair()
-
-
-if __name__ == "__main__":
-    app = QApplication([])
-    window = ExampleApp()
-    window.show()
-    app.exec()

bec_widgets/examples/eiger_plot/eiger_plot.py

@@ -6,20 +6,11 @@ import h5py
 import numpy as np
 import pyqtgraph as pg
 import zmq
+from pyqtgraph.Qt import uic
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtGui import QKeySequence
-from qtpy.QtWidgets import (
-    QWidget,
-    QFileDialog,
-    QShortcut,
-    QDialog,
-    QVBoxLayout,
-    QLabel,
-    QFrame,
-)
-from pyqtgraph.Qt import uic
-
+from qtpy.QtWidgets import QDialog, QFileDialog, QFrame, QLabel, QShortcut, QVBoxLayout, QWidget
 
 # from scipy.stats import multivariate_normal
 
@@ -307,6 +298,7 @@ class EigerPlot(QWidget):
 
 if __name__ == "__main__":
     import sys
+
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -0,0 +1,102 @@
+import os
+
+import numpy as np
+import pyqtgraph as pg
+from pyqtgraph.Qt import uic
+from qtconsole.inprocess import QtInProcessKernelManager
+from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.widgets import BECFigure
+
+
+class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
+    def __init__(self):
+        super().__init__()
+
+        self.kernel_manager = QtInProcessKernelManager()
+        self.kernel_manager.start_kernel(show_banner=False)
+        self.kernel_client = self.kernel_manager.client()
+        self.kernel_client.start_channels()
+
+        self.kernel_manager.kernel.shell.push({"np": np, "pg": pg})
+        # self.set_console_font_size(70)
+
+    def shutdown_kernel(self):
+        self.kernel_client.stop_channels()
+        self.kernel_manager.shutdown_kernel()
+
+
+class JupyterConsoleWindow(QWidget):  # pragma: no cover:
+    """A widget that contains a Jupyter console linked to BEC Widgets with full API access (contains Qt and pyqtgraph API)."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        current_path = os.path.dirname(__file__)
+        uic.loadUi(os.path.join(current_path, "jupyter_console_window.ui"), self)
+
+        self._init_ui()
+
+        self.splitter.setSizes([200, 100])
+        self.safe_close = False
+        # self.figure.clean_signal.connect(self.confirm_close)
+
+        # console push
+        self.console.kernel_manager.kernel.shell.push(
+            {
+                "fig": self.figure,
+                "w1": self.w1,
+                "w2": self.w2,
+                "w3": self.w3,
+                "bec": self.figure.client,
+                "scans": self.figure.client.scans,
+                "dev": self.figure.client.device_manager.devices,
+            }
+        )
+
+    def _init_ui(self):
+        # Plotting window
+        self.glw_1_layout = QVBoxLayout(self.glw)  # Create a new QVBoxLayout
+        self.figure = BECFigure(parent=self, gui_id="remote")  # Create a new BECDeviceMonitor
+        self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout
+
+        # add stuff to figure
+        self._init_figure()
+
+        self.console_layout = QVBoxLayout(self.widget_console)
+        self.console = JupyterConsoleWidget()
+        self.console_layout.addWidget(self.console)
+        self.console.set_default_style("linux")
+
+    def _init_figure(self):
+        self.figure.plot("samx", "bpm4d")
+        self.figure.motor_map("samx", "samy")
+        self.figure.image("eiger", color_map="viridis", vrange=(0, 100))
+
+        self.figure.change_layout(2, 2)
+
+        self.w1 = self.figure[0, 0]
+        self.w2 = self.figure[0, 1]
+        self.w3 = self.figure[1, 0]
+
+        # curves for w1
+        self.w1.add_curve_scan("samx", "samy", "bpm4i", pen_style="dash")
+        self.w1.add_curve_scan("samx", "samy", "bpm3a", pen_style="dash")
+        self.c1 = self.w1.get_config()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+    client.start()
+
+    app = QApplication(sys.argv)
+    app.setApplicationName("Jupyter Console")
+    win = JupyterConsoleWindow()
+    win.show()
+
+    sys.exit(app.exec_())

bec_widgets/examples/jupyter_console/jupyter_console_window.ui

@@ -6,25 +6,20 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>901</width>
-    <height>1000</height>
+    <width>2104</width>
+    <height>966</height>
    </rect>
   </property>
   <property name="windowTitle">
-   <string>Form</string>
+   <string>Plotting Console</string>
   </property>
-  <layout class="QVBoxLayout" name="verticalLayout_3">
+  <layout class="QVBoxLayout" name="verticalLayout">
    <item>
-    <widget class="QSplitter" name="splitter_2">
+    <widget class="QSplitter" name="splitter">
      <property name="orientation">
-      <enum>Qt::Vertical</enum>
+      <enum>Qt::Horizontal</enum>
      </property>
-     <widget class="QSplitter" name="splitter">
-      <property name="orientation">
-       <enum>Qt::Horizontal</enum>
-      </property>
-      <widget class="QWidget" name="glw" native="true"/>
-     </widget>
+     <widget class="QWidget" name="glw" native="true"/>
      <widget class="QWidget" name="widget_console" native="true"/>
     </widget>
    </item>

bec_widgets/examples/mca_readout/mca_plot.py

@@ -1,19 +1,15 @@
 # import simulation_progress as SP
 import numpy as np
 import pyqtgraph as pg
-from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
-from qtpy.QtWidgets import (
-    QApplication,
-    QVBoxLayout,
-    QWidget,
-)
-
 from bec_lib import MessageEndpoints, messages
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
 
 class StreamApp(QWidget):
     update_signal = pyqtSignal()
-    new_scanID = pyqtSignal(str)
+    new_scan_id = pyqtSignal(str)
 
     def __init__(self, device, sub_device):
         super().__init__()
@@ -23,7 +19,7 @@ class StreamApp(QWidget):
         self.setWindowTitle("MCA readout")
 
         self.data = None
-        self.scanID = None
+        self.scan_id = None
         self.stream_consumer = None
 
         self.device = device
@@ -33,7 +29,7 @@ class StreamApp(QWidget):
 
         # self.start_device_consumer(self.device)  # for simulation
 
-        self.new_scanID.connect(self.create_new_stream_consumer)
+        self.new_scan_id.connect(self.create_new_stream_consumer)
         self.update_signal.connect(self.plot_new)
 
     def init_ui(self):
@@ -64,17 +60,17 @@ class StreamApp(QWidget):
         # self.glw.addItem(self.hist)
 
     @pyqtSlot(str)
-    def create_new_stream_consumer(self, scanID: str):
-        print(f"Creating new stream consumer for scanID: {scanID}")
+    def create_new_stream_consumer(self, scan_id: str):
+        print(f"Creating new stream consumer for scan_id: {scan_id}")
 
-        self.connect_stream_consumer(scanID, self.device)
+        self.connect_stream_consumer(scan_id, self.device)
 
-    def connect_stream_consumer(self, scanID, device):
+    def connect_stream_consumer(self, scan_id, device):
         if self.stream_consumer is not None:
             self.stream_consumer.shutdown()
 
         self.stream_consumer = connector.stream_consumer(
-            topics=MessageEndpoints.device_async_readback(scanID=scanID, device=device),
+            topics=MessageEndpoints.device_async_readback(scan_id=scan_id, device=device),
             cb=self._streamer_cb,
             parent=self,
         )
@@ -125,24 +121,25 @@ class StreamApp(QWidget):
 
         msgDEV = msg.value
 
-        current_scanID = msgDEV.content["scanID"]
+        current_scan_id = msgDEV.content["scan_id"]
 
-        if parent.scanID is None:
-            parent.scanID = current_scanID
-            parent.new_scanID.emit(current_scanID)
-            print(f"New scanID: {current_scanID}")
+        if parent.scan_id is None:
+            parent.scan_id = current_scan_id
+            parent.new_scan_id.emit(current_scan_id)
+            print(f"New scan_id: {current_scan_id}")
 
-        if current_scanID != parent.scanID:
-            parent.scanID = current_scanID
+        if current_scan_id != parent.scan_id:
+            parent.scan_id = current_scan_id
             # parent.data = None
             # parent.imageItem.clear()
-            parent.new_scanID.emit(current_scanID)
+            parent.new_scan_id.emit(current_scan_id)
 
-            print(f"New scanID: {current_scanID}")
+            print(f"New scan_id: {current_scan_id}")
 
 
 if __name__ == "__main__":
     import argparse
+
     from bec_lib import RedisConnector
 
     parser = argparse.ArgumentParser(description="Stream App.")

bec_widgets/examples/mca_readout/mca_sim.py

@@ -1,31 +1,23 @@
-from bec_lib import messages, MessageEndpoints, RedisConnector
 import time
 
+from bec_lib import MessageEndpoints, RedisConnector, messages
+
 connector = RedisConnector("localhost:6379")
-producer = connector.producer()
 metadata = {}
 
-scanID = "ScanID1"
+scan_id = "ScanID1"
 
 metadata.update(
-    {
-        "scanID": scanID,  # this will be different for each scan
-        "async_update": "append",
-    }
+    {"scan_id": scan_id, "async_update": "append"}  # this will be different for each scan
 )
 for ii in range(20):
     data = {"mca1": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "mca2": [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]}
-    msg = messages.DeviceMessage(
-        signals=data,
-        metadata=metadata,
-    ).dumps()
+    msg = messages.DeviceMessage(signals=data, metadata=metadata).dumps()
 
-    # producer.send(topic=MessageEndpoints.device_status(device="mca"), msg=msg)
-
-    producer.xadd(
+    connector.xadd(
         topic=MessageEndpoints.device_async_readback(
-            scanID=scanID, device="mca"
-        ),  # scanID will be different for each scan
+            scan_id=scan_id, device="mca"
+        ),  # scan_id will be different for each scan
         msg={"data": msg},  # TODO should be msg_dict
         expire=1800,
     )

bec_widgets/examples/modular_app/modular_app.py

@@ -1,7 +1,7 @@
 import os
 
 from qtpy import uic
-from qtpy.QtWidgets import QMainWindow, QApplication
+from qtpy.QtWidgets import QApplication, QMainWindow
 
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.widgets import BECMonitor

bec_widgets/examples/motor_movement/__init__.py

@@ -2,8 +2,8 @@ from .motor_control_compilations import (
     MotorControlApp,
     MotorControlMap,
     MotorControlPanel,
-    MotorControlPanelRelative,
     MotorControlPanelAbsolute,
+    MotorControlPanelRelative,
     MotorCoordinateTable,
     MotorThread,
 )

bec_widgets/examples/motor_movement/motor_control_compilations.py

@@ -1,22 +1,17 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 
 import qdarktheme
-from qtpy.QtWidgets import QApplication
-from qtpy.QtWidgets import QVBoxLayout
-from qtpy.QtWidgets import (
-    QWidget,
-    QSplitter,
-)
 from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QApplication, QSplitter, QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.widgets import (
     MotorControlAbsolute,
     MotorControlRelative,
     MotorControlSelection,
-    MotorThread,
-    MotorMap,
     MotorCoordinateTable,
+    MotorMap,
+    MotorThread,
 )
 
 CONFIG_DEFAULT = {
@@ -242,19 +237,19 @@ if __name__ == "__main__":  # pragma: no cover
     qdarktheme.setup_theme("auto")
 
     if args.variant == "app":
-        window = MotorControlApp(client=client, config=CONFIG_DEFAULT)
+        window = MotorControlApp(client=client)  # , config=CONFIG_DEFAULT)
     elif args.variant == "map":
-        window = MotorControlMap(client=client, config=CONFIG_DEFAULT)
+        window = MotorControlMap(client=client)  # , config=CONFIG_DEFAULT)
     elif args.variant == "panel":
-        window = MotorControlPanel(client=client, config=CONFIG_DEFAULT)
+        window = MotorControlPanel(client=client)  # , config=CONFIG_DEFAULT)
     elif args.variant == "panel_abs":
-        window = MotorControlPanelAbsolute(client=client, config=CONFIG_DEFAULT)
+        window = MotorControlPanelAbsolute(client=client)  # , config=CONFIG_DEFAULT)
     elif args.variant == "panel_rel":
-        window = MotorControlPanelRelative(client=client, config=CONFIG_DEFAULT)
+        window = MotorControlPanelRelative(client=client)  # , config=CONFIG_DEFAULT)
     else:
         print("Please specify a valid variant to run. Use -h for help.")
         print("Running the full application by default.")
-        window = MotorControlApp(client=client, config=CONFIG_DEFAULT)
+        window = MotorControlApp(client=client)  # , config=CONFIG_DEFAULT)
 
     window.show()
     sys.exit(app.exec())

bec_widgets/examples/motor_movement/motor_controller.ui

@@ -883,7 +883,7 @@
          </column>
          <column>
           <property name="text">
-           <string>scanID</string>
+           <string>scan_id</string>
           </property>
          </column>
          <column>

bec_widgets/examples/motor_movement/motor_example.py

@@ -5,29 +5,28 @@ from functools import partial
 
 import numpy as np
 import pyqtgraph as pg
+from bec_lib import MessageEndpoints, messages
+from pyqtgraph.Qt import QtCore, QtWidgets, uic
 from qtpy import QtGui
-from qtpy.QtCore import QThread, Slot as pyqtSlot
-from qtpy.QtCore import Signal as pyqtSignal, Qt
-from qtpy.QtGui import QDoubleValidator
-from qtpy.QtGui import QKeySequence
+from qtpy.QtCore import Qt, QThread
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtGui import QDoubleValidator, QKeySequence
 from qtpy.QtWidgets import (
     QApplication,
-    QWidget,
-    QFileDialog,
     QDialog,
-    QVBoxLayout,
-    QLabel,
-    QPushButton,
+    QFileDialog,
     QFrame,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QShortcut,
+    QVBoxLayout,
+    QWidget,
 )
-from qtpy.QtWidgets import QMessageBox
-from qtpy.QtWidgets import QShortcut
-from pyqtgraph.Qt import QtWidgets, uic, QtCore
 
-from bec_lib import MessageEndpoints, messages
 from bec_widgets.utils import DoubleValidationDelegate
 
-
 # TODO - General features
 #  - put motor status (moving, stopped, etc)
 #  - add mouse interactions with the plot -> click to select coordinates, double click to move?
@@ -1306,9 +1305,9 @@ class MotorControl(QThread):
 
 
 if __name__ == "__main__":
-    import yaml
     import argparse
 
+    import yaml
     from bec_lib import BECClient, ServiceConfig
 
     parser = argparse.ArgumentParser(description="Motor App")

bec_widgets/examples/oneplot/config_gaussworker.yaml

@@ -1,3 +0,0 @@
-x_value: "samx"
-y_values: ["gauss_bpm", "gauss_adc1", "gauss_adc2"]
-dap_worker: "gaussian_fit_worker_3"

bec_widgets/examples/oneplot/config_noworker.yaml

@@ -1,3 +0,0 @@
-x_value: "samx"
-y_values: ["gauss_bpm", "gauss_adc1", "gauss_adc2"]
-dap_worker: None

bec_widgets/examples/oneplot/oneplot.py

@@ -1,271 +0,0 @@
-import os
-
-import numpy as np
-import qtpy.QtWidgets
-import pyqtgraph as pg
-from bec_lib import MessageEndpoints
-from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
-from qtpy.QtWidgets import QApplication, QTableWidgetItem, QWidget
-from pyqtgraph import mkBrush, mkColor, mkPen
-from pyqtgraph.Qt import QtCore, uic
-
-from bec_widgets.utils import Crosshair, ctrl_c
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-
-# TODO implement:
-#   - implement scanID database for visualizing previous scans
-#   - multiple signals for different monitors
-#   - change how dap is handled in bec_dispatcher to handle more workers
-
-
-class PlotApp(QWidget):
-    """
-    Main class for the PlotApp used to plot two signals from the BEC.
-
-    Attributes:
-        update_signal (pyqtSignal): Signal to trigger plot updates.
-        update_dap_signal (pyqtSignal): Signal to trigger DAP updates.
-
-    Args:
-        x_value (str): The x device/signal for plotting.
-        y_values (list of str): List of y device/signals for plotting.
-        dap_worker (str, optional): DAP process to specify. Set to None to disable.
-        parent (QWidget, optional): Parent widget.
-    """
-
-    update_signal = pyqtSignal()
-    update_dap_signal = pyqtSignal()
-
-    def __init__(self, x_value, y_values, dap_worker=None, parent=None):
-        super(PlotApp, self).__init__(parent)
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "oneplot.ui"), self)
-
-        self.x_value = x_value
-        self.y_values = y_values
-        self.dap_worker = dap_worker
-
-        self.scanID = None
-        self.data_x = []
-        self.data_y = []
-
-        self.dap_x = np.array([])
-        self.dap_y = np.array([])
-
-        self.fit = None
-
-        self.init_ui()
-        self.init_curves()
-        self.hook_crosshair()
-
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=25, slot=self.update_plot
-        )
-        self.proxy_update_fit = pg.SignalProxy(
-            self.update_dap_signal, rateLimit=25, slot=self.update_fit_table
-        )
-
-    def init_ui(self) -> None:
-        """Initialize the UI components."""
-        self.plot = pg.PlotItem()
-        self.glw.addItem(self.plot)
-        self.plot.setLabel("bottom", self.x_value)
-        self.plot.setLabel("left", ", ".join(self.y_values))
-        self.plot.addLegend()
-
-    def init_curves(self) -> None:
-        """Initialize curve data and properties."""
-        self.plot.clear()
-
-        self.curves_data = []
-        self.curves_dap = []
-
-        colors_y_values = PlotApp.golden_angle_color(colormap="CET-R2", num=len(self.y_values))
-        # colors_y_daps = PlotApp.golden_angle_color(
-        #     colormap="CET-I2", num=len(self.dap_worker)
-        # )  # TODO adapt for multiple dap_workers
-
-        # Initialize curves for y_values
-        for ii, (signal, color) in enumerate(zip(self.y_values, colors_y_values)):
-            pen_curve = mkPen(color=color, width=2, style=QtCore.Qt.DashLine)
-            brush_curve = mkBrush(color=color)
-            curve_data = pg.PlotDataItem(
-                symbolSize=5,
-                symbolBrush=brush_curve,
-                pen=pen_curve,
-                skipFiniteCheck=True,
-                name=f"{signal}",
-            )
-            self.curves_data.append(curve_data)
-            self.plot.addItem(curve_data)
-
-        # Initialize curves for DAP if dap_worker is not None
-        if self.dap_worker is not None:
-            # for ii, (monitor, color) in enumerate(zip(self.dap_worker, colors_y_daps)):#TODO adapt for multiple dap_workers
-            pen_dap = mkPen(color="#3b5998", width=2, style=QtCore.Qt.DashLine)
-            curve_dap = pg.PlotDataItem(
-                pen=pen_dap, skipFiniteCheck=True, symbolSize=5, name=f"{self.dap_worker}"
-            )
-            self.curves_dap.append(curve_dap)
-            self.plot.addItem(curve_dap)
-
-        self.tableWidget_crosshair.setRowCount(len(self.y_values))
-        self.tableWidget_crosshair.setVerticalHeaderLabels(self.y_values)
-        self.hook_crosshair()
-
-    def hook_crosshair(self) -> None:
-        """Attach the crosshair to the plot."""
-        self.crosshair_1d = Crosshair(self.plot, precision=3)
-        self.crosshair_1d.coordinatesChanged1D.connect(
-            lambda x, y: self.update_table(self.tableWidget_crosshair, x, y, column=0)
-        )
-        self.crosshair_1d.coordinatesClicked1D.connect(
-            lambda x, y: self.update_table(self.tableWidget_crosshair, x, y, column=1)
-        )
-
-    def update_table(
-        self, table_widget: qtpy.QtWidgets.QTableWidget, x: float, y_values: list, column: int
-    ) -> None:
-        for i, y in enumerate(y_values):
-            table_widget.setItem(i, column, QTableWidgetItem(f"({x}, {y})"))
-            table_widget.resizeColumnsToContents()
-
-    def update_plot(self) -> None:
-        """Update the plot data."""
-        for ii, curve in enumerate(self.curves_data):
-            curve.setData(self.data_x, self.data_y[ii])
-
-        if self.dap_worker is not None:
-            # for ii, curve in enumerate(self.curves_dap): #TODO adapt for multiple dap_workers
-            #     curve.setData(self.dap_x, self.dap_y[ii])
-            self.curves_dap[0].setData(self.dap_x, self.dap_y)
-
-    def update_fit_table(self):
-        """Update the table for fit data."""
-
-        self.tableWidget_fit.setData(self.fit)
-
-    @pyqtSlot(dict, dict)
-    def on_dap_update(self, msg: dict, metadata: dict) -> None:
-        """
-        Update DAP  related data.
-
-        Args:
-            msg (dict): Message received with data.
-            metadata (dict): Metadata of the DAP.
-        """
-
-        # TODO adapt for multiple dap_workers
-        self.dap_x = msg[self.dap_worker]["x"]
-        self.dap_y = msg[self.dap_worker]["y"]
-
-        self.fit = metadata["fit_parameters"]
-
-        self.update_dap_signal.emit()
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, msg: dict, metadata: dict):
-        """
-        Handle new scan segments.
-
-        Args:
-            msg (dict): Message received with scan data.
-            metadata (dict): Metadata of the scan.
-        """
-        current_scanID = msg["scanID"]
-
-        if current_scanID != self.scanID:
-            self.scanID = current_scanID
-            self.data_x = []
-            self.data_y = [[] for _ in self.y_values]
-            self.init_curves()
-
-        dev_x = self.x_value
-        data_x = msg["data"][dev_x][dev[dev_x]._hints[0]]["value"]
-        self.data_x.append(data_x)
-
-        for ii, dev_y in enumerate(self.y_values):
-            data_y = msg["data"][dev_y][dev[dev_y]._hints[0]]["value"]
-            self.data_y[ii].append(data_y)
-
-        self.update_signal.emit()
-
-    @staticmethod
-    def golden_ratio(num: int) -> list:
-        """Calculate the golden ratio for a given number of angles.
-
-        Args:
-            num (int): Number of angles
-        """
-        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
-        angles = []
-        for ii in range(num):
-            x = np.cos(ii * phi)
-            y = np.sin(ii * phi)
-            angle = np.arctan2(y, x)
-            angles.append(angle)
-        return angles
-
-    @staticmethod
-    def golden_angle_color(colormap: str, num: int) -> list:
-        """
-        Extract num colors for from the specified colormap following golden angle distribution.
-
-        Args:
-            colormap (str): Name of the colormap
-            num (int): Number of requested colors
-
-        Returns:
-            list: List of colors with length <num>
-
-        Raises:
-            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
-        """
-
-        cmap = pg.colormap.get(colormap)
-        cmap_colors = cmap.color
-        if num > len(cmap_colors):
-            raise ValueError(
-                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
-            )
-        angles = PlotApp.golden_ratio(len(cmap_colors))
-        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
-        colors = [
-            mkColor(tuple((cmap_colors[int(ii)] * 255).astype(int))) for ii in color_selection[:num]
-        ]
-        return colors
-
-
-if __name__ == "__main__":
-    import yaml
-
-    with open("config_noworker.yaml", "r") as file:
-        config = yaml.safe_load(file)
-
-    x_value = config["x_value"]
-    y_values = config["y_values"]
-    dap_worker = config["dap_worker"]
-
-    dap_worker = None if dap_worker == "None" else dap_worker
-
-    # BECclient global variables
-    bec_dispatcher = BECDispatcher()
-    client = bec_dispatcher.client
-    client.start()
-
-    dev = client.device_manager.devices
-    scans = client.scans
-    queue = client.queue
-
-    app = QApplication([])
-    plotApp = PlotApp(x_value=x_value, y_values=y_values, dap_worker=dap_worker)
-
-    # Connecting signals from bec_dispatcher
-    bec_dispatcher.connect_slot(plotApp.on_dap_update, MessageEndpoints.processed_data(dap_worker))
-    bec_dispatcher.connect_slot(plotApp.on_scan_segment, MessageEndpoints.scan_segment())
-    ctrl_c.setup(app)
-
-    window = plotApp
-    window.show()
-    app.exec()

bec_widgets/examples/oneplot/oneplot.ui

@@ -1,75 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>Form</class>
- <widget class="QWidget" name="Form">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>547</width>
-    <height>653</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout" stretch="1,2">
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout" stretch="2,1">
-     <item>
-      <widget class="QGroupBox" name="groupBox">
-       <property name="title">
-        <string>Cursor</string>
-       </property>
-       <layout class="QGridLayout" name="gridLayout">
-        <item row="0" column="0">
-         <widget class="QTableWidget" name="tableWidget_crosshair">
-          <column>
-           <property name="text">
-            <string>Moved</string>
-           </property>
-          </column>
-          <column>
-           <property name="text">
-            <string>Clicked</string>
-           </property>
-          </column>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="groupBox_2">
-       <property name="title">
-        <string>Fit</string>
-       </property>
-       <layout class="QGridLayout" name="gridLayout_2">
-        <item row="0" column="0">
-         <widget class="TableWidget" name="tableWidget_fit"/>
-        </item>
-       </layout>
-      </widget>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <widget class="GraphicsLayoutWidget" name="glw"/>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>GraphicsLayoutWidget</class>
-   <extends>QGraphicsView</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
-  <customwidget>
-   <class>TableWidget</class>
-   <extends>QTableWidget</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>

bec_widgets/examples/plot_app/config_example.yaml

@@ -1,130 +0,0 @@
-plot_settings:
-  background_color: "black"
-  num_columns: 2
-  colormap: "plasma"
-  scan_types: False # True to show scan types
-
-# example to use without scan_type -> only one general configuration
-plot_data:
-  - plot_name: "BPM4i plots vs samy"
-    x:
-      label: 'Motor Y'
-      signals:
-        - name: "samy"
-#          entry: "samy" # here I also forgot to specify entry
-    y:
-      label: 'bpm4i'
-      signals:
-        - name: "bpm4i"
-          entry: "bpm4i"
-          # I will not specify entry, because I want to take hint from gauss_adc2
-  - plot_name: "BPM4i plots vs samx"
-    x:
-      label: 'Motor Y'
-      signals:
-        - name: "samy"
-#          entry: "samy" # here I also forgot to specify entry
-    y:
-      label: 'bpm4i'
-      signals:
-        - name: "bpm4i"
-          entry: "bpm4i"
-          # I will not specify entry, because I want to take hint from gauss_adc2
-  - plot_name: "MCS Channel 4 (Cyberstar) vs samx"
-    x:
-      label: 'Motor X'
-      signals:
-        - name: "samx"
-          entry: "samx"
-    y:
-      label: 'mcs4 cyberstar'
-      signals:
-        - name: "mcs"
-          entry: "mca4"
-  - plot_name: "MCS Channel 4 (Cyberstar) vs samy"
-    x:
-      label: 'Motor X'
-      signals:
-        - name: "samy"
-          entry: "samy"
-    y:
-      label: 'mcs4 cyberstar'
-      signals:
-        - name: "mcs"
-          entry: "mca4"
-
-
-
-# example to use with scan_type -> different configuration for different scan types
-#plot_data:
-#  line_scan:
-#    - plot_name: "BPM plot"
-#      x:
-#        label: 'Motor X'
-#        signals:
-#          - name: "samx"
-#  #          entry: "samx"
-#      y:
-#        label: 'BPM'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-#          - name: "gauss_adc1"
-#            entry: "gauss_adc1"
-#          - name: "gauss_adc2"
-#            entry: "gauss_adc2"
-#
-#    - plot_name: "Multi"
-#      x:
-#        label: 'Motor X'
-#        signals:
-#          - name: "samx"
-#            entry: "samx"
-#      y:
-#        label: 'Multi'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-#          - name: "samx"
-#            entry: ["samx", "samx_setpoint"]
-#
-#  grid_scan:
-#    - plot_name: "Grid plot 1"
-#      x:
-#        label: 'Motor X'
-#        signals:
-#          - name: "samx"
-#            entry: "samx"
-#      y:
-#        label: 'BPM'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-#          - name: "gauss_adc1"
-#            entry: "gauss_adc1"
-#    - plot_name: "Grid plot 2"
-#      x:
-#        label: 'Motor X'
-#        signals:
-#          - name: "samx"
-#            entry: "samx"
-#      y:
-#        label: 'BPM'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-#          - name: "gauss_adc1"
-#            entry: "gauss_adc1"
-#
-#    - plot_name: "Grid plot 3"
-#      x:
-#        label: 'Motor Y'
-#        signals:
-#          - name: "samy"
-#            entry: "samy"
-#      y:
-#        label: 'BPM'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-

bec_widgets/examples/plot_app/config_scans_example.yaml

@@ -1,91 +0,0 @@
-plot_settings:
-  background_color: "black"
-  num_columns: 2
-  colormap: "plasma"
-  scan_types: True # True to show scan types
-
-# example to use with scan_type -> different configuration for different scan types
-plot_data:
-  line_scan:
-    - plot_name: "BPM plot"
-      x:
-        label: 'Motor X'
-        signals:
-          - name: "samx"
-  #          entry: "samx"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-          - name: "gauss_adc1"
-            entry: "gauss_adc1"
-          - name: "gauss_adc2"
-            entry: "gauss_adc2"
-
-    - plot_name: "Multi"
-      x:
-        label: 'Motor X'
-        signals:
-          - name: "samx"
-            entry: "samx"
-      y:
-        label: 'Multi'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-          - name: "samx"
-            entry: ["samx", "samx_setpoint"]
-
-  grid_scan:
-    - plot_name: "Grid plot 1"
-      x:
-        label: 'Motor X'
-        signals:
-          - name: "samx"
-            entry: "samx"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-          - name: "gauss_adc1"
-            entry: "gauss_adc1"
-    - plot_name: "Grid plot 2"
-      x:
-        label: 'Motor X'
-        signals:
-          - name: "samx"
-            entry: "samx"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-          - name: "gauss_adc1"
-            entry: "gauss_adc1"
-
-    - plot_name: "Grid plot 3"
-      x:
-        label: 'Motor Y'
-        signals:
-          - name: "samy"
-            entry: "samy"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-
-    - plot_name: "Grid plot 4"
-      x:
-        label: 'Motor Y'
-        signals:
-          - name: "samy"
-            entry: "samy"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_adc3"
-            entry: "gauss_adc3"
-

bec_widgets/examples/plot_app/plot_app.py

@@ -1,730 +0,0 @@
-import logging
-import os
-
-# import traceback
-
-import pyqtgraph
-import pyqtgraph as pg
-
-from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
-
-from qtpy.QtWidgets import (
-    QApplication,
-    QWidget,
-    QTableWidgetItem,
-    QTableWidget,
-    QFileDialog,
-    QMessageBox,
-)
-from pyqtgraph import ColorButton
-from pyqtgraph import mkBrush, mkPen
-from pyqtgraph.Qt import QtCore, uic
-from pyqtgraph.Qt import QtWidgets
-
-from bec_lib import MessageEndpoints
-from bec_widgets.utils import Crosshair, Colors
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-
-# TODO implement:
-#   - implement scanID database for visualizing previous scans
-
-
-class PlotApp(QWidget):
-    """
-    Main class for PlotApp, designed to plot multiple signals in a grid layout
-    based on a flexible YAML configuration.
-
-    Attributes:
-        update_signal (pyqtSignal): Signal to trigger plot updates.
-        plot_data (list of dict): List of dictionaries containing plot configurations.
-                                  Each dictionary specifies x and y signals, including their
-                                  name and entry, for a particular plot.
-
-    Args:
-        config (dict): Configuration dictionary containing all settings for the plotting app.
-                      It should include the following keys:
-                      - 'plot_settings': Dictionary containing global plot settings.
-                      - 'plot_data': List of dictionaries specifying the signals to plot.
-        parent (QWidget, optional): Parent widget.
-
-    Example:
-        General Plot Configuration:
-        {
-            'plot_settings': {'background_color': 'black', 'num_columns': 2, 'colormap': 'plasma', 'scan_types': False},
-            'plot_data': [
-                {
-                    'plot_name': 'Plot A',
-                    'x': {'label': 'X-axis', 'signals': [{'name': 'device_x', 'entry': 'entry_x'}]},
-                    'y': {'label': 'Y-axis', 'signals': [{'name': 'device_y', 'entry': 'entry_y'}]}
-                }
-            ]
-        }
-
-        Different Scans Mode Configuration:
-        {
-            'plot_settings': {'background_color': 'black', 'num_columns': 2, 'colormap': 'plasma', 'scan_types': True},
-            'plot_data': {
-                'scan_type_1': [
-                    {
-                        'plot_name': 'Plot 1',
-                        'x': {'label': 'X-axis', 'signals': [{'name': 'device_x1', 'entry': 'entry_x1'}]},
-                        'y': {'label': 'Y-axis', 'signals': [{'name': 'device_y1', 'entry': 'entry_y1'}]}
-                    }
-                ],
-                'scan_type_2': [
-                    {
-                        'plot_name': 'Plot 2',
-                        'x': {'label': 'X-axis', 'signals': [{'name': 'device_x2', 'entry': 'entry_x2'}]},
-                        'y': {'label': 'Y-axis', 'signals': [{'name': 'device_y2', 'entry': 'entry_y2'}]}
-                    }
-                ]
-            }
-        }
-    """
-
-    update_signal = pyqtSignal()
-    update_dap_signal = pyqtSignal()
-
-    def __init__(self, config: dict, client=None, parent=None):
-        super(PlotApp, self).__init__(parent)
-
-        # Error handler
-        self.error_handler = ErrorHandler(parent=self)
-
-        # Client and device manager from BEC
-        self.client = BECDispatcher().client if client is None else client
-        self.dev = self.client.device_manager.devices
-
-        # Loading UI
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "plot_app.ui"), self)
-
-        self.data = {}
-
-        self.crosshairs = None
-        self.plots = None
-        self.curves_data = None
-        self.grid_coordinates = None
-        self.scanID = None
-
-        self.user_colors = {}  # key: (plot_name, y_name, y_entry), value: color
-
-        # Default config
-        self.config = config
-
-        # Validate the configuration before proceeding
-        self.load_config(self.config)
-
-        # Default splitter size
-        self.splitter.setSizes([400, 100])
-
-        # Buttons
-        self.pushButton_save.clicked.connect(self.save_settings_to_yaml)
-        self.pushButton_load.clicked.connect(self.load_settings_from_yaml)
-
-        # Connect the update signal to the update plot method
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=25, slot=self.update_plot
-        )
-
-        # Change layout of plots when the number of columns is changed in GUI
-        self.spinBox_N_columns.valueChanged.connect(lambda x: self.init_ui(x))
-
-    def load_config(self, config: dict) -> None:
-        """
-        Load and validate the configuration, retrying until a valid configuration is provided or the user cancels.
-        Args:
-            config (dict): Configuration dictionary form .yaml file.
-
-        Returns:
-            None
-        """
-        valid_config = False
-        self.error_handler.set_retry_action(self.load_settings_from_yaml)
-        while not valid_config:
-            if config is None:
-                self.config = (
-                    self.load_settings_from_yaml()
-                )  # Load config if it hasn't been loaded yet
-            try:  # Validate loaded config file
-                self.error_handler.validate_config_file(config)
-                valid_config = True
-            except ValueError as e:
-                self.config = None  # Reset config_to_test to force reloading configuration
-                self.config = self.error_handler.handle_error(str(e))
-        if valid_config is True:  # Initialize config if validation succeeds
-            self.init_config(self.config)
-
-    def init_config(self, config: dict) -> None:
-        """
-        Initializes or update the configuration settings for the PlotApp.
-
-        Args:
-            config (dict): Dictionary containing plot settings and data configurations.
-        """
-
-        # YAML config
-        self.plot_settings = config.get("plot_settings", {})
-        self.plot_data_config = config.get("plot_data", {})
-        self.scan_types = self.plot_settings.get("scan_types", False)
-
-        if self.scan_types is False:  # Device tracking mode
-            self.plot_data = self.plot_data_config  # TODO logic has to be improved
-        else:  # setup first line scan as default, then changed with different scan type
-            self.plot_data = self.plot_data_config[list(self.plot_data_config.keys())[0]]
-
-        # Setting global plot settings
-        self.init_plot_background(self.plot_settings["background_color"])
-
-        # Initialize the UI
-        self.init_ui(self.plot_settings["num_columns"])
-        self.spinBox_N_columns.setValue(
-            self.plot_settings["num_columns"]
-        )  # TODO has to be checked if it will not setup more columns than plots
-        self.spinBox_N_columns.setMaximum(len(self.plot_data))
-
-    def init_plot_background(self, background_color: str) -> None:
-        """
-        Initialize plot settings based on the background color.
-
-        Args:
-            background_color (str): The background color ('white' or 'black').
-
-        This method sets the background and foreground colors for pyqtgraph.
-        If the background is dark ('black'), the foreground will be set to 'white',
-        and vice versa.
-        """
-        if background_color.lower() == "black":
-            pg.setConfigOption("background", "k")
-            pg.setConfigOption("foreground", "w")
-        elif background_color.lower() == "white":
-            pg.setConfigOption("background", "w")
-            pg.setConfigOption("foreground", "k")
-        else:
-            raise ValueError(
-                f"Invalid background color {background_color}. Allowed values are 'white' or 'black'."
-            )
-
-        # TODO simplify -> find way how to setup also foreground color
-        # if background_color.lower() not in ["black", "white"]:
-        #     raise ValueError(
-        #         f"Invalid background color {background_color}. Allowed values are 'white' or 'black'."
-        #     )
-        # self.glw.setBackground(background_color.lower())
-
-    def init_ui(self, num_columns: int = 3) -> None:
-        """
-        Initialize the UI components, create plots and store their grid positions.
-
-        Args:
-            num_columns (int): Number of columns to wrap the layout.
-
-        This method initializes a dictionary `self.plots` to store the plot objects
-        along with their corresponding x and y signal names. It dynamically arranges
-        the plots in a grid layout based on the given number of columns and dynamically
-        stretches the last plots to fit the remaining space.
-        """
-        self.glw.clear()
-        self.plots = {}
-        self.grid_coordinates = []
-
-        num_plots = len(self.plot_data)
-
-        # Check if num_columns exceeds the number of plots
-        if num_columns >= num_plots:
-            num_columns = num_plots
-            self.plot_settings["num_columns"] = num_columns  # Update the settings
-            print(
-                f"Warning: num_columns in the YAML file was greater than the number of plots. Resetting num_columns to number of plots:{num_columns}."
-            )
-        else:
-            self.plot_settings["num_columns"] = num_columns  # Update the settings
-
-        num_rows = num_plots // num_columns
-        last_row_cols = num_plots % num_columns
-        remaining_space = num_columns - last_row_cols
-
-        for i, plot_config in enumerate(self.plot_data):
-            row, col = i // num_columns, i % num_columns
-            colspan = 1
-
-            if row == num_rows and remaining_space > 0:
-                if last_row_cols == 1:
-                    colspan = num_columns
-                else:
-                    colspan = remaining_space // last_row_cols + 1
-                    remaining_space -= colspan - 1
-                    last_row_cols -= 1
-
-            plot_name = plot_config.get("plot_name", "")
-            x_label = plot_config["x"].get("label", "")
-            y_label = plot_config["y"].get("label", "")
-
-            plot = self.glw.addPlot(row=row, col=col, colspan=colspan, title=plot_name)
-            plot.setLabel("bottom", x_label)
-            plot.setLabel("left", y_label)
-            plot.addLegend()
-
-            self.plots[plot_name] = plot
-            self.grid_coordinates.append((row, col))
-
-        self.init_curves()
-
-    def init_curves(self) -> None:
-        """
-        Initialize curve data and properties, and update table row labels.
-
-        This method initializes a nested dictionary `self.curves_data` to store
-        the curve objects for each x and y signal pair. It also updates the row labels
-        in `self.tableWidget_crosshair` to include the grid position for each y-value.
-        """
-        self.curves_data = {}
-        row_labels = []
-
-        for idx, plot_config in enumerate(self.plot_data):
-            plot_name = plot_config.get("plot_name", "")
-            plot = self.plots[plot_name]
-            plot.clear()
-
-            y_configs = plot_config["y"]["signals"]
-            colors_ys = Colors.golden_angle_color(
-                colormap=self.plot_settings["colormap"], num=len(y_configs)
-            )
-
-            curve_list = []
-            for i, (y_config, color) in enumerate(zip(y_configs, colors_ys)):
-                # print(y_config)
-                y_name = y_config["name"]
-                y_entries = y_config.get("entry", [y_name])
-
-                if not isinstance(y_entries, list):
-                    y_entries = [y_entries]
-
-                for y_entry in y_entries:
-                    user_color = self.user_colors.get((plot_name, y_name, y_entry), None)
-                    color_to_use = user_color if user_color else color
-
-                    pen_curve = mkPen(color=color_to_use, width=2, style=QtCore.Qt.DashLine)
-                    brush_curve = mkBrush(color=color_to_use)
-
-                    curve_data = pg.PlotDataItem(
-                        symbolSize=5,
-                        symbolBrush=brush_curve,
-                        pen=pen_curve,
-                        skipFiniteCheck=True,
-                        name=f"{y_name} ({y_entry})",
-                    )
-
-                    curve_list.append((y_name, y_entry, curve_data))
-                    plot.addItem(curve_data)
-                    row_labels.append(f"{y_name} ({y_entry}) - {plot_name}")
-
-                    # Create a ColorButton and set its color
-                    color_btn = ColorButton()
-                    color_btn.setColor(color_to_use)
-                    color_btn.sigColorChanged.connect(
-                        lambda btn=color_btn, plot=plot_name, yname=y_name, yentry=y_entry, curve=curve_data: self.change_curve_color(
-                            btn, plot, yname, yentry, curve
-                        )
-                    )
-
-                    # Add the ColorButton as a QWidget to the table
-                    color_widget = QtWidgets.QWidget()
-                    layout = QtWidgets.QHBoxLayout()
-                    layout.addWidget(color_btn)
-                    layout.setContentsMargins(0, 0, 0, 0)
-                    color_widget.setLayout(layout)
-
-                    row = len(row_labels) - 1  # The row index in the table
-                    self.tableWidget_crosshair.setCellWidget(row, 2, color_widget)
-
-            self.curves_data[plot_name] = curve_list
-
-        self.tableWidget_crosshair.setRowCount(len(row_labels))
-        self.tableWidget_crosshair.setVerticalHeaderLabels(row_labels)
-        self.hook_crosshair()
-
-    def change_curve_color(
-        self,
-        btn: pyqtgraph.ColorButton,
-        plot_name: str,
-        y_name: str,
-        y_entry: str,
-        curve: pyqtgraph.PlotDataItem,
-    ) -> None:
-        """
-        Change the color of a curve and update the corresponding ColorButton.
-
-        Args:
-            btn (ColorButton): The ColorButton that was clicked.
-            plot_name (str): The name of the plot where the curve belongs.
-            y_name (str): The name of the y signal.
-            y_entry (str): The entry of the y signal.
-            curve (PlotDataItem): The curve to be changed.
-        """
-        color = btn.color()
-        pen_curve = mkPen(color=color, width=2, style=QtCore.Qt.DashLine)
-        brush_curve = mkBrush(color=color)
-        curve.setPen(pen_curve)
-        curve.setSymbolBrush(brush_curve)
-        self.user_colors[(plot_name, y_name, y_entry)] = color
-
-    def hook_crosshair(self) -> None:
-        """Attach crosshairs to each plot and connect them to the update_table method."""
-        self.crosshairs = {}
-        for plot_name, plot in self.plots.items():
-            crosshair = Crosshair(plot, precision=3)
-            crosshair.coordinatesChanged1D.connect(
-                lambda x, y, plot=plot: self.update_table(
-                    self.tableWidget_crosshair, x, y, column=0, plot=plot
-                )
-            )
-            crosshair.coordinatesClicked1D.connect(
-                lambda x, y, plot=plot: self.update_table(
-                    self.tableWidget_crosshair, x, y, column=1, plot=plot
-                )
-            )
-            self.crosshairs[plot_name] = crosshair
-
-    def update_table(
-        self, table_widget: QTableWidget, x: float, y_values: list, column: int, plot: pg.PlotItem
-    ) -> None:
-        """
-        Update the table with coordinates based on cursor movements and clicks.
-
-        Args:
-            table_widget (QTableWidget): The table to be updated.
-            x (float): The x-coordinate from the plot.
-            y_values (list): The y-coordinates from the plot.
-            column (int): The column in the table to be updated.
-            plot (PlotItem): The plot from which the coordinates are taken.
-
-        This method calculates the correct row in the table for each y-value
-        and updates the cell at (row, column) with the new x and y coordinates.
-        """
-        plot_name = [name for name, value in self.plots.items() if value == plot][0]
-
-        starting_row = 0
-        for plot_config in self.plot_data:
-            if plot_config.get("plot_name", "") == plot_name:
-                break
-            for y_config in plot_config.get("y", {}).get("signals", []):
-                y_entries = y_config.get("entry", [y_config.get("name", "")])
-                if not isinstance(y_entries, list):
-                    y_entries = [y_entries]
-                starting_row += len(y_entries)
-
-        for i, y in enumerate(y_values):
-            row = starting_row + i
-            table_widget.setItem(row, column, QTableWidgetItem(f"({x}, {y})"))
-            table_widget.resizeColumnsToContents()
-
-    def update_plot(self) -> None:
-        """Update the plot data based on the stored data dictionary."""
-        for plot_name, curve_list in self.curves_data.items():
-            for y_name, y_entry, curve in curve_list:
-                x_config = next(
-                    (pc["x"] for pc in self.plot_data if pc.get("plot_name") == plot_name), {}
-                )
-                x_signal_config = x_config["signals"][0]
-                x_name = x_signal_config.get("name", "")
-                x_entry = x_signal_config.get("entry", x_name)
-
-                key = (x_name, x_entry, y_name, y_entry)
-                data_x = self.data.get(key, {}).get("x", [])
-                data_y = self.data.get(key, {}).get("y", [])
-
-                curve.setData(data_x, data_y)
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(
-        self, msg, metadata
-    ) -> None:  # TODO the logic should be separated from GUI operation
-        """
-        Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
-
-        Args:
-            msg (dict): Message received with scan data.
-            metadata (dict): Metadata of the scan.
-        """
-
-        current_scanID = msg.get("scanID", None)
-        if current_scanID is None:
-            return
-
-        if current_scanID != self.scanID:
-            if self.scan_types is False:
-                self.plot_data = self.plot_data_config
-            elif self.scan_types is True:
-                currentName = metadata.get("scan_name")
-                if currentName is None:
-                    raise ValueError(
-                        f"Scan name not found in metadata. Please check the scan_name in the YAML config or in bec "
-                        f"configuration."
-                    )
-                self.plot_data = self.plot_data_config.get(currentName, [])
-                if self.plot_data == []:
-                    raise ValueError(
-                        f"Scan name {currentName} not found in the YAML config. Please check the scan_name in the "
-                        f"YAML config or in bec configuration."
-                    )
-
-                # Init UI
-                self.init_ui(self.plot_settings["num_columns"])
-                self.spinBox_N_columns.setValue(
-                    self.plot_settings["num_columns"]
-                )  # TODO has to be checked if it will not setup more columns than plots
-                self.spinBox_N_columns.setMaximum(len(self.plot_data))
-
-            self.scanID = current_scanID
-            self.data = {}
-            self.init_curves()
-
-        for plot_config in self.plot_data:
-            plot_name = plot_config.get("plot_name", "Unnamed Plot")
-            x_config = plot_config["x"]
-            x_signal_config = x_config["signals"][0]  # Assuming there's at least one signal for x
-
-            x_name = x_signal_config.get("name", "")
-            if not x_name:
-                raise ValueError(f"Name for x signal must be specified in plot: {plot_name}.")
-
-            x_entry_list = x_signal_config.get("entry", [])
-            if not x_entry_list:
-                x_entry_list = (
-                    self.dev[x_name]._hints if hasattr(self.dev[x_name], "_hints") else [x_name]
-                )
-
-            if not isinstance(x_entry_list, list):
-                x_entry_list = [x_entry_list]
-
-            y_configs = plot_config["y"]["signals"]
-
-            for x_entry in x_entry_list:
-                for y_config in y_configs:
-                    y_name = y_config.get("name", "")
-                    if not y_name:
-                        raise ValueError(
-                            f"Name for y signal must be specified in plot: {plot_name}."
-                        )
-
-                    y_entry_list = y_config.get("entry", [])
-                    if not y_entry_list:
-                        y_entry_list = (
-                            self.dev[y_name]._hints
-                            if hasattr(self.dev[y_name], "_hints")
-                            else [y_name]
-                        )
-
-                    if not isinstance(y_entry_list, list):
-                        y_entry_list = [y_entry_list]
-
-                    for y_entry in y_entry_list:
-                        key = (x_name, x_entry, y_name, y_entry)
-
-                        data_x = msg["data"].get(x_name, {}).get(x_entry, {}).get("value", None)
-                        data_y = msg["data"].get(y_name, {}).get(y_entry, {}).get("value", None)
-
-                        if data_x is None:
-                            raise ValueError(
-                                f"Incorrect entry '{x_entry}' specified for x in plot: {plot_name}, x name: {x_name}"
-                            )
-
-                        if data_y is None:
-                            if hasattr(self.dev[y_name], "_hints"):
-                                raise ValueError(
-                                    f"Incorrect entry '{y_entry}' specified for y in plot: {plot_name}, y name: {y_name}"
-                                )
-                            else:
-                                raise ValueError(
-                                    f"No hints available for y in plot: {plot_name}, and name '{y_name}' did not work as entry"
-                                )
-
-                        if data_x is not None:
-                            self.data.setdefault(key, {}).setdefault("x", []).append(data_x)
-
-                        if data_y is not None:
-                            self.data.setdefault(key, {}).setdefault("y", []).append(data_y)
-
-        self.update_signal.emit()
-
-    def save_settings_to_yaml(self):
-        """Save the current settings to a .yaml file using a file dialog."""
-        options = QFileDialog.Options()
-        options |= QFileDialog.DontUseNativeDialog
-        file_path, _ = QFileDialog.getSaveFileName(
-            self, "Save Settings", "", "YAML Files (*.yaml);;All Files (*)", options=options
-        )
-
-        if file_path:
-            try:
-                if not file_path.endswith(".yaml"):
-                    file_path += ".yaml"
-
-                with open(file_path, "w") as file:
-                    yaml.dump(
-                        {"plot_settings": self.plot_settings, "plot_data": self.plot_data_config},
-                        file,
-                    )
-                print(f"Settings saved to {file_path}")
-            except Exception as e:
-                print(f"An error occurred while saving the settings to {file_path}: {e}")
-
-    def load_settings_from_yaml(self) -> dict:  # TODO can be replace by the utils function
-        """Load settings from a .yaml file using a file dialog and update the current settings."""
-        options = QFileDialog.Options()
-        options |= QFileDialog.DontUseNativeDialog
-        file_path, _ = QFileDialog.getOpenFileName(
-            self, "Load Settings", "", "YAML Files (*.yaml);;All Files (*)", options=options
-        )
-
-        if file_path:
-            try:
-                with open(file_path, "r") as file:
-                    self.config = yaml.safe_load(file)
-                    self.load_config(self.config)  # validate new config
-                return config
-            except FileNotFoundError:
-                print(f"The file {file_path} was not found.")
-            except Exception as e:
-                print(f"An error occurred while loading the settings from {file_path}: {e}")
-                return None  # Return None on exception to indicate failure
-
-
-class ErrorHandler:
-    def __init__(self, parent=None):
-        self.parent = parent
-        self.errors = []
-        self.retry_action = None
-        logging.basicConfig(level=logging.ERROR)  # Configure logging
-
-    def set_retry_action(self, action):
-        self.retry_action = action  # Store a reference to the retry action
-
-    def handle_error(self, error_message: str):
-        # logging.error(f"{error_message}\n{traceback.format_exc()}") #TODO decide if useful
-
-        choice = QMessageBox.critical(
-            self.parent,
-            "Error",
-            f"{error_message}\n\nWould you like to retry?",
-            QMessageBox.Retry | QMessageBox.Cancel,
-        )
-        if choice == QMessageBox.Retry and self.retry_action is not None:
-            return self.retry_action()
-        else:
-            exit(1)  # Exit the program if the user selects Cancel or if no retry_action is provided
-
-    def validate_config_file(self, config: dict) -> None:
-        """
-        Validate the configuration dictionary.
-        Args:
-            config (dict): Configuration dictionary form .yaml file.
-
-        Returns:
-            None
-        """
-        self.errors = []
-
-        # Validate common keys
-        required_top_level_keys = ["plot_settings", "plot_data"]
-        for key in required_top_level_keys:
-            if key not in config:
-                self.errors.append(f"Missing required key: {key}")
-
-        # Only continue if no errors so far
-        if not self.errors:
-            # Determine the configuration mode (device or scan)
-            plot_settings = config.get("plot_settings", {})
-            scan_types = plot_settings.get("scan_types", False)
-
-            plot_data = config.get("plot_data", [])
-
-            if scan_types:
-                # Validate scan mode configuration
-                for scan_type, plots in plot_data.items():
-                    for i, plot_config in enumerate(plots):
-                        self.validate_plot_config(plot_config, i)
-            else:
-                # Validate device mode configuration
-                for i, plot_config in enumerate(plot_data):
-                    self.validate_plot_config(plot_config, i)
-
-        if self.errors != []:
-            self.handle_error("\n".join(self.errors))
-
-    def validate_plot_config(self, plot_config: dict, i: int):
-        """
-        Validate individual plot configuration.
-        Args:
-            plot_config (dict): Individual plot configuration.
-            i (int): Index of the plot configuration.
-
-        Returns:
-            None
-        """
-        for axis in ["x", "y"]:
-            axis_config = plot_config.get(axis)
-            plot_name = plot_config.get("plot_name", "")
-            if axis_config is None:
-                error_msg = f"Missing '{axis}' configuration in plot {i} - {plot_name}"
-                logging.error(error_msg)  # Log the error
-                self.errors.append(error_msg)
-
-            signals_config = axis_config.get("signals")
-            if signals_config is None:
-                error_msg = (
-                    f"Missing 'signals' configuration for {axis} axis in plot {i} - '{plot_name}'"
-                )
-                logging.error(error_msg)  # Log the error
-                self.errors.append(error_msg)
-            elif not isinstance(signals_config, list) or len(signals_config) == 0:
-                error_msg = (
-                    f"'signals' configuration for {axis} axis in plot {i} must be a non-empty list"
-                )
-                logging.error(error_msg)  # Log the error
-                self.errors.append(error_msg)
-            # TODO add condition for name and entry
-
-
-if __name__ == "__main__":
-    import yaml
-    import argparse
-
-    # from bec_widgets import ctrl_c
-    parser = argparse.ArgumentParser(description="Plotting App")
-    parser.add_argument(
-        "--config",
-        "-c",
-        help="Path to the .yaml configuration file",
-        default="config_example.yaml",
-    )
-    args = parser.parse_args()
-
-    try:
-        with open(args.config, "r") as file:
-            config = yaml.safe_load(file)
-
-    except FileNotFoundError:
-        print(f"The file {args.config} was not found.")
-        exit(1)
-    except Exception as e:
-        print(f"An error occurred while loading the config file: {e}")
-        exit(1)
-
-    # BECclient global variables
-    bec_dispatcher = BECDispatcher()
-    client = bec_dispatcher.client
-    client.start()
-
-    app = QApplication([])
-    plotApp = PlotApp(config=config, client=client)
-
-    # Connecting signals from bec_dispatcher
-    bec_dispatcher.connect_slot(plotApp.on_scan_segment, MessageEndpoints.scan_segment())
-    # ctrl_c.setup(app)
-
-    window = plotApp
-    window.show()
-    app.exec()

bec_widgets/examples/plot_app/plot_app.ui

@@ -1,115 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>MultiWindow</class>
- <widget class="QWidget" name="MultiWindow">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>1248</width>
-    <height>564</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>MultiWindow</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QSplitter" name="splitter">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <widget class="GraphicsLayoutWidget" name="glw"/>
-     <widget class="QWidget" name="">
-      <layout class="QGridLayout" name="gridLayout_2">
-       <item row="1" column="0">
-        <spacer name="horizontalSpacer">
-         <property name="orientation">
-          <enum>Qt::Horizontal</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>40</width>
-           <height>20</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-       <item row="2" column="0" colspan="3">
-        <widget class="QGroupBox" name="groupBox">
-         <property name="title">
-          <string>Cursor</string>
-         </property>
-         <layout class="QGridLayout" name="gridLayout">
-          <item row="0" column="0">
-           <widget class="QTableWidget" name="tableWidget_crosshair">
-            <column>
-             <property name="text">
-              <string>Moved</string>
-             </property>
-            </column>
-            <column>
-             <property name="text">
-              <string>Clicked</string>
-             </property>
-            </column>
-            <column>
-             <property name="text">
-              <string>Color</string>
-             </property>
-            </column>
-           </widget>
-          </item>
-         </layout>
-        </widget>
-       </item>
-       <item row="1" column="1">
-        <widget class="QLabel" name="label">
-         <property name="text">
-          <string>Number of Columns:</string>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="2">
-        <widget class="QSpinBox" name="spinBox_N_columns">
-         <property name="minimum">
-          <number>1</number>
-         </property>
-         <property name="maximum">
-          <number>10</number>
-         </property>
-         <property name="value">
-          <number>3</number>
-         </property>
-        </widget>
-       </item>
-       <item row="0" column="1">
-        <widget class="QPushButton" name="pushButton_load">
-         <property name="text">
-          <string>Load Config</string>
-         </property>
-        </widget>
-       </item>
-       <item row="0" column="2">
-        <widget class="QPushButton" name="pushButton_save">
-         <property name="text">
-          <string>Save Config</string>
-         </property>
-        </widget>
-       </item>
-      </layout>
-     </widget>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>GraphicsLayoutWidget</class>
-   <extends>QGraphicsView</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>

bec_widgets/examples/stream_plot/stream_plot.py

@@ -5,14 +5,15 @@ import time
 import numpy as np
 import pyqtgraph
 import pyqtgraph as pg
-from bec_lib import messages, MessageEndpoints
+from bec_lib import MessageEndpoints, messages
 from bec_lib.redis_connector import RedisConnector
-from qtpy.QtCore import Slot as pyqtSlot
-from qtpy.QtWidgets import QTableWidgetItem
 from pyqtgraph import mkBrush, mkPen
 from pyqtgraph.Qt import QtCore, QtWidgets, uic
 from pyqtgraph.Qt.QtCore import pyqtSignal
-from bec_widgets.utils import Crosshair, Colors
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QTableWidgetItem
+
+from bec_widgets.utils import Colors, Crosshair
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 
@@ -40,7 +41,7 @@ class StreamPlot(QtWidgets.QWidget):
         uic.loadUi(os.path.join(current_path, "line_plot.ui"), self)
 
         self._idle_time = 100
-        self.producer = RedisConnector(["localhost:6379"]).producer()
+        self.connector = RedisConnector(["localhost:6379"])
 
         self.y_value_list = y_value_list
         self.previous_y_value_list = None
@@ -214,7 +215,7 @@ class StreamPlot(QtWidgets.QWidget):
             ]
         }
         msg = messages.DeviceMessage(signals=return_dict).dumps()
-        self.producer.set_and_publish("px_stream/gui_event", msg=msg)
+        self.connector.set_and_publish("px_stream/gui_event", msg=msg)
         self.roi_signal.emit(region)
 
     def init_table(self):
@@ -270,7 +271,7 @@ class StreamPlot(QtWidgets.QWidget):
                 time.sleep(0.1)
                 continue
             endpoint = f"px_stream/projection_{self._current_proj}/data"
-            msgs = self.client.producer.lrange(topic=endpoint, start=-1, end=-1)
+            msgs = self.client.connector.lrange(topic=endpoint, start=-1, end=-1)
             data = msgs
             if not data:
                 continue
@@ -295,7 +296,7 @@ class StreamPlot(QtWidgets.QWidget):
     def new_proj(self, content: dict, _metadata: dict):
         proj_nr = content["signals"]["proj_nr"]
         endpoint = f"px_stream/projection_{proj_nr}/metadata"
-        msg_raw = self.client.producer.get(topic=endpoint)
+        msg_raw = self.client.connector.get(topic=endpoint)
         msg = messages.DeviceMessage.loads(msg_raw)
         self._current_q = msg.content["signals"]["q"]
         self._current_norm = msg.content["signals"]["norm_sum"]

bec_widgets/qtdesigner_plugins/scan2d_plot_plugin.py

@@ -1,56 +0,0 @@
-from qtpy.QtDesigner import QPyDesignerCustomWidgetPlugin
-from qtpy.QtGui import QIcon
-
-from bec_widgets.widgets.scan_plot.scan2d_plot import BECScanPlot2D
-
-
-class BECScanPlot2DPlugin(QPyDesignerCustomWidgetPlugin):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-
-        self._initialized = False
-
-    def initialize(self, formEditor):
-        if self._initialized:
-            return
-
-        self._initialized = True
-
-    def isInitialized(self):
-        return self._initialized
-
-    def createWidget(self, parent):
-        return BECScanPlot2D(parent)
-
-    def name(self):
-        return "BECScanPlot2D"
-
-    def group(self):
-        return "BEC widgets"
-
-    def icon(self):
-        return QIcon()
-
-    def toolTip(self):
-        return "BEC plot for 2D scans"
-
-    def whatsThis(self):
-        return "BEC plot for 2D scans"
-
-    def isContainer(self):
-        return False
-
-    def domXml(self):
-        return (
-            '<widget class="BECScanPlot2D" name="BECScanPlot2D">\n'
-            ' <property name="toolTip" >\n'
-            "  <string>BEC plot for 2D scans</string>\n"
-            " </property>\n"
-            ' <property name="whatsThis" >\n'
-            "  <string>BEC plot for 2D scans in Python using PyQt.</string>\n"
-            " </property>\n"
-            "</widget>\n"
-        )
-
-    def includeFile(self):
-        return "scan2d_plot"

bec_widgets/qtdesigner_plugins/scan_plot_plugin.py

@@ -1,56 +0,0 @@
-from qtpy.QtDesigner import QPyDesignerCustomWidgetPlugin
-from qtpy.QtGui import QIcon
-
-from bec_widgets.widgets.scan_plot.scan_plot import BECScanPlot
-
-
-class BECScanPlotPlugin(QPyDesignerCustomWidgetPlugin):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-
-        self._initialized = False
-
-    def initialize(self, formEditor):
-        if self._initialized:
-            return
-
-        self._initialized = True
-
-    def isInitialized(self):
-        return self._initialized
-
-    def createWidget(self, parent):
-        return BECScanPlot(parent)
-
-    def name(self):
-        return "BECScanPlot"
-
-    def group(self):
-        return "BEC widgets"
-
-    def icon(self):
-        return QIcon()
-
-    def toolTip(self):
-        return "BEC plot for scans"
-
-    def whatsThis(self):
-        return "BEC plot for scans"
-
-    def isContainer(self):
-        return False
-
-    def domXml(self):
-        return (
-            '<widget class="BECScanPlot" name="BECScanPlot">\n'
-            ' <property name="toolTip" >\n'
-            "  <string>BEC plot for scans</string>\n"
-            " </property>\n"
-            ' <property name="whatsThis" >\n'
-            "  <string>BEC plot for scans in Python using PyQt.</string>\n"
-            " </property>\n"
-            "</widget>\n"
-        )
-
-    def includeFile(self):
-        return "scan_plot"

bec_widgets/utils/__init__.py

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

bec_widgets/utils/bec_connector.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import time
-from typing import Type, Optional
+from typing import Optional, Type
 
 from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import Slot as pyqtSlot
@@ -31,13 +31,16 @@ class ConnectionConfig(BaseModel):
 class BECConnector:
     """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
 
+    USER_ACCESS = ["config_dict"]
+
     def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
         # BEC related connections
-        self.bec_dispatcher = BECDispatcher()
+        self.bec_dispatcher = BECDispatcher(client=client)
         self.client = self.bec_dispatcher.client if client is None else client
 
         if config:
             self.config = config
+            self.config.widget_class = self.__class__.__name__
         else:
             print(
                 f"No initial config found for {self.__class__.__name__}.\n"
@@ -51,6 +54,24 @@ class BECConnector:
         else:
             self.gui_id = self.config.gui_id
 
+    @property
+    def config_dict(self) -> dict:
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+        return self.config.model_dump()
+
+    @config_dict.setter
+    def config_dict(self, config: BaseModel) -> None:
+        """
+        Get the configuration of the widget.
+        Returns:
+            dict: The configuration of the widget.
+        """
+        self.config = config
+
     @pyqtSlot(str)
     def set_gui_id(self, gui_id: str) -> None:
         """

bec_widgets/utils/bec_dispatcher.py

@@ -1,159 +1,141 @@
 from __future__ import annotations
 
 import argparse
-import itertools
-import os
+import collections
 from collections.abc import Callable
-from typing import Union
+from typing import TYPE_CHECKING, Union
 
 import redis
-from bec_lib import BECClient, ServiceConfig
+from bec_lib import BECClient
+from bec_lib.redis_connector import MessageObject, RedisConnector
 from qtpy.QtCore import QObject
 from qtpy.QtCore import Signal as pyqtSignal
 
-# Adding a new pyqt signal requires a class factory, as they must be part of the class definition
-# and cannot be dynamically added as class attributes after the class has been defined.
-_signal_class_factory = (
-    type(f"Signal{i}", (QObject,), dict(signal=pyqtSignal(dict, dict))) for i in itertools.count()
-)
+if TYPE_CHECKING:
+    from bec_lib.endpoints import EndpointInfo
 
 
-class _Connection:
-    """Utility class to keep track of slots connected to a particular redis connector"""
+class QtThreadSafeCallback(QObject):
+    cb_signal = pyqtSignal(dict, dict)
 
-    def __init__(self, callback) -> None:
-        self.callback = callback
-
-        self.slots = set()
-        # keep a reference to a new signal class, so it is not gc'ed
-        self._signal_container = next(_signal_class_factory)()
-        self.signal: pyqtSignal = self._signal_container.signal
-
-
-class _BECDispatcher(QObject):
-    """Utility class to keep track of slots connected to a particular redis connector"""
-
-    def __init__(self, bec_config=None):
+    def __init__(self, cb):
         super().__init__()
-        self.client = BECClient()
 
-        # TODO: this is a workaround for now to provide service config within qtdesigner, but is
-        # it possible to provide config via a cli arg?
-        if bec_config is None and os.path.isfile("bec_config.yaml"):
-            bec_config = "bec_config.yaml"
+        self.cb = cb
+        self.cb_signal.connect(self.cb)
+
+    def __hash__(self):
+        # make 2 differents QtThreadSafeCallback to look
+        # identical when used as dictionary keys, if the
+        # callback is the same
+        return id(self.cb)
+
+    def __call__(self, msg_content, metadata):
+        self.cb_signal.emit(msg_content, metadata)
+
+
+class QtRedisConnector(RedisConnector):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def _execute_callback(self, cb, msg, kwargs):
+        if not isinstance(cb, QtThreadSafeCallback):
+            return super()._execute_callback(cb, msg, kwargs)
+        # if msg.msg_type == "bundle_message":
+        #    # big warning: how to handle bundle messages?
+        #    # message with messages inside ; which slot to call?
+        #    # bundle_msg = msg
+        #    # for msg in bundle_msg:
+        #    #    ...
+        #    # for now, only consider the 1st message
+        #    msg = msg[0]
+        #    raise RuntimeError(f"
+        if isinstance(msg, MessageObject):
+            if isinstance(msg.value, list):
+                msg = msg.value[0]
+            else:
+                msg = msg.value
+
+            # we can notice kwargs are lost when passed to Qt slot
+            metadata = msg.metadata
+            cb(msg.content, metadata)
+        else:
+            # from stream
+            msg = msg["data"]
+            cb(msg.content, msg.metadata)
+
+
+class BECDispatcher:
+    """Utility class to keep track of slots connected to a particular redis connector"""
+
+    _instance = None
+    _initialized = False
+
+    def __new__(cls, client=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):
+        if self._initialized:
+            return
+
+        self._slots = collections.defaultdict(set)
+        self.client = client
+
+        if self.client is None:
+            self.client = BECClient(connector_cls=QtRedisConnector, forced=True)
+        else:
+            if self.client.started:
+                # have to reinitialize client to use proper connector
+                self.client.shutdown()
+            self.client._BECClient__init_params["connector_cls"] = QtRedisConnector
 
         try:
-            self.client.initialize(config=ServiceConfig(config_path=bec_config))
-        except redis.exceptions.ConnectionError as e:
-            print(f"Failed to initialize BECClient: {e}")
-        self._connections = {}
+            self.client.start()
+        except redis.exceptions.ConnectionError:
+            print("Could not connect to Redis, skipping start of BECClient.")
+
+        self._initialized = True
+
+    @classmethod
+    def reset_singleton(cls):
+        cls._instance = None
+        cls._initialized = False
 
     def connect_slot(
-        self, slot: Callable, topics: Union[str, list], single_callback_for_all_topics=False
+        self,
+        slot: Callable,
+        topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]],
     ) -> None:
         """Connect widget's pyqt slot, so that it is called on new pub/sub topic message.
 
         Args:
             slot (Callable): A slot method/function that accepts two inputs: content and metadata of
                 the corresponding pub/sub message
-            topics (str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
-            single_callback_for_all_topics (bool): If True, use the same callback for all topics, otherwise use
-                separate callbacks.
+            topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
         """
-        if isinstance(topics, str):
-            topics = [topics]
+        slot = QtThreadSafeCallback(slot)
+        self.client.connector.register(topics, cb=slot)
+        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
+        self._slots[slot].update(set(topics_str))
 
-        # Ensure topics_key is a tuple, whether single_callback_for_all_topics is True or False.
-        topics_key = tuple(sorted(topics)) if single_callback_for_all_topics else tuple(topics)
+    def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
+        self.client.connector.unregister(topics, cb=slot)
+        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
+        self._slots[slot].difference_update(set(topics_str))
+        if not self._slots[slot]:
+            del self._slots[slot]
 
-        if topics_key not in self._connections:
-            self._connections[topics_key] = self._create_connection(topics)
-        connection = self._connections[topics_key]
-        if slot not in connection.slots:
-            connection.signal.connect(slot)
-            connection.slots.add(slot)
+    def disconnect_topics(self, topics: Union[str, list]):
+        self.client.connector.unregister(topics)
+        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
+        for slot in list(self._slots.keys()):
+            slot_topics = self._slots[slot]
+            slot_topics.difference_update(set(topics_str))
+            if not slot_topics:
+                del self._slots[slot]
 
-    def _create_connection(self, topics: list) -> _Connection:
-        """Creates a new connection for given topics."""
-
-        def cb(msg):
-            msg = msg.value
-            for connection_key, connection in self._connections.items():
-                if set(topics).intersection(connection_key):
-                    if isinstance(msg, list):
-                        msg = msg[0]
-                    connection.signal.emit(msg.content, msg.metadata)
-
-        try:
-            self.client.connector.register(topics=topics, cb=cb)
-        except redis.exceptions.ConnectionError:
-            print("Could not connect to Redis, skipping registration of topics.")
-
-        return _Connection(cb)
-
-    def _do_disconnect_slot(self, topic, slot):
-        print(f"Disconnecting {slot} from {topic}")
-        connection = self._connections[topic]
-        try:
-            connection.signal.disconnect(slot)
-        except TypeError:
-            print(f"Could not disconnect slot:'{slot}' from topic:'{topic}'")
-            print("Continue to remove slot:'{slot}' from 'connection.slots'.")
-        connection.slots.remove(slot)
-        if not connection.slots:
-            del self._connections[topic]
-
-    def _disconnect_slot_from_topic(self, slot: Callable, topic: str) -> None:
-        """A helper method to disconnect a slot from a specific topic.
-
-        Args:
-            slot (Callable): A slot to be disconnected
-            topic (str): A corresponding topic that can typically be acquired via
-                bec_lib.MessageEndpoints
-        """
-        connection = self._connections.get(topic)
-        if connection and slot in connection.slots:
-            self._do_disconnect_slot(topic, slot)
-
-    def disconnect_slot(self, slot: Callable, topics: Union[str, list]) -> None:
-        """Disconnect widget's pyqt slot from pub/sub updates on a topic.
-
-        Args:
-            slot (Callable): A slot to be disconnected
-            topics (str | list): A corresponding topic or list of topics that can typically be acquired via
-                bec_lib.MessageEndpoints
-        """
-        if isinstance(topics, str):
-            topics = [topics]
-
-        for key, connection in list(self._connections.items()):
-            if slot in connection.slots:
-                common_topics = set(topics).intersection(key)
-                if common_topics:
-                    remaining_topics = set(key) - set(topics)
-                    # Disconnect slot from common topics
-                    self._do_disconnect_slot(key, slot)
-                    # Reconnect slot to remaining topics if any
-                    if remaining_topics:
-                        self.connect_slot(slot, list(remaining_topics), True)
-
-    def disconnect_all(self):
-        """Disconnect all slots from all topics."""
-        for key, connection in list(self._connections.items()):
-            for slot in list(connection.slots):
-                self._disconnect_slot_from_topic(slot, key)
-
-
-# variable holding the Singleton instance of BECDispatcher
-_bec_dispatcher = None
-
-
-def BECDispatcher():
-    global _bec_dispatcher
-    if _bec_dispatcher is None:
-        parser = argparse.ArgumentParser()
-        parser.add_argument("--bec-config", default=None)
-        args, _ = parser.parse_known_args()
-
-        _bec_dispatcher = _BECDispatcher(args.bec_config)
-    return _bec_dispatcher
+    def disconnect_all(self, *args, **kwargs):
+        self.disconnect_topics(self.client.connector._topics_cb)

bec_widgets/utils/bec_table.py

@@ -1,5 +1,5 @@
-from qtpy.QtWidgets import QTableWidget
 from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QTableWidget
 
 
 class BECTable(QTableWidget):

bec_widgets/utils/container_utils.py

@@ -0,0 +1,45 @@
+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

@@ -2,7 +2,8 @@ import numpy as np
 import pyqtgraph as pg
 
 # from qtpy.QtCore import QObject, pyqtSignal
-from qtpy.QtCore import QObject, Signal as pyqtSignal
+from qtpy.QtCore import QObject
+from qtpy.QtCore import Signal as pyqtSignal
 
 
 class Crosshair(QObject):

bec_widgets/utils/entry_validator.py

@@ -3,6 +3,15 @@ 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 +24,17 @@ 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/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/validator_delegate.py

@@ -2,7 +2,7 @@
 # from qtpy.QtWidgets import QStyledItemDelegate, QLineEdit
 
 from qtpy.QtGui import QDoubleValidator
-from qtpy.QtWidgets import QStyledItemDelegate, QLineEdit
+from qtpy.QtWidgets import QLineEdit, QStyledItemDelegate
 
 
 class DoubleValidationDelegate(QStyledItemDelegate):

bec_widgets/utils/widget_io.py

@@ -3,16 +3,16 @@ from abc import ABC, abstractmethod
 
 from qtpy.QtWidgets import (
     QApplication,
-    QWidget,
-    QLineEdit,
+    QCheckBox,
     QComboBox,
-    QTableWidget,
-    QSpinBox,
     QDoubleSpinBox,
+    QLabel,
+    QLineEdit,
+    QSpinBox,
+    QTableWidget,
     QTableWidgetItem,
     QVBoxLayout,
-    QCheckBox,
-    QLabel,
+    QWidget,
 )
 
 

bec_widgets/utils/yaml_dialog.py

@@ -1,6 +1,7 @@
 # pylint: disable=no-name-in-module
 
 from typing import Union
+
 import yaml
 from qtpy.QtWidgets import QFileDialog
 

bec_widgets/validation/monitor_config_validator.py

@@ -1,6 +1,6 @@
-from typing import Optional, Union, Literal
+from typing import Literal, Optional, Union
 
-from pydantic import BaseModel, Field, field_validator, model_validator, ValidationError
+from pydantic import BaseModel, Field, ValidationError, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
 
@@ -92,12 +92,12 @@ class SourceHistoryValidator(BaseModel):
     """History source validator
     Attributes:
         type (str): type of source - history
-        scanID (str): Scan ID for history source.
+        scan_id (str): Scan ID for history source.
         signals (list): Signal for the source.
     """
 
     type: Literal["history"]
-    scanID: str  # TODO can be validated if it is a valid scanID
+    scan_id: str  # TODO can be validated if it is a valid scan_id
     signals: AxisSignal
 
 
@@ -131,12 +131,12 @@ class Source(BaseModel):  # TODO decide if it should stay for general Source val
     General source validation, includes all Optional arguments of all other sources.
     Attributes:
         type (list): type of source (scan_segment, history)
-        scanID (Optional[str]): Scan ID for history source.
+        scan_id (Optional[str]): Scan ID for history source.
         signals (Optional[AxisSignal]): Signal for the source.
     """
 
     type: Literal["scan_segment", "history", "redis"]
-    scanID: Optional[str] = None
+    scan_id: Optional[str] = None
     signals: Optional[dict] = None
 
 

bec_widgets/widgets/__init__.py

@@ -1,15 +1,13 @@
-from .monitor import BECMonitor, ConfigDialog
-from .motor_map import MotorMap
-from .scan_control import ScanControl
-from .toolbar import ModularToolBar
 from .editor import BECEditor
-from .monitor_scatter_2D import BECMonitor2DScatter
+from .figure import BECFigure, FigureConfig
+from .monitor import BECMonitor
 from .motor_control import (
-    MotorControlRelative,
     MotorControlAbsolute,
+    MotorControlRelative,
     MotorControlSelection,
-    MotorThread,
     MotorCoordinateTable,
+    MotorThread,
 )
-from .figure import FigureConfig, BECFigure
-from .plots import BECWaveform1D, BECCurve, BECPlotBase
+from .motor_map import MotorMap
+from .plots import BECCurve, BECMotorMap, BECWaveform
+from .scan_control import ScanControl

bec_widgets/widgets/editor/editor.py

@@ -3,24 +3,16 @@ import subprocess
 import qdarktheme
 from jedi import Script
 from jedi.api import Completion
-
-# pylint: disable=no-name-in-module
-from qtpy.Qsci import QsciScintilla, QsciLexerPython, QsciAPIs
-from qtpy.QtCore import Qt
-from qtpy.QtCore import Signal, QThread
-from qtpy.QtGui import QColor, QFont
-from qtpy.QtWidgets import (
-    QApplication,
-    QFileDialog,
-    QTextEdit,
-    QVBoxLayout,
-    QWidget,
-)
-from qtpy.QtWidgets import QSplitter
 from qtconsole.manager import QtKernelManager
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
 
-from bec_widgets.widgets import ModularToolBar
+# 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):

bec_widgets/widgets/figure/__init__.py

@@ -1 +1 @@
-from .figure import FigureConfig, BECFigure
+from .figure import BECFigure, FigureConfig

bec_widgets/widgets/figure/figure.py

@@ -4,18 +4,27 @@ from __future__ import annotations
 import itertools
 import os
 from collections import defaultdict
-from typing import Literal, Optional
+from typing import Literal, Optional, Type
 
 import numpy as np
 import pyqtgraph as pg
 import qdarktheme
 from pydantic import Field
 from pyqtgraph.Qt import uic
-from qtpy.QtWidgets import QApplication, QWidget
-from qtpy.QtWidgets import QVBoxLayout, QMainWindow
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
 
-from bec_widgets.utils import BECConnector, BECDispatcher, ConnectionConfig
-from bec_widgets.widgets.plots import BECPlotBase, BECWaveform1D, Waveform1DConfig, WidgetConfig
+from bec_widgets.utils import BECConnector, BECDispatcher, ConnectionConfig, WidgetContainerUtils
+from bec_widgets.widgets.plots import (
+    BECImageShow,
+    BECMotorMap,
+    BECPlotBase,
+    BECWaveform,
+    Waveform1DConfig,
+    WidgetConfig,
+)
+from bec_widgets.widgets.plots.image import ImageConfig
+from bec_widgets.widgets.plots.motor_map import MotorMapConfig
 
 
 class FigureConfig(ConnectionConfig):
@@ -35,7 +44,9 @@ class WidgetHandler:
     def __init__(self):
         self.widget_factory = {
             "PlotBase": (BECPlotBase, WidgetConfig),
-            "Waveform1D": (BECWaveform1D, Waveform1DConfig),
+            "Waveform1D": (BECWaveform, Waveform1DConfig),
+            "ImShow": (BECImageShow, ImageConfig),
+            "MotorMap": (BECMotorMap, MotorMapConfig),
         }
 
     def create_widget(
@@ -65,6 +76,8 @@ class WidgetHandler:
             raise ValueError(f"Unsupported widget type: {widget_type}")
 
         widget_class, config_class = entry
+        if config is not None and isinstance(config, config_class):
+            config = config.model_dump()
         widget_config_dict = {
             "widget_class": widget_class.__name__,
             "parent_id": parent_id,
@@ -83,7 +96,23 @@ class WidgetHandler:
 
 
 class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
-    USER_ACCESS = ["add_plot", "remove", "change_layout", "change_theme", "clear_all"]
+    USER_ACCESS = [
+        "config_dict",
+        "axes",
+        "widgets",
+        "add_plot",
+        "add_image",
+        "add_motor_map",
+        "plot",
+        "image",
+        "motor_map",
+        "remove",
+        "change_layout",
+        "change_theme",
+        "clear_all",
+    ]
+
+    clean_signal = pyqtSignal()
 
     def __init__(
         self,
@@ -104,24 +133,52 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         self.widget_handler = WidgetHandler()
 
         # Widget container to reference widgets by 'widget_id'
-        self.widgets = defaultdict(dict)
+        self._widgets = defaultdict(dict)
 
         # Container to keep track of the grid
         self.grid = []
 
-    def change_theme(self, theme: Literal["dark", "light"]) -> None:
+    @property
+    def axes(self) -> list[BECPlotBase]:
         """
-        Change the theme of the figure widget.
-        Args:
-            theme(Literal["dark","light"]): The theme to set for the figure widget.
+        Access all widget in BECFigure as a list
+        Returns:
+            list[BECPlotBase]: List of all widgets in the figure.
         """
-        qdarktheme.setup_theme(theme)
-        self.setBackground("k" if theme == "dark" else "w")
-        self.config.theme = theme
+        axes = [value for value in self._widgets.values() if isinstance(value, BECPlotBase)]
+        return axes
+
+    @axes.setter
+    def axes(self, value: list[BECPlotBase]):
+        self._axes = value
+
+    @property
+    def widgets(self) -> dict:
+        return self._widgets
+
+    @widgets.setter
+    def widgets(self, value: dict):
+        self._widgets = value
 
     def add_plot(
-        self, widget_id: str = None, row: int = None, col: int = None, config=None, **axis_kwargs
-    ) -> BECWaveform1D:
+        self,
+        x_name: str = None,
+        y_name: str = None,
+        z_name: str = None,
+        x_entry: str = None,
+        y_entry: str = None,
+        z_entry: str = None,
+        x: list | np.ndarray = None,
+        y: list | np.ndarray = None,
+        color: Optional[str] = None,
+        color_map_z: Optional[str] = "plasma",
+        label: Optional[str] = None,
+        validate: bool = True,
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> BECWaveform:
         """
         Add a Waveform1D plot to the figure at the specified position.
         Args:
@@ -131,7 +188,8 @@ 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.
         """
-        return self.add_widget(
+        widget_id = WidgetContainerUtils.generate_unique_widget_id(self._widgets)
+        waveform = self.add_widget(
             widget_type="Waveform1D",
             widget_id=widget_id,
             row=row,
@@ -140,9 +198,329 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             **axis_kwargs,
         )
 
+        # TODO remove repetition from .plot method
+
+        # User wants to add scan curve -> 1D Waveform
+        if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
+            waveform.add_curve_scan(
+                x_name=x_name,
+                y_name=y_name,
+                x_entry=x_entry,
+                y_entry=y_entry,
+                validate=validate,
+                color=color,
+                label=label,
+            )
+        # User wants to add scan curve -> 2D Waveform Scatter
+        if (
+            x_name is not None
+            and y_name is not None
+            and z_name is not None
+            and x is None
+            and y is None
+        ):
+            waveform.add_curve_scan(
+                x_name=x_name,
+                y_name=y_name,
+                z_name=z_name,
+                x_entry=x_entry,
+                y_entry=y_entry,
+                z_entry=z_entry,
+                color=color,
+                color_map_z=color_map_z,
+                label=label,
+                validate=validate,
+            )
+        # User wants to add custom curve
+        elif x is not None and y is not None and x_name is None and y_name is None:
+            waveform.add_curve_custom(
+                x=x,
+                y=y,
+                color=color,
+                label=label,
+            )
+
+        return waveform
+
+    def plot(
+        self,
+        x_name: str = None,
+        y_name: str = None,
+        z_name: str = None,
+        x_entry: str = None,
+        y_entry: str = None,
+        z_entry: str = None,
+        x: list | np.ndarray = None,
+        y: list | np.ndarray = None,
+        color: Optional[str] = None,
+        color_map_z: Optional[str] = "plasma",
+        label: Optional[str] = None,
+        validate: bool = True,
+        **axis_kwargs,
+    ) -> 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.
+            z_name(str): The name of the device for the z-axis.
+            x_entry(str): The name of the entry for the x-axis.
+            y_entry(str): The name of the entry for the y-axis.
+            z_entry(str): The name of the entry for the z-axis.
+            x(list | np.ndarray): Custom x data to plot.
+            y(list | np.ndarray): Custom y data to plot.
+            color(str): The color of the curve.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str): The label of the curve.
+            validate(bool): If True, validate the device names and entries.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECWaveform: The waveform plot widget.
+        """
+        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)
+        else:
+            waveform = self.add_plot(**axis_kwargs)
+
+        # User wants to add scan curve -> 1D Waveform
+        if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
+            waveform.add_curve_scan(
+                x_name=x_name,
+                y_name=y_name,
+                x_entry=x_entry,
+                y_entry=y_entry,
+                color=color,
+                color_map_z="plasma",
+                label=label,
+                validate=validate,
+            )
+        # User wants to add scan curve -> 2D Waveform Scatter
+        elif (
+            x_name is not None
+            and y_name is not None
+            and z_name is not None
+            and x is None
+            and y is None
+        ):
+            waveform.add_curve_scan(
+                x_name=x_name,
+                y_name=y_name,
+                z_name=z_name,
+                x_entry=x_entry,
+                y_entry=y_entry,
+                z_entry=z_entry,
+                color=color,
+                color_map_z=color_map_z,
+                label=label,
+                validate=validate,
+            )
+        # User wants to add custom curve
+        elif (
+            x is not None and y is not None and x_name is None and y_name is None and z_name is None
+        ):
+            waveform.add_curve_custom(
+                x=x,
+                y=y,
+                color=color,
+                label=label,
+            )
+        else:
+            raise ValueError(
+                "Invalid input. Provide either device names (x_name, y_name) or custom data."
+            )
+        return waveform
+
+    def image(
+        self,
+        monitor: str = None,
+        color_bar: Literal["simple", "full"] = "full",
+        color_map: str = "magma",
+        data: np.ndarray = None,
+        vrange: tuple[float, float] = None,
+        **axis_kwargs,
+    ) -> 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.
+            color_map(str): The color map to use for the image.
+            data(np.ndarray): Custom data to display.
+            vrange(tuple[float, float]): The range of values to display.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECImageShow: The image widget.
+        """
+        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)
+        else:
+            image = self.add_image(color_bar=color_bar, **axis_kwargs)
+
+        # Setting data #TODO check logic if monitor or data are already created
+        if monitor is not None and data is None:
+            image.add_monitor_image(
+                monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar
+            )
+        elif data is not None and monitor is None:
+            image.add_custom_image(
+                name="custom", data=data, color_map=color_map, vrange=vrange, color_bar=color_bar
+            )
+        elif data is None and monitor is None:
+            # Setting appearance
+            if vrange is not None:
+                image.set_vrange(vmin=vrange[0], vmax=vrange[1])
+            if color_map is not None:
+                image.set_color_map(color_map)
+        else:
+            raise ValueError("Invalid input. Provide either monitor name or custom data.")
+        return image
+
+    def add_image(
+        self,
+        monitor: str = None,
+        color_bar: Literal["simple", "full"] = "full",
+        color_map: str = "magma",
+        data: np.ndarray = None,
+        vrange: tuple[float, float] = None,
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> 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.
+            color_map(str): The color map to use for the image.
+            data(np.ndarray): Custom data to display.
+            vrange(tuple[float, float]): The range of values to display.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Additional configuration for the widget.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECImageShow: The image widget.
+        """
+
+        widget_id = WidgetContainerUtils.generate_unique_widget_id(self._widgets)
+        if config is None:
+            config = ImageConfig(
+                widget_class="BECImageShow",
+                gui_id=widget_id,
+                parent_id=self.gui_id,
+                color_map=color_map,
+                color_bar=color_bar,
+                vrange=vrange,
+            )
+        image = self.add_widget(
+            widget_type="ImShow",
+            widget_id=widget_id,
+            row=row,
+            col=col,
+            config=config,
+            **axis_kwargs,
+        )
+        # TODO remove repetition from .image method
+        if monitor is not None and data is None:
+            image.add_monitor_image(
+                monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar
+            )
+        elif data is not None and monitor is None:
+            image.add_custom_image(
+                name="custom", data=data, color_map=color_map, vrange=vrange, color_bar=color_bar
+            )
+        elif data is None and monitor is None:
+            # Setting appearance
+            if vrange is not None:
+                image.set_vrange(vmin=vrange[0], vmax=vrange[1])
+            if color_map is not None:
+                image.set_color_map(color_map)
+
+        return image
+
+    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.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECMotorMap: The motor map widget.
+        """
+        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)
+        else:
+            motor_map = self.add_motor_map(**axis_kwargs)
+
+        if motor_x is not None and motor_y is not None:
+            motor_map.change_motors(motor_x, motor_y)
+
+        return motor_map
+
+    def add_motor_map(
+        self,
+        motor_x: str = None,
+        motor_y: str = None,
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> BECMotorMap:
+        """
+
+        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.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Additional configuration for the widget.
+            **axis_kwargs:
+
+        Returns:
+            BECMotorMap: The motor map widget.
+        """
+        widget_id = WidgetContainerUtils.generate_unique_widget_id(self._widgets)
+        if config is None:
+            config = MotorMapConfig(
+                widget_class="BECMotorMap",
+                gui_id=widget_id,
+                parent_id=self.gui_id,
+            )
+        motor_map = self.add_widget(
+            widget_type="MotorMap",
+            widget_id=widget_id,
+            row=row,
+            col=col,
+            config=config,
+            **axis_kwargs,
+        )
+
+        if motor_x is not None and motor_y is not None:
+            motor_map.change_motors(motor_x, motor_y)
+
+        return motor_map
+
     def add_widget(
         self,
-        widget_type: Literal["PlotBase", "Waveform1D"] = "PlotBase",
+        widget_type: Literal["PlotBase", "Waveform1D", "ImShow"] = "PlotBase",
         widget_id: str = None,
         row: int = None,
         col: int = None,
@@ -160,8 +538,8 @@ 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()
-        if widget_id in self.widgets:
+            widget_id = WidgetContainerUtils.generate_unique_widget_id(self._widgets)
+        if widget_id in self._widgets:
             raise ValueError(f"Widget with ID '{widget_id}' already exists.")
 
         widget = self.widget_handler.create_widget(
@@ -197,7 +575,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
         # Saving config for future referencing
         self.config.widgets[widget_id] = widget.config
-        self.widgets[widget_id] = widget
+        self._widgets[widget_id] = widget
 
         # Reflect the grid coordinates
         self._change_grid(widget_id, row, col)
@@ -228,6 +606,16 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         else:
             raise ValueError("Must provide either widget_id or coordinates for removal.")
 
+    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.
+        """
+        qdarktheme.setup_theme(theme)
+        self.setBackground("k" if theme == "dark" else "w")
+        self.config.theme = theme
+
     def _remove_by_coordinates(self, row: int, col: int) -> None:
         """
         Remove a widget from the figure by its coordinates.
@@ -238,7 +626,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         widget = self._get_widget_by_coordinates(row, col)
         if widget:
             widget_id = widget.config.gui_id
-            if widget_id in self.widgets:
+            if widget_id in self._widgets:
                 self._remove_by_id(widget_id)
 
     def _remove_by_id(self, widget_id: str) -> None:
@@ -247,8 +635,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         Args:
             widget_id(str): The unique identifier of the widget to remove.
         """
-        if widget_id in self.widgets:
-            widget = self.widgets.pop(widget_id)
+        if widget_id in self._widgets:
+            widget = self._widgets.pop(widget_id)
             widget.cleanup()
             self.removeItem(widget)
             self.grid[widget.config.row][widget.config.col] = None
@@ -263,10 +651,10 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         if isinstance(key, tuple) and len(key) == 2:
             return self._get_widget_by_coordinates(*key)
         elif isinstance(key, str):
-            widget = self.widgets.get(key)
+            widget = self._widgets.get(key)
             if widget is None:
                 raise KeyError(f"No widget with ID {key}")
-            return self.widgets.get(key)
+            return self._widgets.get(key)
         else:
             raise TypeError(
                 "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
@@ -294,14 +682,6 @@ 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.
@@ -329,7 +709,10 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         # Update the config of each object to reflect its new position
         for row_idx, row in enumerate(new_grid):
             for col_idx, widget in enumerate(row):
-                self.widgets[widget].config.row, self.widgets[widget].config.col = row_idx, col_idx
+                self._widgets[widget].config.row, self._widgets[widget].config.col = (
+                    row_idx,
+                    col_idx,
+                )
 
         self.grid = new_grid
         self._replot_layout()
@@ -339,7 +722,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         self.clear()
         for row_idx, row in enumerate(self.grid):
             for col_idx, widget in enumerate(row):
-                self.addItem(self.widgets[widget], row=row_idx, col=col_idx)
+                self.addItem(self._widgets[widget], row=row_idx, col=col_idx)
 
     def change_layout(self, max_columns=None, max_rows=None):
         """
@@ -351,7 +734,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             max_rows (Optional[int]): The new maximum number of rows in the figure.
         """
         # Calculate total number of widgets
-        total_widgets = len(self.widgets)
+        total_widgets = len(self._widgets)
 
         if max_columns:
             # Calculate the required number of rows based on max_columns
@@ -367,7 +750,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
         # Populate the new grid with widgets' IDs
         current_idx = 0
-        for widget_id, widget in self.widgets.items():
+        for widget_id, widget in self._widgets.items():
             row = current_idx // len(new_grid[0])
             col = current_idx % len(new_grid[0])
             new_grid[row][col] = widget_id
@@ -383,142 +766,12 @@ 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()
-        self.widgets = defaultdict(dict)
+        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 start(self):
-        import sys
-
-        app = QApplication(sys.argv)
-        win = QMainWindow()
-        win.setCentralWidget(self)
-        win.show()
-
-        sys.exit(app.exec_())
-
-
-##################################################
-##################################################
-# Debug window
-##################################################
-##################################################
-
-from qtconsole.inprocess import QtInProcessKernelManager
-from qtconsole.rich_jupyter_widget import RichJupyterWidget
-
-
-class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
-    def __init__(self):
-        super().__init__()
-
-        self.kernel_manager = QtInProcessKernelManager()
-        self.kernel_manager.start_kernel(show_banner=False)
-        self.kernel_client = self.kernel_manager.client()
-        self.kernel_client.start_channels()
-
-        self.kernel_manager.kernel.shell.push({"np": np, "pg": pg})
-
-    def shutdown_kernel(self):
-        self.kernel_client.stop_channels()
-        self.kernel_manager.shutdown_kernel()
-
-
-class DebugWindow(QWidget):  # pragma: no cover:
-    """Debug window for BEC widgets"""
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "figure_debug_minimal.ui"), self)
-
-        self._init_ui()
-
-        self.splitter.setSizes([200, 100])
-
-        # console push
-        self.console.kernel_manager.kernel.shell.push(
-            {"fig": self.figure, "w1": self.w1, "w2": self.w2}
-        )
-
-    def _init_ui(self):
-        # Plotting window
-        self.glw_1_layout = QVBoxLayout(self.glw)  # Create a new QVBoxLayout
-        self.figure = BECFigure(parent=self)  # Create a new BECDeviceMonitor
-        self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout
-
-        # add stuff to figure
-        self._init_figure()
-
-        self.console_layout = QVBoxLayout(self.widget_console)
-        self.console = JupyterConsoleWidget()
-        self.console_layout.addWidget(self.console)
-        self.console.set_default_style("linux")
-
-    def _init_figure(self):
-        self.figure.add_widget(widget_type="Waveform1D", row=0, col=0, title="Widget 1")
-        self.figure.add_widget(widget_type="Waveform1D", row=1, col=0, title="Widget 2")
-        self.figure.add_widget(widget_type="Waveform1D", row=0, col=1, title="Widget 3")
-        self.figure.add_widget(widget_type="Waveform1D", row=1, col=1, title="Widget 4")
-
-        self.w1 = self.figure[0, 0]
-        self.w2 = self.figure[1, 0]
-        self.w3 = self.figure[0, 1]
-        self.w4 = self.figure[1, 1]
-
-        # curves for w1
-        self.w1.add_curve_scan("samx", "bpm4i", pen_style="dash")
-        self.w1.add_curve_custom(
-            x=[1, 2, 3, 4, 5],
-            y=[1, 2, 3, 4, 5],
-            label="curve-custom",
-            color="blue",
-            pen_style="dashdot",
-        )
-        self.c1 = self.w1.get_config()
-
-        # curves for w2
-        self.w2.add_curve_scan("samx", "bpm3a", pen_style="solid")
-        self.w2.add_curve_scan("samx", "bpm4d", pen_style="dot")
-        self.w2.add_curve_custom(
-            x=[1, 2, 3, 4, 5], y=[5, 4, 3, 2, 1], color="red", pen_style="dashdot"
-        )
-
-        # curves for w3
-        self.w3.add_curve_scan("samx", "bpm4i", pen_style="dash")
-        self.w3.add_curve_custom(
-            x=[1, 2, 3, 4, 5],
-            y=[1, 2, 3, 4, 5],
-            label="curve-custom",
-            color="blue",
-            pen_style="dashdot",
-        )
-
-        # curves for w4
-        self.w4.add_curve_scan("samx", "bpm4i", pen_style="dash")
-        self.w4.add_curve_custom(
-            x=[1, 2, 3, 4, 5],
-            y=[1, 2, 3, 4, 5],
-            label="curve-custom",
-            color="blue",
-            pen_style="dashdot",
-        )
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    bec_dispatcher = BECDispatcher()
-    client = bec_dispatcher.client
-    client.start()
-
-    app = QApplication(sys.argv)
-    win = DebugWindow()
-    win.show()
-
-    sys.exit(app.exec_())

bec_widgets/widgets/monitor/__init__.py

@@ -1,2 +1 @@
 from .monitor import BECMonitor
-from .config_dialog import ConfigDialog

bec_widgets/widgets/monitor/config_dialog.py

@@ -1,23 +1,22 @@
 import os
 
+from pydantic import ValidationError
 from qtpy import uic
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtWidgets import (
     QApplication,
-    QWidget,
-    QVBoxLayout,
-    QTableWidget,
-    QTabWidget,
-    QTableWidgetItem,
     QLineEdit,
+    QMessageBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QTabWidget,
+    QVBoxLayout,
+    QWidget,
 )
 
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.utils.yaml_dialog import load_yaml, save_yaml
 from bec_widgets.validation import MonitorConfigValidator
-from pydantic import ValidationError
-from qtpy.QtWidgets import QApplication, QMessageBox
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
 
 current_path = os.path.dirname(__file__)
 Ui_Form, BaseClass = uic.loadUiType(os.path.join(current_path, "config_dialog.ui"))

bec_widgets/widgets/monitor/monitor.py

@@ -11,8 +11,9 @@ from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QApplication, QMessageBox
 
 from bec_widgets.utils import Colors, Crosshair, yaml_dialog
-from bec_widgets.validation import MonitorConfigValidator
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.validation import MonitorConfigValidator
+from bec_widgets.widgets.monitor.config_dialog import ConfigDialog
 
 # just for demonstration purposes if script run directly
 CONFIG_SCAN_MODE = {
@@ -59,10 +60,7 @@ CONFIG_SCAN_MODE = {
                 "sources": [
                     {
                         "type": "scan_segment",
-                        "signals": {
-                            "x": [{"name": "samy"}],
-                            "y": [{"name": "bpm4i"}],
-                        },
+                        "signals": {"x": [{"name": "samy"}], "y": [{"name": "bpm4i"}]},
                     }
                 ],
             },
@@ -137,7 +135,7 @@ CONFIG_WRONG = {
                 },
                 {
                     "type": "history",
-                    "scanID": "<scanID>",
+                    "scan_id": "<scan_id>",
                     "signals": {
                         "x": [{"name": "samy"}],
                         "y": [{"name": "bpm4i", "entry": "bpm4i"}],
@@ -170,11 +168,8 @@ CONFIG_WRONG = {
                 {
                     "signals": {
                         "x": [{"name": "samx", "entry": "samx"}],
-                        "y": [
-                            {"name": "samx"},
-                            {"name": "samy", "entry": "samx"},
-                        ],
-                    },
+                        "y": [{"name": "samx"}, {"name": "samy", "entry": "samx"}],
+                    }
                 }
             ],
         },
@@ -315,7 +310,7 @@ class BECMonitor(pg.GraphicsLayoutWidget):
         self.plots = None
         self.curves_data = None
         self.grid_coordinates = None
-        self.scanID = None
+        self.scan_id = None
 
         # TODO make colors accessible to users
         self.user_colors = {}  # key: (plot_name, y_name, y_entry), value: color
@@ -352,7 +347,7 @@ class BECMonitor(pg.GraphicsLayoutWidget):
         # Initialize the UI
         self._init_ui(self.plot_settings["num_columns"])
 
-        if self.scanID is not None:
+        if self.scan_id is not None:
             self.replot_last_scan()
 
     def _init_database(self, plot_data_config: dict, source_type_to_init=None) -> dict:
@@ -602,7 +597,6 @@ class BECMonitor(pg.GraphicsLayoutWidget):
 
     def show_config_dialog(self):
         """Show the configuration dialog."""
-        from bec_widgets.widgets import ConfigDialog
 
         dialog = ConfigDialog(
             client=self.client, default_config=self.config, skip_validation=self.skip_validation
@@ -729,11 +723,11 @@ class BECMonitor(pg.GraphicsLayoutWidget):
             msg (dict): Message received with scan data.
             metadata (dict): Metadata of the scan.
         """
-        current_scanID = msg.get("scanID", None)
-        if current_scanID is None:
+        current_scan_id = msg.get("scan_id", None)
+        if current_scan_id is None:
             return
 
-        if current_scanID != self.scanID:
+        if current_scan_id != self.scan_id:
             if self.scan_types is False:
                 self.plot_data = self.plot_data_config
             elif self.scan_types is True:
@@ -753,10 +747,10 @@ class BECMonitor(pg.GraphicsLayoutWidget):
                 # Init UI
                 self._init_ui(self.plot_settings["num_columns"])
 
-            self.scanID = current_scanID
-            self.scan_data = self.queue.scan_storage.find_scan_by_ID(self.scanID)
+            self.scan_id = current_scan_id
+            self.scan_data = self.queue.scan_storage.find_scan_by_ID(self.scan_id)
             if not self.scan_data:
-                print(f"No data found for scanID: {self.scanID}")  # TODO better error
+                print(f"No data found for scan_id: {self.scan_id}")  # TODO better error
                 return
             self.flush(source_type_to_flush="scan_segment")
 
@@ -766,7 +760,7 @@ class BECMonitor(pg.GraphicsLayoutWidget):
 
     def scan_segment_update(self):
         """
-        Update the database with data from scan storage based on the provided scanID.
+        Update the database with data from scan storage based on the provided scan_id.
         """
         scan_data = self.scan_data.data
         for device_name, device_entries in self.database.get("scan_segment", {}).items():
@@ -840,11 +834,7 @@ if __name__ == "__main__":  # pragma: no cover
     client = BECDispatcher().client
     client.start()
     app = QApplication(sys.argv)
-    monitor = BECMonitor(
-        config=config,
-        gui_id=args.id,
-        skip_validation=False,
-    )
+    monitor = BECMonitor(config=config, gui_id=args.id, skip_validation=False)
     monitor.show()
     # just to test redis data
     # redis_data = {

bec_widgets/widgets/monitor_scatter_2D/__init__.py

@@ -1 +0,0 @@
-from .monitor_scatter_2D import BECMonitor2DScatter

bec_widgets/widgets/monitor_scatter_2D/monitor_scatter_2D.py

@@ -1,382 +0,0 @@
-# pylint: disable = no-name-in-module,missing-module-docstring
-import time
-from collections import defaultdict
-
-import numpy as np
-import pyqtgraph as pg
-from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtCore import Slot as pyqtSlot
-from qtpy.QtWidgets import QApplication
-from qtpy.QtWidgets import QVBoxLayout, QWidget
-
-from bec_lib import MessageEndpoints
-from bec_widgets.utils import yaml_dialog
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-CONFIG_DEFAULT = {
-    "plot_settings": {
-        "colormap": "CET-L4",
-        "num_columns": 1,
-    },
-    "waveform2D": [
-        {
-            "plot_name": "Waveform 2D Scatter (1)",
-            "x_label": "Sam X",
-            "y_label": "Sam Y",
-            "signals": {
-                "x": [{"name": "samx", "entry": "samx"}],
-                "y": [{"name": "samy", "entry": "samy"}],
-                "z": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-            },
-        },
-        {
-            "plot_name": "Waveform 2D Scatter (2)",
-            "x_label": "Sam Y",
-            "y_label": "Sam X",
-            "signals": {
-                "x": [{"name": "samy", "entry": "samy"}],
-                "y": [{"name": "samx", "entry": "samx"}],
-                "z": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-            },
-        },
-    ],
-}
-
-
-class BECMonitor2DScatter(QWidget):
-    update_signal = pyqtSignal()
-
-    def __init__(
-        self,
-        parent=None,
-        client=None,
-        config: dict = None,
-        enable_crosshair: bool = True,
-        gui_id=None,
-        skip_validation: bool = True,
-        toolbar_enabled=True,
-    ):
-        super().__init__(parent=parent)
-
-        # Client and device manager from BEC
-        self.plot_data = None
-        bec_dispatcher = BECDispatcher()
-        self.client = bec_dispatcher.client if client is None else client
-        self.dev = self.client.device_manager.devices
-        self.queue = self.client.queue
-
-        self.validator = None  # TODO implement validator when ready
-        self.gui_id = gui_id
-
-        if self.gui_id is None:
-            self.gui_id = self.__class__.__name__ + str(time.time())
-
-        # Connect dispatcher slots #TODO connect endpoints related to CLI
-        bec_dispatcher.connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
-
-        # Config related variables
-        self.plot_data = None
-        self.plot_settings = None
-        self.num_columns = None
-        self.database = {}
-        self.plots = {}
-        self.grid_coordinates = []
-
-        self.curves_data = {}
-        # Current configuration
-        self.config = config
-        self.skip_validation = skip_validation
-
-        # Enable crosshair
-        self.enable_crosshair = enable_crosshair
-
-        # Displayed Data
-        self.database = {}
-
-        self.crosshairs = None
-        self.plots = None
-        self.curves_data = None
-        self.grid_coordinates = None
-        self.scanID = None
-
-        # Connect the update signal to the update plot method
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=10, slot=self.update_plot
-        )
-
-        # Init UI
-        self.layout = QVBoxLayout(self)
-        self.setLayout(self.layout)
-        if toolbar_enabled:  # TODO implement toolbar when ready
-            self._init_toolbar()
-
-        self.glw = pg.GraphicsLayoutWidget()
-        self.layout.addWidget(self.glw)
-
-        if self.config is None:
-            print("No initial config found for BECDeviceMonitor")
-        else:
-            self.on_config_update(self.config)
-
-    def _init_toolbar(self):
-        """Initialize the toolbar."""
-        # TODO implement toolbar when ready
-        # from bec_widgets.widgets import ModularToolBar
-        #
-        # # Create and configure the toolbar
-        # self.toolbar = ModularToolBar(self)
-        #
-        # # Add the toolbar to the layout
-        # self.layout.addWidget(self.toolbar)
-
-    def _init_config(self):
-        """Initialize the configuration."""
-        # Global widget settings
-        self._get_global_settings()
-
-        # Plot data
-        self.plot_data = self.config.get("waveform2D", [])
-
-        # Initiate database
-        self.database = self._init_database()
-
-        # Initialize the plot UI
-        self._init_ui()
-
-    def _get_global_settings(self):
-        """Get the global widget settings."""
-
-        self.plot_settings = self.config.get("plot_settings", {})
-
-        self.num_columns = self.plot_settings.get("num_columns", 1)
-        self.colormap = self.plot_settings.get("colormap", "viridis")
-
-    def _init_database(self) -> dict:
-        """
-        Initialize the database to store the data for each plot.
-        Returns:
-            dict: The database.
-        """
-
-        database = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
-
-        return database
-
-    def _init_ui(self, num_columns: int = 3) -> None:
-        """
-        Initialize the UI components, create plots and store their grid positions.
-
-        Args:
-            num_columns (int): Number of columns to wrap the layout.
-
-        This method initializes a dictionary `self.plots` to store the plot objects
-        along with their corresponding x and y signal names. It dynamically arranges
-        the plots in a grid layout based on the given number of columns and dynamically
-        stretches the last plots to fit the remaining space.
-        """
-        self.glw.clear()
-        self.plots = {}
-        self.imageItems = {}
-        self.grid_coordinates = []
-        self.scatterPlots = {}
-        self.colorBars = {}
-
-        num_plots = len(self.plot_data)
-        # Check if num_columns exceeds the number of plots
-        if num_columns >= num_plots:
-            num_columns = num_plots
-            self.plot_settings["num_columns"] = num_columns  # Update the settings
-            print(
-                "Warning: num_columns in the YAML file was greater than the number of plots."
-                f" Resetting num_columns to number of plots:{num_columns}."
-            )
-        else:
-            self.plot_settings["num_columns"] = num_columns  # Update the settings
-
-        num_rows = num_plots // num_columns
-        last_row_cols = num_plots % num_columns
-        remaining_space = num_columns - last_row_cols
-
-        for i, plot_config in enumerate(self.plot_data):
-            row, col = i // num_columns, i % num_columns
-            colspan = 1
-
-            if row == num_rows and remaining_space > 0:
-                if last_row_cols == 1:
-                    colspan = num_columns
-                else:
-                    colspan = remaining_space // last_row_cols + 1
-                    remaining_space -= colspan - 1
-                    last_row_cols -= 1
-
-            plot_name = plot_config.get("plot_name", "")
-
-            x_label = plot_config.get("x_label", "")
-            y_label = plot_config.get("y_label", "")
-
-            plot = self.glw.addPlot(row=row, col=col, colspan=colspan, title=plot_name)
-            plot.setLabel("bottom", x_label)
-            plot.setLabel("left", y_label)
-            plot.addLegend()
-
-            self.plots[plot_name] = plot
-
-            self.grid_coordinates.append((row, col))
-
-        self._init_curves()
-
-    def _init_curves(self):
-        """Init scatter plot pg containers"""
-        self.scatterPlots = {}
-        for i, plot_config in enumerate(self.plot_data):
-            plot_name = plot_config.get("plot_name", "")
-            plot = self.plots[plot_name]
-            plot.clear()
-
-            # Create ScatterPlotItem for each plot
-            scatterPlot = pg.ScatterPlotItem(size=10)
-            plot.addItem(scatterPlot)
-            self.scatterPlots[plot_name] = scatterPlot
-
-    @pyqtSlot(dict)
-    def on_config_update(self, config: dict):
-        """
-        Validate and update the configuration settings.
-        Args:
-            config(dict): Configuration settings
-        """
-        # TODO implement BEC CLI commands similar to BECPlotter
-        # convert config from BEC CLI to correct formatting
-        config_tag = config.get("config", None)
-        if config_tag is not None:
-            config = config["config"]
-
-        if self.skip_validation is True:
-            self.config = config
-            self._init_config()
-
-        else:  # TODO implement validator
-            print("Do validation")
-
-    def flush(self):
-        """Reset current plot"""
-
-        self.database = self._init_database()
-        self._init_curves()
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, msg, metadata):
-        """
-        Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
-
-        Args:
-            msg (dict): Message received with scan data.
-            metadata (dict): Metadata of the scan.
-        """
-
-        # TODO check if this is correct
-        current_scanID = msg.get("scanID", None)
-        if current_scanID is None:
-            return
-
-        if current_scanID != self.scanID:
-            self.scanID = current_scanID
-            self.scan_data = self.queue.scan_storage.find_scan_by_ID(self.scanID)
-            if not self.scan_data:
-                print(f"No data found for scanID: {self.scanID}")  # TODO better error
-                return
-            self.flush()
-
-        # Update the database with new data
-        self.update_database_with_scan_data(msg)
-
-        # Emit signal to update plot #TODO could be moved to update_database_with_scan_data just for coresponding plot name
-        self.update_signal.emit()
-
-    def update_database_with_scan_data(self, msg):
-        """
-        Update the database with data from the new scan segment.
-
-        Args:
-            msg (dict): Message containing the new scan data.
-        """
-        data = msg.get("data", {})
-        for plot_config in self.plot_data:  # Iterate over the list
-            plot_name = plot_config["plot_name"]
-            x_signal = plot_config["signals"]["x"][0]["name"]
-            y_signal = plot_config["signals"]["y"][0]["name"]
-            z_signal = plot_config["signals"]["z"][0]["name"]
-
-            if x_signal in data and y_signal in data and z_signal in data:
-                x_value = data[x_signal][x_signal]["value"]
-                y_value = data[y_signal][y_signal]["value"]
-                z_value = data[z_signal][z_signal]["value"]
-
-                # Update database for the corresponding plot
-                self.database[plot_name]["x"][x_signal].append(x_value)
-                self.database[plot_name]["y"][y_signal].append(y_value)
-                self.database[plot_name]["z"][z_signal].append(z_value)
-
-    def update_plot(self):
-        """
-        Update the plots with the latest data from the database.
-        """
-        for plot_name, scatterPlot in self.scatterPlots.items():
-            x_data = self.database[plot_name]["x"]
-            y_data = self.database[plot_name]["y"]
-            z_data = self.database[plot_name]["z"]
-
-            if x_data and y_data and z_data:
-                # Extract values for each axis
-                x_values = next(iter(x_data.values()), [])
-                y_values = next(iter(y_data.values()), [])
-                z_values = next(iter(z_data.values()), [])
-
-                # Check if the data lists are not empty
-                if x_values and y_values and z_values:
-                    # Normalize z_values for color mapping
-                    z_min, z_max = np.min(z_values), np.max(z_values)
-                    if z_max != z_min:  # Ensure that there is a range in the z values
-                        z_values_norm = (z_values - z_min) / (z_max - z_min)
-                        colormap = pg.colormap.get(
-                            self.colormap
-                        )  # using colormap from global settings
-                        colors = [colormap.map(z) for z in z_values_norm]
-
-                        # Update scatter plot data with colors
-                        scatterPlot.setData(x=x_values, y=y_values, brush=colors)
-                    else:
-                        # Handle case where all z values are the same (e.g., avoid division by zero)
-                        scatterPlot.setData(x=x_values, y=y_values)  # Default brush can be used
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import argparse
-    import json
-    import sys
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--config_file", help="Path to the config file.")
-    parser.add_argument("--config", help="Path to the config file.")
-    parser.add_argument("--id", help="GUI ID.")
-    args = parser.parse_args()
-
-    if args.config is not None:
-        # Load config from file
-        config = json.loads(args.config)
-    elif args.config_file is not None:
-        # Load config from file
-        config = yaml_dialog.load_yaml(args.config_file)
-    else:
-        config = CONFIG_DEFAULT
-
-    client = BECDispatcher().client
-    client.start()
-    app = QApplication(sys.argv)
-    monitor = BECMonitor2DScatter(
-        config=config,
-        gui_id=args.id,
-        skip_validation=True,
-    )
-    monitor.show()
-    sys.exit(app.exec())

bec_widgets/widgets/motor_control/__init__.py

@@ -1,7 +1,7 @@
 from .motor_control import (
-    MotorControlRelative,
     MotorControlAbsolute,
+    MotorControlRelative,
     MotorControlSelection,
-    MotorThread,
     MotorCoordinateTable,
+    MotorThread,
 )

bec_widgets/widgets/motor_control/motor_control.py

@@ -2,25 +2,26 @@
 import os
 from enum import Enum
 
-from qtpy import uic
-from qtpy.QtCore import QThread, Slot as pyqtSlot
-from qtpy.QtCore import Signal as pyqtSignal, Qt
-from qtpy.QtGui import QKeySequence, QDoubleValidator
-from qtpy.QtWidgets import QMessageBox
-from qtpy.QtWidgets import (
-    QComboBox,
-    QWidget,
-    QDoubleSpinBox,
-    QShortcut,
-    QTableWidget,
-    QPushButton,
-    QTableWidgetItem,
-    QCheckBox,
-    QLineEdit,
-)
-
 from bec_lib.alarm_handler import AlarmBase
 from bec_lib.device import Positioner
+from qtpy import uic
+from qtpy.QtCore import Qt, QThread
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtGui import QDoubleValidator, QKeySequence
+from qtpy.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QDoubleSpinBox,
+    QLineEdit,
+    QMessageBox,
+    QPushButton,
+    QShortcut,
+    QTableWidget,
+    QTableWidgetItem,
+    QWidget,
+)
+
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 CONFIG_DEFAULT = {
@@ -45,6 +46,9 @@ class MotorControlWidget(QWidget):
         self.motor_thread = motor_thread
         self.config = config
 
+        self.motor_x = None
+        self.motor_y = None
+
         if not self.client:
             bec_dispatcher = BECDispatcher()
             self.client = bec_dispatcher.client

bec_widgets/widgets/motor_map/motor_map.py

@@ -7,14 +7,13 @@ from typing import Any, Union
 import numpy as np
 import pyqtgraph as pg
 from bec_lib import MessageEndpoints
-from qtpy import QtCore
-from qtpy import QtGui
+from qtpy import QtCore, QtGui
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QApplication
 
-from bec_widgets.utils.yaml_dialog import load_yaml
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.utils.yaml_dialog import load_yaml
 
 CONFIG_DEFAULT = {
     "plot_settings": {
@@ -218,7 +217,6 @@ class MotorMap(pg.GraphicsLayoutWidget):
         bec_dispatcher.connect_slot(
             self.on_device_readback,
             endpoints,
-            single_callback_for_all_topics=True,
         )
 
     def _add_limits_to_plot_data(self):

bec_widgets/widgets/plots/__init__.py

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

bec_widgets/widgets/plots/image.py

@@ -0,0 +1,943 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Literal, Optional
+
+import numpy as np
+import pyqtgraph as pg
+from bec_lib import MessageEndpoints
+from pydantic import BaseModel, Field, ValidationError
+from qtpy.QtCore import QObject, QThread
+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, EntryValidator
+
+from .plot_base import BECPlotBase, WidgetConfig
+
+
+class ProcessingConfig(BaseModel):
+    fft: Optional[bool] = Field(False, description="Whether to perform FFT on the monitor data.")
+    log: Optional[bool] = Field(False, description="Whether to perform log on the monitor data.")
+    center_of_mass: Optional[bool] = Field(
+        False, description="Whether to calculate the center of mass of the monitor data."
+    )
+    transpose: Optional[bool] = Field(
+        False, description="Whether to transpose the monitor data before displaying."
+    )
+    rotation: Optional[int] = Field(
+        None, description="The rotation angle of the monitor data before displaying."
+    )
+
+
+class ImageItemConfig(ConnectionConfig):
+    parent_id: Optional[str] = Field(None, description="The parent plot of the image.")
+    monitor: Optional[str] = Field(None, description="The name of the monitor.")
+    source: Optional[str] = Field(None, description="The source of the curve.")
+    color_map: Optional[str] = Field("magma", description="The color map of the image.")
+    downsample: Optional[bool] = Field(True, description="Whether to downsample the image.")
+    opacity: Optional[float] = Field(1.0, description="The opacity of the image.")
+    vrange: Optional[tuple[int, int]] = Field(
+        None, description="The range of the color bar. If None, the range is automatically set."
+    )
+    color_bar: Optional[Literal["simple", "full"]] = Field(
+        "simple", description="The type of the color bar."
+    )
+    autorange: Optional[bool] = Field(True, description="Whether to autorange the color bar.")
+    processing: ProcessingConfig = Field(
+        default_factory=ProcessingConfig, description="The post processing of the image."
+    )
+
+
+class ImageConfig(WidgetConfig):
+    images: dict[str, ImageItemConfig] = Field(
+        {},
+        description="The configuration of the images. The key is the name of the image (source).",
+    )
+
+
+class BECImageItem(BECConnector, pg.ImageItem):
+    USER_ACCESS = [
+        "config_dict",
+        "set",
+        "set_fft",
+        "set_log",
+        "set_rotation",
+        "set_transpose",
+        "set_opacity",
+        "set_autorange",
+        "set_color_map",
+        "set_auto_downsample",
+        "set_monitor",
+        "set_vrange",
+        "get_data",
+    ]
+
+    def __init__(
+        self,
+        config: Optional[ImageItemConfig] = None,
+        gui_id: Optional[str] = None,
+        parent_image: Optional[BECImageItem] = None,
+        **kwargs,
+    ):
+        if config is None:
+            config = ImageItemConfig(widget_class=self.__class__.__name__)
+            self.config = config
+        else:
+            self.config = config
+        super().__init__(config=config, gui_id=gui_id)
+        pg.ImageItem.__init__(self)
+
+        self.parent_image = parent_image
+        self.colorbar_bar = None
+
+        self._add_color_bar(
+            self.config.color_bar, self.config.vrange
+        )  # TODO can also support None to not have any colorbar
+        self.apply_config()
+        if kwargs:
+            self.set(**kwargs)
+
+    def apply_config(self):
+        """
+        Apply current configuration.
+        """
+        self.set_color_map(self.config.color_map)
+        self.set_auto_downsample(self.config.downsample)
+        if self.config.vrange is not None:
+            self.set_vrange(vrange=self.config.vrange)
+
+    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
+            - monitor
+            - opacity
+            - vrange
+            - fft
+            - log
+            - rot
+            - transpose
+        """
+        method_map = {
+            "downsample": self.set_auto_downsample,
+            "color_map": self.set_color_map,
+            "monitor": self.set_monitor,
+            "opacity": self.set_opacity,
+            "vrange": self.set_vrange,
+            "fft": self.set_fft,
+            "log": self.set_log,
+            "rot": self.set_rotation,
+            "transpose": self.set_transpose,
+        }
+        for key, value in kwargs.items():
+            if key in method_map:
+                method_map[key](value)
+            else:
+                print(f"Warning: '{key}' is not a recognized property.")
+
+    def set_fft(self, enable: bool = False):
+        """
+        Set the FFT of the image.
+        Args:
+            enable(bool): Whether to perform FFT on the monitor data.
+        """
+        self.config.processing.fft = enable
+
+    def set_log(self, enable: bool = False):
+        """
+        Set the log of the image.
+        Args:
+            enable(bool): Whether to perform log on the monitor data.
+        """
+        self.config.processing.log = enable
+        if enable and self.color_bar and self.config.color_bar == "full":
+            self.color_bar.autoHistogramRange()
+
+    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.
+        """
+        self.config.processing.rotation = deg_90
+
+    def set_transpose(self, enable: bool = False):
+        """
+        Set the transpose of the image.
+        Args:
+            enable(bool): Whether to transpose the image.
+        """
+        self.config.processing.transpose = enable
+
+    def set_opacity(self, opacity: float = 1.0):
+        """
+        Set the opacity of the image.
+        Args:
+            opacity(float): The opacity of the image.
+        """
+        self.setOpacity(opacity)
+        self.config.opacity = opacity
+
+    def set_autorange(self, autorange: bool = False):
+        """
+        Set the autorange of the color bar.
+        Args:
+            autorange(bool): Whether to autorange the color bar.
+        """
+        self.config.autorange = autorange
+        if self.color_bar is not None:
+            self.color_bar.autoHistogramRange()
+
+    def set_color_map(self, cmap: str = "magma"):
+        """
+        Set the color map of the image.
+        Args:
+            cmap(str): The color map of the image.
+        """
+        self.setColorMap(cmap)
+        if self.color_bar is not None:
+            if self.config.color_bar == "simple":
+                self.color_bar.setColorMap(cmap)
+            elif self.config.color_bar == "full":
+                self.color_bar.gradient.loadPreset(cmap)
+        self.config.color_map = cmap
+
+    def set_auto_downsample(self, auto: bool = True):
+        """
+        Set the auto downsample of the image.
+        Args:
+            auto(bool): Whether to downsample the image.
+        """
+        self.setAutoDownsample(auto)
+        self.config.downsample = auto
+
+    def set_monitor(self, monitor: str):
+        """
+        Set the monitor of the image.
+        Args:
+            monitor(str): The name of the monitor.
+        """
+        self.config.monitor = monitor
+
+    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.
+        """
+        if vrange is not None:
+            vmin, vmax = vrange
+        self.setLevels([vmin, vmax])
+        self.config.vrange = (vmin, vmax)
+        self.config.autorange = False
+        if self.color_bar is not None:
+            if self.config.color_bar == "simple":
+                self.color_bar.setLevels(low=vmin, high=vmax)
+            elif self.config.color_bar == "full":
+                self.color_bar.setLevels(min=vmin, max=vmax)
+                self.color_bar.setHistogramRange(vmin - 0.1 * vmin, vmax + 0.1 * vmax)
+
+    def get_data(self) -> np.ndarray:
+        """
+        Get the data of the image.
+        Returns:
+            np.ndarray: The data of the image.
+        """
+        return self.image
+
+    def _add_color_bar(
+        self, color_bar_style: str = "simple", vrange: Optional[tuple[int, int]] = None
+    ):
+        """
+        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.
+        """
+        if color_bar_style == "simple":
+            self.color_bar = pg.ColorBarItem(colorMap=self.config.color_map)
+            if vrange is not None:
+                self.color_bar.setLevels(low=vrange[0], high=vrange[1])
+            self.color_bar.setImageItem(self)
+            self.parent_image.addItem(self.color_bar)  # , row=0, col=1)
+            self.config.color_bar = "simple"
+        elif color_bar_style == "full":
+            # Setting histogram
+            self.color_bar = pg.HistogramLUTItem()
+            self.color_bar.setImageItem(self)
+            self.color_bar.gradient.loadPreset(self.config.color_map)
+            if vrange is not None:
+                self.color_bar.setLevels(min=vrange[0], max=vrange[1])
+                self.color_bar.setHistogramRange(
+                    vrange[0] - 0.1 * vrange[0], vrange[1] + 0.1 * vrange[1]
+                )
+
+            # Adding histogram to the layout
+            self.parent_image.addItem(self.color_bar)  # , row=0, col=1)
+
+            # save settings
+            self.config.color_bar = "full"
+        else:
+            raise ValueError("style should be 'simple' or 'full'")
+
+
+class BECImageShow(BECPlotBase):
+    USER_ACCESS = [
+        "config_dict",
+        "add_image_by_config",
+        "get_image_config",
+        "get_image_dict",
+        "add_monitor_image",
+        "add_custom_image",
+        "set_vrange",
+        "set_color_map",
+        "set_autorange",
+        "set_monitor",
+        "set_processing",
+        "set_image_properties",
+        "set_fft",
+        "set_log",
+        "set_rotation",
+        "set_transpose",
+        "toggle_threading",
+        "set",
+        "set_title",
+        "set_x_label",
+        "set_y_label",
+        "set_x_scale",
+        "set_y_scale",
+        "set_x_lim",
+        "set_y_lim",
+        "set_grid",
+        "lock_aspect_ratio",
+        "plot",
+        "remove",
+        "images",
+    ]
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        parent_figure=None,
+        config: Optional[ImageConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = ImageConfig(widget_class=self.__class__.__name__)
+        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()
+        self.use_threading = False  # TODO WILL be moved to the init method and to figure method
+
+    def _create_thread_worker(self, device: str, image: np.ndarray):
+        thread = QThread()
+        worker = ProcessorWorker(self.processor)
+        worker.moveToThread(thread)
+
+        # Connect signals and slots
+        thread.started.connect(lambda: worker.process_image(device, image))
+        worker.processed.connect(self.update_image)
+        worker.finished.connect(thread.quit)
+        worker.finished.connect(thread.wait)
+        worker.finished.connect(worker.deleteLater)
+        thread.finished.connect(thread.deleteLater)
+
+        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.
+
+        Returns:
+            BECImageItem: The widget with the given gui_id.
+        """
+        for source, images in self._images.items():
+            for key, value in images.items():
+                if key == item_id and isinstance(value, BECImageItem):
+                    return value
+                elif isinstance(value, dict):
+                    result = self.find_image_by_monitor(item_id)
+                    if result is not None:
+                        return result
+
+    def apply_config(self, config: dict | WidgetConfig):
+        """
+        Apply the configuration to the 1D waveform widget.
+        Args:
+            config(dict|WidgetConfig): Configuration settings.
+            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
+        """
+        if isinstance(config, dict):
+            try:
+                config = ImageConfig(**config)
+            except ValidationError as e:
+                print(f"Validation error when applying config to BECImageShow: {e}")
+                return
+        self.config = config
+        self.plot_item.clear()
+
+        self.apply_axis_config()
+        self._images = defaultdict(dict)
+
+        # TODO extend by adding image by config
+
+    def change_gui_id(self, new_gui_id: str):
+        """
+        Change the GUI ID of the image widget and update the parent_id in all associated curves.
+
+        Args:
+            new_gui_id (str): The new GUI ID to be set for the image widget.
+        """
+        self.gui_id = new_gui_id
+        self.config.gui_id = new_gui_id
+
+        for source, images in self._images.items():
+            for id, image_item in images.items():
+                image_item.config.parent_id = new_gui_id
+
+    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.
+
+        Returns:
+            BECImageItem: The image object.
+        """
+        if isinstance(config, dict):
+            config = ImageItemConfig(**config)
+            config.parent_id = self.gui_id
+        name = config.monitor if config.monitor is not None else config.gui_id
+        image = self._add_image_object(source=config.source, name=name, config=config)
+        return image
+
+    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.
+
+        Returns:
+            ImageItemConfig|dict: The configuration of the image.
+        """
+        for source, images in self._images.items():
+            for id, image in images.items():
+                if id == image_id:
+                    if dict_output:
+                        return image.config.dict()
+                    else:
+                        return image.config  # TODO check if this works
+
+    @property
+    def images(self) -> list[BECImageItem]:
+        """
+        Get the list of images.
+        Returns:
+            list[BECImageItem]: The list of images.
+        """
+        images = []
+        for source, images_dict in self._images.items():
+            for id, image in images_dict.items():
+                images.append(image)
+        return images
+
+    @images.setter
+    def images(self, value: dict[str, dict[str, BECImageItem]]):
+        """
+        Set the images from a dictionary.
+
+        Args:
+            value (dict[str, dict[str, BECImageItem]]): The images to set, organized by source and id.
+        """
+        self._images = value
+
+    def get_image_dict(self) -> dict[str, dict[str, BECImageItem]]:
+        """
+        Get all images.
+        Returns:
+            dict[str, dict[str, BECImageItem]]: The dictionary of images.
+        """
+        return self._images
+
+    def add_monitor_image(
+        self,
+        monitor: str,
+        color_map: Optional[str] = "magma",
+        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        downsample: Optional[bool] = True,
+        opacity: Optional[float] = 1.0,
+        vrange: Optional[tuple[int, int]] = None,
+        # post_processing: Optional[PostProcessingConfig] = None,
+        **kwargs,
+    ) -> BECImageItem:
+        image_source = "device_monitor"
+
+        image_exits = self._check_image_id(monitor, self._images)
+        if image_exits:
+            raise ValueError(
+                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,
+            color_map=color_map,
+            color_bar=color_bar,
+            downsample=downsample,
+            opacity=opacity,
+            vrange=vrange,
+            # post_processing=post_processing,
+            **kwargs,
+        )
+
+        image = self._add_image_object(source=image_source, name=monitor, config=image_config)
+        self._connect_device_monitor(monitor)
+        return image
+
+    def add_custom_image(
+        self,
+        name: str,
+        data: Optional[np.ndarray] = None,
+        color_map: Optional[str] = "magma",
+        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        downsample: Optional[bool] = True,
+        opacity: Optional[float] = 1.0,
+        vrange: Optional[tuple[int, int]] = None,
+        # post_processing: Optional[PostProcessingConfig] = None,
+        **kwargs,
+    ):
+        image_source = "device_monitor"
+
+        image_exits = self._check_curve_id(name, self._images)
+        if image_exits:
+            raise ValueError(f"Monitor with ID '{name}' already exists in widget '{self.gui_id}'.")
+
+        image_config = ImageItemConfig(
+            widget_class="BECImageItem",
+            parent_id=self.gui_id,
+            monitor=name,
+            color_map=color_map,
+            color_bar=color_bar,
+            downsample=downsample,
+            opacity=opacity,
+            vrange=vrange,
+            # post_processing=post_processing,
+            **kwargs,
+        )
+
+        image = self._add_image_object(source=image_source, config=image_config, data=data)
+        return image
+
+    def apply_setting_to_images(
+        self, setting_method_name: str, args: list, kwargs: dict, image_id: str = None
+    ):
+        """
+        Apply a setting to all images or a specific image by its ID.
+
+        Args:
+            setting_method_name (str): The name of the method to apply (e.g., 'set_color_map').
+            args (list): Positional arguments for the setting method.
+            kwargs (dict): Keyword arguments for the setting method.
+            image_id (str, optional): The ID of the specific image to apply the setting to. If None, applies to all images.
+        """
+        if image_id:
+            image = self.find_image_by_monitor(image_id)
+            if image:
+                getattr(image, setting_method_name)(*args, **kwargs)
+        else:
+            for source, images in self._images.items():
+                for _, image in images.items():
+                    getattr(image, setting_method_name)(*args, **kwargs)
+
+    def set_vrange(self, vmin: float, vmax: float, name: str = None):
+        """
+        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.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_vrange", args=[vmin, vmax], kwargs={}, image_id=name)
+
+    def set_color_map(self, cmap: str, name: str = None):
+        """
+        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.
+        """
+        self.apply_setting_to_images("set_color_map", args=[cmap], kwargs={}, image_id=name)
+
+    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.
+        """
+        self.apply_setting_to_images("set_autorange", args=[enable], kwargs={}, image_id=name)
+
+    def set_monitor(self, monitor: str, name: str = None):
+        """
+        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.
+        """
+        self.apply_setting_to_images("set_monitor", args=[monitor], kwargs={}, image_id=name)
+
+    def set_processing(self, name: str = None, **kwargs):
+        """
+        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.
+        Possible properties:
+            - fft: bool
+            - log: bool
+            - rot: int
+            - transpose: bool
+        """
+        self.apply_setting_to_images("set", args=[], kwargs=kwargs, image_id=name)
+
+    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.
+        Possible properties:
+            - downsample: bool
+            - color_map: str
+            - monitor: str
+            - opacity: float
+            - vrange: tuple[int,int]
+            - fft: bool
+            - log: bool
+            - rot: int
+            - transpose: bool
+        """
+        self.apply_setting_to_images("set", args=[], kwargs=kwargs, image_id=name)
+
+    def set_fft(self, enable: bool = False, name: str = None):
+        """
+        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.
+        """
+        self.apply_setting_to_images("set_fft", args=[enable], kwargs={}, image_id=name)
+
+    def set_log(self, enable: bool = False, name: str = None):
+        """
+        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.
+        """
+        self.apply_setting_to_images("set_log", args=[enable], kwargs={}, image_id=name)
+
+    def set_rotation(self, deg_90: int = 0, name: str = None):
+        """
+        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.
+        """
+        self.apply_setting_to_images("set_rotation", args=[deg_90], kwargs={}, image_id=name)
+
+    def set_transpose(self, enable: bool = False, name: str = None):
+        """
+        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.
+        """
+        self.apply_setting_to_images("set_transpose", args=[enable], kwargs={}, image_id=name)
+
+    def toggle_threading(self, use_threading: bool):
+        """
+        Toggle threading for the widgets postprocessing and updating.
+        Args:
+            use_threading(bool): Whether to use threading.
+        """
+        self.use_threading = use_threading
+        if self.use_threading is False and self.thread.isRunning():
+            self.cleanup()
+
+    @pyqtSlot(dict)
+    def on_image_update(self, msg: dict):
+        """
+        Update the image of the device monitor from bec.
+        Args:
+            msg(dict): The message from bec.
+        """
+        data = msg["data"]
+        device = msg["device"]
+        image_to_update = self._images["device_monitor"][device]
+        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)
+
+    @pyqtSlot(str, np.ndarray)
+    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.
+        """
+        image_to_update = self._images["device_monitor"][device]
+        image_to_update.updateImage(data, autoLevels=image_to_update.config.autorange)
+
+    def _connect_device_monitor(self, monitor: str):
+        """
+        Connect to the device monitor.
+        Args:
+            monitor(str): The name of the monitor.
+        """
+        image_item = self.find_image_by_monitor(monitor)
+        try:
+            previous_monitor = image_item.config.monitor
+        except AttributeError:
+            previous_monitor = None
+        if previous_monitor != monitor:
+            if previous_monitor:
+                self.bec_dispatcher.disconnect_slot(
+                    self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
+                )
+            if monitor:
+                self.bec_dispatcher.connect_slot(
+                    self.on_image_update, MessageEndpoints.device_monitor(monitor)
+                )
+                image_item.set_monitor(monitor)
+
+    def _add_image_object(
+        self, source: str, name: str, config: ImageItemConfig, data=None
+    ) -> BECImageItem:  # TODO fix types
+        config.parent_id = self.gui_id
+        image = BECImageItem(config=config, parent_image=self)
+        self.plot_item.addItem(image)
+        self._images[source][name] = image
+        self.config.images[name] = config
+        if data is not None:
+            image.setImage(data)
+        return image
+
+    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.
+
+        Returns:
+            bool: True if val is in the values of the dict_to_check or in the values of the nested dictionaries, False otherwise.
+        """
+        if val in dict_to_check.keys():
+            return True
+        for key in dict_to_check:
+            if isinstance(dict_to_check[key], dict):
+                if self._check_image_id(val, dict_to_check[key]):
+                    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()
+
+
+class ImageProcessor:
+    """
+    Class for processing the image data.
+    """
+
+    def __init__(self, config: ProcessingConfig = None):
+        if config is None:
+            config = ProcessingConfig()
+        self.config = config
+
+    def set_config(self, config: ProcessingConfig):
+        """
+        Set the configuration of the processor.
+        Args:
+            config(ProcessingConfig): The configuration of the processor.
+        """
+        self.config = config
+
+    def FFT(self, data: np.ndarray) -> np.ndarray:
+        """
+        Perform FFT on the data.
+        Args:
+            data(np.ndarray): The data to be processed.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        return np.abs(np.fft.fftshift(np.fft.fft2(data)))
+
+    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.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        return np.rot90(data, k=rotate_90, axes=(0, 1))
+
+    def transpose(self, data: np.ndarray) -> np.ndarray:
+        """
+        Transpose the data.
+        Args:
+            data(np.ndarray): The data to be processed.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        return np.transpose(data)
+
+    def log(self, data: np.ndarray) -> np.ndarray:
+        """
+        Perform log on the data.
+        Args:
+            data(np.ndarray): The data to be processed.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        # TODO this is not final solution -> data should stay as int16
+        data = data.astype(np.float32)
+        offset = 1e-6
+        data_offset = data + offset
+        return np.log10(data_offset)
+
+    # def center_of_mass(self, data: np.ndarray) -> tuple:  # TODO check functionality
+    #     return np.unravel_index(np.argmax(data), data.shape)
+
+    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.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        if self.config.fft:
+            data = self.FFT(data)
+        if self.config.rotation is not None:
+            data = self.rotation(data, self.config.rotation)
+        if self.config.transpose:
+            data = self.transpose(data)
+        if self.config.log:
+            data = self.log(data)
+        return data
+
+
+class ProcessorWorker(QObject):
+    """
+    Worker for processing the image data.
+    """
+
+    processed = pyqtSignal(str, np.ndarray)
+    stopRequested = pyqtSignal()
+    finished = pyqtSignal()
+
+    def __init__(self, processor):
+        super().__init__()
+        self.processor = processor
+        self._isRunning = False
+        self.stopRequested.connect(self.stop)
+
+    @pyqtSlot(str, np.ndarray)
+    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.
+        """
+        self._isRunning = True
+        processed_image = self.processor.process_image(image)
+        self._isRunning = False
+        if not self._isRunning:
+            self.processed.emit(device, processed_image)
+            self.finished.emit()
+
+    def stop(self):
+        self._isRunning = False

bec_widgets/widgets/plots/motor_map.py

@@ -0,0 +1,435 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Optional, Union
+
+import numpy as np
+import pyqtgraph as pg
+from bec_lib import MessageEndpoints
+from pydantic import Field
+from qtpy import QtCore, QtGui
+from qtpy.QtCore import Signal as pyqtSignal
+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.waveform import Signal, SignalData
+
+
+class MotorMapConfig(WidgetConfig):
+    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."
+    )  # TODO decide if useful for anything, or just keep GREYS always
+    scatter_size: Optional[int] = Field(5, description="Size of the scatter points.")
+    max_points: Optional[int] = Field(1000, description="Maximum number of points to display.")
+    num_dim_points: Optional[int] = Field(
+        100,
+        description="Number of points to dim before the color remains same for older recorded position.",
+    )
+    precision: Optional[int] = Field(2, description="Decimal precision of the motor position.")
+    background_value: Optional[int] = Field(
+        25, description="Background value of the motor map."
+    )  # TODO can be percentage from 255 calculated
+
+
+class BECMotorMap(BECPlotBase):
+    USER_ACCESS = [
+        "config_dict",
+        "change_motors",
+        "set_max_points",
+        "set_precision",
+        "set_num_dim_points",
+        "set_background_value",
+        "set_scatter_size",
+        "get_data",
+    ]
+
+    # QT Signals
+    update_signal = pyqtSignal()
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        parent_figure=None,
+        config: Optional[MotorMapConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = MotorMapConfig(widget_class=self.__class__.__name__)
+        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.motor_x = None
+        self.motor_y = None
+        self.database_buffer = {"x": [], "y": []}
+        self.plot_components = defaultdict(dict)  # container for plot components
+
+        # connect update signal to update plot
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self._update_plot
+        )
+
+    # TODO decide if needed to implement, maybe there will be no children widgets for motormap for now...
+    # 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
+
+    @pyqtSlot(str, str, str, str, bool)
+    def change_motors(
+        self,
+        motor_x: str,
+        motor_y: str,
+        motor_x_entry: str = None,
+        motor_y_entry: str = None,
+        validate_bec: bool = True,
+    ) -> None:
+        """
+        Change the active motors for the plot.
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            motor_x_entry(str): Motor entry for the X axis.
+            motor_y_entry(str): Motor entry for the Y axis.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        """
+        motor_x_entry, motor_y_entry = self._validate_signal_entries(
+            motor_x, motor_y, motor_x_entry, motor_y_entry, validate_bec
+        )
+
+        motor_x_limit = self._get_motor_limit(motor_x)
+        motor_y_limit = self._get_motor_limit(motor_y)
+
+        signal = Signal(
+            source="device_readback",
+            x=SignalData(name=motor_x, entry=motor_x_entry, limits=motor_x_limit),
+            y=SignalData(name=motor_y, entry=motor_y_entry, limits=motor_y_limit),
+        )
+        self.config.signals = signal
+
+        # reconnect the signals
+        self._connect_motor_to_slots()
+
+        # Redraw the motor map
+        self._make_motor_map()
+
+    def get_data(self) -> dict:
+        """
+        Get the data of the motor map.
+        Returns:
+            dict: Data of the motor map.
+        """
+        data = {
+            "x": self.database_buffer["x"],
+            "y": self.database_buffer["y"],
+        }
+        return data
+
+    # TODO setup all visual properties
+    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.
+        """
+        self.config.max_points = max_points
+
+    def set_precision(self, precision: int) -> None:
+        """
+        Set the decimal precision of the motor position.
+        Args:
+            precision(int): Decimal precision of the motor position.
+        """
+        self.config.precision = precision
+
+    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.
+        """
+        self.config.num_dim_points = num_dim_points
+
+    def set_background_value(self, background_value: int) -> None:
+        """
+        Set the background value of the motor map.
+        Args:
+            background_value(int): Background value of the motor map.
+        """
+        self.config.background_value = background_value
+
+    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."""
+        if self.motor_x is not None and self.motor_y is not None:
+            old_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.motor_x = self.config.signals.x.name
+        self.motor_y = self.config.signals.y.name
+
+        endpoints = [
+            MessageEndpoints.device_readback(self.motor_x),
+            MessageEndpoints.device_readback(self.motor_y),
+        ]
+
+        self.bec_dispatcher.connect_slot(self.on_device_readback, endpoints)
+
+    def _make_motor_map(self):
+        """
+        Create the motor map plot.
+        """
+        # Create limit map
+        motor_x_limit = self.config.signals.x.limits
+        motor_y_limit = self.config.signals.y.limits
+        self.plot_components["limit_map"] = self._make_limit_map(motor_x_limit, motor_y_limit)
+        self.plot_item.addItem(self.plot_components["limit_map"])
+        self.plot_components["limit_map"].setZValue(-1)
+
+        # Create scatter plot
+        scatter_size = self.config.scatter_size
+        self.plot_components["scatter"] = pg.ScatterPlotItem(
+            size=scatter_size, brush=pg.mkBrush(255, 255, 255, 255)
+        )
+        self.plot_item.addItem(self.plot_components["scatter"])
+        self.plot_components["scatter"].setZValue(0)
+
+        # Enable Grid
+        self.set_grid(True, True)
+
+        # Add the crosshair for initial motor coordinates
+        initial_position_x = self._get_motor_init_position(
+            self.motor_x, self.config.signals.x.entry, self.config.precision
+        )
+        initial_position_y = self._get_motor_init_position(
+            self.motor_y, self.config.signals.y.entry, self.config.precision
+        )
+
+        self.database_buffer["x"] = [initial_position_x]
+        self.database_buffer["y"] = [initial_position_y]
+
+        self.plot_components["scatter"].setData([initial_position_x], [initial_position_y])
+        self._add_coordinantes_crosshair(initial_position_x, initial_position_y)
+
+        # Set default labels for the plot
+        self.set(x_label=f"Motor X ({self.motor_x})", y_label=f"Motor Y ({self.motor_y})")
+
+    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.
+        """
+
+        # Crosshair to highlight the current position
+        highlight_H = pg.InfiniteLine(
+            angle=0, movable=False, pen=pg.mkPen(color="r", width=1, style=QtCore.Qt.DashLine)
+        )
+        highlight_V = pg.InfiniteLine(
+            angle=90, movable=False, pen=pg.mkPen(color="r", width=1, style=QtCore.Qt.DashLine)
+        )
+
+        # Add crosshair to the curve list for future referencing
+        self.plot_components["highlight_H"] = highlight_H
+        self.plot_components["highlight_V"] = highlight_V
+
+        # Add crosshair to the plot
+        self.plot_item.addItem(highlight_H)
+        self.plot_item.addItem(highlight_V)
+
+        highlight_V.setPos(x)
+        highlight_H.setPos(y)
+
+    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.
+
+        Returns:
+            pg.ImageItem: Limit map.
+        """
+        limit_x_min, limit_x_max = limits_x
+        limit_y_min, limit_y_max = limits_y
+
+        map_width = int(limit_x_max - limit_x_min + 1)
+        map_height = int(limit_y_max - limit_y_min + 1)
+
+        # Create limits map
+        background_value = self.config.background_value
+        limit_map_data = np.full((map_width, map_height), background_value, dtype=np.float32)
+        limit_map = pg.ImageItem()
+        limit_map.setImage(limit_map_data)
+
+        # Translate and scale the image item to match the motor coordinates
+        tr = QtGui.QTransform()
+        tr.translate(limit_x_min, limit_y_min)
+        limit_map.setTransform(tr)
+
+        return limit_map
+
+    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.
+        """
+        init_position = round(self.dev[name].read()[entry]["value"], precision)
+        return init_position
+
+    def _validate_signal_entries(
+        self,
+        x_name: str,
+        y_name: str,
+        x_entry: str | None,
+        y_entry: str | None,
+        validate_bec: bool = True,
+    ) -> 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.
+        """
+        if validate_bec:
+            x_entry = self.entry_validator.validate_signal(x_name, x_entry)
+            y_entry = self.entry_validator.validate_signal(y_name, y_entry)
+        else:
+            x_entry = x_name if x_entry is None else x_entry
+            y_entry = y_name if y_entry is None else y_entry
+        return x_entry, y_entry
+
+    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.
+
+        Returns:
+            float: Motor limit.
+        """
+        try:
+            limits = self.dev[motor].limits
+            if limits == [0, 0]:
+                return None
+            return limits
+        except AttributeError:  # TODO maybe not needed, if no limits it returns [0,0]
+            # If the motor doesn't have a 'limits' attribute, return a default value or raise a custom exception
+            print(f"The device '{motor}' does not have defined limits.")
+            return None
+
+    def _update_plot(self):
+        """Update the motor map plot."""
+        x = self.database_buffer["x"]
+        y = self.database_buffer["y"]
+
+        # Setup gradient brush for history
+        brushes = [pg.mkBrush(50, 50, 50, 255)] * len(x)
+
+        # Calculate the decrement step based on self.num_dim_points
+        num_dim_points = self.config.num_dim_points
+        decrement_step = (255 - 50) / num_dim_points
+        for i in range(1, min(num_dim_points + 1, len(x) + 1)):
+            brightness = max(60, 255 - decrement_step * (i - 1))
+            brushes[-i] = pg.mkBrush(brightness, brightness, brightness, 255)
+        brushes[-1] = pg.mkBrush(255, 255, 255, 255)  # Newest point is always full brightness
+        scatter_size = self.config.scatter_size
+
+        # Update the scatter plot
+        self.plot_components["scatter"].setData(
+            x=x,
+            y=y,
+            brush=brushes,
+            pen=None,
+            size=scatter_size,
+        )
+
+        # Get last know position for crosshair
+        current_x = x[-1]
+        current_y = y[-1]
+
+        # Update the crosshair
+        self.plot_components["highlight_V"].setPos(current_x)
+        self.plot_components["highlight_H"].setPos(current_y)
+
+        # TODO not update title but some label
+        # Update plot title
+        precision = self.config.precision
+        self.set_title(
+            f"Motor position: ({round(current_x,precision)}, {round(current_y,precision)})"
+        )
+
+    @pyqtSlot(dict)
+    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.
+        """
+        if self.motor_x is None or self.motor_y is None:
+            return
+
+        if self.motor_x in msg["signals"]:
+            x = msg["signals"][self.motor_x]["value"]
+            self.database_buffer["x"].append(x)
+            self.database_buffer["y"].append(self.database_buffer["y"][-1])
+
+        elif self.motor_y in msg["signals"]:
+            y = msg["signals"][self.motor_y]["value"]
+            self.database_buffer["y"].append(y)
+            self.database_buffer["x"].append(self.database_buffer["x"][-1])
+
+        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_())

bec_widgets/widgets/plots/plot_base.py

@@ -4,7 +4,6 @@ from typing import Literal, Optional
 
 import numpy as np
 import pyqtgraph as pg
-
 from pydantic import BaseModel, Field
 from qtpy.QtWidgets import QWidget
 
@@ -36,8 +35,9 @@ class WidgetConfig(ConnectionConfig):
     )
 
 
-class BECPlotBase(BECConnector, pg.PlotItem):
+class BECPlotBase(BECConnector, pg.GraphicsLayout):
     USER_ACCESS = [
+        "config_dict",
         "set",
         "set_title",
         "set_x_label",
@@ -47,7 +47,8 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         "set_x_lim",
         "set_y_lim",
         "set_grid",
-        "plot_data",
+        "lock_aspect_ratio",
+        "plot",
         "remove",
     ]
 
@@ -62,9 +63,10 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         if config is None:
             config = WidgetConfig(widget_class=self.__class__.__name__)
         super().__init__(client=client, config=config, gui_id=gui_id)
-        pg.PlotItem.__init__(self, parent)
+        pg.GraphicsLayout.__init__(self, parent)
 
         self.figure = parent_figure
+        self.plot_item = self.addPlot(row=0, col=0)
 
         self.add_legend()
 
@@ -118,7 +120,7 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         Args:
             title(str): Title of the plot widget.
         """
-        self.setTitle(title)
+        self.plot_item.setTitle(title)
         self.config.axis.title = title
 
     def set_x_label(self, label: str):
@@ -127,7 +129,7 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         Args:
             label(str): Label of the x-axis.
         """
-        self.setLabel("bottom", label)
+        self.plot_item.setLabel("bottom", label)
         self.config.axis.x_label = label
 
     def set_y_label(self, label: str):
@@ -136,7 +138,7 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         Args:
             label(str): Label of the y-axis.
         """
-        self.setLabel("left", label)
+        self.plot_item.setLabel("left", label)
         self.config.axis.y_label = label
 
     def set_x_scale(self, scale: Literal["linear", "log"] = "linear"):
@@ -145,7 +147,7 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         Args:
             scale(Literal["linear", "log"]): Scale of the x-axis.
         """
-        self.setLogMode(x=(scale == "log"))
+        self.plot_item.setLogMode(x=(scale == "log"))
         self.config.axis.x_scale = scale
 
     def set_y_scale(self, scale: Literal["linear", "log"] = "linear"):
@@ -154,7 +156,7 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         Args:
             scale(Literal["linear", "log"]): Scale of the y-axis.
         """
-        self.setLogMode(y=(scale == "log"))
+        self.plot_item.setLogMode(y=(scale == "log"))
         self.config.axis.y_scale = scale
 
     def set_x_lim(self, *args) -> None:
@@ -177,7 +179,7 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         else:
             raise ValueError("set_x_lim expects either two separate arguments or a single tuple")
 
-        self.setXRange(x_min, x_max)
+        self.plot_item.setXRange(x_min, x_max)
         self.config.axis.x_lim = (x_min, x_max)
 
     def set_y_lim(self, *args) -> None:
@@ -200,7 +202,7 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         else:
             raise ValueError("set_y_lim expects either two separate arguments or a single tuple")
 
-        self.setYRange(y_min, y_max)
+        self.plot_item.setYRange(y_min, y_max)
         self.config.axis.y_lim = (y_min, y_max)
 
     def set_grid(self, x: bool = False, y: bool = False):
@@ -210,14 +212,23 @@ class BECPlotBase(BECConnector, pg.PlotItem):
             x(bool): Show grid on the x-axis.
             y(bool): Show grid on the y-axis.
         """
-        self.showGrid(x, y)
+        self.plot_item.showGrid(x, y)
         self.config.axis.x_grid = x
         self.config.axis.y_grid = y
 
     def add_legend(self):
-        self.addLegend()
+        """Add legend to the plot"""
+        self.plot_item.addLegend()
 
-    def plot_data(self, data_x: list | np.ndarray, data_y: list | np.ndarray, **kwargs):
+    def lock_aspect_ratio(self, lock):
+        """
+        Lock aspect ratio.
+        Args:
+            lock(bool): True to lock, False to unlock.
+        """
+        self.plot_item.setAspectLocked(lock)
+
+    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:
@@ -227,7 +238,7 @@ class BECPlotBase(BECConnector, pg.PlotItem):
         """
         # TODO very basic so far, add more options
         # TODO decide name of the method
-        self.plot(data_x, data_y, **kwargs)
+        self.plot_item.plot(data_x, data_y, **kwargs)
 
     def remove(self):
         """Remove the plot widget from the figure."""

bec_widgets/widgets/plots/waveform.py

@@ -1,39 +1,40 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Literal, Optional, Any
+from typing import Any, Literal, Optional
 
 import numpy as np
 import pyqtgraph as pg
-from pydantic import Field, BaseModel, ValidationError
+from bec_lib import MessageEndpoints
+from bec_lib.scan_data import ScanData
+from pydantic import BaseModel, Field, ValidationError
 from pyqtgraph import mkBrush
 from qtpy import QtCore
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
 
-from bec_lib import MessageEndpoints
-from bec_lib.scan_data import ScanData
-from bec_widgets.utils import Colors, ConnectionConfig, BECConnector, EntryValidator
-from bec_widgets.widgets.plots import BECPlotBase, WidgetConfig
+from bec_widgets.utils import BECConnector, Colors, ConnectionConfig, EntryValidator
+from bec_widgets.widgets.plots.plot_base import BECPlotBase, WidgetConfig
 
 
 class SignalData(BaseModel):
     """The data configuration of a signal in the 1D waveform widget for x and y axis."""
 
-    # TODO add validator on name and entry
     name: str
     entry: str
     unit: Optional[str] = None  # todo implement later
     modifier: Optional[str] = None  # todo implement later
+    limits: Optional[list[float]] = None  # todo implement later
 
 
 class Signal(BaseModel):
     """The configuration of a signal in the 1D waveform widget."""
 
-    source: str  # TODO add validator on the source type
-    x: SignalData
+    source: str
+    x: SignalData  # TODO maybe add metadata for config gui later
     y: SignalData
+    z: Optional[SignalData] = None
 
 
 class CurveConfig(ConnectionConfig):
@@ -47,16 +48,15 @@ class CurveConfig(ConnectionConfig):
     pen_style: Optional[Literal["solid", "dash", "dot", "dashdot"]] = Field(
         "solid", description="The style of the pen of the curve."
     )
-    source: Optional[str] = Field(
-        None, description="The source of the curve."
-    )  # TODO here on or curve??
+    source: Optional[str] = Field(None, description="The source of the curve.")
     signals: Optional[Signal] = Field(None, description="The signal of the curve.")
+    colormap: Optional[str] = Field("plasma", description="The colormap of the curves z gradient.")
 
 
 class Waveform1DConfig(WidgetConfig):
     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
     curves: dict[str, CurveConfig] = Field(
         {}, description="The list of curves to be added to the 1D waveform widget."
     )
@@ -64,9 +64,11 @@ class Waveform1DConfig(WidgetConfig):
 
 class BECCurve(BECConnector, pg.PlotDataItem):
     USER_ACCESS = [
+        "config_dict",
         "set",
         "set_data",
         "set_color",
+        "set_colormap",
         "set_symbol",
         "set_symbol_color",
         "set_symbol_size",
@@ -137,6 +139,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         # Mapping of keywords to setter methods
         method_map = {
             "color": self.set_color,
+            "colormap": self.set_colormap,
             "symbol": self.set_symbol,
             "symbol_color": self.set_symbol_color,
             "symbol_size": self.set_symbol_size,
@@ -205,6 +208,14 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         self.config.pen_style = pen_style
         self.apply_config()
 
+    def set_colormap(self, colormap: str):
+        """
+        Set the colormap for the scatter plot z gradient.
+        Args:
+            colormap(str): Colormap for the scatter plot.
+        """
+        self.config.colormap = colormap
+
     def get_data(self) -> tuple[np.ndarray, np.ndarray]:
         """
         Get the data of the curve.
@@ -215,18 +226,30 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         return x_data, y_data
 
 
-class BECWaveform1D(BECPlotBase):
+class BECWaveform(BECPlotBase):
     USER_ACCESS = [
+        "config_dict",
         "add_curve_scan",
         "add_curve_custom",
         "remove_curve",
         "scan_history",
         "curves",
-        "curves_data",
         "get_curve",
         "get_curve_config",
         "apply_config",
         "get_all_data",
+        "set",
+        "set_title",
+        "set_x_label",
+        "set_y_label",
+        "set_x_scale",
+        "set_y_scale",
+        "set_x_lim",
+        "set_y_lim",
+        "set_grid",
+        "lock_aspect_ratio",
+        "plot",
+        "remove",
     ]
     scan_signal_update = pyqtSignal()
 
@@ -244,8 +267,8 @@ class BECWaveform1D(BECPlotBase):
             parent=parent, parent_figure=parent_figure, config=config, client=client, gui_id=gui_id
         )
 
-        self.curves_data = defaultdict(dict)
-        self.scanID = None
+        self._curves_data = defaultdict(dict)
+        self.scan_id = None
 
         # Scan segment update proxy
         self.proxy_update_plot = pg.SignalProxy(
@@ -260,15 +283,19 @@ class BECWaveform1D(BECPlotBase):
 
         self.entry_validator = EntryValidator(self.dev)
 
-        self.addLegend()
+        self.add_legend()
         self.apply_config(self.config)
 
-    # TODO check config assigning
-    # TODO check the functionality of config generator
-    def find_widget_by_id(
-        self, item_id: str
-    ):  # TODO implement this on level of BECConnector and all other widgets
-        for curve in self.curves:
+    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
 
@@ -287,12 +314,12 @@ class BECWaveform1D(BECPlotBase):
                 return
 
         self.config = config
-        self.clear()
+        self.plot_item.clear()  # TODO not sure if on the plot or layout level
 
         self.apply_axis_config()
         # Reset curves
         self._curves_data = defaultdict(dict)
-        self._curves = []
+        self._curves = self.plot_item.curves
         for curve_id, curve_config in self.config.curves.items():
             self.add_curve_by_config(curve_config)
         if replot_last_scan:
@@ -335,7 +362,7 @@ class BECWaveform1D(BECPlotBase):
         Returns:
             CurveConfig|dict: Configuration of the curve.
         """
-        for source, curves in self.curves_data.items():
+        for source, curves in self._curves_data.items():
             if curve_id in curves:
                 if dict_output:
                     return curves[curve_id].config.model_dump()
@@ -343,7 +370,7 @@ class BECWaveform1D(BECPlotBase):
                     return curves[curve_id].config
 
     @property
-    def curves(self) -> list[BECCurve]:  # TODO discuss if it should be marked as @property for RPC
+    def curves(self) -> list[BECCurve]:
         """
         Get the curves of the plot widget as a list
         Returns:
@@ -355,19 +382,6 @@ class BECWaveform1D(BECPlotBase):
     def curves(self, value: list[BECCurve]):
         self._curves = value
 
-    @property
-    def curves_data(self) -> dict:  # TODO discuss if it should be marked as @property for RPC
-        """
-        Get the curves data of the plot widget as a dictionary
-        Returns:
-            dict: Dictionary of curves data.
-        """
-        return self._curves_data
-
-    @curves_data.setter
-    def curves_data(self, value: dict):
-        self._curves_data = value
-
     def get_curve(self, identifier) -> BECCurve:
         """
         Get the curve by its index or ID.
@@ -377,9 +391,9 @@ class BECWaveform1D(BECPlotBase):
             BECCurve: The curve object.
         """
         if isinstance(identifier, int):
-            return self.curves[identifier]
+            return self.plot_item.curves[identifier]
         elif isinstance(identifier, str):
-            for source_type, curves in self.curves_data.items():
+            for source_type, curves in self._curves_data.items():
                 if identifier in curves:
                     return curves[identifier]
             raise ValueError(f"Curve with ID '{identifier}' not found.")
@@ -407,9 +421,9 @@ class BECWaveform1D(BECPlotBase):
             BECCurve: The curve object.
         """
         curve_source = "custom"
-        curve_id = label or f"Curve {len(self.curves) + 1}"
+        curve_id = label or f"Curve {len(self.plot_item.curves) + 1}"
 
-        curve_exits = self._check_curve_id(curve_id, self.curves_data)
+        curve_exits = self._check_curve_id(curve_id, self._curves_data)
         if curve_exits:
             raise ValueError(
                 f"Curve with ID '{curve_id}' already exists in widget '{self.gui_id}'."
@@ -418,7 +432,7 @@ class BECWaveform1D(BECPlotBase):
         color = (
             color
             or Colors.golden_angle_color(
-                colormap=self.config.color_palette, num=len(self.curves) + 1, format="HEX"
+                colormap=self.config.color_palette, num=len(self.plot_item.curves) + 1, format="HEX"
             )[-1]
         )
 
@@ -455,8 +469,8 @@ class BECWaveform1D(BECPlotBase):
             BECCurve: The curve object.
         """
         curve = BECCurve(config=config, name=name)
-        self.curves_data[source][name] = curve
-        self.addItem(curve)
+        self._curves_data[source][name] = curve
+        self.plot_item.addItem(curve)
         self.config.curves[name] = curve.config
         if data is not None:
             curve.setData(data[0], data[1])
@@ -466,9 +480,12 @@ class BECWaveform1D(BECPlotBase):
         self,
         x_name: str,
         y_name: str,
+        z_name: Optional[str] = None,
         x_entry: Optional[str] = None,
         y_entry: Optional[str] = None,
+        z_entry: Optional[str] = None,
         color: Optional[str] = None,
+        color_map_z: Optional[str] = "plasma",
         label: Optional[str] = None,
         validate_bec: bool = True,
         **kwargs,
@@ -480,7 +497,10 @@ class BECWaveform1D(BECPlotBase):
             x_entry(str): Entry of the x signal.
             y_name(str): Name of the y signal.
             y_entry(str): Entry of the y signal.
+            z_name(str): Name of the z signal.
+            z_entry(str): Entry of the z signal.
             color(str, optional): Color of the curve. Defaults to None.
+            color_map_z(str): The color map to use for the z-axis.
             label(str, optional): Label of the curve. Defaults to None.
             **kwargs: Additional keyword arguments for the curve configuration.
 
@@ -491,20 +511,23 @@ class BECWaveform1D(BECPlotBase):
         curve_source = "scan_segment"
 
         # Get entry if not provided and validate
-        x_entry, y_entry = self._validate_signal_entries(
-            x_name, y_name, x_entry, y_entry, validate_bec
+        x_entry, y_entry, z_entry = self._validate_signal_entries(
+            x_name, y_name, z_name, x_entry, y_entry, z_entry, validate_bec
         )
 
-        label = label or f"{y_name}-{y_entry}"
+        if z_name is not None and z_entry is not None:
+            label = label or f"{z_name}-{z_entry}"
+        else:
+            label = label or f"{y_name}-{y_entry}"
 
-        curve_exits = self._check_curve_id(label, self.curves_data)
+        curve_exits = self._check_curve_id(label, self._curves_data)
         if curve_exits:
             raise ValueError(f"Curve with ID '{label}' already exists in widget '{self.gui_id}'.")
 
         color = (
             color
             or Colors.golden_angle_color(
-                colormap=self.config.color_palette, num=len(self.curves) + 1, format="HEX"
+                colormap=self.config.color_palette, num=len(self.plot_item.curves) + 1, format="HEX"
             )[-1]
         )
 
@@ -514,11 +537,13 @@ class BECWaveform1D(BECPlotBase):
             parent_id=self.gui_id,
             label=label,
             color=color,
+            color_map=color_map_z,
             source=curve_source,
             signals=Signal(
                 source=curve_source,
                 x=SignalData(name=x_name, entry=x_entry),
                 y=SignalData(name=y_name, entry=y_entry),
+                z=SignalData(name=z_name, entry=z_entry) if z_name else None,
             ),
             **kwargs,
         )
@@ -529,28 +554,35 @@ class BECWaveform1D(BECPlotBase):
         self,
         x_name: str,
         y_name: str,
+        z_name: str | None,
         x_entry: str | None,
         y_entry: str | None,
+        z_entry: str | None,
         validate_bec: bool = True,
-    ) -> tuple[str, str]:
+    ) -> 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.
+            z_name(str): Name of the z signal.
             x_entry(str|None): Entry of the x signal.
             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]: Validated x and y entries.
+            tuple[str,str,str|None]: Validated x, y, z entries.
         """
         if validate_bec:
             x_entry = self.entry_validator.validate_signal(x_name, x_entry)
             y_entry = self.entry_validator.validate_signal(y_name, y_entry)
+            if z_name:
+                z_entry = self.entry_validator.validate_signal(z_name, z_entry)
         else:
             x_entry = x_name if x_entry is None else x_entry
             y_entry = y_name if y_entry is None else y_entry
-        return x_entry, y_entry
+            z_entry = z_name if z_entry is None else z_entry
+        return x_entry, y_entry, z_entry
 
     def _check_curve_id(self, val: Any, dict_to_check: dict) -> bool:
         """
@@ -592,13 +624,13 @@ class BECWaveform1D(BECPlotBase):
         Args:
             curve_id(str): ID of the curve to be removed.
         """
-        for source, curves in self.curves_data.items():
+        for source, curves in self._curves_data.items():
             if curve_id in curves:
                 curve = curves.pop(curve_id)
-                self.removeItem(curve)
+                self.plot_item.removeItem(curve)
                 del self.config.curves[curve_id]
-                if curve in self.curves:
-                    self.curves.remove(curve)
+                if curve in self.plot_item.curves:
+                    self.plot_item.curves.remove(curve)
                 return
         raise KeyError(f"Curve with ID '{curve_id}' not found.")
 
@@ -608,13 +640,13 @@ class BECWaveform1D(BECPlotBase):
         Args:
             N(int): Order of the curve to be removed.
         """
-        if N < len(self.curves):
-            curve = self.curves[N]
+        if N < len(self.plot_item.curves):
+            curve = self.plot_item.curves[N]
             curve_id = curve.name()  # Assuming curve's name is used as its ID
-            self.removeItem(curve)
+            self.plot_item.removeItem(curve)
             del self.config.curves[curve_id]
             # Remove from self.curve_data
-            for source, curves in self.curves_data.items():
+            for source, curves in self._curves_data.items():
                 if curve_id in curves:
                     del curves[curve_id]
                     break
@@ -630,14 +662,14 @@ class BECWaveform1D(BECPlotBase):
             msg (dict): Message received with scan data.
             metadata (dict): Metadata of the scan.
         """
-        current_scanID = msg.get("scanID", None)
-        if current_scanID is None:
+        current_scan_id = msg.get("scan_id", None)
+        if current_scan_id is None:
             return
 
-        if current_scanID != self.scanID:
-            self.scanID = current_scanID
+        if current_scan_id != self.scan_id:
+            self.scan_id = current_scan_id
             self.scan_segment_data = self.queue.scan_storage.find_scan_by_ID(
-                self.scanID
+                self.scan_id
             )  # TODO do scan access through BECFigure
 
         self.scan_signal_update.emit()
@@ -653,37 +685,72 @@ class BECWaveform1D(BECPlotBase):
         Args:
             data(ScanData): Data from the scan segment.
         """
-        for curve_id, curve in self.curves_data["scan_segment"].items():
+        data_x = None
+        data_y = None
+        data_z = None
+        for curve_id, curve in self._curves_data["scan_segment"].items():
             x_name = curve.config.signals.x.name
             x_entry = curve.config.signals.x.entry
             y_name = curve.config.signals.y.name
             y_entry = curve.config.signals.y.entry
+            if curve.config.signals.z:
+                z_name = curve.config.signals.z.name
+                z_entry = curve.config.signals.z.entry
 
             try:
                 data_x = data[x_name][x_entry].val
                 data_y = data[y_name][y_entry].val
+                if curve.config.signals.z:
+                    data_z = data[z_name][z_entry].val
+                    color_z = self._make_z_gradient(
+                        data_z, curve.config.colormap
+                    )  # TODO decide how to implement custom gradient
             except TypeError:
                 continue
 
-            curve.setData(data_x, data_y)
+            if data_z is not None and color_z is not None:
+                curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+            else:
+                curve.setData(data_x, data_y)
 
-    def scan_history(self, scan_index: int = None, scanID: str = None):
+    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.
+
+        Returns:
+            list: List of colors for the z values.
+        """
+        # Normalize z_values for color mapping
+        z_min, z_max = np.min(data_z), np.max(data_z)
+
+        if z_max != z_min:  # Ensure that there is a range in the z values
+            z_values_norm = (data_z - z_min) / (z_max - z_min)
+            colormap = pg.colormap.get(colormap)  # using colormap from global settings
+            colors = [colormap.map(z, mode="qcolor") for z in z_values_norm]
+            return colors
+        else:
+            return None
+
+    def scan_history(self, scan_index: int = None, scan_id: str = None):
         """
         Update the scan curves with the data from the scan storage.
-        Provide only one of scanID or scan_index.
+        Provide only one of scan_id or scan_index.
         Args:
-            scanID(str, optional): ScanID of the scan to be updated. Defaults to None.
+            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.
         """
-        if scan_index is not None and scanID is not None:
-            raise ValueError("Only one of scanID or scan_index can be provided.")
+        if scan_index is not None and scan_id is not None:
+            raise ValueError("Only one of scan_id or scan_index can be provided.")
 
         if scan_index is not None:
-            self.scanID = self.queue.scan_storage.storage[scan_index].scanID
-            data = self.queue.scan_storage.find_scan_by_ID(self.scanID).data
-        elif scanID is not None:
-            self.scanID = scanID
-            data = self.queue.scan_storage.find_scan_by_ID(self.scanID).data
+            self.scan_id = self.queue.scan_storage.storage[scan_index].scan_id
+            data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data
+        elif scan_id is not None:
+            self.scan_id = scan_id
+            data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data
 
         self._update_scan_curves(data)
 
@@ -709,7 +776,7 @@ class BECWaveform1D(BECPlotBase):
                 )
                 output = "dict"
 
-        for curve in self.curves:
+        for curve in self.plot_item.curves:
             x_data, y_data = curve.get_data()
             if x_data is not None or y_data is not None:
                 if output == "dict":
@@ -719,9 +786,9 @@ class BECWaveform1D(BECPlotBase):
 
         if output == "pandas" and pd is not None:
             combined_data = pd.concat(
-                [data[curve.name()] for curve in self.curves],
+                [data[curve.name()] for curve in self.plot_item.curves],
                 axis=1,
-                keys=[curve.name() for curve in self.curves],
+                keys=[curve.name() for curve in self.plot_item.curves],
             )
             return combined_data
         return data

bec_widgets/widgets/scan_control/scan_control.py

@@ -1,28 +1,28 @@
 import msgpack
+from bec_lib import MessageEndpoints
 from qtpy.QtWidgets import (
     QApplication,
-    QWidget,
-    QComboBox,
-    QPushButton,
-    QVBoxLayout,
-    QGroupBox,
-    QLabel,
-    QLineEdit,
-    QDoubleSpinBox,
-    QSpinBox,
     QCheckBox,
+    QComboBox,
+    QDoubleSpinBox,
     QFrame,
-    QHBoxLayout,
-    QLayout,
     QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLayout,
+    QLineEdit,
+    QPushButton,
+    QSpinBox,
     QTableWidget,
     QTableWidgetItem,
-    QHeaderView,
+    QVBoxLayout,
+    QWidget,
 )
 
-from bec_lib import MessageEndpoints
-from bec_widgets.utils.widget_io import WidgetIO
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.utils.widget_io import WidgetIO
 
 
 class ScanArgType:

bec_widgets/widgets/scan_plot/scan2d_plot.py

@@ -1,152 +0,0 @@
-from threading import RLock
-
-import numpy as np
-import pyqtgraph as pg
-from bec_lib import MessageEndpoints
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property as pyqtProperty, Slot as pyqtSlot
-
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-logger = bec_logger.logger
-
-
-pg.setConfigOptions(background="w", foreground="k", antialias=True)
-
-
-class BECScanPlot2D(pg.GraphicsView):
-    def __init__(self, parent=None, background="default"):
-        super().__init__(parent, background)
-        BECDispatcher().connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
-
-        self._scanID = None
-        self._scanID_lock = RLock()
-
-        self._x_channel = ""
-        self._y_channel = ""
-        self._z_channel = ""
-
-        self._xpos = []
-        self._ypos = []
-
-        self._x_ind = None
-        self._y_ind = None
-
-        self.plot_item = pg.PlotItem()
-        self.setCentralItem(self.plot_item)
-        self.plot_item.setAspectLocked(True)
-
-        self.imageItem = pg.ImageItem()
-        self.plot_item.addItem(self.imageItem)
-
-    def reset_plots(self, _scan_segment, metadata):
-        # TODO: Do we reset in case of a scan type change?
-        self.imageItem.clear()
-
-        # TODO: better to check the number of coordinates in metadata["positions"]?
-        if metadata["scan_name"] != "grid_scan":
-            return
-
-        positions = [sorted(set(pos)) for pos in zip(*metadata["positions"])]
-
-        motors = metadata["scan_motors"]
-        if self.x_channel and self.y_channel:
-            self._x_ind = motors.index(self.x_channel) if self.x_channel in motors else None
-            self._y_ind = motors.index(self.y_channel) if self.y_channel in motors else None
-        elif not self.x_channel and not self.y_channel:
-            # Plot the first and second motors along x and y axes respectively
-            self._x_ind = 0
-            self._y_ind = 1
-        else:
-            logger.warning(
-                f"X and Y channels should be either both empty or both set in {self.objectName()}"
-            )
-
-        if self._x_ind is None or self._y_ind is None:
-            return
-
-        xpos = positions[self._x_ind]
-        ypos = positions[self._y_ind]
-
-        self._xpos = xpos
-        self._ypos = ypos
-
-        self.imageItem.setImage(np.zeros(shape=(len(xpos), len(ypos))))
-
-        w = max(xpos) - min(xpos)
-        h = max(ypos) - min(ypos)
-        w_pix = w / (len(xpos) - 1)
-        h_pix = h / (len(ypos) - 1)
-        self.imageItem.setRect(min(xpos) - w_pix / 2, min(ypos) - h_pix / 2, w + w_pix, h + h_pix)
-
-        self.plot_item.setLabel("bottom", motors[self._x_ind])
-        self.plot_item.setLabel("left", motors[self._y_ind])
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, scan_segment, metadata):
-        # reset plots on scanID change
-        with self._scanID_lock:
-            scan_id = scan_segment["scanID"]
-            if self._scanID != scan_id:
-                self._scanID = scan_id
-                self.reset_plots(scan_segment, metadata)
-
-        if not self.z_channel or metadata["scan_name"] != "grid_scan":
-            return
-
-        if self._x_ind is None or self._y_ind is None:
-            return
-
-        point_coord = metadata["positions"][scan_segment["point_id"]]
-
-        x_coord_ind = self._xpos.index(point_coord[self._x_ind])
-        y_coord_ind = self._ypos.index(point_coord[self._y_ind])
-
-        data = scan_segment["data"]
-        z_new = data[self.z_channel][self.z_channel]["value"]
-
-        image = self.imageItem.image
-        image[x_coord_ind, y_coord_ind] = z_new
-        self.imageItem.setImage()
-
-    @pyqtProperty(str)
-    def x_channel(self):
-        return self._x_channel
-
-    @x_channel.setter
-    def x_channel(self, new_val):
-        self._x_channel = new_val
-        self.plot_item.setLabel("bottom", new_val)
-
-    @pyqtProperty(str)
-    def y_channel(self):
-        return self._y_channel
-
-    @y_channel.setter
-    def y_channel(self, new_val):
-        self._y_channel = new_val
-        self.plot_item.setLabel("left", new_val)
-
-    @pyqtProperty(str)
-    def z_channel(self):
-        return self._z_channel
-
-    @z_channel.setter
-    def z_channel(self, new_val):
-        self._z_channel = new_val
-
-
-if __name__ == "__main__":
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-
-    plot = BECScanPlot2D()
-    # If x_channel and y_channel are both omitted, they will be inferred from each running grid scan
-    plot.z_channel = "bpm3y"
-
-    plot.show()
-
-    sys.exit(app.exec())

bec_widgets/widgets/scan_plot/scan_plot.py

@@ -1,152 +0,0 @@
-import itertools
-from threading import RLock
-
-import pyqtgraph as pg
-from bec_lib import MessageEndpoints
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property as pyqtProperty, Slot as pyqtSlot
-
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-logger = bec_logger.logger
-
-
-pg.setConfigOptions(background="w", foreground="k", antialias=True)
-COLORS = ["#fd7f6f", "#7eb0d5", "#b2e061", "#bd7ebe", "#ffb55a"]
-
-
-class BECScanPlot(pg.GraphicsView):
-    def __init__(self, parent=None, background="default"):
-        super().__init__(parent, background)
-        BECDispatcher().connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
-
-        self.view = pg.PlotItem()
-        self.setCentralItem(self.view)
-
-        self._scanID = None
-        self._scanID_lock = RLock()
-
-        self._x_channel = ""
-        self._y_channel_list = []
-
-        self.scan_curves = {}
-        self.dap_curves = {}
-
-    def reset_plots(self, _scan_segment, _metadata):
-        for plot_curve in {**self.scan_curves, **self.dap_curves}.values():
-            plot_curve.setData(x=[], y=[])
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, scan_segment, metadata):
-        # reset plots on scanID change
-        with self._scanID_lock:
-            scan_id = scan_segment["scanID"]
-            if self._scanID != scan_id:
-                self._scanID = scan_id
-                self.reset_plots(scan_segment, metadata)
-
-        if not self.x_channel:
-            return
-
-        data = scan_segment["data"]
-
-        if self.x_channel not in data:
-            logger.warning(f"Unknown channel `{self.x_channel}` for X data in {self.objectName()}")
-            return
-
-        x_new = data[self.x_channel][self.x_channel]["value"]
-        for chan, plot_curve in self.scan_curves.items():
-            if not chan:
-                continue
-
-            if chan not in data:
-                logger.warning(f"Unknown channel `{chan}` for Y data in {self.objectName()}")
-                continue
-
-            y_new = data[chan][chan]["value"]
-            x, y = plot_curve.getData()  # TODO: is it a good approach?
-            if x is None:
-                x = []
-            if y is None:
-                y = []
-
-            plot_curve.setData(x=[*x, x_new], y=[*y, y_new])
-
-    @pyqtSlot(dict, dict)
-    def redraw_dap(self, content, _metadata):
-        data = content["data"]
-        for chan, plot_curve in self.dap_curves.items():
-            if not chan:
-                continue
-
-            if chan not in data:
-                logger.warning(f"Unknown channel `{chan}` for DAP data in {self.objectName()}")
-                continue
-
-            x_new = data[chan]["x"]
-            y_new = data[chan]["y"]
-
-            plot_curve.setData(x=x_new, y=y_new)
-
-    @pyqtProperty("QStringList")
-    def y_channel_list(self):
-        return self._y_channel_list
-
-    @y_channel_list.setter
-    def y_channel_list(self, new_list):
-        bec_dispatcher = BECDispatcher()
-        # TODO: do we want to care about dap/not dap here?
-        chan_removed = [chan for chan in self._y_channel_list if chan not in new_list]
-        if chan_removed and chan_removed[0].startswith("dap."):
-            chan_removed = chan_removed[0].partition("dap.")[-1]
-            chan_removed_ep = MessageEndpoints.processed_data(chan_removed)
-            bec_dispatcher.disconnect_slot(self.redraw_dap, chan_removed_ep)
-
-        self._y_channel_list = new_list
-
-        # Prepare plot for a potentially different list of y channels
-        self.view.clear()
-
-        self.view.addLegend()
-        colors = itertools.cycle(COLORS)
-
-        for y_chan in new_list:
-            if y_chan.startswith("dap."):
-                y_chan = y_chan.partition("dap.")[-1]
-                curves = self.dap_curves
-                y_chan_ep = MessageEndpoints.processed_data(y_chan)
-                bec_dispatcher.connect_slot(self.redraw_dap, y_chan_ep)
-            else:
-                curves = self.scan_curves
-
-            curves[y_chan] = self.view.plot(
-                x=[], y=[], pen=pg.mkPen(color=next(colors), width=2), name=y_chan
-            )
-
-        if len(new_list) == 1:
-            self.view.setLabel("left", new_list[0])
-
-    @pyqtProperty(str)
-    def x_channel(self):
-        return self._x_channel
-
-    @x_channel.setter
-    def x_channel(self, new_val):
-        self._x_channel = new_val
-        self.view.setLabel("bottom", new_val)
-
-
-if __name__ == "__main__":
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-
-    plot = BECScanPlot()
-    plot.x_channel = "samx"
-    plot.y_channel_list = ["bpm3y", "bpm6y"]
-
-    plot.show()
-
-    sys.exit(app.exec())

bec_widgets/widgets/toolbar/toolbar.py

@@ -1,11 +1,9 @@
 from abc import ABC, abstractmethod
 
 # pylint: disable=no-name-in-module
-from qtpy.QtCore import QSize
-from qtpy.QtWidgets import QToolBar, QStyle, QApplication
-from qtpy.QtCore import QTimer
+from qtpy.QtCore import QSize, QTimer
 from qtpy.QtGui import QAction
-from qtpy.QtWidgets import QWidget
+from qtpy.QtWidgets import QApplication, QStyle, QToolBar, QWidget
 
 
 class ToolBarAction(ABC):

docs/developer/developer.md

@@ -1,6 +1,14 @@
 (developer)=
 # Development
 
+```{toctree}
+---
+maxdepth: 1
+hidden: true
+---
+reference/
+```
+
 To contribute to the development of BEC Widgets, start by setting up the development environment:
 
 1. **Clone the Repository**: 
@@ -13,4 +21,6 @@ cd bec-widgets
 Installing the package in editable mode allows you to make changes to the code and test them in real-time.
 ```bash
 pip install -e .[dev]
-```
+```
+
+

docs/developer/reference.md

@@ -0,0 +1,10 @@
+## API Reference
+
+```{eval-rst}
+.. autosummary::
+   :toctree: _autosummary
+   :template: custom-module-template.rst
+   :recursive:
+
+   bec_widgets
+```

docs/user/installation.md

@@ -6,7 +6,7 @@
 
 Before installing BEC Widgets, please ensure the following requirements are met:
 
-1. **Python Version:** BEC Widgets requires Python version 3.9 or higher. Verify your Python version to ensure compatibility.
+1. **Python Version:** BEC Widgets requires Python version 3.10 or higher. Verify your Python version to ensure compatibility.
 2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).
 
 **Standard Installation**
@@ -43,4 +43,4 @@ If you encounter issues during installation, particularly with PyQt, try purging
 pip cache purge
 ```
 
-This can resolve conflicts or issues with package installations.
+This can resolve conflicts or issues with package installations.

setup.cfg

@@ -15,7 +15,7 @@ classifiers =
 package_dir =
     = .
 packages = find:
-python_requires = >=3.9
+python_requires = >=3.10
 
 [options.packages.find]
 where = .

setup.py

@@ -1,7 +1,7 @@
 # pylint: disable= missing-module-docstring
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
 
-__version__ = "0.41.3"
+__version__ = "0.48.0"
 
 # Default to PyQt6 if no other Qt binding is installed
 QT_DEPENDENCY = "PyQt6>=6.0"
@@ -40,6 +40,7 @@ if __name__ == "__main__":
                 "coverage",
                 "pytest-qt",
                 "black",
+                "isort",
             ],
             "pyqt5": ["PyQt5>=5.9"],
             "pyqt6": ["PyQt6>=6.0"],

tests/client_mocks.py

@@ -1,77 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-
-import pytest
-from unittest.mock import MagicMock
-
-
-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True):
-        self.name = name
-        self.enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name}}
-
-    def __contains__(self, item):
-        return item == self.name
-
-    @property
-    def _hints(self):
-        return [self.name]
-
-    def set_value(self, fake_value: float = 1.0) -> None:
-        """
-        Setup fake value for device readout
-        Args:
-            fake_value(float): Desired fake value
-        """
-        self.signals[self.name]["value"] = fake_value
-
-    def describe(self) -> dict:
-        """
-        Get the description of the device
-        Returns:
-            dict: Description of the device
-        """
-        return self.description
-
-
-def get_mocked_device(device_name: str):
-    """
-    Helper function to mock the devices
-    Args:
-        device_name(str): Name of the device to mock
-    """
-    return FakeDevice(name=device_name, enabled=True)
-
-
-@pytest.fixture(scope="function")
-def mocked_client():
-    # Create a dictionary of mocked devices
-    device_names = [
-        "samx",
-        "samy",
-        "gauss_bpm",
-        "gauss_adc1",
-        "gauss_adc2",
-        "gauss_adc3",
-        "bpm4i",
-        "bpm3a",
-        "bpm3i",
-    ]
-    mocked_devices = {name: get_mocked_device(name) for name in device_names}
-
-    # Create a MagicMock object
-    client = MagicMock()
-
-    # Mock the device_manager.devices attribute
-    client.device_manager.devices = MagicMock()
-    client.device_manager.devices.__getitem__.side_effect = lambda x: mocked_devices.get(x)
-    client.device_manager.devices.__contains__.side_effect = lambda x: x in mocked_devices
-
-    # Set each device as an attribute of the mock
-    for name, device in mocked_devices.items():
-        setattr(client.device_manager.devices, name, device)
-
-    return client

tests/conftest.py

@@ -1,35 +0,0 @@
-import pytest
-import threading
-
-from bec_lib.bec_service import BECService
-from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
-
-
-@pytest.fixture()
-def threads_check():
-    current_threads = set(
-        th
-        for th in threading.enumerate()
-        if "loguru" not in th.name and th is not threading.main_thread()
-    )
-    yield
-    threads_after = set(
-        th
-        for th in threading.enumerate()
-        if "loguru" not in th.name and th is not threading.main_thread()
-    )
-    additional_threads = threads_after - current_threads
-    assert (
-        len(additional_threads) == 0
-    ), f"Test creates {len(additional_threads)} threads that are not cleaned: {additional_threads}"
-
-
-@pytest.fixture(autouse=True)
-def bec_dispatcher(threads_check):
-    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
-    yield bec_dispatcher
-    bec_dispatcher.disconnect_all()
-    # clean BEC client
-    BECService.shutdown(bec_dispatcher.client)
-    # reinitialize singleton for next test
-    bec_dispatcher_module._bec_dispatcher = None

tests/end-2-end/test_bec_figure_rpc.py

@@ -0,0 +1,181 @@
+import numpy as np
+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
+
+    ax = fig.add_plot()
+    curve = ax.add_curve_custom([1, 2, 3], [1, 2, 3])
+    curve.set_color("red")
+    curve = ax.curves[0]
+    curve.set_color("blue")
+
+    assert len(fig_server.widgets) == 1
+    assert len(fig_server.widgets["widget_1"].curves) == 1
+
+
+def test_rpc_plotting_shortcuts_init_configs(rpc_server, qtbot):
+    fig = BECFigure(rpc_server.gui_id)
+    fig_server = rpc_server.fig
+
+    plt = fig.plot("samx", "bpm4i")
+    im = fig.image("eiger")
+    motor_map = fig.motor_map("samx", "samy")
+    plt_z = fig.add_plot("samx", "samy", "bpm4i")
+
+    # Checking if classes are correctly initialised
+    assert len(fig_server.widgets) == 4
+    assert plt.__class__.__name__ == "BECWaveform"
+    assert plt.__class__ == BECWaveform
+    assert im.__class__.__name__ == "BECImageShow"
+    assert im.__class__ == BECImageShow
+    assert motor_map.__class__.__name__ == "BECMotorMap"
+    assert motor_map.__class__ == BECMotorMap
+
+    # check if the correct devices are set
+    # plot
+    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,
+    }
+    # image
+    assert im.config_dict["images"]["eiger"]["monitor"] == "eiger"
+    # motor map
+    assert motor_map.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,
+    }
+    # plot with z scatter
+    assert plt_z.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+        "source": "scan_segment",
+        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
+        "y": {"name": "samy", "entry": "samy", "unit": None, "modifier": None, "limits": None},
+        "z": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
+    }
+
+
+def test_rpc_waveform_scan(rpc_server, qtbot):
+    fig = BECFigure(rpc_server.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
+    dev = client.device_manager.devices
+    scans = client.scans
+    queue = client.queue
+
+    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
+
+    # wait for scan to finish
+    while not status.status == "COMPLETED":
+        qtbot.wait(200)
+
+    last_scan_data = queue.scan_storage.storage[-1].data
+
+    # get data from curves
+    plt_data = plt.get_all_data()
+
+    # check plotted data
+    assert plt_data["bpm4i-bpm4i"]["x"] == last_scan_data["samx"]["samx"].val
+    assert plt_data["bpm4i-bpm4i"]["y"] == last_scan_data["bpm4i"]["bpm4i"].val
+    assert plt_data["bpm3a-bpm3a"]["x"] == last_scan_data["samx"]["samx"].val
+    assert plt_data["bpm3a-bpm3a"]["y"] == last_scan_data["bpm3a"]["bpm3a"].val
+    assert plt_data["bpm4d-bpm4d"]["x"] == last_scan_data["samx"]["samx"].val
+    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)
+
+    im = fig.image("eiger")
+
+    client = rpc_server.client
+    dev = client.device_manager.devices
+    scans = client.scans
+
+    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)
+
+    last_image_device = client.connector.get_last(MessageEndpoints.device_monitor("eiger"))[
+        "data"
+    ].data
+    qtbot.wait(500)
+    last_image_plot = im.images[0].get_data()
+
+    # check plotted data
+    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
+
+    motor_map = fig.motor_map("samx", "samy")
+
+    client = rpc_server.client
+    dev = client.device_manager.devices
+    scans = client.scans
+
+    initial_pos_x = dev.samx.read()["samx"]["value"]
+    initial_pos_y = dev.samy.read()["samy"]["value"]
+
+    status = scans.mv(dev.samx, 1, dev.samy, 2, relative=True)
+
+    # wait for scan to finish
+    while not status.status == "COMPLETED":
+        qtbot.wait(200)
+    final_pos_x = dev.samx.read()["samx"]["value"]
+    final_pos_y = dev.samy.read()["samy"]["value"]
+
+    # check plotted data
+    motor_map_data = motor_map.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]
+    )

tests/test_bec_dispatcher.py

@@ -1,240 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-from unittest.mock import Mock
-
-import pytest
-from bec_lib.messages import ScanMessage
-from bec_lib.connector import MessageObject
-
-
-msg = MessageObject(topic="", value=ScanMessage(point_id=0, scanID=0, data={}))
-
-
-@pytest.fixture(name="consumer")
-def _consumer(bec_dispatcher):
-    bec_dispatcher.client.connector = Mock()
-    yield bec_dispatcher.client.connector
-
-
-@pytest.mark.filterwarnings("ignore:Failed to connect to redis.")
-def test_connect_one_slot(bec_dispatcher, consumer):
-    slot1 = Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    consumer.register.assert_called_once()
-    # trigger consumer callback as if a message was published
-    consumer.register.call_args.kwargs["cb"](msg)
-    slot1.assert_called_once()
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-
-
-def test_connect_identical(bec_dispatcher, consumer):
-    slot1 = Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    consumer.register.assert_called_once()
-
-    consumer.register.call_args.kwargs["cb"](msg)
-    slot1.assert_called_once()
-
-
-def test_connect_many_slots_one_topic(bec_dispatcher, consumer):
-    slot1, slot2 = Mock(), Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    consumer.register.assert_called_once()
-    bec_dispatcher.connect_slot(slot=slot2, topics="topic0")
-    consumer.register.assert_called_once()
-    # trigger consumer callback as if a message was published
-    consumer.register.call_args.kwargs["cb"](msg)
-    slot1.assert_called_once()
-    slot2.assert_called_once()
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-    assert slot2.call_count == 2
-
-
-def test_connect_one_slot_many_topics(bec_dispatcher, consumer):
-    slot1 = Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    assert consumer.register.call_count == 1
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic1")
-    assert consumer.register.call_count == 2
-    # trigger consumer callback as if a message was published
-    consumer.register.call_args_list[0].kwargs["cb"](msg)
-    slot1.assert_called_once()
-    consumer.register.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 2
-
-
-def test_disconnect_one_slot_one_topic(bec_dispatcher, consumer):
-    slot1, slot2 = Mock(), Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-
-    # disconnect using a different topic
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic1")
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 1
-
-    # disconnect using a different slot
-    bec_dispatcher.disconnect_slot(slot=slot2, topics="topic0")
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-
-    # disconnect using the right slot and topics
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic0")
-    # reset count to  for slot
-    slot1.reset_mock()
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 0
-
-
-def test_disconnect_identical(bec_dispatcher, consumer):
-    slot1 = Mock()
-    # Try to connect slot twice
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-
-    # Test to call the slot once (slot should be not connected twice)
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 1
-
-    # Disconnect the slot
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic0")
-
-    # Test to call the slot once (slot should be not connected anymore), count remains 1
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 1
-
-
-def test_disconnect_many_slots_one_topic(bec_dispatcher, consumer):
-    slot1, slot2, slot3 = Mock(), Mock(), Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot2, topics="topic0")
-
-    # disconnect using a different slot
-    bec_dispatcher.disconnect_slot(slot3, topics="topic0")
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 1
-    assert slot2.call_count == 1
-
-    # disconnect using a different topics
-    bec_dispatcher.disconnect_slot(slot1, topics="topic1")
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-    assert slot2.call_count == 2
-
-    # disconnect using the right slot and topics
-    bec_dispatcher.disconnect_slot(slot1, topics="topic0")
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-    assert slot2.call_count == 3
-
-
-def test_disconnect_one_slot_many_topics(bec_dispatcher, consumer):
-    slot1, slot2 = Mock(), Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic1")
-
-    # disconnect using a different slot
-    bec_dispatcher.disconnect_slot(slot=slot2, topics="topic0")
-    consumer.register.call_args_list[0].kwargs["cb"](msg)
-    assert slot1.call_count == 1
-    consumer.register.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 2
-
-    # disconnect using a different topics
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic3")
-    consumer.register.call_args_list[0].kwargs["cb"](msg)
-    assert slot1.call_count == 3
-    consumer.register.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 4
-
-    # disconnect using the right slot and topics
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic0")
-    # Calling disconnected topic0 should not call slot1
-    consumer.register.call_args_list[0].kwargs["cb"](msg)
-    assert slot1.call_count == 4
-    # Calling topic1 should still call slot1
-    consumer.register.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 5
-
-    # disconnect remaining topic1 from slot1, calling any topic should not increase count
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic1")
-    consumer.register.call_args_list[0].kwargs["cb"](msg)
-    consumer.register.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 5
-
-
-def test_disconnect_all(bec_dispatcher, consumer):
-    # Mock slots to connect
-    slot1, slot2, slot3 = Mock(), Mock(), Mock()
-
-    # Connect slots to different topics
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot2, topics="topic1")
-    bec_dispatcher.connect_slot(slot=slot3, topics="topic2")
-
-    # Call disconnect_all method
-    bec_dispatcher.disconnect_all()
-
-    # Simulate messages and verify that none of the slots are called
-    consumer.register.call_args_list[0].kwargs["cb"](msg)
-    consumer.register.call_args_list[1].kwargs["cb"](msg)
-    consumer.register.call_args_list[2].kwargs["cb"](msg)
-
-    # Ensure that the slots have not been called
-    assert slot1.call_count == 0
-    assert slot2.call_count == 0
-    assert slot3.call_count == 0
-
-    # Also, check that the consumer for each topic is shutdown
-    assert "topic0" not in bec_dispatcher._connections
-    assert "topic1" not in bec_dispatcher._connections
-    assert "topic2" not in bec_dispatcher._connections
-
-
-def test_connect_one_slot_multiple_topics_single_callback(bec_dispatcher, consumer):
-    slot1 = Mock()
-
-    # Connect the slot to multiple topics using a single callback
-    topics = ["topic1", "topic2"]
-    bec_dispatcher.connect_slot(slot=slot1, topics=topics, single_callback_for_all_topics=True)
-
-    # Verify the initial state
-    assert len(bec_dispatcher._connections) == 1  # One connection for all topics
-    assert len(bec_dispatcher._connections[tuple(sorted(topics))].slots) == 1  # One slot connected
-
-    # Simulate messages being published on each topic
-    for topic in topics:
-        msg_with_topic = MessageObject(
-            topic=topic, value=ScanMessage(point_id=0, scanID=0, data={}).dumps()
-        )
-        consumer.register.call_args.kwargs["cb"](msg_with_topic)
-
-    # Verify that the slot is called once for each topic
-    assert slot1.call_count == len(topics)
-
-    # Verify that a single consumer is created for all topics
-    consumer.register.assert_called_once()
-
-
-def test_disconnect_all_with_single_callback_for_multiple_topics(bec_dispatcher, consumer):
-    slot1 = Mock()
-
-    # Connect the slot to multiple topics using a single callback
-    topics = ["topic1", "topic2"]
-    bec_dispatcher.connect_slot(slot=slot1, topics=topics, single_callback_for_all_topics=True)
-
-    # Verify the initial state
-    assert len(bec_dispatcher._connections) == 1  # One connection for all topics
-    assert len(bec_dispatcher._connections[tuple(sorted(topics))].slots) == 1  # One slot connected
-
-    # Call disconnect_all method
-    bec_dispatcher.disconnect_all()
-
-    # Verify that the slot is disconnected
-    assert len(bec_dispatcher._connections) == 0  # All connections are removed
-    assert slot1.call_count == 0  # Slot has not been called
-
-    # Simulate messages and verify that the slot is not called
-    consumer.register.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 0  # Slot has not been called

tests/test_bec_monitor_scatter2D.py

@@ -1,186 +0,0 @@
-# pylint: disable=missing-module-docstring, missing-function-docstring
-from collections import defaultdict
-
-import pytest
-from unittest.mock import MagicMock
-from qtpy import QtGui
-
-from bec_widgets.widgets import BECMonitor2DScatter
-
-CONFIG_DEFAULT = {
-    "plot_settings": {
-        "colormap": "CET-L4",
-        "num_columns": 1,
-    },
-    "waveform2D": [
-        {
-            "plot_name": "Waveform 2D Scatter (1)",
-            "x_label": "Sam X",
-            "y_label": "Sam Y",
-            "signals": {
-                "x": [{"name": "samx", "entry": "samx"}],
-                "y": [{"name": "samy", "entry": "samy"}],
-                "z": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-            },
-        },
-        {
-            "plot_name": "Waveform 2D Scatter (2)",
-            "x_label": "Sam X",
-            "y_label": "Sam Y",
-            "signals": {
-                "x": [{"name": "samy", "entry": "samy"}],
-                "y": [{"name": "samx", "entry": "samx"}],
-                "z": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-            },
-        },
-    ],
-}
-
-CONFIG_ONE_PLOT = {
-    "plot_settings": {
-        "colormap": "CET-L4",
-        "num_columns": 1,
-    },
-    "waveform2D": [
-        {
-            "plot_name": "Waveform 2D Scatter (1)",
-            "x_label": "Sam X",
-            "y_label": "Sam Y",
-            "signals": {
-                "x": [{"name": "aptrx", "entry": "aptrx"}],
-                "y": [{"name": "aptry", "entry": "aptry"}],
-                "z": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-            },
-        },
-    ],
-}
-
-
-@pytest.fixture(scope="function")
-def monitor_2Dscatter(qtbot):
-    client = MagicMock()
-    widget = BECMonitor2DScatter(client=client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-@pytest.mark.parametrize(
-    "config, number_of_plots",
-    [
-        (CONFIG_DEFAULT, 2),
-        (CONFIG_ONE_PLOT, 1),
-    ],
-)
-def test_initialization(monitor_2Dscatter, config, number_of_plots):
-    config_load = config
-    monitor_2Dscatter.on_config_update(config_load)
-    assert isinstance(monitor_2Dscatter, BECMonitor2DScatter)
-    assert monitor_2Dscatter.client is not None
-    assert monitor_2Dscatter.config == config_load
-    assert len(monitor_2Dscatter.plot_data) == number_of_plots
-
-
-@pytest.mark.parametrize(
-    "config ",
-    [
-        (CONFIG_DEFAULT),
-        (CONFIG_ONE_PLOT),
-    ],
-)
-def test_database_initialization(monitor_2Dscatter, config):
-    monitor_2Dscatter.on_config_update(config)
-    # Check if the database is a defaultdict
-    assert isinstance(monitor_2Dscatter.database, defaultdict)
-    for axis_dict in monitor_2Dscatter.database.values():
-        assert isinstance(axis_dict, defaultdict)
-        for signal_list in axis_dict.values():
-            assert isinstance(signal_list, defaultdict)
-
-    # Access the elements
-    for plot_config in config["waveform2D"]:
-        plot_name = plot_config["plot_name"]
-
-        for axis in ["x", "y", "z"]:
-            for signal in plot_config["signals"][axis]:
-                signal_name = signal["name"]
-                assert not monitor_2Dscatter.database[plot_name][axis][signal_name]
-                assert isinstance(monitor_2Dscatter.database[plot_name][axis][signal_name], list)
-
-
-@pytest.mark.parametrize(
-    "config ",
-    [
-        (CONFIG_DEFAULT),
-        (CONFIG_ONE_PLOT),
-    ],
-)
-def test_ui_initialization(monitor_2Dscatter, config):
-    monitor_2Dscatter.on_config_update(config)
-    assert len(monitor_2Dscatter.plots) == len(config["waveform2D"])
-    for plot_config in config["waveform2D"]:
-        plot_name = plot_config["plot_name"]
-        assert plot_name in monitor_2Dscatter.plots
-        plot = monitor_2Dscatter.plots[plot_name]
-        assert plot.titleLabel.text == plot_name
-
-
-def simulate_scan_data(monitor, x_value, y_value, z_value):
-    """Helper function to simulate scan data input with three devices."""
-    msg = {
-        "data": {
-            "samx": {"samx": {"value": x_value}},
-            "samy": {"samy": {"value": y_value}},
-            "gauss_bpm": {"gauss_bpm": {"value": z_value}},
-        },
-        "scanID": 1,
-    }
-    monitor.on_scan_segment(msg, {})
-
-
-def test_data_update_and_plotting(monitor_2Dscatter, qtbot):
-    monitor_2Dscatter.on_config_update(CONFIG_DEFAULT)
-    data_sets = [(1, 4, 7), (2, 5, 8), (3, 6, 9)]  # (x, y, z) tuples
-    plot_name = "Waveform 2D Scatter (1)"
-
-    for x, y, z in data_sets:
-        simulate_scan_data(monitor_2Dscatter, x, y, z)
-        qtbot.wait(100)  # Wait for the plot to update
-
-    # Retrieve the plot and check if the number of data points matches
-    scatterPlot = monitor_2Dscatter.scatterPlots[plot_name]
-    assert len(scatterPlot.data) == len(data_sets)
-
-    # Check if the data in the database matches the sent data
-    x_data = [
-        point
-        for points_list in monitor_2Dscatter.database[plot_name]["x"].values()
-        for point in points_list
-    ]
-    y_data = [
-        point
-        for points_list in monitor_2Dscatter.database[plot_name]["y"].values()
-        for point in points_list
-    ]
-    z_data = [
-        point
-        for points_list in monitor_2Dscatter.database[plot_name]["z"].values()
-        for point in points_list
-    ]
-
-    assert x_data == [x for x, _, _ in data_sets]
-    assert y_data == [y for _, y, _ in data_sets]
-    assert z_data == [z for _, _, z in data_sets]
-
-
-def test_color_mapping(monitor_2Dscatter, qtbot):
-    monitor_2Dscatter.on_config_update(CONFIG_DEFAULT)
-    data_sets = [(1, 4, 7), (2, 5, 8), (3, 6, 9)]  # (x, y, z) tuples
-    for x, y, z in data_sets:
-        simulate_scan_data(monitor_2Dscatter, x, y, z)
-        qtbot.wait(100)  # Wait for the plot to update
-
-    scatterPlot = monitor_2Dscatter.scatterPlots["Waveform 2D Scatter (1)"]
-
-    # Check if colors are applied
-    assert all(isinstance(point.brush().color(), QtGui.QColor) for point in scatterPlot.points())

tests/test_plot_app.py

@@ -1,489 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-import unittest
-from unittest.mock import MagicMock, patch
-
-import pyqtgraph as pg
-import pytest
-from qtpy.QtWidgets import QMessageBox
-
-from bec_widgets.examples.plot_app.plot_app import PlotApp, ErrorHandler
-
-
-def setup_plot_app(qtbot, config):
-    """Helper function to set up the PlotApp widget."""
-    client = MagicMock()
-    widget = PlotApp(config=config, client=client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    return widget
-
-
-@pytest.fixture
-def error_handler():
-    # TODO so far tested separately, but the error message scenarios can be tested directly in the plot app
-    return ErrorHandler()
-
-
-config_device_mode_all_filled = {
-    "plot_settings": {
-        "background_color": "black",
-        "num_columns": 2,
-        "colormap": "plasma",
-        "scan_types": False,
-    },
-    "plot_data": [
-        {
-            "plot_name": "BPM4i plots vs samx",
-            "x": {
-                "label": "Motor Y",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "bpm4i",
-                "signals": [{"name": "bpm4i", "entry": "bpm4i"}],
-            },
-        },
-        {
-            "plot_name": "Gauss plots vs samx",
-            "x": {
-                "label": "Motor X",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "Gauss",
-                "signals": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-            },
-        },
-    ],
-}
-
-config_device_mode_no_entry = {
-    "plot_settings": {
-        "background_color": "white",
-        "num_columns": 1,
-        "colormap": "plasma",
-        "scan_types": False,
-    },
-    "plot_data": [
-        {
-            "plot_name": "BPM4i plots vs samx",
-            "x": {
-                "label": "Motor Y",
-                "signals": [{"name": "samx"}],  # Entry is missing
-            },
-            "y": {
-                "label": "bpm4i",
-                "signals": [{"name": "bpm4i"}],  # Entry is missing
-            },
-        },
-        {
-            "plot_name": "Gauss plots vs samx",
-            "x": {
-                "label": "Motor X",
-                "signals": [{"name": "samx"}],  # Entry is missing
-            },
-            "y": {
-                "label": "Gauss",
-                "signals": [{"name": "gauss_bpm"}],  # Entry is missing
-            },
-        },
-    ],
-}
-
-config_scan_mode = config = {
-    "plot_settings": {
-        "background_color": "white",
-        "num_columns": 3,
-        "colormap": "plasma",
-        "scan_types": True,
-    },
-    "plot_data": {
-        "grid_scan": [
-            {
-                "plot_name": "Grid plot 1",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "gauss_adc1", "entry": "gauss_adc1"},
-                    ],
-                },
-            },
-            {
-                "plot_name": "Grid plot 2",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "gauss_adc1", "entry": "gauss_adc1"},
-                    ],
-                },
-            },
-            {
-                "plot_name": "Grid plot 3",
-                "x": {"label": "Motor Y", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-                },
-            },
-            {
-                "plot_name": "Grid plot 4",
-                "x": {"label": "Motor Y", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [{"name": "gauss_adc3", "entry": "gauss_adc3"}],
-                },
-            },
-        ],
-        "line_scan": [
-            {
-                "plot_name": "BPM plot",
-                "x": {"label": "Motor X", "signals": [{"name": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "gauss_adc1", "entry": "gauss_adc1"},
-                        {"name": "gauss_adc2", "entry": "gauss_adc2"},
-                    ],
-                },
-            },
-            {
-                "plot_name": "Multi",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "Multi",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "samx", "entry": ["samx", "samx_setpoint"]},
-                    ],
-                },
-            },
-            {
-                "plot_name": "Multi",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "Multi",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "samx", "entry": ["samx", "samx_setpoint"]},
-                    ],
-                },
-            },
-        ],
-    },
-}
-
-config_all_wrong = {
-    "plot_settings": {
-        "background_color": "white",
-        "num_columns": 1,
-        "colormap": "plasma",
-        "scan_types": False,
-    },
-    "plot_data": [
-        {
-            "plot_name": "BPM4i plots vs samx",
-            "x": {
-                "label": "Motor Y",
-                # signals are missing
-            },
-            "y": {
-                "label": "bpm4i",
-                "signals": [{"name": "bpm4i", "entry": "gauss_bpm"}],  # wrong entry
-            },
-        },
-    ],
-}
-
-
-@pytest.mark.parametrize(
-    "config, plot_setting_bg, num_plot ,pg_background",
-    [
-        (config_device_mode_all_filled, "black", 2, "k"),
-        (config_device_mode_no_entry, "white", 2, "w"),
-        (config_scan_mode, "white", 4, "w"),
-    ],
-)
-def test_init_config(qtbot, config, plot_setting_bg, num_plot, pg_background):
-    plot_app = setup_plot_app(qtbot, config)
-    assert plot_app.plot_settings["background_color"] == plot_setting_bg
-    assert len(plot_app.plot_data) == num_plot
-    assert pg.getConfigOption("background") == pg_background
-
-
-@pytest.mark.parametrize(
-    "config, num_columns_input, expected_num_columns, expected_plot_names, expected_coordinates",
-    [
-        (
-            config_device_mode_all_filled,
-            2,
-            2,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (0, 1)],
-        ),
-        (
-            config_device_mode_all_filled,
-            5,
-            2,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (0, 1)],
-        ),  # num_columns greater than number of plots
-        (
-            config_device_mode_no_entry,
-            1,
-            1,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (1, 0)],
-        ),
-        (
-            config_device_mode_no_entry,
-            2,
-            2,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (0, 1)],
-        ),
-        (
-            config_device_mode_no_entry,
-            5,
-            2,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (0, 1)],
-        ),  # num_columns greater than number of plots,
-        (
-            config_scan_mode,
-            2,
-            2,
-            [
-                "Grid plot 1",
-                "Grid plot 2",
-                "Grid plot 3",
-                "Grid plot 4",
-            ],
-            [(0, 0), (0, 1), (1, 0), (1, 1)],
-        ),
-        (
-            config_scan_mode,
-            3,
-            3,
-            [
-                "Grid plot 1",
-                "Grid plot 2",
-                "Grid plot 3",
-                "Grid plot 4",
-            ],
-            [(0, 0), (0, 1), (0, 2), (1, 0)],
-        ),
-        (
-            config_scan_mode,
-            5,
-            4,
-            [
-                "Grid plot 1",
-                "Grid plot 2",
-                "Grid plot 3",
-                "Grid plot 4",
-            ],
-            [(0, 0), (0, 1), (0, 2), (0, 3)],
-        ),  # num_columns greater than number of plots
-    ],
-)
-def test_init_ui(
-    qtbot,
-    config,
-    num_columns_input,
-    expected_num_columns,
-    expected_plot_names,
-    expected_coordinates,
-):
-    plot_app = setup_plot_app(qtbot, config)
-    plot_app.init_ui(num_columns_input)
-
-    # Validate number of columns
-    assert plot_app.plot_settings["num_columns"] == expected_num_columns
-
-    # Validate the plots are created correctly
-    for expected_name in expected_plot_names:
-        assert expected_name in plot_app.plots.keys()
-
-    # Validate the grid_coordinates
-    assert plot_app.grid_coordinates == expected_coordinates
-
-
-def mock_getitem(dev_name):
-    """Helper function to mock the __getitem__ method of the 'dev' object.""" ""
-    mock_instance = MagicMock()
-    if dev_name == "samx":
-        mock_instance._hints = "samx"
-    elif dev_name == "bpm4i":
-        mock_instance._hints = "bpm4i"
-    elif dev_name == "gauss_bpm":
-        mock_instance._hints = "gauss_bpm"
-
-    return mock_instance
-
-
-@pytest.mark.parametrize(
-    "config, msg, metadata, expected_data",
-    [
-        # Case: msg does not have 'scanID'
-        (config_device_mode_all_filled, {"data": {}}, {}, {}),
-        # Case: scan_types is False, msg contains all valid fields, and entry is present in config
-        (
-            config_device_mode_all_filled,
-            {
-                "data": {
-                    "samx": {"samx": {"value": 10}},
-                    "bpm4i": {"bpm4i": {"value": 5}},
-                    "gauss_bpm": {"gauss_bpm": {"value": 7}},
-                },
-                "scanID": 1,
-            },
-            {},
-            {
-                ("samx", "samx", "bpm4i", "bpm4i"): {"x": [10], "y": [5]},
-                ("samx", "samx", "gauss_bpm", "gauss_bpm"): {"x": [10], "y": [7]},
-            },
-        ),
-        # Case: scan_types is False, msg contains all valid fields and entry is missing in config, should use hints
-        (
-            config_device_mode_no_entry,
-            {
-                "data": {
-                    "samx": {"samx": {"value": 10}},
-                    "bpm4i": {"bpm4i": {"value": 5}},
-                    "gauss_bpm": {"gauss_bpm": {"value": 7}},
-                },
-                "scanID": 1,
-            },
-            {},
-            {
-                ("samx", "samx", "bpm4i", "bpm4i"): {"x": [10], "y": [5]},
-                ("samx", "samx", "gauss_bpm", "gauss_bpm"): {"x": [10], "y": [7]},
-            },
-        ),
-    ],
-)
-def test_on_scan_segment(qtbot, config, msg, metadata, expected_data):
-    plot_app = setup_plot_app(qtbot, config)
-
-    # Initialize and run test
-    plot_app.data = {}
-    plot_app.scanID = 0
-
-    # Get hints
-    plot_app.dev.__getitem__.side_effect = mock_getitem
-
-    plot_app.on_scan_segment(msg, metadata)
-    assert plot_app.data == expected_data
-
-
-@pytest.mark.parametrize(
-    "config, msg, metadata, expected_exception_message",
-    [
-        # Case: scan_types is True, but metadata does not contain 'scan_name'
-        (
-            config_scan_mode,
-            {"data": {}, "scanID": 1},
-            {},  # No 'scan_name' in metadata
-            "Scan name not found in metadata. Please check the scan_name in the YAML config or in bec configuration.",
-        ),
-        # Case: scan_types is True, metadata contains non-existing 'scan_name'
-        (
-            config_scan_mode,
-            {"data": {}, "scanID": 1},
-            {"scan_name": "non_existing_scan"},
-            "Scan name non_existing_scan not found in the YAML config. Please check the scan_name in the YAML config "
-            "or in bec configuration.",
-        ),
-    ],
-)
-def test_on_scan_message_error_handling(qtbot, config, msg, metadata, expected_exception_message):
-    plot_app = setup_plot_app(qtbot, config)
-
-    # Initialize
-    plot_app.init_curves = MagicMock()
-    plot_app.data = {}
-    plot_app.scanID = 0
-
-    plot_app.dev.__getitem__.side_effect = mock_getitem
-
-    with pytest.raises(ValueError) as exc_info:
-        plot_app.on_scan_segment(msg, metadata)
-    assert str(exc_info.value) == expected_exception_message
-
-
-####################
-# ErrorHandler tests
-####################
-def test_initialization(error_handler):
-    assert error_handler.errors == []
-    assert error_handler.parent is None
-    assert error_handler.retry_action is None
-
-
-@patch(
-    "bec_widgets.examples.plot_app.plot_app.QMessageBox.critical", return_value=QMessageBox.Retry
-)
-def test_handle_error_retry(mocked_critical, error_handler):
-    retry_action = MagicMock()
-    error_handler.set_retry_action(retry_action)
-    error_handler.handle_error("error message")
-    retry_action.assert_called_once()
-
-
-@patch(
-    "bec_widgets.examples.plot_app.plot_app.QMessageBox.critical", return_value=QMessageBox.Cancel
-)
-def test_handle_error_cancel(mocked_critical, error_handler):
-    retry_action = MagicMock()
-    with pytest.raises(SystemExit) as excinfo:
-        error_handler.handle_error("error message")
-    assert excinfo.value.code == 1
-    retry_action.assert_not_called()
-
-
-@pytest.mark.parametrize(
-    "config, expected_errors",
-    [
-        (config_device_mode_all_filled, []),
-        (config_device_mode_no_entry, []),
-        (config_scan_mode, []),
-        (
-            config_all_wrong,
-            ["Missing 'signals' configuration for x axis in plot 0 - 'BPM4i plots vs samx'"],
-        ),
-    ],
-)
-def test_error_handler(error_handler, config, expected_errors):
-    # Mock QMessageBox
-    error_handler.handle_error = MagicMock()
-
-    # Mock logging
-    with unittest.mock.patch("bec_widgets.examples.plot_app.plot_app.logging") as mocked_logging:
-        error_handler.validate_config_file(config)
-
-        # Assert
-        assert error_handler.errors == expected_errors
-
-        # If there are expected errors, check if handle_error was called
-        if expected_errors:
-            error_handler.handle_error.assert_called_once()
-            mocked_logging.error.assert_called()
-        else:
-            mocked_logging.error.assert_not_called()
-            error_handler.handle_error.assert_not_called()
-
-
-def test_validate_plot_config(error_handler):
-    plot_config = {
-        "x": {"label": "Motor X", "signals": []},  # empty signals list should trigger an error
-        "y": {"label": "Motor Y", "signals": [{"name": "samx", "entry": "samx"}]},
-    }
-    error_handler.validate_plot_config(plot_config, 0)
-    assert error_handler.errors == [
-        "'signals' configuration for x axis in plot 0 must be a non-empty list"
-    ]

tests/test_scan_plot.py

@@ -1,92 +0,0 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-from bec_widgets.widgets.scan_plot import scan_plot
-
-
-def test_scan_plot(qtbot):
-    """Test ScanPlot"""
-    plot = scan_plot.BECScanPlot()
-    qtbot.addWidget(plot)
-    plot.show()
-    qtbot.waitExposed(plot)
-
-    plot.x_channel = "x"
-    plot.y_channel_list = ["y1", "y2"]
-
-    plot.on_scan_segment(
-        {
-            "data": {
-                "x": {"x": {"value": 1}},
-                "y1": {"y1": {"value": 1}},
-                "y2": {"y2": {"value": 3}},
-            },
-            "scanID": "test",
-        },
-        {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]},
-    )
-    plot.on_scan_segment(
-        {
-            "data": {
-                "x": {"x": {"value": 2}},
-                "y1": {"y1": {"value": 2}},
-                "y2": {"y2": {"value": 4}},
-            },
-            "scanID": "test",
-        },
-        {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]},
-    )
-
-    assert all(plot.scan_curves["y1"].getData()[0] == [1, 2])
-    assert all(plot.scan_curves["y2"].getData()[1] == [3, 4])
-
-
-def test_scan_plot_clears_data(qtbot):
-    """Test ScanPlot"""
-    plot = scan_plot.BECScanPlot()
-    qtbot.addWidget(plot)
-    plot.show()
-    qtbot.waitExposed(plot)
-
-    plot.x_channel = "x"
-    plot.y_channel_list = ["y1", "y2"]
-
-    plot.on_scan_segment(
-        {
-            "data": {
-                "x": {"x": {"value": 1}},
-                "y1": {"y1": {"value": 1}},
-                "y2": {"y2": {"value": 3}},
-            },
-            "scanID": "test",
-        },
-        {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]},
-    )
-    plot.reset_plots({}, {})
-    plot.on_scan_segment(
-        {
-            "data": {
-                "x": {"x": {"value": 2}},
-                "y1": {"y1": {"value": 2}},
-                "y2": {"y2": {"value": 4}},
-            },
-            "scanID": "test",
-        },
-        {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]},
-    )
-
-    assert all(plot.scan_curves["y1"].getData()[0] == [2])
-    assert all(plot.scan_curves["y2"].getData()[1] == [4])
-
-
-def test_scan_plot_redraws_dap(qtbot):
-    """Test ScanPlot"""
-    plot = scan_plot.BECScanPlot()
-    qtbot.addWidget(plot)
-    plot.show()
-    qtbot.waitExposed(plot)
-
-    plot.y_channel_list = ["dap.y1", "dap.y2"]
-
-    plot.redraw_dap({"data": {"y1": {"x": [1], "y": [1]}, "y2": {"x": [2], "y": [2]}}}, {})
-
-    assert all(plot.dap_curves["y1"].getData()[0] == [1])
-    assert all(plot.dap_curves["y2"].getData()[1] == [2])

tests/unit_tests/client_mocks.py

@@ -0,0 +1,139 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+from unittest.mock import MagicMock, patch
+
+import fakeredis
+import pytest
+from bec_lib import BECClient, RedisConnector
+from bec_lib.device import Positioner
+from bec_lib.devicemanager import DeviceContainer
+
+
+class FakeDevice:
+    """Fake minimal positioner class for testing."""
+
+    def __init__(self, name, enabled=True):
+        self.name = name
+        self.enabled = enabled
+        self.signals = {self.name: {"value": 1.0}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+
+    def __contains__(self, item):
+        return item == self.name
+
+    @property
+    def _hints(self):
+        return [self.name]
+
+    def set_value(self, fake_value: float = 1.0) -> None:
+        """
+        Setup fake value for device readout
+        Args:
+            fake_value(float): Desired fake value
+        """
+        self.signals[self.name]["value"] = fake_value
+
+    def describe(self) -> dict:
+        """
+        Get the description of the device
+        Returns:
+            dict: Description of the device
+        """
+        return self.description
+
+
+class FakePositioner(FakeDevice):
+    def __init__(self, name, enabled=True, limits=None, read_value=1.0):
+        super().__init__(name, enabled)
+        self.limits = limits if limits is not None else [0, 0]
+        self.read_value = read_value
+
+    def set_read_value(self, value):
+        self.read_value = value
+
+    def read(self):
+        return {self.name: {"value": self.read_value}}
+
+    def set_limits(self, limits):
+        self.limits = limits
+
+    def move(self, value, relative=False):
+        """Simulates moving the device to a new position."""
+        if relative:
+            self.read_value += value
+        else:
+            self.read_value = value
+        # Respect the limits
+        self.read_value = max(min(self.read_value, self.limits[1]), self.limits[0])
+
+    @property
+    def readback(self):
+        return MagicMock(get=MagicMock(return_value=self.read_value))
+
+
+class DMMock:
+    def __init__(self):
+        self.devices = DeviceContainer()
+
+    def add_devives(self, devices: list):
+        for device in devices:
+            self.devices[device.name] = device
+
+
+DEVICES = [
+    FakePositioner("samx", limits=[-10, 10], read_value=2.0),
+    FakePositioner("samy", limits=[-5, 5], read_value=3.0),
+    FakePositioner("aptrx", limits=None, read_value=4.0),
+    FakePositioner("aptry", limits=None, read_value=5.0),
+    FakeDevice("gauss_bpm"),
+    FakeDevice("gauss_adc1"),
+    FakeDevice("gauss_adc2"),
+    FakeDevice("gauss_adc3"),
+    FakeDevice("bpm4i"),
+    FakeDevice("bpm3a"),
+    FakeDevice("bpm3i"),
+    FakeDevice("eiger"),
+]
+
+
+def fake_redis_server(host, port):
+    redis = fakeredis.FakeRedis()
+    return redis
+
+
+@pytest.fixture(scope="function")
+def mocked_client(bec_dispatcher):
+    connector = RedisConnector("localhost:1", redis_cls=fake_redis_server)
+    # Create a MagicMock object
+    client = MagicMock()  # TODO change to real BECClient
+
+    # Shutdown the original client
+    bec_dispatcher.client.shutdown()
+    # Mock the connector attribute
+    bec_dispatcher.client = client
+
+    # Mock the device_manager.devices attribute
+    client.connector = connector
+    client.device_manager = DMMock()
+    client.device_manager.add_devives(DEVICES)
+
+    def mock_mv(*args, relative=False):
+        # Extracting motor and value pairs
+        for i in range(0, len(args), 2):
+            motor = args[i]
+            value = args[i + 1]
+            motor.move(value, relative=relative)
+        return MagicMock(wait=MagicMock())
+
+    client.scans = MagicMock(mv=mock_mv)
+
+    # Ensure isinstance check for Positioner passes
+    original_isinstance = isinstance
+
+    def isinstance_mock(obj, class_info):
+        if class_info == Positioner and isinstance(obj, FakePositioner):
+            return True
+        return original_isinstance(obj, class_info)
+
+    with patch("builtins.isinstance", new=isinstance_mock):
+        yield client
+    connector.shutdown()  # TODO change to real BECClient

tests/unit_tests/conftest.py

@@ -0,0 +1,14 @@
+import pytest
+
+from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
+
+
+@pytest.fixture(autouse=True)
+def bec_dispatcher(threads_check):
+    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
+    yield bec_dispatcher
+    bec_dispatcher.disconnect_all()
+    # clean BEC client
+    bec_dispatcher.client.shutdown()
+    # reinitialize singleton for next test
+    bec_dispatcher_module.BECDispatcher.reset_singleton()

tests/unit_tests/test_bec_connector.py

@@ -1,9 +1,10 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import pytest
 
-from .client_mocks import mocked_client
 from bec_widgets.utils import BECConnector, ConnectionConfig
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def bec_connector(mocked_client):

tests/unit_tests/test_bec_dispatcher.py

@@ -0,0 +1,59 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+import time
+from unittest import mock
+
+import pytest
+import redis
+from bec_lib.connector import MessageObject
+from bec_lib.messages import ScanMessage
+from bec_lib.redis_connector import RedisConnector
+from bec_lib.serialization import MsgpackSerialization
+
+from bec_widgets.utils.bec_dispatcher import QtRedisConnector
+
+
+@pytest.fixture
+def bec_dispatcher_w_connector(bec_dispatcher, topics_msg_list):
+    def pubsub_msg_generator():
+        for topic, msg in topics_msg_list:
+            yield {"channel": topic.encode(), "pattern": None, "data": msg}
+        while True:
+            time.sleep(0.2)
+            yield StopIteration
+
+    with mock.patch("redis.Redis"):
+        pubsub = redis.Redis().pubsub()
+        messages = pubsub_msg_generator()
+        pubsub.get_message.side_effect = lambda timeout: next(messages)
+        connector = QtRedisConnector("localhost:1")
+        bec_dispatcher.client.connector = connector
+        yield bec_dispatcher
+
+
+dummy_msg = MsgpackSerialization.dumps(ScanMessage(point_id=0, scan_id="0", data={}))
+
+
+@pytest.mark.parametrize(
+    "topics_msg_list",
+    [
+        (
+            ("topic1", dummy_msg),
+            ("topic2", dummy_msg),
+            ("topic3", dummy_msg),
+        )
+    ],
+)
+def test_dispatcher_disconnect_all(bec_dispatcher_w_connector, qtbot):
+    bec_dispatcher = bec_dispatcher_w_connector
+    cb1 = mock.Mock(spec=[])
+    cb2 = mock.Mock(spec=[])
+
+    bec_dispatcher.connect_slot(cb1, "topic1")
+    bec_dispatcher.connect_slot(cb1, "topic2")
+    bec_dispatcher.connect_slot(cb2, "topic2")
+    bec_dispatcher.connect_slot(cb2, "topic3")
+    assert len(bec_dispatcher.client.connector._topics_cb) == 3
+
+    bec_dispatcher.disconnect_all()
+
+    assert len(bec_dispatcher.client.connector._topics_cb) == 0

tests/unit_tests/test_bec_figure.py

@@ -1,12 +1,14 @@
 # pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
 import os
+from unittest.mock import MagicMock
 
 import numpy as np
 import pytest
-from unittest.mock import MagicMock
+
+from bec_widgets.widgets import BECFigure, BECMotorMap, BECWaveform
+from bec_widgets.widgets.plots import BECImageShow
 
 from .client_mocks import mocked_client
-from bec_widgets.widgets import BECFigure
 
 
 @pytest.fixture
@@ -14,7 +16,8 @@ def bec_figure(qtbot, mocked_client):
     widget = BECFigure(client=mocked_client)
     qtbot.addWidget(widget)
     qtbot.waitExposed(widget)
-    return widget
+    yield widget
+    widget.close()
 
 
 def test_bec_figure_init(bec_figure):
@@ -36,37 +39,47 @@ def test_bec_figure_init_with_config(mocked_client):
 
 
 def test_bec_figure_add_remove_plot(bec_figure):
-    initial_count = len(bec_figure.widgets)
+    initial_count = len(bec_figure._widgets)
 
     # Adding 3 widgets -  2 WaveformBase and 1 PlotBase
     w0 = bec_figure.add_plot()
-    w1 = bec_figure.add_plot(widget_id="test_waveform")
-    w2 = bec_figure.add_widget(widget_id="test_plot", widget_type="PlotBase")
+    w1 = bec_figure.add_plot()
+    w2 = bec_figure.add_widget(widget_type="PlotBase")
 
     # Check if the widgets were added
-    assert len(bec_figure.widgets) == initial_count + 3
-    assert "widget_1" in bec_figure.widgets
-    assert "test_plot" in bec_figure.widgets
-    assert "test_waveform" in bec_figure.widgets
-    assert bec_figure.widgets["widget_1"].config.widget_class == "BECWaveform1D"
-    assert bec_figure.widgets["test_plot"].config.widget_class == "BECPlotBase"
-    assert bec_figure.widgets["test_waveform"].config.widget_class == "BECWaveform1D"
+    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"
 
     # Check accessing positions by the grid in figure
     assert bec_figure[0, 0] == w0
     assert bec_figure[1, 0] == w1
     assert bec_figure[2, 0] == w2
 
-    # Removing 1 widget - PlotBase
-    bec_figure.remove(widget_id="test_plot")
-    assert len(bec_figure.widgets) == initial_count + 2
-    assert "test_plot" not in bec_figure.widgets
-    assert "test_waveform" in bec_figure.widgets
-    assert bec_figure.widgets["test_waveform"].config.widget_class == "BECWaveform1D"
+    # Removing 1 widget
+    bec_figure.remove(widget_id="widget_1")
+    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"
+
+
+def test_add_different_types_of_widgets(bec_figure):
+    plt = bec_figure.plot("samx", "bpm4i")
+    im = bec_figure.image("eiger")
+    motor_map = bec_figure.motor_map("samx", "samy")
+
+    assert plt.__class__ == BECWaveform
+    assert im.__class__ == BECImageShow
+    assert motor_map.__class__ == BECMotorMap
 
 
 def test_access_widgets_access_errors(bec_figure):
-    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    bec_figure.add_plot(row=0, col=0)
 
     # access widget by non-existent coordinates
     with pytest.raises(ValueError) as excinfo:
@@ -88,26 +101,18 @@ def test_access_widgets_access_errors(bec_figure):
 
 
 def test_add_plot_to_occupied_position(bec_figure):
-    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    bec_figure.add_plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
-        bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=0)
+        bec_figure.add_plot(row=0, col=0)
         assert "Position at row 0 and column 0 is already occupied." in str(excinfo.value)
 
 
-def test_add_plot_to_occupied_id(bec_figure):
-    bec_figure.add_plot(widget_id="test_waveform", row=0, col=0)
-
-    with pytest.raises(ValueError) as excinfo:
-        bec_figure.add_plot(widget_id="test_waveform", row=0, col=1)
-        assert "Widget with ID 'test_waveform' already exists" in str(excinfo.value)
-
-
 def test_remove_plots(bec_figure):
-    w1 = bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
-    w2 = bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
-    w3 = bec_figure.add_plot(widget_id="test_waveform_3", row=1, col=0)
-    w4 = bec_figure.add_plot(widget_id="test_waveform_4", row=1, col=1)
+    w1 = bec_figure.add_plot(row=0, col=0)
+    w2 = bec_figure.add_plot(row=0, col=1)
+    w3 = bec_figure.add_plot(row=1, col=0)
+    w4 = bec_figure.add_plot(row=1, col=1)
 
     assert bec_figure[0, 0] == w1
     assert bec_figure[0, 1] == w2
@@ -116,47 +121,47 @@ def test_remove_plots(bec_figure):
 
     # remove by coordinates
     bec_figure[0, 0].remove()
-    assert "test_waveform_1" not in bec_figure.widgets
+    assert "widget_1" not in bec_figure._widgets
 
     # remove by widget_id
-    bec_figure.remove(widget_id="test_waveform_2")
-    assert "test_waveform_2" not in bec_figure.widgets
+    bec_figure.remove(widget_id="widget_2")
+    assert "widget_2" not in bec_figure._widgets
 
     # remove by widget object
     w3.remove()
-    assert "test_waveform_3" not in bec_figure.widgets
+    assert "widget_3" not in bec_figure._widgets
 
     # check the remaining widget 4
     assert bec_figure[0, 0] == w4
-    assert bec_figure["test_waveform_4"] == w4
-    assert "test_waveform_4" in bec_figure.widgets
-    assert len(bec_figure.widgets) == 1
+    assert bec_figure["widget_4"] == w4
+    assert "widget_4" in bec_figure._widgets
+    assert len(bec_figure._widgets) == 1
 
 
 def test_remove_plots_by_coordinates_ints(bec_figure):
-    w1 = bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
-    w2 = bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
+    w1 = bec_figure.add_plot(row=0, col=0)
+    w2 = bec_figure.add_plot(row=0, col=1)
 
     bec_figure.remove(0, 0)
-    assert "test_waveform_1" not in bec_figure.widgets
-    assert "test_waveform_2" in bec_figure.widgets
+    assert "widget_1" not in bec_figure._widgets
+    assert "widget_2" in bec_figure._widgets
     assert bec_figure[0, 0] == w2
-    assert len(bec_figure.widgets) == 1
+    assert len(bec_figure._widgets) == 1
 
 
 def test_remove_plots_by_coordinates_tuple(bec_figure):
-    w1 = bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
-    w2 = bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
+    w1 = bec_figure.add_plot(row=0, col=0)
+    w2 = bec_figure.add_plot(row=0, col=1)
 
     bec_figure.remove(coordinates=(0, 0))
-    assert "test_waveform_1" not in bec_figure.widgets
-    assert "test_waveform_2" in bec_figure.widgets
+    assert "widget_1" not in bec_figure._widgets
+    assert "widget_2" in bec_figure._widgets
     assert bec_figure[0, 0] == w2
-    assert len(bec_figure.widgets) == 1
+    assert len(bec_figure._widgets) == 1
 
 
 def test_remove_plot_by_id_error(bec_figure):
-    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    bec_figure.add_plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
         bec_figure.remove(widget_id="non_existent_widget")
@@ -164,7 +169,7 @@ def test_remove_plot_by_id_error(bec_figure):
 
 
 def test_remove_plot_by_coordinates_error(bec_figure):
-    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    bec_figure.add_plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
         bec_figure.remove(0, 1)
@@ -172,30 +177,30 @@ def test_remove_plot_by_coordinates_error(bec_figure):
 
 
 def test_remove_plot_by_providing_nothing(bec_figure):
-    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    bec_figure.add_plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
         bec_figure.remove()
         assert "Must provide either widget_id or coordinates for removal." in str(excinfo.value)
 
 
-def test_change_theme(bec_figure):
-    bec_figure.change_theme("dark")
-    assert bec_figure.config.theme == "dark"
-    assert bec_figure.backgroundBrush().color().name() == "#000000"
-    bec_figure.change_theme("light")
-    assert bec_figure.config.theme == "light"
-    assert bec_figure.backgroundBrush().color().name() == "#ffffff"
-    bec_figure.change_theme("dark")
-    assert bec_figure.config.theme == "dark"
-    assert bec_figure.backgroundBrush().color().name() == "#000000"
+# def test_change_theme(bec_figure): #TODO do no work at python 3.12
+#     bec_figure.change_theme("dark")
+#     assert bec_figure.config.theme == "dark"
+#     assert bec_figure.backgroundBrush().color().name() == "#000000"
+#     bec_figure.change_theme("light")
+#     assert bec_figure.config.theme == "light"
+#     assert bec_figure.backgroundBrush().color().name() == "#ffffff"
+#     bec_figure.change_theme("dark")
+#     assert bec_figure.config.theme == "dark"
+#     assert bec_figure.backgroundBrush().color().name() == "#000000"
 
 
 def test_change_layout(bec_figure):
-    w1 = bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
-    w2 = bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
-    w3 = bec_figure.add_plot(widget_id="test_waveform_3", row=1, col=0)
-    w4 = bec_figure.add_plot(widget_id="test_waveform_4", row=1, col=1)
+    w1 = bec_figure.add_plot(row=0, col=0)
+    w2 = bec_figure.add_plot(row=0, col=1)
+    w3 = bec_figure.add_plot(row=1, col=0)
+    w4 = bec_figure.add_plot(row=1, col=1)
 
     bec_figure.change_layout(max_columns=1)
 
@@ -215,12 +220,25 @@ def test_change_layout(bec_figure):
 
 
 def test_clear_all(bec_figure):
-    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
-    bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
-    bec_figure.add_plot(widget_id="test_waveform_3", row=1, col=0)
-    bec_figure.add_plot(widget_id="test_waveform_4", row=1, col=1)
+    bec_figure.add_plot(row=0, col=0)
+    bec_figure.add_plot(row=0, col=1)
+    bec_figure.add_plot(row=1, col=0)
+    bec_figure.add_plot(row=1, col=1)
 
     bec_figure.clear_all()
 
-    assert len(bec_figure.widgets) == 0
+    assert len(bec_figure._widgets) == 0
     assert np.shape(bec_figure.grid) == (0,)
+
+
+def test_shortcuts(bec_figure):
+    plt = bec_figure.plot("samx", "bpm4i")
+    im = bec_figure.image("eiger")
+    motor_map = bec_figure.motor_map("samx", "samy")
+
+    assert plt.config.widget_class == "BECWaveform"
+    assert plt.__class__ == BECWaveform
+    assert im.config.widget_class == "BECImageShow"
+    assert im.__class__ == BECImageShow
+    assert motor_map.config.widget_class == "BECMotorMap"
+    assert motor_map.__class__ == BECMotorMap

tests/unit_tests/test_bec_monitor.py

@@ -1,12 +1,14 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import os
-import yaml
-
-import pytest
 from unittest.mock import MagicMock
 
+import pytest
+import yaml
+
 from bec_widgets.widgets import BECMonitor
 
+from .client_mocks import mocked_client
+
 
 def load_test_config(config_name):
     """Helper function to load config from yaml file."""
@@ -16,69 +18,6 @@ def load_test_config(config_name):
     return config
 
 
-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True):
-        self.name = name
-        self.enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name}}
-
-    def __contains__(self, item):
-        return item == self.name
-
-    @property
-    def _hints(self):
-        return [self.name]
-
-    def set_value(self, fake_value: float = 1.0) -> None:
-        """
-        Setup fake value for device readout
-        Args:
-            fake_value(float): Desired fake value
-        """
-        self.signals[self.name]["value"] = fake_value
-
-    def describe(self) -> dict:
-        """
-        Get the description of the device
-        Returns:
-            dict: Description of the device
-        """
-        return self.description
-
-
-def get_mocked_device(device_name: str):
-    """
-    Helper function to mock the devices
-    Args:
-        device_name(str): Name of the device to mock
-    """
-    return FakeDevice(name=device_name, enabled=True)
-
-
-@pytest.fixture(scope="function")
-def mocked_client():
-    # Create a dictionary of mocked devices
-    device_names = ["samx", "gauss_bpm", "gauss_adc1", "gauss_adc2", "gauss_adc3", "bpm4i"]
-    mocked_devices = {name: get_mocked_device(name) for name in device_names}
-
-    # Create a MagicMock object
-    client = MagicMock()
-
-    # Mock the device_manager.devices attribute
-    client.device_manager.devices = MagicMock()
-    client.device_manager.devices.__getitem__.side_effect = lambda x: mocked_devices.get(x)
-    client.device_manager.devices.__contains__.side_effect = lambda x: x in mocked_devices
-
-    # Set each device as an attribute of the mock
-    for name, device in mocked_devices.items():
-        setattr(client.device_manager.devices, name, device)
-
-    return client
-
-
 @pytest.fixture(scope="function")
 def monitor(bec_dispatcher, qtbot, mocked_client):
     # client = MagicMock()
@@ -126,12 +65,7 @@ def test_on_config_update(monitor, config_initial, config_update):
 @pytest.mark.parametrize(
     "config_name, expected_num_columns, expected_plot_names, expected_coordinates",
     [
-        (
-            "config_device",
-            1,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (1, 0)],
-        ),
+        ("config_device", 1, ["BPM4i plots vs samx", "Gauss plots vs samx"], [(0, 0), (1, 0)]),
         (
             "config_scan",
             3,
@@ -186,7 +120,7 @@ msg_1 = {
         "gauss_adc1": {"gauss_adc1": {"value": 8}},
         "gauss_adc2": {"gauss_adc2": {"value": 9}},
     },
-    "scanID": 1,
+    "scan_id": 1,
 }
 metadata_grid = {"scan_name": "grid_scan"}
 metadata_line = {"scan_name": "line_scan"}
@@ -195,7 +129,7 @@ metadata_line = {"scan_name": "line_scan"}
 @pytest.mark.parametrize(
     "config_name, msg, metadata, expected_data",
     [
-        # case: msg does not have 'scanID'
+        # case: msg does not have 'scan_id'
         (
             "config_device",
             {"data": {}},
@@ -271,9 +205,6 @@ def test_on_scan_segment(monitor, config_name, msg, metadata, expected_data):
     config = load_test_config(config_name)
     monitor.on_config_update(config)
 
-    # Get hints
-    monitor.dev.__getitem__.side_effect = mock_getitem
-
     # Mock scan_storage.find_scan_by_ID
     mock_scan_data = MagicMock()
     mock_scan_data.data = {

tests/unit_tests/test_bec_motor_map.py

@@ -0,0 +1,125 @@
+import pytest
+
+from bec_widgets.widgets import BECMotorMap
+from bec_widgets.widgets.plots.motor_map import MotorMapConfig
+from bec_widgets.widgets.plots.waveform import Signal, SignalData
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture(scope="function")
+def bec_motor_map(qtbot, mocked_client):
+    widget = BECMotorMap(client=mocked_client, gui_id="BECMotorMap_test")
+    # qtbot.addWidget(widget)
+    # qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_motor_map_init(bec_motor_map):
+    default_config = MotorMapConfig(widget_class="BECMotorMap", gui_id="BECMotorMap_test")
+
+    assert bec_motor_map.config == default_config
+
+
+def test_motor_map_change_motors(bec_motor_map):
+    bec_motor_map.change_motors("samx", "samy")
+
+    assert bec_motor_map.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
+    assert bec_motor_map.config.signals.y == SignalData(name="samy", entry="samy", limits=[-5, 5])
+
+
+def test_motor_map_get_limits(bec_motor_map):
+    expected_limits = {
+        "samx": [-10, 10],
+        "samy": [-5, 5],
+    }
+
+    for motor_name, expected_limit in expected_limits.items():
+        actual_limit = bec_motor_map._get_motor_limit(motor_name)
+        assert actual_limit == expected_limit
+
+
+def test_motor_map_get_init_position(bec_motor_map):
+    bec_motor_map.set_precision(2)
+
+    motor_map_dev = bec_motor_map.client.device_manager.devices
+
+    expected_positions = {
+        ("samx", "samx"): motor_map_dev["samx"].read()["samx"]["value"],
+        ("samy", "samy"): motor_map_dev["samy"].read()["samy"]["value"],
+        ("aptrx", "aptrx"): motor_map_dev["aptrx"].read()["aptrx"]["value"],
+        ("aptry", "aptry"): motor_map_dev["aptry"].read()["aptry"]["value"],
+    }
+
+    for (motor_name, entry), expected_position in expected_positions.items():
+        actual_position = bec_motor_map._get_motor_init_position(motor_name, entry, 2)
+        assert actual_position == expected_position
+
+
+def test_motor_movement_updates_position_and_database(bec_motor_map):
+    motor_map_dev = bec_motor_map.client.device_manager.devices
+
+    init_positions = {
+        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
+        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
+    }
+
+    bec_motor_map.change_motors("samx", "samy")
+
+    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
+    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+
+    # Simulate motor movement for 'samx' only
+    new_position_samx = 4.0
+    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+
+    init_positions["samx"].append(new_position_samx)
+    init_positions["samy"].append(init_positions["samy"][-1])
+    # Verify database update for 'samx'
+    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
+
+    # Verify 'samy' retains its last known position
+    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+
+
+def test_scatter_plot_rendering(bec_motor_map):
+    motor_map_dev = bec_motor_map.client.device_manager.devices
+
+    init_positions = {
+        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
+        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
+    }
+
+    bec_motor_map.change_motors("samx", "samy")
+
+    # Simulate motor movement for 'samx' only
+    new_position_samx = 4.0
+    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+    bec_motor_map._update_plot()
+
+    # Get the scatter plot item
+    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+
+    # Check the scatter plot item properties
+    assert len(scatter_plot_item.data) > 0, "Scatter plot data is empty"
+    x_data = scatter_plot_item.data["x"]
+    y_data = scatter_plot_item.data["y"]
+    assert x_data[-1] == new_position_samx, "Scatter plot X data not updated correctly"
+    assert (
+        y_data[-1] == init_positions["samy"][-1]
+    ), "Scatter plot Y data should retain last known position"
+
+
+def test_plot_visualization_consistency(bec_motor_map):
+    bec_motor_map.change_motors("samx", "samy")
+    # Simulate updating the plot with new data
+    bec_motor_map.on_device_readback({"signals": {"samx": {"value": 5}}})
+    bec_motor_map.on_device_readback({"signals": {"samy": {"value": 9}}})
+    bec_motor_map._update_plot()
+
+    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+
+    # Check if the scatter plot reflects the new data correctly
+    assert (
+        scatter_plot_item.data["x"][-1] == 5 and scatter_plot_item.data["y"][-1] == 9
+    ), "Plot not updated correctly with new data"

tests/unit_tests/test_client_utils.py

@@ -0,0 +1,29 @@
+from unittest import mock
+
+import pytest
+
+from bec_widgets.cli.client import BECFigure
+
+from .client_mocks import FakeDevice
+
+
+@pytest.fixture
+def cli_figure():
+    fig = BECFigure(gui_id="test")
+    with mock.patch.object(fig, "_run_rpc") as mock_rpc_call:
+        with mock.patch.object(fig, "gui_is_alive", return_value=True):
+            yield fig, mock_rpc_call
+
+
+def test_rpc_call_plot(cli_figure):
+    fig, mock_rpc_call = cli_figure
+    fig.plot("samx", "bpm4i")
+    mock_rpc_call.assert_called_with("plot", "samx", "bpm4i")
+
+
+def test_rpc_call_accepts_device_as_input(cli_figure):
+    dev1 = FakeDevice("samx")
+    dev2 = FakeDevice("bpm4i")
+    fig, mock_rpc_call = cli_figure
+    fig.plot(dev1, dev2)
+    mock_rpc_call.assert_called_with("plot", "samx", "bpm4i")

tests/unit_tests/test_config_dialog.py

@@ -2,12 +2,13 @@
 import os
 from unittest.mock import MagicMock
 
-import yaml
-
 import pytest
-from qtpy.QtWidgets import QTabWidget, QTableWidgetItem
+import yaml
+from qtpy.QtWidgets import QTableWidgetItem, QTabWidget
 
-from bec_widgets.widgets import ConfigDialog
+from bec_widgets.widgets.monitor.config_dialog import ConfigDialog
+
+from .client_mocks import mocked_client
 
 
 def load_test_config(config_name):
@@ -18,69 +19,6 @@ def load_test_config(config_name):
     return config
 
 
-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True):
-        self.name = name
-        self.enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name}}
-
-    def __contains__(self, item):
-        return item == self.name
-
-    @property
-    def _hints(self):
-        return [self.name]
-
-    def set_value(self, fake_value: float = 1.0) -> None:
-        """
-        Setup fake value for device readout
-        Args:
-            fake_value(float): Desired fake value
-        """
-        self.signals[self.name]["value"] = fake_value
-
-    def describe(self) -> dict:
-        """
-        Get the description of the device
-        Returns:
-            dict: Description of the device
-        """
-        return self.description
-
-
-def get_mocked_device(device_name: str):
-    """
-    Helper function to mock the devices
-    Args:
-        device_name(str): Name of the device to mock
-    """
-    return FakeDevice(name=device_name, enabled=True)
-
-
-@pytest.fixture(scope="function")
-def mocked_client():
-    # Create a dictionary of mocked devices
-    device_names = ["samx", "gauss_bpm", "gauss_adc1", "gauss_adc2", "gauss_adc3", "bpm4i"]
-    mocked_devices = {name: get_mocked_device(name) for name in device_names}
-
-    # Create a MagicMock object
-    client = MagicMock()
-
-    # Mock the device_manager.devices attribute
-    client.device_manager.devices = MagicMock()
-    client.device_manager.devices.__getitem__.side_effect = lambda x: mocked_devices.get(x)
-    client.device_manager.devices.__contains__.side_effect = lambda x: x in mocked_devices
-
-    # Set each device as an attribute of the mock
-    for name, device in mocked_devices.items():
-        setattr(client.device_manager.devices, name, device)
-
-    return client
-
-
 @pytest.fixture(scope="function")
 def config_dialog(qtbot, mocked_client):
     client = mocked_client

tests/unit_tests/test_editor.py

@@ -2,13 +2,11 @@
 
 import os
 import tempfile
-from unittest.mock import MagicMock
-from unittest.mock import patch, mock_open
+from unittest.mock import MagicMock, mock_open, patch
 
 import pytest
-
-from qtpy.QtWidgets import QTextEdit
 from qtpy.Qsci import QsciScintilla
+from qtpy.QtWidgets import QTextEdit
 
 from bec_widgets.widgets.editor.editor import AutoCompleter, BECEditor
 

tests/unit_tests/test_eiger_plot.py

@@ -1,10 +1,12 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import json
 from unittest.mock import MagicMock, patch
+
 import numpy as np
 import pyqtgraph as pg
 import pytest
 import zmq
+
 from bec_widgets.examples.eiger_plot.eiger_plot import EigerPlot
 
 

tests/unit_tests/test_generate_cli_client.py

@@ -1,7 +1,9 @@
-import pytest
-from bec_widgets.cli.generate_cli import ClientGenerator
 from textwrap import dedent
+
 import black
+import pytest
+
+from bec_widgets.cli.generate_cli import ClientGenerator
 
 
 # Mock classes to test the generator