0.46.7

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.10
+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,28 +109,64 @@ tests:
         coverage_format: cobertura
         path: coverage.xml
 
-#tests-3.10-pyqt5: #todo enable when we decide what qt distributions we want to support
-#  extends: "tests"
-#  stage: AdditionalTests
-#  image: $CI_DOCKER_REGISTRY/python:3.10
-#  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.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
@@ -137,10 +191,11 @@ semver:
       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
@@ -151,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/

CHANGELOG.md

@@ -2,6 +2,122 @@
 
 <!--next-version-placeholder-->
 
+## 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

bec_widgets/cli/__init__.py

@@ -0,0 +1 @@
+from .client import BECFigure

bec_widgets/cli/client.py

@@ -1,18 +1,18 @@
 # 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 get_config(self, dict_output: "bool" = True) -> "dict | BaseModel":
+    def config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
-        Args:
-            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
         Returns:
-            dict: The configuration of the plot widget.
+            dict: The configuration of the widget.
         """
 
     @rpc_call
@@ -135,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
@@ -155,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.
 
@@ -194,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.
         """
 
@@ -251,16 +266,6 @@ class BECWaveform1D(RPCBase):
             dict | pd.DataFrame: Data of all curves in the specified format.
         """
 
-    @rpc_call
-    def get_config(self, dict_output: "bool" = True) -> "dict | BaseModel":
-        """
-        Get the configuration of the widget.
-        Args:
-            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
-        Returns:
-            dict: The configuration of the plot widget.
-        """
-
     @rpc_call
     def set(self, **kwargs) -> "None":
         """
@@ -382,6 +387,15 @@ class BECWaveform1D(RPCBase):
 
 
 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]":
@@ -403,18 +417,21 @@ class BECFigure(RPCBase, BECFigureClientMixin):
         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
-    ) -> "BECWaveform1D":
+    ) -> "BECWaveform":
         """
         Add a Waveform1D plot to the figure at the specified position.
         Args:
@@ -449,42 +466,71 @@ class BECFigure(RPCBase, BECFigureClientMixin):
             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:
+            **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
-    ) -> "BECWaveform1D":
+    ) -> "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:
-            BECWaveform1D: The waveform plot widget.
+            BECWaveform: The waveform plot widget.
         """
 
     @rpc_call
@@ -511,6 +557,21 @@ class BECFigure(RPCBase, BECFigureClientMixin):
             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,
@@ -553,18 +614,17 @@ class BECFigure(RPCBase, BECFigureClientMixin):
         Clear all widgets from the figure and reset to default state
         """
 
-    @rpc_call
-    def get_config(self, dict_output: "bool" = True) -> "dict | BaseModel":
-        """
-        Get the configuration of the widget.
-        Args:
-            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
-        Returns:
-            dict: The configuration of the plot widget.
-        """
-
 
 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):
         """
@@ -595,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"):
         """
@@ -645,6 +713,15 @@ class BECCurve(RPCBase):
 
 
 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":
         """
@@ -668,14 +745,6 @@ class BECImageShow(RPCBase):
             ImageItemConfig|dict: The configuration of the image.
         """
 
-    @rpc_call
-    def get_image_list(self) -> "list[BECImageItem]":
-        """
-        Get the list of images.
-        Returns:
-            list[BECImageItem]: The list of images.
-        """
-
     @rpc_call
     def get_image_dict(self) -> "dict[str, dict[str, BECImageItem]]":
         """
@@ -837,16 +906,6 @@ class BECImageShow(RPCBase):
             use_threading(bool): Whether to use threading.
         """
 
-    @rpc_call
-    def get_config(self, dict_output: "bool" = True) -> "dict | BaseModel":
-        """
-        Get the configuration of the widget.
-        Args:
-            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
-        Returns:
-            dict: The configuration of the plot widget.
-        """
-
     @rpc_call
     def set(self, **kwargs) -> "None":
         """
@@ -966,20 +1025,37 @@ class BECImageShow(RPCBase):
         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 get_config(self, dict_output: "bool" = True) -> "dict | BaseModel":
+    def config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
-        Args:
-            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
         Returns:
-            dict: The configuration of the plot widget.
+            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):
         """
@@ -1082,11 +1158,87 @@ class BECImageItem(RPCBase):
         """
 
     @rpc_call
-    def get_config(self, dict_output: "bool" = True) -> "dict | BaseModel":
+    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.
-        Args:
-            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
         Returns:
-            dict: The configuration of the plot widget.
+            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,16 +1,27 @@
+from __future__ import annotations
+
 import importlib
+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_lib import MessageEndpoints, messages
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
+if TYPE_CHECKING:
+    from bec_widgets.cli.client import BECFigure
+
 
 def rpc_call(func):
     """
@@ -25,15 +36,119 @@ 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
 
 
+def get_selected_device(monitored_devices, selected_device):
+    """
+    Get the selected device for the plot. If no device is selected, the first
+    device in the monitored devices list is selected.
+    """
+    if selected_device:
+        return selected_device
+    if len(monitored_devices) > 0:
+        sel_device = monitored_devices[0]
+        return sel_device
+    return None
+
+
+def update_script(figure: BECFigure, msg):
+    """
+    Update the script with the given data.
+    """
+    info = msg.info
+    status = msg.status
+    scan_id = msg.scan_id
+    scan_number = info.get("scan_number", 0)
+    scan_name = info.get("scan_name", "Unknown")
+    scan_report_devices = info.get("scan_report_devices", [])
+    monitored_devices = info.get("readout_priority", {}).get("monitored", [])
+    monitored_devices = [dev for dev in monitored_devices if dev not in scan_report_devices]
+
+    if scan_name == "line_scan" and scan_report_devices:
+        dev_x = scan_report_devices[0]
+        dev_y = get_selected_device(monitored_devices, figure.selected_device)
+        print(f"Selected device: {dev_y}")
+        if not dev_y:
+            return
+        figure.clear_all()
+        plt = figure.plot(dev_x, dev_y)
+        plt.set(title=f"Scan {scan_number}", x_label=dev_x, y_label=dev_y)
+    elif scan_name == "grid_scan" and scan_report_devices:
+        print(f"Scan {scan_number} is running")
+        dev_x = scan_report_devices[0]
+        dev_y = scan_report_devices[1]
+        dev_z = get_selected_device(monitored_devices, figure.selected_device)
+        figure.clear_all()
+        plt = figure.plot(dev_x, dev_y, dev_z, label=f"Scan {scan_number}")
+        plt.set(title=f"Scan {scan_number}", x_label=dev_x, y_label=dev_y)
+    elif scan_report_devices:
+        dev_x = scan_report_devices[0]
+        dev_y = get_selected_device(monitored_devices, figure.selected_device)
+        if not dev_y:
+            return
+        figure.clear_all()
+        plt = figure.plot(dev_x, dev_y, label=f"Scan {scan_number}")
+        plt.set(title=f"Scan {scan_number}", x_label=dev_x, y_label=dev_y)
+
+
 class BECFigureClientMixin:
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._process = None
+        self.update_script = update_script
+        self._target_endpoint = MessageEndpoints.scan_status()
+        self._selected_device = None
+        self.stderr_output = []
+
+    @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
+            if msg.status == "open":
+                self.update_script(self, msg)
 
     def show(self) -> None:
         """
@@ -41,6 +156,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:
         """
@@ -49,21 +167,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:
         """
@@ -71,22 +194,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:
@@ -174,9 +297,16 @@ class RPCBase:
         Wait for the response from the server.
         """
         response = None
-        while response is None:
+        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
@@ -106,22 +107,23 @@ class {class_name}(RPCBase):"""
 if __name__ == "__main__":  # pragma: no cover
     import os
 
-    from bec_widgets.widgets.figure import BECFigure
-    from bec_widgets.widgets.plots import BECPlotBase, BECWaveform1D, BECImageShow
-    from bec_widgets.widgets.plots.waveform1d import BECCurve
-    from bec_widgets.widgets.plots.image import BECImageItem
     from bec_widgets.utils import BECConnector
+    from bec_widgets.widgets.figure import BECFigure
+    from bec_widgets.widgets.plots import BECImageShow, BECMotorMap, BECPlotBase, BECWaveform
+    from bec_widgets.widgets.plots.image import BECImageItem
+    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,
+        BECWaveform,
         BECFigure,
         BECCurve,
         BECImageShow,
         BECConnector,
         BECImageItem,
+        BECMotorMap,
     ]
     generator = ClientGenerator()
     generator.generate_client(clss)

bec_widgets/cli/server.py

@@ -1,31 +1,33 @@
 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, BECImageShow
+from bec_widgets.widgets.plots import BECCurve, BECImageShow, BECWaveform
 
 
 class BECWidgetsCLIServer:
-    WIDGETS = [BECWaveform1D, BECFigure, BECCurve, BECImageShow]
+    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()
+        # 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")
@@ -95,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")
+
+    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")
@@ -106,4 +128,10 @@ if __name__ == "__main__":  # pragma: no cover
 
     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/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/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/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/utils/__init__.py

@@ -1,8 +1,8 @@
-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 .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,11 +31,11 @@ class ConnectionConfig(BaseModel):
 class BECConnector:
     """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
 
-    USER_ACCESS = ["get_config"]
+    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:
@@ -54,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,60 +1,113 @@
 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
 
-from bec_lib.endpoints import EndpointInfo
-
-# 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[EndpointInfo, str, list[Union[EndpointInfo, str]]],
-        single_callback_for_all_topics=False,
     ) -> None:
         """Connect widget's pyqt slot, so that it is called on new pub/sub topic message.
 
@@ -62,132 +115,27 @@ class _BECDispatcher(QObject):
             slot (Callable): A slot method/function that accepts two inputs: content and metadata of
                 the corresponding pub/sub message
             topics (EndpointInfo | 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.
         """
-        # Normalise the topics input
-        if isinstance(topics, (str, EndpointInfo)):
-            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))
 
-        endpoint_to_consumer_type = {
-            (topic.endpoint if isinstance(topic, EndpointInfo) else topic): (
-                topic.message_op.name if isinstance(topic, EndpointInfo) else "SEND"
-            )
-            for topic in 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]
 
-        # Group topics by consumer type
-        consumer_type_to_endpoints = {}
-        for endpoint, consumer_type in endpoint_to_consumer_type.items():
-            if consumer_type not in consumer_type_to_endpoints:
-                consumer_type_to_endpoints[consumer_type] = []
-            consumer_type_to_endpoints[consumer_type].append(endpoint)
+    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]
 
-        for consumer_type, endpoints in consumer_type_to_endpoints.items():
-            topics_key = (
-                tuple(sorted(endpoints)) if single_callback_for_all_topics else tuple(endpoints)
-            )
-
-            if topics_key not in self._connections:
-                self._connections[topics_key] = self._create_connection(endpoints, consumer_type)
-            connection = self._connections[topics_key]
-
-            if slot not in connection.slots:
-                connection.signal.connect(slot)
-                connection.slots.add(slot)
-
-    def _create_connection(self, topics: list, consumer_type: str) -> _Connection:
-        """Creates a new connection for given topics."""
-
-        def cb(msg):
-            if isinstance(msg, dict):
-                msg = msg["data"]
-            else:
-                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:
-            if consumer_type == "STREAM":
-                self.client.connector.register_stream(topics=topics, cb=cb, newest_only=True)
-            else:
-                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
-        """
-        # Normalise the topics input
-        if isinstance(topics, (str, EndpointInfo)):
-            topics = [topics]
-
-        endpoints = [
-            topic.endpoint if isinstance(topic, EndpointInfo) else topic for topic in topics
-        ]
-
-        for key, connection in list(self._connections.items()):
-            if slot in connection.slots:
-                common_topics = set(endpoints).intersection(key)
-                if common_topics:
-                    remaining_topics = set(key) - set(endpoints)
-                    # 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/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/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

@@ -11,19 +11,20 @@ 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 (
+    BECImageShow,
+    BECMotorMap,
     BECPlotBase,
-    BECWaveform1D,
+    BECWaveform,
     Waveform1DConfig,
     WidgetConfig,
-    BECImageShow,
 )
 from bec_widgets.widgets.plots.image import ImageConfig
+from bec_widgets.widgets.plots.motor_map import MotorMapConfig
 
 
 class FigureConfig(ConnectionConfig):
@@ -43,8 +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(
@@ -95,17 +97,19 @@ class WidgetHandler:
 
 class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     USER_ACCESS = [
+        "config_dict",
         "axes",
         "widgets",
         "add_plot",
         "add_image",
+        "add_motor_map",
         "plot",
         "image",
+        "motor_map",
         "remove",
         "change_layout",
         "change_theme",
         "clear_all",
-        "get_config",
     ]
 
     clean_signal = pyqtSignal()
@@ -160,18 +164,21 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         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,
-    ) -> BECWaveform1D:
+    ) -> BECWaveform:
         """
         Add a Waveform1D plot to the figure at the specified position.
         Args:
@@ -193,8 +200,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
         # TODO remove repetition from .plot method
 
-        # User wants to add scan curve
-        if x_name is not None and y_name is not None and x is None and y is None:
+        # 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,
@@ -204,7 +211,27 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
                 color=color,
                 label=label,
             )
-            # User wants to add custom curve
+        # 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,
@@ -219,52 +246,81 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         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,
-    ) -> BECWaveform1D:
+    ) -> 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:
-            BECWaveform1D: The waveform plot widget.
+            BECWaveform: The waveform plot widget.
         """
-        waveform = self._find_first_widget_by_class(BECWaveform1D, can_fail=True)
+        waveform = self._find_first_widget_by_class(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
-        if x_name is not None and y_name is not None and x is None and y is None:
+        # 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,
+                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:
+        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,
@@ -348,7 +404,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             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:
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
             BECImageShow: The image widget.
@@ -390,6 +446,72 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
         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 = self._find_first_widget_by_class(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 = self._generate_unique_widget_id()
+        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", "ImShow"] = "PlotBase",
@@ -665,8 +787,8 @@ 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()
+        # for widget in self._widgets.values():
+        #     widget.cleanup()
         self.clear()
         self._widgets = defaultdict(dict)
         self.grid = []
@@ -674,192 +796,3 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         self.config = FigureConfig(
             widget_class=self.__class__.__name__, gui_id=self.gui_id, theme=theme
         )
-
-    # def cleanup(self):
-    #     """Cleanup the figure widget."""
-    #     self.clear_all()
-    #     self.clean_signal.emit()
-
-    def start(self):
-        import sys
-
-        app = QApplication(sys.argv)
-        win = QMainWindow()
-        win.setCentralWidget(self)
-        win.show()
-
-        sys.exit(app.exec_())
-
-
-class BECFigureMainWindow(QMainWindow):
-    def __init__(self, parent=None, bec_figure=None):
-        super().__init__(parent)
-
-        self.figure = bec_figure
-        self.setCentralWidget(self.figure)
-
-        self.figure.clean_signal.connect(self.confirm_close)
-
-        self.safe_close = False
-
-    def confirm_close(self):
-        self.safe_close = True
-
-    def closeEvent(self, event):
-        self.figure.cleanup()
-        # self.figure.client.shutdown()
-        if self.safe_close == True:
-            print("Safe close")
-            event.accept()
-
-
-##################################################
-##################################################
-# 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})
-        # self.set_console_font_size(70)
-
-    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])
-        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,
-                "w4": self.w4,
-                "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.add_widget(widget_type="Waveform1D", row=0, col=0, title="Widget 1")
-        self.figure.add_widget(widget_type="Waveform1D", row=0, col=1, title="Widget 2")
-        self.figure.add_image(
-            title="Image", row=1, col=0, color_map="viridis", color_bar="simple", vrange=(0, 100)
-        )
-        self.figure.add_image(title="Image", row=1, col=1, vrange=(0, 100))
-
-        self.w1 = self.figure[0, 0]
-        self.w2 = self.figure[0, 1]
-        self.w3 = self.figure[1, 0]
-        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",
-        # )
-
-        # Image setting for w3
-
-        self.w3.add_monitor_image("eiger", vrange=(0, 100), color_bar="full")
-
-        # Image setting for w4
-        self.w4.add_monitor_image("eiger", vrange=(0, 100), color_map="viridis")
-
-    # def confirm_close(self):
-    #     self.safe_close = True
-    #
-    # def closeEvent(self, event):
-    #     self.figure.cleanup()
-    #     if self.safe_close == True:
-    #         print("Safe close")
-    #         event.accept()
-
-
-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,3 +1,4 @@
-from .plot_base import AxisConfig, WidgetConfig, BECPlotBase
-from .waveform1d import Waveform1DConfig, BECWaveform1D, BECCurve
-from .image import BECImageShow, ImageItemConfig, BECImageItem
+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

@@ -1,19 +1,20 @@
 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 qtpy.QtCore import QThread, QObject
+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_lib import MessageEndpoints
-from bec_widgets.utils import ConnectionConfig, BECConnector
-from bec_widgets.widgets.plots import BECPlotBase, WidgetConfig
+from bec_widgets.utils import BECConnector, ConnectionConfig, EntryValidator
+
+from .plot_base import BECPlotBase, WidgetConfig
 
 
 class ProcessingConfig(BaseModel):
@@ -58,6 +59,7 @@ class ImageConfig(WidgetConfig):
 
 class BECImageItem(BECConnector, pg.ImageItem):
     USER_ACCESS = [
+        "config_dict",
         "set",
         "set_fft",
         "set_log",
@@ -69,7 +71,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
         "set_auto_downsample",
         "set_monitor",
         "set_vrange",
-        "get_config",
+        "get_data",
     ]
 
     def __init__(
@@ -242,6 +244,14 @@ class BECImageItem(BECConnector, pg.ImageItem):
                 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
     ):
@@ -280,9 +290,9 @@ class BECImageItem(BECConnector, pg.ImageItem):
 
 class BECImageShow(BECPlotBase):
     USER_ACCESS = [
+        "config_dict",
         "add_image_by_config",
         "get_image_config",
-        "get_image_list",
         "get_image_dict",
         "add_monitor_image",
         "add_custom_image",
@@ -297,7 +307,6 @@ class BECImageShow(BECPlotBase):
         "set_rotation",
         "set_transpose",
         "toggle_threading",
-        "get_config",
         "set",
         "set_title",
         "set_x_label",
@@ -310,6 +319,7 @@ class BECImageShow(BECPlotBase):
         "lock_aspect_ratio",
         "plot",
         "remove",
+        "images",
     ]
 
     def __init__(
@@ -325,7 +335,9 @@ class BECImageShow(BECPlotBase):
         super().__init__(
             parent=parent, parent_figure=parent_figure, config=config, client=client, gui_id=gui_id
         )
-
+        # Get bec shortcuts dev, scans, queue, scan_storage, dap
+        self.get_bec_shortcuts()
+        self.entry_validator = EntryValidator(self.dev)
         self._images = defaultdict(dict)
         self.apply_config(self.config)
         self.processor = ImageProcessor()
@@ -447,7 +459,8 @@ class BECImageShow(BECPlotBase):
                     else:
                         return image.config  # TODO check if this works
 
-    def get_image_list(self) -> list[BECImageItem]:
+    @property
+    def images(self) -> list[BECImageItem]:
         """
         Get the list of images.
         Returns:
@@ -459,6 +472,16 @@ class BECImageShow(BECPlotBase):
                 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.
@@ -486,6 +509,8 @@ class BECImageShow(BECPlotBase):
                 f"Monitor with ID '{monitor}' already exists in widget '{self.gui_id}'."
             )
 
+        monitor = self.entry_validator.validate_monitor(monitor)
+
         image_config = ImageItemConfig(
             widget_class="BECImageItem",
             parent_id=self.gui_id,
@@ -764,6 +789,22 @@ class BECImageShow(BECPlotBase):
                     return True
         return False
 
+    def _validate_monitor(self, monitor: str, validate_bec: bool = True):
+        """
+        Validate the monitor name.
+        Args:
+            monitor(str): The name of the monitor.
+            validate_bec(bool): Whether to validate the monitor name with BEC.
+
+        Returns:
+            bool: True if the monitor name is valid, False otherwise.
+        """
+        if not monitor or monitor == "":
+            return False
+        if validate_bec:
+            return monitor in self.dev
+        return True
+
     def cleanup(self):
         """
         Clean up the widget.

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
 
@@ -38,7 +37,7 @@ class WidgetConfig(ConnectionConfig):
 
 class BECPlotBase(BECConnector, pg.GraphicsLayout):
     USER_ACCESS = [
-        "get_config",
+        "config_dict",
         "set",
         "set_title",
         "set_x_label",
@@ -67,7 +66,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
         pg.GraphicsLayout.__init__(self, parent)
 
         self.figure = parent_figure
-        self.plot_item = self.addPlot()
+        self.plot_item = self.addPlot(row=0, col=0)
 
         self.add_legend()
 

bec_widgets/widgets/plots/waveform.py

@@ -1,21 +1,21 @@
 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):
@@ -25,14 +25,16 @@ class SignalData(BaseModel):
     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
-    x: SignalData
+    x: SignalData  # TODO maybe add metadata for config gui later
     y: SignalData
+    z: Optional[SignalData] = None
 
 
 class CurveConfig(ConnectionConfig):
@@ -48,12 +50,13 @@ class CurveConfig(ConnectionConfig):
     )
     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."
     )
@@ -61,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",
@@ -134,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,
@@ -202,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.
@@ -212,8 +226,9 @@ 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",
@@ -223,7 +238,6 @@ class BECWaveform1D(BECPlotBase):
         "get_curve_config",
         "apply_config",
         "get_all_data",
-        "get_config",
         "set",
         "set_title",
         "set_x_label",
@@ -254,7 +268,7 @@ class BECWaveform1D(BECPlotBase):
         )
 
         self._curves_data = defaultdict(dict)
-        self.scanID = None
+        self.scan_id = None
 
         # Scan segment update proxy
         self.proxy_update_plot = pg.SignalProxy(
@@ -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,11 +511,14 @@ 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)
         if curve_exits:
@@ -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:
         """
@@ -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.
         """
+        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)
 

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/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
+```

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.43.1"
+__version__ = "0.46.7"
 
 # 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={})
-        )
-        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/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):
@@ -48,8 +51,8 @@ def test_bec_figure_add_remove_plot(bec_figure):
     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 == "BECWaveform1D"
-    assert bec_figure._widgets["widget_2"].config.widget_class == "BECWaveform1D"
+    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
@@ -62,7 +65,17 @@ def test_bec_figure_add_remove_plot(bec_figure):
     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 == "BECWaveform1D"
+    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):
@@ -216,3 +229,16 @@ def test_clear_all(bec_figure):
 
     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

tests/unit_tests/test_motor_control.py

@@ -1,16 +1,9 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-from unittest.mock import patch
-from bec_lib.device import Positioner
-import pytest
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
+
+import pytest
+from bec_lib.devicemanager import DeviceContainer
 
-from bec_widgets.widgets import (
-    MotorControlSelection,
-    MotorControlAbsolute,
-    MotorControlRelative,
-    MotorThread,
-    MotorCoordinateTable,
-)
 from bec_widgets.examples import (
     MotorControlApp,
     MotorControlMap,
@@ -18,8 +11,16 @@ from bec_widgets.examples import (
     MotorControlPanelAbsolute,
     MotorControlPanelRelative,
 )
+from bec_widgets.widgets import (
+    MotorControlAbsolute,
+    MotorControlRelative,
+    MotorControlSelection,
+    MotorCoordinateTable,
+    MotorThread,
+)
 from bec_widgets.widgets.motor_control.motor_control import MotorActions
 
+from .client_mocks import mocked_client
 
 CONFIG_DEFAULT = {
     "motor_control": {
@@ -53,81 +54,6 @@ CONFIG_DEFAULT = {
     ],
 }
 
-#######################################################
-# Client and devices fixture
-#######################################################
-
-
-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True, limits=None, read_value=1.0):
-        super().__init__()
-        self.name = name
-        self.enabled = enabled
-        self.read_value = read_value
-        self.limits = limits or (-100, 100)  # Default limits if not provided
-
-    def read(self):
-        """Simulates reading the current position of the device."""
-        return {self.name: {"value": self.read_value}}
-
-    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))
-
-    def describe(self):
-        """Describes the device."""
-        return {self.name: {"source": self.name, "dtype": "number", "shape": []}}
-
-
-@pytest.fixture
-def mocked_client():
-    client = MagicMock()
-
-    # Setup the fake devices
-    motors = {
-        "samx": FakeDevice("samx", limits=[-10, 10], read_value=2.0),
-        "samy": FakeDevice("samy", limits=[-5, 5], read_value=3.0),
-        "aptrx": FakeDevice("aptrx", read_value=4.0),
-        "aptry": FakeDevice("aptry", read_value=5.0),
-    }
-
-    client.device_manager.devices = MagicMock()
-    client.device_manager.devices.__getitem__.side_effect = lambda x: motors.get(x, FakeDevice(x))
-    client.device_manager.devices.enabled_devices = list(motors.values())
-
-    # Mock the scans.mv method
-    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())  # Simulate wait method of the move status object
-
-    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:
-            return True
-        return original_isinstance(obj, class_info)
-
-    with patch("builtins.isinstance", new=isinstance_mock):
-        yield client
-
 
 #######################################################
 # Motor Thread
@@ -141,7 +67,7 @@ def motor_thread(mocked_client):
 def test_motor_thread_initialization(mocked_client):
     motor_thread = MotorThread(client=mocked_client)
     assert motor_thread.client == mocked_client
-    assert isinstance(motor_thread.dev, MagicMock)
+    assert isinstance(motor_thread.dev, DeviceContainer)
 
 
 def test_get_all_motors_names(mocked_client):
@@ -176,12 +102,16 @@ def test_move_motor_absolute_by_run(mocked_client):
 
 def test_move_motor_relative_by_run(mocked_client):
     motor_thread = MotorThread(client=mocked_client)
+
+    initial_value = motor_thread.dev["samx"].read()["samx"]["value"]
+    move_value = 2.0
+    expected_value = initial_value + move_value
     motor_thread.motor = "samx"
-    motor_thread.value = 2.0
+    motor_thread.value = move_value
     motor_thread.action = MotorActions.MOVE_RELATIVE
     motor_thread.run()
 
-    assert mocked_client.device_manager.devices["samx"].read_value == 4.0
+    assert mocked_client.device_manager.devices["samx"].read_value == expected_value
 
 
 def test_motor_thread_move_absolute(motor_thread):
@@ -292,8 +222,12 @@ def test_absolute_initialization(motor_absolute_widget):
 
 
 def test_absolute_save_current_coordinates(motor_absolute_widget):
-    motor_absolute_widget.client.device_manager["samx"].set_value(2.0)
-    motor_absolute_widget.client.device_manager["samy"].set_value(3.0)
+    motor_x_value = motor_absolute_widget.client.device_manager.devices["samx"].read()["samx"][
+        "value"
+    ]
+    motor_y_value = motor_absolute_widget.client.device_manager.devices["samy"].read()["samy"][
+        "value"
+    ]
     motor_absolute_widget.change_motors("samx", "samy")
 
     emitted_coordinates = []
@@ -306,8 +240,7 @@ def test_absolute_save_current_coordinates(motor_absolute_widget):
     # Trigger saving current coordinates
     motor_absolute_widget.pushButton_save.click()
 
-    # Default position of samx and samy are 2.0 and 3.0 respectively
-    assert emitted_coordinates == [(2.0, 3.0)]
+    assert emitted_coordinates == [(motor_x_value, motor_y_value)]
 
 
 def test_absolute_set_absolute_coordinates(motor_absolute_widget):

tests/unit_tests/test_motor_map.py

@@ -1,9 +1,12 @@
 # pylint: disable = no-name-in-module,missing-module-docstring, missing-function-docstring
 from unittest.mock import MagicMock
+
 import pytest
 
 from bec_widgets.widgets import MotorMap
 
+from .client_mocks import mocked_client
+
 CONFIG_DEFAULT = {
     "plot_settings": {
         "colormap": "Greys",
@@ -60,68 +63,6 @@ CONFIG_ONE_DEVICE = {
 }
 
 
-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True, limits=None, read_value=1.0):
-        self.name = name
-        self.enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name}}
-        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 __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
-
-
-@pytest.fixture
-def mocked_client():
-    client = MagicMock()
-
-    # Mocking specific motors with their limits
-    motors = {
-        "samx": FakeDevice("samx", limits=[-10, 10], read_value=2.0),
-        "samy": FakeDevice("samy", limits=[-5, 5], read_value=3.0),
-        "aptrx": FakeDevice("aptrx", read_value=4.0),
-        "aptry": FakeDevice("aptry", read_value=5.0),
-    }
-
-    client.device_manager.devices = MagicMock()
-    client.device_manager.devices.__getitem__.side_effect = lambda x: motors.get(x, FakeDevice(x))
-
-    return client
-
-
 @pytest.fixture(scope="function")
 def motor_map(qtbot, mocked_client):
     widget = MotorMap(client=mocked_client)
@@ -143,12 +84,15 @@ def test_motor_limits_initialization(motor_map):
 
 def test_motor_initial_position(motor_map):
     motor_map.precision = 2
+
+    motor_map_dev = motor_map.client.device_manager.devices
+
     # Example test to check if motor initial positions are correctly initialized
     expected_positions = {
-        ("samx", "samx"): 2.0,
-        ("samy", "samy"): 3.0,
-        ("aptrx", "aptrx"): 4.0,
-        ("aptry", "aptry"): 5.0,
+        ("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 = motor_map._get_motor_init_position(motor_name, entry)

tests/unit_tests/test_plot_base.py

@@ -1,5 +1,6 @@
 # pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
 import pytest
+
 from .client_mocks import mocked_client
 from .test_bec_figure import bec_figure
 

tests/unit_tests/test_scan_control.py

@@ -1,15 +1,12 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
-import os
-import pickle
 from unittest.mock import MagicMock
 
 import pytest
 from qtpy.QtWidgets import QLineEdit
 
-from bec_widgets.widgets import ScanControl
 from bec_widgets.utils.widget_io import WidgetIO
-
-from .test_msgs.available_scans_message import available_scans_message
+from bec_widgets.widgets import ScanControl
+from tests.unit_tests.test_msgs.available_scans_message import available_scans_message
 
 
 class FakePositioner:

tests/unit_tests/test_stream_plot.py

@@ -1,11 +1,11 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+import threading
 from unittest import mock
 
 import numpy as np
 import pytest
-from bec_lib import messages, RedisConnector
+from bec_lib import RedisConnector, messages
 from pytestqt import qtbot
-import threading
 
 from bec_widgets.examples.stream_plot.stream_plot import StreamPlot
 

tests/unit_tests/test_validator_errors.py

@@ -1,11 +1,12 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import pytest
 from pydantic import ValidationError
+
 from bec_widgets.validation.monitor_config_validator import (
-    MonitorConfigValidator,
-    Signal,
     AxisSignal,
+    MonitorConfigValidator,
     PlotConfig,
+    Signal,
 )
 
 from .test_bec_monitor import mocked_client
@@ -84,7 +85,7 @@ def test_plot_config_no_source_type_provided(setup_devices):
 def test_plot_config_history_source_type(setup_devices):
     history_source = {
         "type": "history",
-        "scanID": "valid_scan_id",
+        "scan_id": "valid_scan_id",
         "signals": {"x": [{"name": "samx"}], "y": [{"name": "samx"}]},
     }
 
@@ -92,7 +93,7 @@ def test_plot_config_history_source_type(setup_devices):
 
     assert len(plot_config.sources) == 1
     assert plot_config.sources[0].type == "history"
-    assert plot_config.sources[0].scanID == "valid_scan_id"
+    assert plot_config.sources[0].scan_id == "valid_scan_id"
 
 
 def test_plot_config_redis_source_type(setup_devices):

tests/unit_tests/test_waveform1d.py

@@ -4,7 +4,8 @@ from unittest.mock import MagicMock
 import numpy as np
 import pytest
 
-from bec_widgets.widgets.plots.waveform1d import SignalData, Signal, CurveConfig
+from bec_widgets.widgets.plots.waveform import CurveConfig, Signal, SignalData
+
 from .client_mocks import mocked_client
 from .test_bec_figure import bec_figure
 
@@ -48,7 +49,7 @@ def test_adding_curve_with_same_id(bec_figure):
 
 def test_create_waveform1D_by_config(bec_figure):
     w1_config_input = {
-        "widget_class": "BECWaveform1D",
+        "widget_class": "BECWaveform",
         "gui_id": "widget_1",
         "parent_id": "BECFigure_1708689320.788527",
         "row": 0,
@@ -72,6 +73,7 @@ def test_create_waveform1D_by_config(bec_figure):
                 "parent_id": "widget_1",
                 "label": "bpm4i-bpm4i",
                 "color": "#cc4778",
+                "colormap": "plasma",
                 "symbol": "o",
                 "symbol_color": None,
                 "symbol_size": 5,
@@ -80,8 +82,21 @@ def test_create_waveform1D_by_config(bec_figure):
                 "source": "scan_segment",
                 "signals": {
                     "source": "scan_segment",
-                    "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None},
-                    "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None},
+                    "x": {
+                        "name": "samx",
+                        "entry": "samx",
+                        "unit": None,
+                        "modifier": None,
+                        "limits": None,
+                    },
+                    "y": {
+                        "name": "bpm4i",
+                        "entry": "bpm4i",
+                        "unit": None,
+                        "modifier": None,
+                        "limits": None,
+                    },
+                    "z": None,
                 },
             },
             "curve-custom": {
@@ -90,6 +105,7 @@ def test_create_waveform1D_by_config(bec_figure):
                 "parent_id": "widget_1",
                 "label": "curve-custom",
                 "color": "blue",
+                "colormap": "plasma",
                 "symbol": "o",
                 "symbol_color": None,
                 "symbol_size": 5,
@@ -217,8 +233,9 @@ def test_change_curve_appearance_methods(bec_figure, qtbot):
     assert c1.config.source == "scan_segment"
     assert c1.config.signals.model_dump() == {
         "source": "scan_segment",
-        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None},
-        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None},
+        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
+        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
+        "z": None,
     }
 
 
@@ -245,8 +262,9 @@ def test_change_curve_appearance_args(bec_figure):
     assert c1.config.source == "scan_segment"
     assert c1.config.signals.model_dump() == {
         "source": "scan_segment",
-        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None},
-        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None},
+        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
+        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
+        "z": None,
     }
 
 
@@ -330,6 +348,7 @@ def test_curve_add_by_config(bec_figure):
         "parent_id": "widget_1",
         "label": "bpm4i-bpm4i",
         "color": "#cc4778",
+        "colormap": "plasma",
         "symbol": "o",
         "symbol_color": None,
         "symbol_size": 5,
@@ -338,8 +357,15 @@ def test_curve_add_by_config(bec_figure):
         "source": "scan_segment",
         "signals": {
             "source": "scan_segment",
-            "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None},
-            "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None},
+            "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
+            "y": {
+                "name": "bpm4i",
+                "entry": "bpm4i",
+                "unit": None,
+                "modifier": None,
+                "limits": None,
+            },
+            "z": None,
         },
     }
 
@@ -365,7 +391,7 @@ def test_scan_update(bec_figure, qtbot):
             "gauss_adc1": {"gauss_adc1": {"value": 8}},
             "gauss_adc2": {"gauss_adc2": {"value": 9}},
         },
-        "scanID": 1,
+        "scan_id": 1,
     }
     # Mock scan_storage.find_scan_by_ID
     mock_scan_data_waveform = MagicMock()
@@ -400,8 +426,8 @@ def test_scan_history_with_val_access(bec_figure, qtbot):
     mock_scan_storage.find_scan_by_ID.return_value = MagicMock(data=mock_scan_data)
     w1.queue.scan_storage = mock_scan_storage
 
-    fake_scanID = "fake_scanID"
-    w1.scan_history(scanID=fake_scanID)
+    fake_scan_id = "fake_scan_id"
+    w1.scan_history(scan_id=fake_scan_id)
 
     qtbot.wait(500)
 
@@ -409,3 +435,43 @@ def test_scan_history_with_val_access(bec_figure, qtbot):
 
     assert np.array_equal(x_data, [1, 2, 3])
     assert np.array_equal(y_data, [4, 5, 6])
+
+
+def test_scatter_2d_update(bec_figure, qtbot):
+    w1 = bec_figure.add_plot()
+
+    c1 = w1.add_curve_scan(x_name="samx", y_name="samx", z_name="bpm4i")
+
+    msg = {
+        "data": {
+            "samx": {"samx": {"value": [1, 2, 3]}},
+            "samy": {"samy": {"value": [4, 5, 6]}},
+            "bpm4i": {"bpm4i": {"value": [1, 3, 2]}},
+        },
+        "scan_id": 1,
+    }
+    msg_metadata = {"scan_name": "line_scan"}
+
+    mock_scan_data = MagicMock()
+    mock_scan_data.data = {
+        device_name: {
+            entry: MagicMock(val=msg["data"][device_name][entry]["value"])
+            for entry in msg["data"][device_name]
+        }
+        for device_name in msg["data"]
+    }
+
+    w1.queue.scan_storage.find_scan_by_ID.return_value = mock_scan_data
+
+    w1.on_scan_segment(msg, msg_metadata)
+    qtbot.wait(500)
+
+    data = c1.get_data()
+    expected_x_y_data = ([1, 2, 3], [1, 2, 3])
+    expected_z_colors = w1._make_z_gradient([1, 3, 2], "plasma")
+
+    scatter_points = c1.scatter.points()
+    colors = [point.brush().color() for point in scatter_points]
+
+    assert np.array_equal(data, expected_x_y_data)
+    assert colors == expected_z_colors

tests/unit_tests/test_widget_io.py

@@ -1,13 +1,6 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import pytest
-from qtpy.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QLineEdit,
-    QComboBox,
-    QTableWidget,
-    QSpinBox,
-)
+from qtpy.QtWidgets import QComboBox, QLineEdit, QSpinBox, QTableWidget, QVBoxLayout, QWidget
 
 from bec_widgets.utils.widget_io import WidgetHierarchy
 

tests/unit_tests/test_yaml_dialog.py

@@ -2,9 +2,10 @@
 import os
 import tempfile
 from unittest.mock import patch
+
 import pytest
 import yaml
-from qtpy.QtWidgets import QWidget, QVBoxLayout, QPushButton
+from qtpy.QtWidgets import QPushButton, QVBoxLayout, QWidget
 
 from bec_widgets.utils.yaml_dialog import load_yaml, save_yaml