0.38.0

Automatically generated by python-semantic-release

.gitlab-ci.yml

@@ -14,6 +14,7 @@ include:
 stages:
   - Formatter
   - test
+  - AdditionalTests
   - Deploy
 
 formatter:
@@ -25,9 +26,10 @@ formatter:
 pylint:
   stage: Formatter
   needs: []
-  script:
+  before_script:
     - pip install pylint pylint-exit anybadge
     - pip install -e .[dev]
+  script:
     - mkdir ./pylint
     - pylint ./bec_widgets --output-format=text --output=./pylint/pylint.log | tee ./pylint/pylint.log || pylint-exit $?
     - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint.log)
@@ -38,6 +40,37 @@ pylint:
       - ./pylint/
     expire_in: 1 week
 
+pylint-check:
+  stage: Formatter
+  needs: []
+  allow_failure: true
+  before_script:
+    - pip install pylint pylint-exit anybadge
+    - apt-get update
+    - apt-get install -y bc
+  script:
+    # Identify changed Python files
+    - if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then
+        TARGET_BRANCH_COMMIT_SHA=$(git rev-parse $CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
+        CHANGED_FILES=$(git diff --name-only $SOURCE_BRANCH_COMMIT_SHA $TARGET_BRANCH_COMMIT_SHA | grep '\.py$' || true);
+      else
+        CHANGED_FILES=$(git diff --name-only $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | grep '\.py$' || true);
+      fi
+    - if [ -z "$CHANGED_FILES" ]; then echo "No Python files changed."; exit 0; fi
+
+    # Run pylint only on changed files
+    - mkdir ./pylint
+    - pylint $CHANGED_FILES --output-format=text . | tee ./pylint/pylint_changed_files.log || pylint-exit $?
+    - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint_changed_files.log)
+    - echo "Pylint score is $PYLINT_SCORE"
+
+    # Fail the job if the pylint score is below 9
+    - if [ "$(echo "$PYLINT_SCORE < 9" | bc)" -eq 1 ]; then echo "Your pylint score is below the acceptable threshold (9)."; exit 1; fi
+  artifacts:
+    paths:
+      - ./pylint/
+    expire_in: 1 week
+
 tests:
   stage: test
   needs: []
@@ -45,7 +78,7 @@ tests:
       QT_QPA_PLATFORM: "offscreen"
   script:
     - apt-get update
-    - apt-get install -y libgl1-mesa-glx x11-utils libxkbcommon-x11-0 
+    - 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
     - coverage report
@@ -54,7 +87,38 @@ tests:
   artifacts:
     reports:
       junit: report.xml
-      cobertura: coverage.xml
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage.xml
+
+#tests-3.9-pyqt5: #todo enable when we decide what qt distributions we want to support
+#  extends: "tests"
+#  stage: AdditionalTests
+#  image: $CI_DOCKER_REGISTRY/python:3.9
+#  script:
+#    - apt-get update
+#    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+#    - pip install .[dev,pyqt5]
+#    - pytest -v --random-order ./tests
+
+tests-3.10:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DOCKER_REGISTRY/python:3.10
+  allow_failure: true
+
+
+tests-3.11:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DOCKER_REGISTRY/python:3.11
+  allow_failure: true
+
+tests-3.12:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DOCKER_REGISTRY/python:3.12
+  allow_failure: true
 
 
 semver:
@@ -80,22 +144,20 @@ semver:
       semantic-release publish -v DEBUG 
       -D version_variable=./setup.py:__version__  
       -D hvcs=gitlab 
-      
+
   allow_failure: false
   rules:
     - if: '$CI_COMMIT_REF_NAME == "master"'
 
-# pages:
-#   stage: Deploy
-#   needs: ["tests"]
-#   script:
-#     - git clone --branch $OPHYD_DEVICES_BRANCH https://oauth2:$CI_OPHYD_DEVICES_KEY@gitlab.psi.ch/bec/ophyd_devices.git
-#     - export OPHYD_DEVICES_PATH=$PWD/ophyd_devices    
-#     - pip install -r ./docs/source/requirements.txt
-#     - apt-get install -y gcc
-#     - *install-bec-services    
-#     - cd ./docs/source; make html
-#     - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/beamline-experiment-control/221870/
-#   rules:
-#     - if: '$CI_COMMIT_REF_NAME == "master"'
-#     - if: '$CI_COMMIT_REF_NAME == "production"'
+pages:
+  stage: Deploy
+  needs: ["semver"]
+  variables:
+    TARGET_BRANCH: $CI_COMMIT_REF_NAME
+  rules:
+    - if: '$CI_COMMIT_TAG != null'
+      variables:
+        TARGET_BRANCH: $CI_COMMIT_TAG
+    - if: '$CI_COMMIT_REF_NAME == "master"'
+  script:
+    - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/bec-widgets/253243/

.gitlab/issue_templates/bug_report_template.md

@@ -0,0 +1,17 @@
+## Bug report
+
+## Summary
+
+[Provide a brief description of the bug.]
+
+## Expected Behavior vs Actual Behavior
+
+[Describe what you expected to happen and what actually happened.]
+
+## Steps to Reproduce
+
+[Outline the steps that lead to the bug's occurrence. Be specific and provide a clear sequence of actions.]
+
+## Related Issues
+
+[Paste links to any related issues or feature requests.]

.gitlab/issue_templates/documentation_update_template.md

@@ -0,0 +1,27 @@
+## Documentation Section
+
+[Specify the section or page of the documentation that needs updating]
+
+## Current Information
+
+[Provide the current information in the documentation that needs to be updated]
+
+## Proposed Update
+
+[Describe the proposed update or correction. Be specific about the changes that need to be made]
+
+## Reason for Update
+
+[Explain the reason for the documentation update. Include any recent changes, new features, or corrections that necessitate the update]
+
+## Additional Context
+
+[Include any additional context or information that can help the documentation team understand the update better]
+
+## Attachments
+
+[Attach any files, screenshots, or references that can assist in making the documentation update]
+
+## Priority
+
+[Assign a priority level to the documentation update based on its urgency. Use a scale such as Low, Medium, High]

.gitlab/issue_templates/feature_request_template.md

@@ -0,0 +1,40 @@
+## Feature Summary
+
+[Provide a brief and clear summary of the new feature you are requesting]
+
+## Problem Description
+
+[Explain the problem or need that this feature aims to address. Be specific about the issues or gaps in the current functionality]
+
+## Use Case
+
+[Describe a real-world scenario or use case where this feature would be beneficial. Explain how it would improve the user experience or workflow]
+
+## Proposed Solution
+
+[If you have a specific solution in mind, describe it here. Explain how it would work and how it would address the problem described above]
+
+## Benefits
+
+[Explain the benefits and advantages of implementing this feature. Highlight how it adds value to the product or improves user satisfaction]
+
+## Alternatives Considered
+
+[If you've considered alternative solutions or workarounds, mention them here. Explain why the proposed feature is the preferred option]
+
+## Impact on Existing Functionality
+
+[Discuss how the new feature might impact or interact with existing features. Address any potential conflicts or dependencies]
+
+## Priority
+
+[Assign a priority level to the feature request based on its importance. Use a scale such as Low, Medium, High]
+
+## Attachments
+
+[Include any relevant attachments, such as sketches, diagrams, or references that can help the development team understand your feature request better]
+
+## Additional Information
+
+[Provide any additional information that might be relevant to the feature request, such as user feedback, market trends, or similar features in other products]
+

.gitlab/merge_request_templates/default.md

@@ -0,0 +1,28 @@
+## Description
+
+[Provide a brief description of the changes introduced by this merge request.]
+
+## Related Issues
+
+[Cite any related issues or feature requests that are addressed or resolved by this merge request. Use the gitlab syntax for linking issues, for example, `fixes #123` or `closes #123`.]
+
+## Type of Change
+
+- Change 1
+- Change 2
+
+## Potential side effects
+
+[Describe any potential side effects or risks of merging this MR.]
+
+## Screenshots / GIFs (if applicable)
+
+[Include any relevant screenshots or GIFs to showcase the changes made.]
+
+## Additional Comments
+
+[Add any additional comments or information that may be helpful for reviewers.]
+
+## Definition of Done
+- [ ] Documentation is up-to-date.
+

.readthedocs.yaml

@@ -0,0 +1,25 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the version of Python and other tools you might need
+build:
+  os: ubuntu-20.04
+  tools:
+    python: "3.9"
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+   configuration: docs/conf.py
+
+# If using Sphinx, optionally build your docs in additional formats such as PDF
+# formats:
+#    - pdf
+
+# Optionally declare the Python requirements required to build your docs
+python:
+   install:
+   - requirements: docs/requirements.txt

CHANGELOG.md

@@ -2,6 +2,251 @@
 
 <!--next-version-placeholder-->
 
+## v0.38.0 (2024-01-23)
+
+### Feature
+
+* BECMonitor2DScatter for plotting x/y/z signal as a mesh of scatter plot ([`75090b8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/75090b857526fa642218986806d0daeb1dec0914))
+
+### Fix
+
+* Monitor_scatter_2D.py changed to new BECDispatcher definition ([`747e97e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/747e97e0c924cdedb85e9fe7d47512002b791b10))
+
+## v0.37.1 (2024-01-23)
+
+### Fix
+
+* **tests:** Ensure BEC service is shutdown after bec dispatcher test ([`4664568`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/46645686725a2acb7196dbd1a504c98dbf2e4b5d))
+* **tests:** Ensure threads started during plot tests are properly stopped ([`3fb6644`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3fb6644543b4065236216b70a583641956a09a60))
+
+## v0.37.0 (2024-01-17)
+
+### Feature
+
+* Independent motor_map widget ([`1a429b3`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1a429b3024e76446ed530bee71ed797c20843fba))
+
+## v0.36.2 (2024-01-17)
+
+### Fix
+
+* Bec_dispatcher.py can partially disconnect topics from slot ([`7607d7a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/7607d7a3b64b3861f4833c9b8f5afc360f31b38d))
+* Bec_dispatcher.py can connect multiple topics to one callback slot ([`e51be04`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/e51be04b95f1a9549a4a3b00d76944aa58b0526a))
+
+## v0.36.1 (2024-01-15)
+
+### Fix
+
+* Motor_example.py fix to the new .read() structure from bec_lib ([`f9c5c82`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f9c5c82381907a19582bf9132740fe27b48d48cc))
+
+## v0.36.0 (2024-01-12)
+
+### Feature
+
+* Bec_dispatcher can link multiple endpoints topics for one qt slot ([`58721be`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/58721bea1a2b4b06220ef0e3b2dcec8c1656213d))
+
+## v0.35.0 (2024-01-12)
+
+### Feature
+
+* Monitor.py can access custom data send through redis ([`6e4775a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/6e4775a1248153f6027be754054f3f43c18514d1))
+* Monitor.py access data directly from scan storage ([`26c07c3`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/26c07c3205debaf88a346410a8ebab0a3ab7a5d9))
+
+### Fix
+
+* Monitor.py clear command from BECPlotter CLI clear now flush database and clear the plots ([`ebd4fcc`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ebd4fccda2321aa0dc108a5436fb4cc717911d4b))
+* Monitor.py crosshair enabled by default ([`97dcc5a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/97dcc5ac768cc4f0122382591238fd5a9d035270))
+* Monitor.py change import of ConfigDialog from relative to absolute in order to make BECPlotter be able to open it ([`6061b31`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/6061b3150e990141eafb8d5b17c7e931c7bf8631))
+* Monitor_config_validator.py changed to check .describe() instead of signals ([`5ab82bc`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5ab82bc13340adb992c921a7211e8e2265861f7a))
+* Monitor.py fixed not updating config changes after receiving refresh from BECPlotter ([`00ef3ae`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/00ef3ae9256a368f4842c1dc38a407131181ec1d))
+* Monitor_config_validator.py valid color is Literal['black','white'] ([`86c5f25`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/86c5f25205dbaa45b7b2efd255f3a3cb2d3eb0b1))
+* Monitor.py fixed scan mode ([`a706da2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a706da2490f4cce80e9515633e8437b3667b0db0))
+* Motor_config_validation changed to new monitor config structure ([`d67bdd2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d67bdd26167dca6c65627192dbd098af08355d06))
+
+## v0.34.1 (2023-12-12)
+
+### Fix
+
+* Formatter and tests fixed ([`186c42d`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/186c42d6676a495bc2f66d8b7ed37dbf7d0be747))
+
+### Documentation
+
+* Readdocs updated ([`af995a7`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/af995a74f34d59eeaff5d9100117f103ec79765d))
+* Readme.md updated ([`cba8131`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cba81313671acfee0a40410753c1974008316d07))
+* Gitlab templates for issues and merge requests from main bec repo ([`831eddc`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/831eddc13600cc06b67de92d39509af37bb05002))
+
+## v0.34.0 (2023-12-08)
+
+### Feature
+
+* Monitor.py error message popup ([`a3b24f9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a3b24f92420420c8968ef4793342c3857c826e57))
+
+### Fix
+
+* Monitor_config_validator.py - Signal validation changed from field_validator to model_validator to check first name and then entry ([`0868047`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/086804780d19956331d8385381d2f7f9c181e77c))
+* Monitor_config_validator.py fix entry validation executed only if name validator is successful ([`af71e35`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/af71e35e73733472228c4be0061faefaf655b769))
+
+## v0.33.0 (2023-12-07)
+
+### Feature
+
+* Added axis_width and axis_color as optional plot settings ([`504944f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/504944f696a7b2881adec06d29c271fec7e2c981))
+
+### Fix
+
+* Fixed default config options ([`03bdf98`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/03bdf980bcfc37e217cde1beb258d11cee97e0eb))
+* Added hooks to react to incoming config messages and instructions ([`1084bc0`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1084bc0a803ff73cfa2ab53819bc9809588fa622))
+
+## v0.32.2 (2023-12-06)
+
+### Fix
+
+* Changed exec_ to exec for all apps ([`080c258`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/080c258d1542aaace093bca74225297b30453f77))
+* Yaml_dialog.py changed to use native solution of OS -> should prevent crashing on py3.11 ([`5adde23`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5adde23a457bbd3ae1488b77d4b927b5bded0473))
+
+## v0.32.1 (2023-12-06)
+
+### Fix
+
+* Widget_io print_widget_hierarchy fix comboboxes ([`d1f9979`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d1f9979ab1372c2f650c8aff12ccb17d668b52eb))
+* WidgetIO combobox fixed for qt6 distributions ([`4f70097`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4f700976ddd78a6f06e358950786b731ef9051ce))
+
+## v0.32.0 (2023-11-30)
+
+### Feature
+
+* Jupyter rich console added as alternative to default QTextEdit terminal output ([`016b26f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/016b26f5cf05e90da144487a9359ac2a54c8e549))
+* Editor.py basic signature calltip ([`045b1ba`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/045b1baa60a93d2266800821940d7aa29bd8bbe1))
+* Editor.py jedi autocomplete hooked ([`fb555b2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fb555b278a5139f180592280408742d34dc5fa84))
+* Editor.py added splitter between editor and terminal ([`c70ddb3`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c70ddb3cb19fecf7ce14b551d7d265e2e0cff357))
+* Toolbar.py proof-of-concept ([`286e62d`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/286e62df92927d2efe0b4ab07995f7b5e36a0435))
+* Basic text editor + running terminal output ([`9487844`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/94878448c8f39a69e9e65df2789da029a9acfc0e))
+
+### Fix
+
+* Added missing dependency jedi ([`d978740`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d978740f9879580d01e092ad1fead46786d3ed5c))
+* Editor.py switch to disable docstring ([`3cc05cd`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3cc05cde147cd520b98f0896beb64781ea47d816))
+* Editor.py compact signature on tooltip ([`f96cacc`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f96caccfcb43c904887ebfc0b34fd779ffff8bf1))
+* Editor.py removed automatic background behind edited text ([`d865e2f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d865e2f1af6eb3d5fb31f9c53088b629a232343f))
+* Toolbar.py automatic initialisation works ([`8ad3059`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/8ad305959257a58b297896218baae06d09520ee1))
+* Terminal output as QThread ([`a0d172e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a0d172e3dc35bdc2d7e1b43185e31bb9a3629631))
+
+## v0.31.0 (2023-11-13)
+
+### Feature
+
+* Pydantic validation module for monitor.py ([`7fec0c7`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/7fec0c7e4411c221413d69aeeb4d68ade10d502b))
+
+### Documentation
+
+* Pydantic validation module docs ([`92a5325`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/92a5325aad02fe308caaf9088a3c4386ca055124))
+
+## v0.30.0 (2023-11-10)
+
+### Feature
+
+* WidgetIO support for QLabel ([`aa4c7c3`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/aa4c7c3385f52e4bbc805ee2aced181929943a89))
+* Scan_control.py added option to limit scan selection from list of strings as init parameter ([`0fe06ad`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0fe06ade5b44d13a9188aef474364b36baa480ef))
+* Scan_control.py a general widget which can generate GUI for scan input ([`088fa51`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/088fa516a8876d112a98cd60aa2a5701dff6b97c))
+
+### Fix
+
+* Added imports to __init__.py in widget for ScanControl class ([`b85cc89`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b85cc898d521df1c99a65e579b8fe853bb04cc32))
+* Scan_control.py args_size_max fixed ([`da9025e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/da9025e032c2bc9b34cf359a20745e3156d2f731))
+* Scan_control.py default spinBox limits increases ([`5c67026`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5c67026637472d9c77185a59e1bf9a24cfe01307))
+* Scan_control.py supports minimum and maximum number of args ([`ee2f36f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ee2f36fb402d626c300a018afacbd57eff14a665))
+* Scan_control.py wipe table and reinitialise devices when scan is changed ([`5ac3526`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5ac3526384b9ee0eb94568bac035b348eaa52abd))
+* Widget_IO.py added handler for QCheckBox ([`18a7025`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/18a702572f6bed41081d368e39c8fc69122c6203))
+* Scan_control.py scan can be executed from GUI ([`2e42ba1`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/2e42ba174f7abe1590b9afb099dc2d068eb848ae))
+* Scan_control.py all kwargs are rendered ([`4b7592c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4b7592c2795a26591b3e30870c73aa406316588d))
+* Scan_control.py kwargs and args are added to the correct layouts ([`b311069`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b311069722226b95a7902f42815d2c1e219e9584))
+
+## v0.29.0 (2023-10-31)
+
+### Feature
+
+* Widget_hierarchy.py tool to inspect hierarchy of the widget ([`cda8dae`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cda8daeb35b36692316173a19fb29f1cc0dbdb7c))
+* Yaml_dialog.py interactive QFileDialog window to load/save .yaml files to/from dict ([`2b29b6c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/2b29b6cfe2ea94a974da4a332c47473176ddddff))
+* Qt_utils custom class for class where one can delete the row with backspace or delete ([`a6616f5`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a6616f5986d59ad8d065105234f5b704731cce71))
+* Modular_app.py, device_monitor.py, config_dialog.py linked together, plot configuration can be done through GUI ([`bf2a09e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/bf2a09e6307da63ecf02a1286095a19e5f1dcab4))
+* Config_dialog.py interactive editor of plot settings ([`c9e5dd5`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c9e5dd542c9eb7c9069d1c0f1256a634a166eb40))
+
+### Fix
+
+* Yaml_dialog.py added support for .yml files ([`10539f0`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/10539f0ba59be716102b2c0577ea62f5c4a3136a))
+* Yaml_dialog.py added return None if no file path is specified ([`ff1d918`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ff1d918d43f0f2e5fe8d78c6de9051c50e0e12c1))
+* Wrong __init__.py in modular_app ([`d52aa15`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d52aa15aac42f09487c828836e377c78596037bd))
+* Test_bec_monitor.py config loaded fresh in the test function to avoid parameter leak ([`3866d7c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3866d7ce4de3391fe57ef872808f7620562eeeb0))
+* Test_bec_monitor.py setup_monitor help function changed to pytest.fixture ([`989cd51`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/989cd51162147805db1229b50b330af29f275204))
+* Test_config_dialog.py - QApplication removed ([`1cdd760`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1cdd760e4062de1f19837737766ce05edc9ac2da))
+* Test_config_dialog.py - test_add_new_plot_and_modify qtbot action .click() changed -> function called directly ([`1333e6c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1333e6cbca18943b0a61206dc1ba63720b031b40))
+* Test_config_dialog.py disabled ([`4e710dd`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4e710dda5e88b2e82ec87db350e8b1fe6aa09181))
+* Test_bec_monitor.py QApplication instance removed ([`77e1d09`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/77e1d0925db2dc6669159fbe3fb08daf330cb5c8))
+* Test_config_dialog.py QApplication instance added ([`60e864b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/60e864b2590d121e1b0ad645d39d1a028abe8d7b))
+* Device_monitor.py BECDeviceMonitor can be promoted in the QtDesigner and then setup in the modular app ([`afab283`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/afab283988a1acc008bc53ae5a56a8f67504da81))
+* Device_monitor.py crosshairs can be attached again ([`644a97a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/644a97aee848c973125375d5f28d3edf2ffc20cf))
+* Config_dialog.py prevents to add one scan twice ([`12469c8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/12469c8c1e45f83cc0c65708bd412103a8ec1838))
+* Config_dialog.py export to .yaml fixed ([`7e99920`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/7e99920fc565acd59cb3a4286ac5ee40597d8af4))
+* Config_dialog.py scan_type structure implemented ([`e41d81c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/e41d81cbd9371f8633c1e7de82c8f9b64fcb721b))
+* Config_dialog.py config from default mode can be exported to dict ([`55b5ca7`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/55b5ca7381dc33119baac0f48c76fc9d9e8215ae))
+* Config_dialog.py tabs for scans and plots are closable now ([`ec88564`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ec88564e6577cd6579c30f36193c4a0e5fcbc483))
+* Modular_app.py configs are linked to the actual version of the state of the device monitor ([`d78940d`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d78940da3f114062aa397b87c169f26cbc131a5f))
+* Config_dialog.py can load the current configuration of the plot ([`f94a29b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f94a29bf4be0a883abc200821746c3d81a0c00d4))
+
+### Documentation
+
+* Config_dialog.py comments added to example cases ([`4a6e73f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4a6e73f4f791d2152ff29680a4e28529a8df0b47))
+* Device_monitor.py update docstrings ([`a785bca`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a785bca8806613f9e1e4b67380e72867b581fe6e))
+* Added sphinx base structure ([`9d36b96`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9d36b9686e31b2c4b4206ad47b385c8f2769c641))
+
+## v0.28.1 (2023-10-19)
+
+### Fix
+
+* Stream_plot.py on_dap_update data dict opened correctly ([`28908dd`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/28908dd07c1eef8a9d3213a581393e665b310d1b))
+
+## v0.28.0 (2023-10-13)
+
+### Feature
+
+* BECDeviceMonitor modular class which can be used to replace placeholder in .ui file. ([`f3f55a7`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f3f55a7ee0ad58aab74526a24f27436fd2bef61d))
+* Placeholders initialised ([`75af040`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/75af0404b3aa5f454528255e8971af07c4e8b39b))
+
+### Fix
+
+* Scan_mode for BECDeviceMonitor fixed init_ui ([`59bba14`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/59bba1429c1f8aeeb562b539583e71303506bd58))
+
+## v0.27.2 (2023-10-12)
+
+### Fix
+
+* Scan_plot tests ([`f7cbdbc`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f7cbdbc5ca318d60a9501df3fa03c7dea15b5b21))
+
+## v0.27.1 (2023-10-10)
+
+### Fix
+
+* Extreme.py default config file changed to the config_example.yaml ([`5814113`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5814113f73fb1c4552bb715b27d3330decd9c878))
+* Extreme.py retry action fixed in ErrorHandler ([`5162270`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5162270d28ca8eab4eac9d9665e2fb4c5e8a33a3))
+* Extreme.py advanced error handling with possibility to reload different config ([`51c3a9e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/51c3a9e9ee3d75c8324300afac366dcdb9adb876))
+* Extreme.py error in configuration are displayed as messagebox ([`9750039`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9750039097c9e4b9a45603dcefe76e5b2e8920fd))
+* Extreme.py validation function to check config key component structure ([`824ce82`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/824ce821cd5f060f2c550b970afb1f3479a006ef))
+* Extreme.py improved error handling for scan types mode ([`fbd299c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fbd299c7e7cf548886e2b1787d8e188c708ee8cd))
+* Extreme.py init_ui changed > to >= for setting number of columns ([`6c773c7`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/6c773c7c94e5eee700b74a792657978be86dbbf4))
+* Extreme.py init_plot_background error handling ([`c525eba`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c525eba88576e0094063019d00fba6a43c52b42e))
+* Extreme.py ui is initialised for the first scan of config in scan mode ([`fc60984`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fc6098414e328e14ec9ab6006538f46e36f17723))
+* Extreme.py client and device manager initialisation ([`ae79faa`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ae79faa7ed8e9d8f680e1be1afefe43706305d9a))
+* Extreme.py default config file changed to the config_example.yaml ([`d356cf7`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d356cf734b81fd7ed2c9b48ee85a1722af179d83))
+* Extreme.py retry action fixed in ErrorHandler ([`b76df1b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b76df1b583a5922229f97876f9e65e0cad64c88e))
+* Extreme.py advanced error handling with possibility to reload different config ([`d623cf9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d623cf95391adfc89837cd54ca1b2a1b6e491a3c))
+* Extreme.py error in configuration are displayed as messagebox ([`89a52a0`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/89a52a0948ee300e57bb7198eac339ee771bff06))
+* Extreme.py validation function to check config key component structure ([`5a7ac86`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5a7ac860a8cf5cef53ae699b2869e649c1721f9d))
+* Extreme.py improved error handling for scan types mode ([`ece1859`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ece1859a63b83b1d56b33cc610efea6876dd9e1f))
+* Extreme.py init_ui changed > to >= for setting number of columns ([`a0a89fe`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a0a89fe704db6c11a99a26a080051af1c677ba7a))
+* Extreme.py init_plot_background error handling ([`dafb6fa`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/dafb6fae7a526d5b311ded1d0424ac4dbb3c8b74))
+* Extreme.py ui is initialised for the first scan of config in scan mode ([`82bebe6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/82bebe6b41004befcb1b54db141e20ff844f76e5))
+* Extreme.py client and device manager initialisation ([`cf15163`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cf15163bd91291e9851662c147b2e799ae022b9e))
+* Formatter fixed ([`153c5f4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/153c5f4f9d168f433380bd2deddd2b17a45916a3))
+
 ## v0.27.0 (2023-09-25)
 
 ### Feature

README.md

@@ -1,2 +1,73 @@
 # BEC Widgets
 
+BEC Widgets is a GUI framework designed for interaction with [BEC (Beamline Experiment Control)](https://gitlab.psi.ch/bec/bec).
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install BEC Widgets:
+
+```bash
+pip install bec-widgets
+```
+
+For development purposes, you can clone the repository and install the package locally in editable mode:
+
+```bash
+git clone https://gitlab.psi.ch/bec/bec-widgets
+cd bec-widgets
+pip install -e .[dev]
+```
+
+BEC Widgets currently supports both PyQt5 and PyQt6. By default, PyQt6 is installed.
+
+To select a specific Python Qt distribution, install the package with an additional tag:
+
+```bash
+pip install bec-widgets[pyqt6]
+```
+or 
+
+```bash
+pip install bec-widgets[pyqt5]
+```
+## Documentation
+
+Documentation of BEC Widgets can be found [here](https://bec-widgets.readthedocs.io/en/latest/). The documentation of the BEC can be found [here](https://beamline-experiment-control.readthedocs.io/en/latest/).
+
+## Contributing
+
+All commits should use the Angular commit scheme:
+
+> #### <a name="commit-header"></a>Angular Commit Message Header
+> 
+> ```
+> <type>(<scope>): <short summary>
+>   │       │             │
+>   │       │             └─⫸ Summary in present tense. Not capitalized. No period at the end.
+>   │       │
+>   │       └─⫸ Commit Scope: animations|bazel|benchpress|common|compiler|compiler-cli|core|
+>   │                          elements|forms|http|language-service|localize|platform-browser|
+>   │                          platform-browser-dynamic|platform-server|router|service-worker|
+>   │                          upgrade|zone.js|packaging|changelog|docs-infra|migrations|ngcc|ve|
+>   │                          devtools
+>   │
+>   └─⫸ Commit Type: build|ci|docs|feat|fix|perf|refactor|test
+> ```
+> 
+> The `<type>` and `<summary>` fields are mandatory, the `(<scope>)` field is optional.
+
+> ##### Type
+> 
+> Must be one of the following:
+> 
+> * **build**: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
+> * **ci**: Changes to our CI configuration files and scripts (examples: CircleCi, SauceLabs)
+> * **docs**: Documentation only changes
+> * **feat**: A new feature
+> * **fix**: A bug fix
+> * **perf**: A code change that improves performance
+> * **refactor**: A code change that neither fixes a bug nor adds a feature
+> * **test**: Adding missing tests or correcting existing tests
+
+## License
+
+[BSD-3-Clause](https://choosealicense.com/licenses/bsd-3-clause/)

bec_widgets/basic_plot.py

@@ -1,457 +0,0 @@
-import os
-import threading
-import time
-import warnings
-from typing import Any
-
-import numpy as np
-import pyqtgraph
-import pyqtgraph as pg
-from bec_lib.core import BECMessage
-from PyQt5.QtCore import pyqtSlot
-from PyQt5.QtWidgets import QCheckBox, QTableWidgetItem
-from pyqtgraph import mkBrush, mkColor, mkPen
-from pyqtgraph.Qt import QtCore, QtWidgets, uic
-from pyqtgraph.Qt.QtCore import pyqtSignal
-
-from bec_widgets.bec_dispatcher import bec_dispatcher
-from bec_lib.core.redis_connector import MessageObject, RedisConnector
-
-client = bec_dispatcher.client
-
-
-class BasicPlot(QtWidgets.QWidget):
-    update_signal = pyqtSignal()
-    roi_signal = pyqtSignal(tuple)
-
-    def __init__(self, name="", y_value_list=["gauss_bpm"]) -> None:
-        """
-        Basic plot widget for displaying scan data.
-
-        Args:
-            name (str, optional): Name of the plot. Defaults to "".
-            y_value_list (list, optional): List of signals to be plotted. Defaults to ["gauss_bpm"].
-        """
-
-        super(BasicPlot, self).__init__()
-        # Set style for pyqtgraph plots
-        pg.setConfigOption("background", "w")
-        pg.setConfigOption("foreground", "k")
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "basic_plot.ui"), self)
-
-        # Set splitter distribution of widgets
-        self.splitter.setSizes([3, 1])
-
-        self._idle_time = 100
-        self.title = ""
-        self.label_bottom = ""
-        self.label_left = ""
-        self.producer = RedisConnector(["localhost:6379"]).producer()
-
-        self.scan_motors = []
-        self.y_value_list = y_value_list
-        self.previous_y_value_list = None
-        self.plotter_data_x = []
-        self.plotter_data_y = []
-        self.curves = []
-        self.pens = []
-        self.brushs = []
-
-        self.plotter_scan_id = None
-
-        # TODO to be moved to utils function
-        plotstyles = {
-            "symbol": "o",
-            "symbolSize": 10,
-        }
-
-        color_list = BasicPlot.golden_angle_color(colormap="CET-R2", num=len(self.y_value_list))
-
-        # setup plots - GraphicsLayoutWidget
-        # LabelItem
-        self.label = pg.LabelItem(justify="center")
-        self.glw.addItem(self.label)
-        self.label.setText("ROI region")
-
-        # PlotItem - main window
-        self.glw.nextRow()
-        self.plot = pg.PlotItem()
-        self.plot.setLogMode(True, True)
-        self.glw.addItem(self.plot)
-        self.plot.addLegend()
-
-        # ImageItem - 2D view #TODO add 2D plot for ROI and 1D plot for mouse click
-        self.glw.nextRow()
-        self.plot_roi = pg.PlotItem()
-        self.img = pg.ImageItem()
-        self.glw.addItem(self.plot_roi)
-        self.plot_roi.addItem(self.img)
-
-        # ROI selector - so far from [-1,1] #TODO update to scale with xrange
-        self.roi_selector = pg.LinearRegionItem([-1, 1])
-
-        for ii, y_value in enumerate(self.y_value_list):
-            pen = mkPen(color=color_list[ii], width=2, style=QtCore.Qt.DashLine)
-            brush = mkBrush(color=color_list[ii])
-            curve = pg.PlotDataItem(
-                **plotstyles, symbolBrush=brush, pen=pen, skipFiniteCheck=True, name=y_value
-            )
-            self.plot.addItem(curve)
-            self.curves.append(curve)
-            self.pens.append(pen)
-            self.brushs.append(brush)
-
-        self.add_crosshair(self.plot)
-        self.add_crosshair(self.plot_roi)
-
-        self.crosshair_v = pg.InfiniteLine(angle=90, movable=False)
-        self.crosshair_h = pg.InfiniteLine(angle=0, movable=False)
-        #
-        # for plot in (self.plot_roi, self.plot):
-        #     plot.addItem(self.crosshair_v, ignoreBounds=True)
-        #     plot.addItem(self.crosshair_h, ignoreBounds=True)
-
-        # self.plot.addItem(self.crosshair_v, ignoreBounds=True)
-        # self.plot.addItem(self.crosshair_h, ignoreBounds=True)
-
-        # self.plot_roi.addItem(self.crosshair_v, ignoreBounds=True)
-        # self.plot_roi.addItem(self.crosshair_h, ignoreBounds=True)
-
-        # Add textItems
-        self.add_text_items()
-
-        # Manage signals
-        self.proxy = pg.SignalProxy(
-            self.plot.scene().sigMouseMoved, rateLimit=60, slot=self.mouse_moved
-        )
-        self.proxy_update = pg.SignalProxy(self.update_signal, rateLimit=25, slot=self.update)
-        self.roi_selector.sigRegionChangeFinished.connect(self.get_roi_region)
-
-        # Debug functions
-        self.pushButton_debug.clicked.connect(self.generate_2D_data_update)
-        # self.generate_2D_data()
-
-        self._current_proj = None
-        self._current_metadata_ep = "px_stream/projection_{}/metadata"
-
-        self.data_retriever = threading.Thread(target=self.on_projection, daemon=True)
-        self.data_retriever.start()
-
-    def debug(self):
-        """
-        Debug button just for quick testing
-        """
-
-    def generate_2D_data(self):
-        data = np.random.normal(size=(1, 100))
-        self.img.setImage(data)
-
-    def generate_2D_data_update(self):
-        data = np.random.normal(size=(200, 300))
-        self.img.setImage(data, levels=(0.2, 0.5))
-
-    def add_crosshair(self, plot):
-        crosshair_v = pg.InfiniteLine(angle=90, movable=False)
-        crosshair_h = pg.InfiniteLine(angle=0, movable=False)
-
-        plot.addItem(crosshair_v)
-        plot.addItem(crosshair_h)
-
-    def get_roi_region(self):
-        """For testing purpose now, get roi region and print it to self.label as tuple"""
-        region = self.roi_selector.getRegion()
-        self.label.setText(f"x = {(10**region[0]):.4f}, y ={(10**region[1]):.4f}")
-        return_dict = {
-            "horiz_roi": [
-                np.where(self.plotter_data_x[0] > 10 ** region[0])[0][0],
-                np.where(self.plotter_data_x[0] < 10 ** region[1])[0][-1],
-            ]
-        }
-        msg = BECMessage.DeviceMessage(signals=return_dict).dumps()
-        self.producer.set_and_publish("px_stream/gui_event", msg=msg)
-        self.roi_signal.emit(region)
-
-    def add_text_items(self):  # TODO probably can be removed
-        """Add text items to the plot"""
-
-        # self.mouse_box_data.setText("Mouse cursor")
-        # TODO Via StyleSheet, one may set the color of the full QLabel
-        # self.mouse_box_data.setStyleSheet(f"QLabel {{color : rgba{self.pens[0].color().getRgb()}}}")
-
-    def mouse_moved(self, event: tuple) -> None:
-        """
-        Update the mouse table with the current mouse position and the corresponding data.
-
-        Args:
-            event (tuple):  Mouse event containing the position of the mouse cursor.
-                            The position is stored in first entry as horizontal, vertical pixel.
-        """
-        pos = event[0]
-        if not self.plot.sceneBoundingRect().contains(pos):
-            return
-        mousePoint = self.plot.vb.mapSceneToView(pos)
-        self.crosshair_v.setPos(mousePoint.x())
-        self.crosshair_h.setPos(mousePoint.y())
-        if not self.plotter_data_x:
-            return
-
-        closest_point = self.closest_x_y_value(
-            mousePoint.x(), self.plotter_data_x[0], self.plotter_data_y[0]
-        )
-        # self.precision = 3
-        # ii = 0
-        # y_value = self.y_value_list[ii]
-        # x_data = f"{10**closest_point[0]:.{self.precision}f}"
-        # y_data = f"{10**closest_point[1]:.{self.precision}f}"
-        #
-        # # Write coordinate to QTable
-        # self.mouse_table.setItem(ii, 1, QTableWidgetItem(str(y_value)))
-        # self.mouse_table.setItem(ii, 2, QTableWidgetItem(str(x_data)))
-        # self.mouse_table.setItem(ii, 3, QTableWidgetItem(str(y_data)))
-        #
-        # self.mouse_table.resizeColumnsToContents()
-
-    def closest_x_y_value(self, input_value, list_x, list_y) -> tuple:
-        """
-        Find the closest x and y value to the input value.
-
-        Args:
-            input_value (float): Input value
-            list_x (list): List of x values
-            list_y (list): List of y values
-
-        Returns:
-            tuple: Closest x and y value
-        """
-        arr = np.asarray(list_x)
-        i = (np.abs(arr - input_value)).argmin()
-        return list_x[i], list_y[i]
-
-    def update(self):
-        """Update the plot with the new data."""
-        # check if roi selector is in the plot
-        if self.roi_selector not in self.plot.items:
-            self.plot.addItem(self.roi_selector)
-
-        # check if QTable was initialised and if list of devices was changed
-        if self.y_value_list != self.previous_y_value_list:
-            self.setup_cursor_table()
-            self.previous_y_value_list = self.y_value_list.copy() if self.y_value_list else None
-
-        self.curves[0].setData(self.plotter_data_x[0], self.plotter_data_y[0])
-        # if len(self.plotter_data_x[0]) <= 1:
-        #     return
-        # self.plot.setLabel("bottom", self.label_bottom)
-        # self.plot.setLabel("left", self.label_left)
-        # for ii in range(len(self.y_value_list)):
-        #     self.curves[0].setData(self.plotter_data_x[0], self.plotter_data_y[0])
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, data: dict, metadata: dict) -> None:
-        """Update function that is called during the scan callback. To avoid
-        too many renderings, the GUI is only processing events every <_idle_time> ms.
-
-        Args:
-            data (dict): Dictionary containing a new scan segment
-            metadata (dict): Scan metadata
-
-        """
-        if metadata["scanID"] != self.plotter_scan_id:
-            self.plotter_scan_id = metadata["scanID"]
-            self._reset_plot_data()
-
-        self.title = f"Scan {metadata['scan_number']}"
-
-        self.scan_motors = scan_motors = metadata.get("scan_report_devices")
-        # client = BECClient()
-        remove_y_value_index = [
-            index
-            for index, y_value in enumerate(self.y_value_list)
-            if y_value not in client.device_manager.devices
-        ]
-        if remove_y_value_index:
-            for ii in sorted(remove_y_value_index, reverse=True):
-                # TODO Use bec warning message??? to be discussed with Klaus
-                warnings.warn(
-                    f"Warning: no matching signal for {self.y_value_list[ii]} found in list of devices. Removing from plot."
-                )
-                self.remove_curve_by_name(self.plot, self.y_value_list[ii])
-                self.y_value_list.pop(ii)
-
-        self.precision = client.device_manager.devices[scan_motors[0]]._info["describe"][
-            scan_motors[0]
-        ]["precision"]
-        # TODO after update of bec_lib, this will be new way to access data
-        # self.precision = client.device_manager.devices[scan_motors[0]].precision
-
-        x = data["data"][scan_motors[0]][scan_motors[0]]["value"]
-        self.plotter_data_x.append(x)
-        for ii, y_value in enumerate(self.y_value_list):
-            y = data["data"][y_value][y_value]["value"]
-            self.plotter_data_y[ii].append(y)
-        self.label_bottom = scan_motors[0]
-        self.label_left = f"{', '.join(self.y_value_list)}"
-
-        # print(f'metadata scan N{metadata["scan_number"]}') #TODO put as label on top of plot
-        # print(f'Data point = {data["point_id"]}') #TODO can be used for progress bar
-
-        if len(self.plotter_data_x) <= 1:
-            return
-        self.update_signal.emit()
-
-    def _reset_plot_data(self):
-        """Reset the plot data."""
-        self.plotter_data_x = []
-        self.plotter_data_y = []
-        for ii in range(len(self.y_value_list)):
-            self.curves[ii].setData([], [])
-            self.plotter_data_y.append([])
-
-    def setup_cursor_table(self):
-        """QTable formatting according to N of devices displayed in plot."""
-
-        # Init number of rows in table according to n of devices
-        self.mouse_table.setRowCount(len(self.y_value_list))
-
-        for ii, y_value in enumerate(self.y_value_list):
-            checkbox = QCheckBox()
-            checkbox.setChecked(True)
-            # TODO just for testing, will be replaced by removing/adding curve
-            checkbox.stateChanged.connect(lambda: print("status Changed"))
-            # checkbox.stateChanged.connect(lambda: self.remove_curve_by_name(plot=self.plot, checkbox=checkbox, name=y_value))
-            self.mouse_table.setCellWidget(ii, 0, checkbox)
-            self.mouse_table.setItem(ii, 1, QTableWidgetItem(str(y_value)))
-
-            self.mouse_table.resizeColumnsToContents()
-
-    @staticmethod
-    def remove_curve_by_name(plot: pyqtgraph.PlotItem, name: str) -> None:
-        # def remove_curve_by_name(plot: pyqtgraph.PlotItem, checkbox: QtWidgets.QCheckBox, name: str) -> None:
-        """Removes a curve from the given plot by the specified name.
-
-        Args:
-            plot (pyqtgraph.PlotItem): The plot from which to remove the curve.
-            name (str): The name of the curve to remove.
-        """
-        # if checkbox.isChecked():
-        for item in plot.items:
-            if isinstance(item, pg.PlotDataItem) and getattr(item, "opts", {}).get("name") == name:
-                plot.removeItem(item)
-                return
-
-        # else:
-        #     return
-
-    @staticmethod
-    def golden_ratio(num: int) -> list:
-        """Calculate the golden ratio for a given number of angles.
-
-        Args:
-            num (int): Number of angles
-        """
-        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
-        angles = []
-        for ii in range(num):
-            x = np.cos(ii * phi)
-            y = np.sin(ii * phi)
-            angle = np.arctan2(y, x)
-            angles.append(angle)
-        return angles
-
-    @staticmethod
-    def golden_angle_color(colormap: str, num: int) -> list:
-        """
-        Extract num colors for from the specified colormap following golden angle distribution.
-
-        Args:
-            colormap (str): Name of the colormap
-            num (int): Number of requested colors
-
-        Returns:
-            list: List of colors with length <num>
-
-        Raises:
-            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
-        """
-
-        cmap = pg.colormap.get(colormap)
-        cmap_colors = cmap.color
-        if num > len(cmap_colors):
-            raise ValueError(
-                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
-            )
-        angles = BasicPlot.golden_ratio(len(cmap_colors))
-        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
-        colors = [
-            mkColor(tuple((cmap_colors[int(ii)] * 255).astype(int))) for ii in color_selection[:num]
-        ]
-        return colors
-
-    def on_projection(self):
-        while True:
-            if self._current_proj is None:
-                time.sleep(0.1)
-                continue
-            endpoint = f"px_stream/projection_{self._current_proj}/data"
-            msgs = client.producer.lrange(topic=endpoint, start=-1, end=-1)
-            data = [BECMessage.DeviceMessage.loads(msg) for msg in msgs]
-            if not data:
-                continue
-            with np.errstate(divide="ignore", invalid="ignore"):
-                self.plotter_data_y = [
-                    np.sum(
-                        np.sum(data[-1].content["signals"]["data"] * self._current_norm, axis=1)
-                        / np.sum(self._current_norm, axis=0),
-                        axis=0,
-                    ).squeeze()
-                ]
-
-            self.update_signal.emit()
-
-    @pyqtSlot(dict, dict)
-    def on_dap_update(self, data: dict, metadata: dict):
-        self.img.setImage(data["z"].T)
-        # time.sleep(0,1)
-
-    @pyqtSlot(dict)
-    def new_proj(self, data):
-        proj_nr = data["proj_nr"]
-        endpoint = f"px_stream/projection_{proj_nr}/metadata"
-        msg_raw = client.producer.get(topic=endpoint)
-        msg = BECMessage.DeviceMessage.loads(msg_raw)
-        self._current_q = msg.content["signals"]["q"]
-        self._current_norm = msg.content["signals"]["norm_sum"]
-        self._current_metadata = msg.content["signals"]["metadata"]
-
-        self.plotter_data_x = [self._current_q]
-        self._current_proj = proj_nr
-
-
-if __name__ == "__main__":
-    import argparse
-
-    from bec_widgets import ctrl_c
-    from bec_widgets.bec_dispatcher import bec_dispatcher
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--signals",
-        help="specify recorded signals",
-        nargs="+",
-        default=["gauss_bpm"],
-    )
-    # default = ["gauss_bpm", "bpm4i", "bpm5i", "bpm6i", "xert"],
-    value = parser.parse_args()
-    print(f"Plotting signals for: {', '.join(value.signals)}")
-    client = bec_dispatcher.client
-    # client.start()
-    app = QtWidgets.QApplication([])
-    ctrl_c.setup(app)
-    plot = BasicPlot(y_value_list=value.signals)
-    # bec_dispatcher.connect(plot)
-    bec_dispatcher.connect_proj_id(plot.new_proj)
-    bec_dispatcher.connect_dap_slot(plot.on_dap_update, "px_dap_worker")
-    plot.show()
-    # client.callbacks.register("scan_segment", plot, sync=False)
-    app.exec_()

bec_widgets/basic_plot.ui

@@ -1,77 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>Form</class>
- <widget class="QWidget" name="Form">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>845</width>
-    <height>635</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Line Plot</string>
-  </property>
-  <layout class="QHBoxLayout" name="horizontalLayout">
-   <item>
-    <widget class="QSplitter" name="splitter">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="opaqueResize">
-      <bool>false</bool>
-     </property>
-     <widget class="QWidget" name="verticalLayoutWidget">
-      <layout class="QVBoxLayout" name="verticalLayout">
-       <item>
-        <widget class="QPushButton" name="pushButton_debug">
-         <property name="text">
-          <string>Debug</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="GraphicsLayoutWidget" name="glw"/>
-       </item>
-      </layout>
-     </widget>
-     <widget class="QTableWidget" name="mouse_table">
-      <property name="textElideMode">
-       <enum>Qt::ElideMiddle</enum>
-      </property>
-      <column>
-       <property name="text">
-        <string>Display</string>
-       </property>
-      </column>
-      <column>
-       <property name="text">
-        <string>Device</string>
-       </property>
-      </column>
-      <column>
-       <property name="text">
-        <string>X</string>
-       </property>
-      </column>
-      <column>
-       <property name="text">
-        <string>Y</string>
-       </property>
-      </column>
-     </widget>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>GraphicsLayoutWidget</class>
-   <extends>QGraphicsView</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>

bec_widgets/bec_dispatcher.py

@@ -1,237 +0,0 @@
-import argparse
-import itertools
-import os
-from dataclasses import dataclass
-from threading import RLock
-
-from bec_lib import BECClient
-from bec_lib.core import BECMessage, MessageEndpoints, ServiceConfig
-from bec_lib.core.redis_connector import RedisConsumerThreaded
-from PyQt5.QtCore import QObject, pyqtSignal
-
-
-@dataclass
-class _BECDap:
-    """Utility class to keep track of slots associated with a particular dap redis consumer"""
-
-    consumer: RedisConsumerThreaded
-    slots = set()
-
-
-# Adding a new pyqt signal requres 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()
-)
-
-
-@dataclass
-class _Connection:
-    """Utility class to keep track of slots connected to a particular redis consumer"""
-
-    consumer: RedisConsumerThreaded
-    slots = set()
-    # keep a reference to a new signal class, so it is not gc'ed
-    _signal_container = next(_signal_class_factory)()
-
-    def __post_init__(self):
-        self.signal = self._signal_container.signal
-
-
-class _BECDispatcher(QObject):
-    new_scan = pyqtSignal(dict, dict)
-    scan_segment = pyqtSignal(dict, dict)
-    new_dap_data = pyqtSignal(dict, dict)
-
-    new_projection_id = pyqtSignal(dict)
-    new_projection_data = pyqtSignal(dict)
-
-    def __init__(self, bec_config=None):
-        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.client.initialize(config=ServiceConfig(config_path=bec_config))
-
-        self._slot_signal_map = {
-            "on_scan_segment": self.scan_segment,
-            "on_new_scan": self.new_scan,
-        }
-        self._daps = {}
-        self._connections = {}
-
-        self._scan_id = None
-        scan_lock = RLock()
-
-        # self.new_projection_id.connect(self.new_projection_data)
-
-        def _scan_segment_cb(msg):
-            msg = BECMessage.ScanMessage.loads(msg.value)[0]
-            with scan_lock:
-                # TODO: use ScanStatusMessage instead?
-                scan_id = msg.content["scanID"]
-                if self._scan_id != scan_id:
-                    self._scan_id = scan_id
-                    self.new_scan.emit(msg.content, msg.metadata)
-            self.scan_segment.emit(msg.content, msg.metadata)
-
-        scan_segment_topic = MessageEndpoints.scan_segment()
-        self._scan_segment_thread = self.client.connector.consumer(
-            topics=scan_segment_topic,
-            cb=_scan_segment_cb,
-        )
-        self._scan_segment_thread.start()
-
-    def connect(self, widget):
-        for slot_name, signal in self._slot_signal_map.items():
-            slot = getattr(widget, slot_name, None)
-            if callable(slot):
-                signal.connect(slot)
-
-    def connect_slot(self, slot, topic):
-        # create new connection for topic if it doesn't exist
-        if topic not in self._connections:
-
-            def cb(msg):
-                msg = BECMessage.MessageReader.loads(msg.value)
-                if not isinstance(msg, list):
-                    msg = [msg]
-                for msg_i in msg:
-                    self._connections[topic].signal.emit(msg_i.content, msg_i.metadata)
-
-            consumer = self.client.connector.consumer(topics=topic, cb=cb)
-            consumer.start()
-
-            self._connections[topic] = _Connection(consumer)
-
-        # connect slot if it's not connected
-        if slot not in self._connections[topic].slots:
-            self._connections[topic].signal.connect(slot)
-            self._connections[topic].slots.add(slot)
-
-    def disconnect_slot(self, slot, topic):
-        if topic not in self._connections:
-            return
-
-        if slot not in self._connections[topic].slots:
-            return
-
-        self._connections[topic].signal.disconnect(slot)
-        self._connections[topic].slots.remove(slot)
-
-        if not self._connections[topic].slots:
-            # shutdown consumer if there are no more connected slots
-            self._connections[topic].consumer.shutdown()
-            del self._connections[topic]
-
-    def connect_dap_slot(self, slot, dap_names):
-        if not isinstance(dap_names, list):
-            dap_names = [dap_names]
-
-        for dap_name in dap_names:
-            if dap_name not in self._daps:  # create a new consumer and connect slot
-                self.add_new_dap_connection(slot, dap_name)
-
-            else:
-                # connect slot if it's not yet connected
-                if slot not in self._daps[dap_name].slots:
-                    self.new_dap_data.connect(slot)
-                    self._daps[dap_name].slots.add(slot)
-
-    def add_new_dap_connection(self, slot, dap_name):
-        def _dap_cb(msg):
-            msg = BECMessage.ProcessedDataMessage.loads(msg.value)
-            if not isinstance(msg, list):
-                msg = [msg]
-            for i in msg:
-                self.new_dap_data.emit(i.content["data"], i.metadata)
-
-        dap_ep = MessageEndpoints.processed_data(dap_name)
-        consumer = self.client.connector.consumer(topics=dap_ep, cb=_dap_cb)
-        consumer.start()
-
-        self.new_dap_data.connect(slot)
-
-        self._daps[dap_name] = _BECDap(consumer)
-        self._daps[dap_name].slots.add(slot)
-
-    def disconnect_dap_slot(self, slot, dap_name):
-        if dap_name not in self._daps:
-            return
-
-        if slot not in self._daps[dap_name].slots:
-            return
-
-        self.new_dap_data.disconnect(slot)
-        self._daps[dap_name].slots.remove(slot)
-
-        if not self._daps[dap_name].slots:
-            # shutdown consumer if there are no more connected slots
-            self._daps[dap_name].consumer.shutdown()
-            del self._daps[dap_name]
-
-    # def connect_proj_data(self, slot):
-    #     keys = self.client.producer.keys("px_stream/projection_*")
-    #     keys = keys or []
-    #
-    #     def _dap_cb(msg):
-    #         msg = BECMessage.DeviceMessage.loads(msg.value)
-    #         self.new_projection_data.emit(msg.content["data"])
-    #
-    #     proj_numbers = set(key.decode().split("px_stream/projection_")[1].split("/")[0] for key in keys)
-    #     last_proj_id = sorted(proj_numbers)[-1]
-    #     dap_ep = MessageEndpoints.processed_data(f"px_stream/projection_{last_proj_id}/")
-    #
-    #     consumer = self.client.connector.consumer(topics=dap_ep, cb=_dap_cb)
-    #     consumer.start()
-    #
-    #     self.new_projection_data.connect(slot)
-
-    def connect_proj_id(self, slot):
-        def _dap_cb(msg):
-            msg = BECMessage.DeviceMessage.loads(msg.value)
-            self.new_projection_id.emit(msg.content["signals"])
-
-        dap_ep = "px_stream/proj_nr"
-        consumer = self.client.connector.consumer(topics=dap_ep, cb=_dap_cb)
-        consumer.start()
-
-        self.new_projection_id.connect(slot)
-
-    def connect_proj_data(self, slot: object, data_ep: str) -> object:
-        def _dap_cb(msg):
-            msg = BECMessage.DeviceMessage.loads(msg.value)
-            self.new_projection_data.emit(msg.content["signals"])
-
-        consumer = self.client.connector.consumer(topics=data_ep, cb=_dap_cb)
-        consumer.start()
-        self._daps[data_ep] = _BECDap(consumer)
-        self._daps[data_ep].slots.add(slot)
-
-        self.new_projection_data.connect(slot)
-
-    def disconnect_proj_data(self, slot, data_ep):
-        if data_ep not in self._daps:
-            return
-
-        if slot not in self._daps[data_ep].slots:
-            return
-
-        self.new_projection_data.disconnect(slot)
-        self._daps[data_ep].slots.remove(slot)
-
-        if not self._daps[data_ep].slots:
-            # shutdown consumer if there are no more connected slots
-            self._daps[data_ep].consumer.shutdown()
-            del self._daps[data_ep]
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--bec-config", default=None)
-args, _ = parser.parse_known_args()
-
-bec_dispatcher = _BECDispatcher(args.bec_config)

bec_widgets/config_plotter.py

@@ -1,129 +0,0 @@
-from typing import List
-
-import numpy as np
-import pyqtgraph as pg
-from pyqtgraph import mkPen
-from pyqtgraph.Qt import QtCore, QtWidgets
-
-
-class ConfigPlotter(pg.GraphicsWidget):
-    """
-    ConfigPlotter is a widget that can be used to plot data from multiple channels
-    in a grid layout. The layout is specified by a list of dicts, where each dict
-    specifies the position of the plot in the grid, the channels to plot, and the
-    type of plot to use. The plot type is specified by the name of the pyqtgraph
-    item to use. For example, to plot a single channel in a PlotItem, the config
-    would look like this:
-
-    config = [
-        {
-            "cols": 1,
-            "rows": 1,
-            "y": 0,
-            "x": 0,
-            "config": {"channels": ["a"], "label_xy": ["", "a"], "item": "PlotItem"},
-        }
-    ]
-
-    """
-
-    def __init__(self, configs: List[dict], parent=None):
-        super().__init__(parent)
-        self.configs = configs
-        self.plots = {}
-        self._init_ui()
-        self._init_plots()
-
-    def _init_ui(self):
-        pg.setConfigOption("background", "w")
-        pg.setConfigOption("foreground", "k")
-
-        # pylint: disable=no-member
-        self.pen = mkPen(color=(56, 76, 107), width=4, style=QtCore.Qt.SolidLine)
-
-        self.view = pg.GraphicsView()
-        self.view.setAntialiasing(True)
-        self.view.show()
-
-        self.layout = pg.GraphicsLayout()
-        self.view.setCentralWidget(self.layout)
-
-    def _init_plots(self):
-        for config in self.configs:
-            channels = config["config"]["channels"]
-            for channel in channels:
-                item = pg.PlotItem()
-                self.layout.addItem(
-                    item,
-                    row=config["y"],
-                    col=config["x"],
-                    rowspan=config["rows"],
-                    colspan=config["cols"],
-                )
-
-                # call the corresponding init function, e.g. init_plotitem
-                init_func = getattr(self, f"init_{config['config']['item']}")
-                init_func(channel, config["config"], item)
-
-                # self.init_ImageItem(channel, config["config"], item)
-
-    def init_PlotItem(self, channel: str, config: dict, item: pg.GraphicsItem):
-        """
-        Initialize a PlotItem
-
-        Args:
-            channel(str): channel to plot
-            config(dict): config dict for the channel
-            item(pg.GraphicsItem): PlotItem to plot the data
-        """
-        # pylint: disable=invalid-name
-        plot_data = item.plot(np.random.rand(100), pen=self.pen)
-        item.setLabel("left", channel)
-        self.plots[channel] = {"item": item, "plot_data": plot_data}
-
-    def init_ImageItem(self, channel: str, config: dict, item: pg.GraphicsItem):
-        """
-        Initialize an ImageItem
-
-        Args:
-            channel(str): channel to plot
-            config(dict): config dict for the channel
-            item(pg.GraphicsItem): ImageItem to plot the data
-        """
-        # pylint: disable=invalid-name
-        img = pg.ImageItem()
-        item.addItem(img)
-        img.setImage(np.random.rand(100, 100))
-        self.plots[channel] = {"item": item, "plot_data": img}
-
-
-if __name__ == "__main__":
-    import sys
-
-    CONFIG = [
-        {
-            "cols": 1,
-            "rows": 1,
-            "y": 0,
-            "x": 0,
-            "config": {"channels": ["a"], "label_xy": ["", "a"], "item": "PlotItem"},
-        },
-        {
-            "cols": 1,
-            "rows": 1,
-            "y": 1,
-            "x": 0,
-            "config": {"channels": ["b"], "label_xy": ["", "b"], "item": "PlotItem"},
-        },
-        {
-            "cols": 1,
-            "rows": 2,
-            "y": 0,
-            "x": 1,
-            "config": {"channels": ["c"], "label_xy": ["", "c"], "item": "ImageItem"},
-        },
-    ]
-
-    app = QtWidgets.QApplication(sys.argv)
-    win = ConfigPlotter(CONFIG)
-    pg.exec()

bec_widgets/ctrl_c.py

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

bec_widgets/display_ui_file.py

@@ -1,33 +0,0 @@
-import os
-import sys
-
-from PyQt5 import QtWidgets, uic
-
-
-class UI(QtWidgets.QWidget):
-    def __init__(self, uipath):
-        super().__init__()
-
-        self.ui = uic.loadUi(uipath, self)
-
-        _, fname = os.path.split(uipath)
-        self.setWindowTitle(fname)
-
-        self.show()
-
-
-def main():
-    """A basic script to display UI file
-
-    Run the script, passing UI file path as an argument, e.g.
-    $ python bec_widgets/display_ui_file.py bec_widgets/line_plot.ui
-    """
-    app = QtWidgets.QApplication(sys.argv)
-
-    UI(sys.argv[1])
-
-    sys.exit(app.exec_())
-
-
-if __name__ == "__main__":
-    main()

bec_widgets/examples/crosshair_example/crosshair_example.py

@@ -1,6 +1,6 @@
 import numpy as np
 import pyqtgraph as pg
-from PyQt5.QtWidgets import (
+from qtpy.QtWidgets import (
     QApplication,
     QVBoxLayout,
     QLabel,
@@ -12,7 +12,7 @@ from PyQt5.QtWidgets import (
 )
 from pyqtgraph import mkPen
 from pyqtgraph.Qt import QtCore
-from bec_widgets.qt_utils import Crosshair
+from bec_widgets.utils import Crosshair
 
 
 class ExampleApp(QWidget):
@@ -165,4 +165,4 @@ if __name__ == "__main__":
     app = QApplication([])
     window = ExampleApp()
     window.show()
-    app.exec_()
+    app.exec()

bec_widgets/examples/eiger_plot/eiger_plot.py

@@ -6,10 +6,10 @@ import h5py
 import numpy as np
 import pyqtgraph as pg
 import zmq
-from PyQt5.QtCore import pyqtSignal
-from PyQt5.QtCore import pyqtSlot
-from PyQt5.QtGui import QKeySequence
-from PyQt5.QtWidgets import (
+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,
@@ -47,7 +47,13 @@ class EigerPlot(QWidget):
         self.key_bindings()
 
         # ZMQ Consumer
-        self.start_zmq_consumer()
+        self._zmq_consumer_exit_event = threading.Event()
+        self._zmq_consumer_thread = self.start_zmq_consumer()
+
+    def close(self):
+        super().close()
+        self._zmq_consumer_exit_event.set()
+        self._zmq_consumer_thread.join()
 
     def init_ui(self):
         # Create Plot and add ImageItem
@@ -182,25 +188,36 @@ class EigerPlot(QWidget):
     ###############################
 
     def start_zmq_consumer(self):
-        consumer_thread = threading.Thread(target=self.zmq_consumer, daemon=True).start()
+        consumer_thread = threading.Thread(
+            target=self.zmq_consumer, args=(self._zmq_consumer_exit_event,), daemon=True
+        )
+        consumer_thread.start()
+        return consumer_thread
 
-    def zmq_consumer(self):
-        try:
-            print("starting consumer")
-            live_stream_url = "tcp://129.129.95.38:20000"
-            receiver = zmq.Context().socket(zmq.SUB)
-            receiver.connect(live_stream_url)
-            receiver.setsockopt_string(zmq.SUBSCRIBE, "")
+    def zmq_consumer(self, exit_event):
+        print("starting consumer")
+        live_stream_url = "tcp://129.129.95.38:20000"
+        receiver = zmq.Context().socket(zmq.SUB)
+        receiver.connect(live_stream_url)
+        receiver.setsockopt_string(zmq.SUBSCRIBE, "")
+
+        poller = zmq.Poller()
+        poller.register(receiver, zmq.POLLIN)
+
+        # code could be a bit simpler here, testing exit_event in
+        # 'while' condition, but like this it is easier for the
+        # 'test_zmq_consumer' test
+        while True:
+            if poller.poll(1000):  # 1s timeout
+                raw_meta, raw_data = receiver.recv_multipart(zmq.NOBLOCK)
 
-            while True:
-                raw_meta, raw_data = receiver.recv_multipart()
                 meta = json.loads(raw_meta.decode("utf-8"))
                 self.image = np.frombuffer(raw_data, dtype=meta["type"]).reshape(meta["shape"])
                 self.update_signal.emit()
+            if exit_event.is_set():
+                break
 
-        finally:
-            receiver.disconnect(live_stream_url)
-            receiver.context.term()
+        receiver.disconnect(live_stream_url)
 
     ###############################
     # just simulations from here
@@ -257,7 +274,7 @@ class EigerPlot(QWidget):
         )
 
         dialog.setLayout(layout)
-        dialog.exec_()
+        dialog.exec()
 
     ###############################
     # just simulations from here
@@ -290,9 +307,9 @@ class EigerPlot(QWidget):
 
 if __name__ == "__main__":
     import sys
-    from PyQt5.QtWidgets import QApplication
+    from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
     plot = EigerPlot()
     plot.show()
-    sys.exit(app.exec_())
+    sys.exit(app.exec())

bec_widgets/examples/mca_readout/mca_plot.py

@@ -1,14 +1,14 @@
 # import simulation_progress as SP
 import numpy as np
 import pyqtgraph as pg
-from PyQt5.QtCore import pyqtSignal, pyqtSlot
-from PyQt5.QtWidgets import (
+from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
+from qtpy.QtWidgets import (
     QApplication,
     QVBoxLayout,
     QWidget,
 )
 
-from bec_lib.core import MessageEndpoints, BECMessage
+from bec_lib import MessageEndpoints, messages
 
 
 class StreamApp(QWidget):
@@ -49,9 +49,9 @@ class StreamApp(QWidget):
         self.plot_item = pg.PlotItem()
         self.plot_item.setAspectLocked(False)
         self.imageItem = pg.ImageItem()
-        #self.plot_item1D = pg.PlotItem()
-        #self.plot_item.addItem(self.imageItem)
-        #self.plot_item.addItem(self.plot_item1D)
+        # self.plot_item1D = pg.PlotItem()
+        # self.plot_item.addItem(self.imageItem)
+        # self.plot_item.addItem(self.plot_item1D)
 
         # Setting up histogram
         # self.hist = pg.HistogramLUTItem()
@@ -96,13 +96,13 @@ class StreamApp(QWidget):
     #     self.device_consumer.start()
 
     def plot_new(self):
-        print(f'Printing data from plot update: {self.data}')
+        print(f"Printing data from plot update: {self.data}")
         self.plot_item.plot(self.data[0])
-        #self.imageItem.setImage(self.data, autoLevels=False)
+        # self.imageItem.setImage(self.data, autoLevels=False)
 
     @staticmethod
     def _streamer_cb(msg, *, parent, **_kwargs) -> None:
-        msgMCS = BECMessage.DeviceMessage.loads(msg.value)
+        msgMCS = messages.DeviceMessage.loads(msg.value)
         print(msgMCS)
         row = msgMCS.content["signals"][parent.sub_device]
         metadata = msgMCS.metadata
@@ -110,7 +110,7 @@ class StreamApp(QWidget):
         # Check if the current number of rows is odd
         # if parent.data is not None and parent.data.shape[0] % 2 == 1:
         #     row = np.flip(row)  # Flip the row
-        print(f'Printing data from callback update: {row}')
+        print(f"Printing data from callback update: {row}")
         parent.data = np.array([row])
         # if parent.data is None:
         #     parent.data = np.array([row])
@@ -123,7 +123,7 @@ class StreamApp(QWidget):
     def _device_cv(msg, *, parent, **_kwargs) -> None:
         print("Getting ScanID")
 
-        msgDEV = BECMessage.ScanStatusMessage.loads(msg.value)
+        msgDEV = messages.ScanStatusMessage.loads(msg.value)
 
         current_scanID = msgDEV.content["scanID"]
 
@@ -134,8 +134,8 @@ class StreamApp(QWidget):
 
         if current_scanID != parent.scanID:
             parent.scanID = current_scanID
-            #parent.data = None
-            #parent.imageItem.clear()
+            # parent.data = None
+            # parent.imageItem.clear()
             parent.new_scanID.emit(current_scanID)
 
             print(f"New scanID: {current_scanID}")
@@ -143,12 +143,10 @@ class StreamApp(QWidget):
 
 if __name__ == "__main__":
     import argparse
-    from bec_lib.core import RedisConnector
+    from bec_lib import RedisConnector
 
     parser = argparse.ArgumentParser(description="Stream App.")
-    parser.add_argument(
-        "--port", type=str, default="pc15543:6379", help="Port for RedisConnector"
-    )
+    parser.add_argument("--port", type=str, default="pc15543:6379", help="Port for RedisConnector")
     parser.add_argument("--device", type=str, default="mcs", help="Device name")
     parser.add_argument("--sub_device", type=str, default="mca4", help="Sub-device name")
 
@@ -160,4 +158,4 @@ if __name__ == "__main__":
     streamApp = StreamApp(device=args.device, sub_device=args.sub_device)
 
     streamApp.show()
-    app.exec_()
+    app.exec()

bec_widgets/examples/mca_readout/mca_sim.py

@@ -1,4 +1,4 @@
-from bec_lib.core import BECMessage, MessageEndpoints, RedisConnector
+from bec_lib import messages, MessageEndpoints, RedisConnector
 import time
 
 connector = RedisConnector("localhost:6379")
@@ -15,7 +15,7 @@ metadata.update(
 )
 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 = BECMessage.DeviceMessage(
+    msg = messages.DeviceMessage(
         signals=data,
         metadata=metadata,
     ).dumps()

bec_widgets/examples/modular_app/modular.ui

@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1433</width>
+    <height>689</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <layout class="QGridLayout" name="gridLayout">
+    <item row="1" column="2">
+     <widget class="QLabel" name="label_3">
+      <property name="text">
+       <string>Plot  Config 2</string>
+      </property>
+     </widget>
+    </item>
+    <item row="3" column="0" colspan="2">
+     <widget class="BECMonitor" name="plot_1"/>
+    </item>
+    <item row="1" column="3">
+     <widget class="QPushButton" name="pushButton_setting_2">
+      <property name="text">
+       <string>Setting Plot 2</string>
+      </property>
+     </widget>
+    </item>
+    <item row="3" column="2" colspan="2">
+     <widget class="BECMonitor" name="plot_2"/>
+    </item>
+    <item row="1" column="4">
+     <widget class="QLabel" name="label_2">
+      <property name="text">
+       <string>Plot Scan Types = True</string>
+      </property>
+     </widget>
+    </item>
+    <item row="1" column="1">
+     <widget class="QPushButton" name="pushButton_setting_1">
+      <property name="text">
+       <string>Setting Plot 1</string>
+      </property>
+     </widget>
+    </item>
+    <item row="1" column="0">
+     <widget class="QLabel" name="label">
+      <property name="text">
+       <string>Plot Config 1</string>
+      </property>
+     </widget>
+    </item>
+    <item row="1" column="5">
+     <widget class="QPushButton" name="pushButton_setting_3">
+      <property name="text">
+       <string>Setting Plot 3</string>
+      </property>
+     </widget>
+    </item>
+    <item row="3" column="4" colspan="2">
+     <widget class="BECMonitor" name="plot_3"/>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>1433</width>
+     <height>37</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>BECMonitor</class>
+   <extends>QGraphicsView</extends>
+   <header location="global">bec_widgets.widgets.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/examples/modular_app/modular_app.py

@@ -0,0 +1,200 @@
+import os
+
+from qtpy import uic
+from qtpy.QtWidgets import QMainWindow, QApplication
+
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.widgets import BECMonitor
+
+# some default configs for demonstration purposes
+CONFIG_SIMPLE = {
+    "plot_settings": {
+        "background_color": "black",
+        "num_columns": 2,
+        "colormap": "plasma",
+        "scan_types": False,
+    },
+    "plot_data": [
+        {
+            "plot_name": "BPM4i plots vs samx",
+            "x_label": "Motor X",
+            "y_label": "bpm4i",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": [{"name": "samx"}],
+                        "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                    },
+                },
+                # {
+                #     "type": "history",
+                #     "signals": {
+                #         "x": [{"name": "samx"}],
+                #         "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                #     },
+                # },
+                # {
+                #     "type": "dap",
+                #     'worker':'some_worker',
+                #     "signals": {
+                #         "x": [{"name": "samx"}],
+                #         "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                #     },
+                # },
+            ],
+        },
+        {
+            "plot_name": "Gauss plots vs samx",
+            "x_label": "Motor X",
+            "y_label": "Gauss",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": [{"name": "samx", "entry": "samx"}],
+                        "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
+                    },
+                }
+            ],
+        },
+    ],
+}
+
+
+CONFIG_SCAN_MODE = {
+    "plot_settings": {
+        "background_color": "white",
+        "num_columns": 3,
+        "colormap": "plasma",
+        "scan_types": True,
+    },
+    "plot_data": {
+        "grid_scan": [
+            {
+                "plot_name": "Grid plot 1",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_bpm"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 2",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_adc1"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 3",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy"}],
+                            "y": [{"name": "gauss_adc2"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 4",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy", "entry": "samy"}],
+                            "y": [{"name": "gauss_adc3"}],
+                        },
+                    }
+                ],
+            },
+        ],
+        "line_scan": [
+            {
+                "plot_name": "BPM plots vs samx",
+                "x_label": "Motor X",
+                "y_label": "Gauss",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "bpm4i"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Gauss plots vs samx",
+                "x_label": "Motor X",
+                "y_label": "Gauss",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
+                        },
+                    }
+                ],
+            },
+        ],
+    },
+}
+
+
+class ModularApp(QMainWindow):
+    def __init__(self, client=None, parent=None):
+        super(ModularApp, self).__init__(parent)
+
+        # Client and device manager from BEC
+        self.client = BECDispatcher().client if client is None else client
+
+        # Loading UI
+        current_path = os.path.dirname(__file__)
+        uic.loadUi(os.path.join(current_path, "modular.ui"), self)
+
+        self._init_plots()
+
+    def _init_plots(self):
+        """Initialize plots and connect the buttons to the config dialogs"""
+        plots = [self.plot_1, self.plot_2, self.plot_3]
+        configs = [CONFIG_SIMPLE, CONFIG_SCAN_MODE, CONFIG_SCAN_MODE]
+        buttons = [self.pushButton_setting_1, self.pushButton_setting_2, self.pushButton_setting_3]
+
+        # hook plots, configs and buttons together
+        for plot, config, button in zip(plots, configs, buttons):
+            plot.on_config_update(config)
+            button.clicked.connect(plot.show_config_dialog)
+
+
+if __name__ == "__main__":
+    # BECclient global variables
+    client = BECDispatcher().client
+    client.start()
+
+    app = QApplication([])
+    modularApp = ModularApp(client=client)
+
+    window = modularApp
+    window.show()
+    app.exec()

bec_widgets/examples/motor_movement/motor_example.py

@@ -5,12 +5,12 @@ from functools import partial
 
 import numpy as np
 import pyqtgraph as pg
-from PyQt5 import QtGui
-from PyQt5.QtCore import QThread, pyqtSlot
-from PyQt5.QtCore import pyqtSignal, Qt
-from PyQt5.QtGui import QDoubleValidator
-from PyQt5.QtGui import QKeySequence
-from PyQt5.QtWidgets import (
+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.QtWidgets import (
     QApplication,
     QWidget,
     QFileDialog,
@@ -20,12 +20,12 @@ from PyQt5.QtWidgets import (
     QPushButton,
     QFrame,
 )
-from PyQt5.QtWidgets import QMessageBox
-from PyQt5.QtWidgets import QShortcut
+from qtpy.QtWidgets import QMessageBox
+from qtpy.QtWidgets import QShortcut
 from pyqtgraph.Qt import QtWidgets, uic, QtCore
 
-from bec_lib.core import MessageEndpoints, BECMessage
-from bec_widgets.qt_utils import DoubleValidationDelegate
+from bec_lib import MessageEndpoints, messages
+from bec_widgets.utils import DoubleValidationDelegate
 
 
 # TODO - General features
@@ -1081,7 +1081,7 @@ class MotorApp(QWidget):
         layout.addWidget(ok_button)
 
         dialog.setLayout(layout)
-        dialog.exec_()
+        dialog.exec()
 
     @staticmethod
     def param_changed(ui_element):
@@ -1129,10 +1129,12 @@ class MotorControl(QThread):
             motor_x_name (str): The name of the motor for the x-axis.
             motor_y_name (str): The name of the motor for the y-axis.
         """
+        self.motor_x_name = motor_x_name
+        self.motor_y_name = motor_y_name
 
         self.motor_x, self.motor_y = (
-            dev[motor_x_name],
-            dev[motor_y_name],
+            dev[self.motor_x_name],
+            dev[self.motor_y_name],
         )
 
         (self.current_x, self.current_y) = self.get_coordinates()
@@ -1179,8 +1181,8 @@ class MotorControl(QThread):
 
     def get_coordinates(self) -> tuple:
         """Get current motor position"""
-        x = self.motor_x.read(cached=True)["value"]
-        y = self.motor_y.read(cached=True)["value"]
+        x = self.motor_x.readback.get()
+        y = self.motor_y.readback.get()
         return x, y
 
     def retrieve_coordinates(self) -> tuple:
@@ -1295,7 +1297,7 @@ class MotorControl(QThread):
 
     @staticmethod
     def _device_status_callback_motors(msg, *, parent, **_kwargs) -> None:
-        deviceMSG = BECMessage.DeviceMessage.loads(msg.value)
+        deviceMSG = messages.DeviceMessage.loads(msg.value)
         if parent.motor_x.name in deviceMSG.content["signals"]:
             parent.current_x = deviceMSG.content["signals"][parent.motor_x.name]["value"]
         elif parent.motor_y.name in deviceMSG.content["signals"]:
@@ -1307,9 +1309,7 @@ if __name__ == "__main__":
     import yaml
     import argparse
 
-    from bec_lib import BECClient
-
-    from bec_lib.core import ServiceConfig
+    from bec_lib import BECClient, ServiceConfig
 
     parser = argparse.ArgumentParser(description="Motor App")
 
@@ -1350,4 +1350,4 @@ if __name__ == "__main__":
     MotorApp = MotorApp(selected_motors=selected_motors, plot_motors=plot_motors)
     window = MotorApp
     window.show()
-    app.exec_()
+    app.exec()

bec_widgets/examples/oneplot/oneplot.py

@@ -1,18 +1,17 @@
 import os
 
-import PyQt5.QtWidgets
 import numpy as np
-
+import qtpy.QtWidgets
 import pyqtgraph as pg
-from PyQt5.QtCore import pyqtSignal, pyqtSlot
-from PyQt5.QtWidgets import QApplication, QWidget
-from PyQt5.QtWidgets import QTableWidgetItem
-from pyqtgraph import mkBrush, mkPen
+from bec_lib import MessageEndpoints
+from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
+from qtpy.QtWidgets import QApplication, QTableWidgetItem, QWidget
 from pyqtgraph import mkBrush, mkColor, mkPen
 from pyqtgraph.Qt import QtCore, uic
 
-from bec_widgets.qt_utils import Crosshair
-from bec_lib.core import MessageEndpoints
+from bec_widgets.utils import Crosshair, ctrl_c
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
 
 # TODO implement:
 #   - implement scanID database for visualizing previous scans
@@ -106,10 +105,7 @@ class PlotApp(QWidget):
             # for ii, (monitor, color) in enumerate(zip(self.dap_worker, colors_y_daps)):#TODO adapt for multiple dap_workers
             pen_dap = mkPen(color="#3b5998", width=2, style=QtCore.Qt.DashLine)
             curve_dap = pg.PlotDataItem(
-                pen=pen_dap,
-                skipFiniteCheck=True,
-                symbolSize=5,
-                name=f"{self.dap_worker}",
+                pen=pen_dap, skipFiniteCheck=True, symbolSize=5, name=f"{self.dap_worker}"
             )
             self.curves_dap.append(curve_dap)
             self.plot.addItem(curve_dap)
@@ -129,7 +125,7 @@ class PlotApp(QWidget):
         )
 
     def update_table(
-        self, table_widget: PyQt5.QtWidgets.QTableWidget, x: float, y_values: list, column: int
+        self, table_widget: qtpy.QtWidgets.QTableWidget, x: float, y_values: list, column: int
     ) -> None:
         for i, y in enumerate(y_values):
             table_widget.setItem(i, column, QTableWidgetItem(f"({x}, {y})"))
@@ -243,8 +239,6 @@ class PlotApp(QWidget):
 
 if __name__ == "__main__":
     import yaml
-    from bec_widgets import ctrl_c
-    from bec_widgets.bec_dispatcher import bec_dispatcher
 
     with open("config_noworker.yaml", "r") as file:
         config = yaml.safe_load(file)
@@ -256,6 +250,7 @@ if __name__ == "__main__":
     dap_worker = None if dap_worker == "None" else dap_worker
 
     # BECclient global variables
+    bec_dispatcher = BECDispatcher()
     client = bec_dispatcher.client
     client.start()
 
@@ -267,10 +262,10 @@ if __name__ == "__main__":
     plotApp = PlotApp(x_value=x_value, y_values=y_values, dap_worker=dap_worker)
 
     # Connecting signals from bec_dispatcher
-    bec_dispatcher.connect_dap_slot(plotApp.on_dap_update, dap_worker)
+    bec_dispatcher.connect_slot(plotApp.on_dap_update, MessageEndpoints.processed_data(dap_worker))
     bec_dispatcher.connect_slot(plotApp.on_scan_segment, MessageEndpoints.scan_segment())
     ctrl_c.setup(app)
 
     window = plotApp
     window.show()
-    app.exec_()
+    app.exec()

bec_widgets/examples/plot_app/plot_app.py

@@ -1,16 +1,29 @@
+import logging
 import os
 
+# import traceback
+
 import pyqtgraph
 import pyqtgraph as pg
-from PyQt5.QtCore import pyqtSignal, pyqtSlot
-from PyQt5.QtWidgets import QApplication, QWidget, QTableWidgetItem, QTableWidget, QFileDialog
+
+from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
+
+from qtpy.QtWidgets import (
+    QApplication,
+    QWidget,
+    QTableWidgetItem,
+    QTableWidget,
+    QFileDialog,
+    QMessageBox,
+)
 from pyqtgraph import ColorButton
 from pyqtgraph import mkBrush, mkPen
 from pyqtgraph.Qt import QtCore, uic
 from pyqtgraph.Qt import QtWidgets
 
-from bec_lib.core import MessageEndpoints
-from bec_widgets.qt_utils import Crosshair, Colors
+from bec_lib import MessageEndpoints
+from bec_widgets.utils import Crosshair, Colors
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 
 # TODO implement:
@@ -73,12 +86,19 @@ class PlotApp(QWidget):
     update_signal = pyqtSignal()
     update_dap_signal = pyqtSignal()
 
-    def __init__(self, config: dict, parent=None):
+    def __init__(self, config: dict, client=None, parent=None):
         super(PlotApp, self).__init__(parent)
 
+        # Error handler
+        self.error_handler = ErrorHandler(parent=self)
+
+        # Client and device manager from BEC
+        self.client = BECDispatcher().client if client is None else client
+        self.dev = self.client.device_manager.devices
+
         # Loading UI
         current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "extreme.ui"), self)
+        uic.loadUi(os.path.join(current_path, "plot_app.ui"), self)
 
         self.data = {}
 
@@ -90,9 +110,13 @@ class PlotApp(QWidget):
 
         self.user_colors = {}  # key: (plot_name, y_name, y_entry), value: color
 
-        # YAML config
-        self.init_config(config)
+        # Default config
+        self.config = config
 
+        # Validate the configuration before proceeding
+        self.load_config(self.config)
+
+        # Default splitter size
         self.splitter.setSizes([400, 100])
 
         # Buttons
@@ -107,6 +131,31 @@ class PlotApp(QWidget):
         # Change layout of plots when the number of columns is changed in GUI
         self.spinBox_N_columns.valueChanged.connect(lambda x: self.init_ui(x))
 
+    def load_config(self, config: dict) -> None:
+        """
+        Load and validate the configuration, retrying until a valid configuration is provided or the user cancels.
+        Args:
+            config (dict): Configuration dictionary form .yaml file.
+
+        Returns:
+            None
+        """
+        valid_config = False
+        self.error_handler.set_retry_action(self.load_settings_from_yaml)
+        while not valid_config:
+            if config is None:
+                self.config = (
+                    self.load_settings_from_yaml()
+                )  # Load config if it hasn't been loaded yet
+            try:  # Validate loaded config file
+                self.error_handler.validate_config_file(config)
+                valid_config = True
+            except ValueError as e:
+                self.config = None  # Reset config_to_test to force reloading configuration
+                self.config = self.error_handler.handle_error(str(e))
+        if valid_config is True:  # Initialize config if validation succeeds
+            self.init_config(self.config)
+
     def init_config(self, config: dict) -> None:
         """
         Initializes or update the configuration settings for the PlotApp.
@@ -120,21 +169,20 @@ class PlotApp(QWidget):
         self.plot_data_config = config.get("plot_data", {})
         self.scan_types = self.plot_settings.get("scan_types", False)
 
-        if self.scan_types is False:
+        if self.scan_types is False:  # Device tracking mode
             self.plot_data = self.plot_data_config  # TODO logic has to be improved
-        else:
-            self.plot_data = {}
+        else:  # setup first line scan as default, then changed with different scan type
+            self.plot_data = self.plot_data_config[list(self.plot_data_config.keys())[0]]
 
         # Setting global plot settings
         self.init_plot_background(self.plot_settings["background_color"])
 
         # Initialize the UI
-        if self.scan_types is False:
-            self.init_ui(self.plot_settings["num_columns"])
-            self.spinBox_N_columns.setValue(
-                self.plot_settings["num_columns"]
-            )  # TODO has to be checked if it will not setup more columns than plots
-            self.spinBox_N_columns.setMaximum(len(self.plot_data))
+        self.init_ui(self.plot_settings["num_columns"])
+        self.spinBox_N_columns.setValue(
+            self.plot_settings["num_columns"]
+        )  # TODO has to be checked if it will not setup more columns than plots
+        self.spinBox_N_columns.setMaximum(len(self.plot_data))
 
     def init_plot_background(self, background_color: str) -> None:
         """
@@ -154,7 +202,16 @@ class PlotApp(QWidget):
             pg.setConfigOption("background", "w")
             pg.setConfigOption("foreground", "k")
         else:
-            print(f"Warning: Unknown background color {background_color}. Using default settings.")
+            raise ValueError(
+                f"Invalid background color {background_color}. Allowed values are 'white' or 'black'."
+            )
+
+        # TODO simplify -> find way how to setup also foreground color
+        # if background_color.lower() not in ["black", "white"]:
+        #     raise ValueError(
+        #         f"Invalid background color {background_color}. Allowed values are 'white' or 'black'."
+        #     )
+        # self.glw.setBackground(background_color.lower())
 
     def init_ui(self, num_columns: int = 3) -> None:
         """
@@ -175,12 +232,14 @@ class PlotApp(QWidget):
         num_plots = len(self.plot_data)
 
         # Check if num_columns exceeds the number of plots
-        if num_columns > num_plots:
+        if num_columns >= num_plots:
             num_columns = num_plots
             self.plot_settings["num_columns"] = num_columns  # Update the settings
             print(
-                f"Warning: num_columns in the YAML file was greater than the number of plots. Resetting num_columns to {num_columns}."
+                f"Warning: num_columns in the YAML file was greater than the number of plots. Resetting num_columns to number of plots:{num_columns}."
             )
+        else:
+            self.plot_settings["num_columns"] = num_columns  # Update the settings
 
         num_rows = num_plots // num_columns
         last_row_cols = num_plots % num_columns
@@ -235,7 +294,7 @@ class PlotApp(QWidget):
 
             curve_list = []
             for i, (y_config, color) in enumerate(zip(y_configs, colors_ys)):
-                print(y_config)
+                # print(y_config)
                 y_name = y_config["name"]
                 y_entries = y_config.get("entry", [y_name])
 
@@ -379,7 +438,9 @@ class PlotApp(QWidget):
                 curve.setData(data_x, data_y)
 
     @pyqtSlot(dict, dict)
-    def on_scan_segment(self, msg, metadata) -> None:
+    def on_scan_segment(
+        self, msg, metadata
+    ) -> None:  # TODO the logic should be separated from GUI operation
         """
         Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
 
@@ -397,7 +458,17 @@ class PlotApp(QWidget):
                 self.plot_data = self.plot_data_config
             elif self.scan_types is True:
                 currentName = metadata.get("scan_name")
+                if currentName is None:
+                    raise ValueError(
+                        f"Scan name not found in metadata. Please check the scan_name in the YAML config or in bec "
+                        f"configuration."
+                    )
                 self.plot_data = self.plot_data_config.get(currentName, [])
+                if self.plot_data == []:
+                    raise ValueError(
+                        f"Scan name {currentName} not found in the YAML config. Please check the scan_name in the "
+                        f"YAML config or in bec configuration."
+                    )
 
                 # Init UI
                 self.init_ui(self.plot_settings["num_columns"])
@@ -421,7 +492,9 @@ class PlotApp(QWidget):
 
             x_entry_list = x_signal_config.get("entry", [])
             if not x_entry_list:
-                x_entry_list = dev[x_name]._hints if hasattr(dev[x_name], "_hints") else [x_name]
+                x_entry_list = (
+                    self.dev[x_name]._hints if hasattr(self.dev[x_name], "_hints") else [x_name]
+                )
 
             if not isinstance(x_entry_list, list):
                 x_entry_list = [x_entry_list]
@@ -439,7 +512,9 @@ class PlotApp(QWidget):
                     y_entry_list = y_config.get("entry", [])
                     if not y_entry_list:
                         y_entry_list = (
-                            dev[y_name]._hints if hasattr(dev[y_name], "_hints") else [y_name]
+                            self.dev[y_name]._hints
+                            if hasattr(self.dev[y_name], "_hints")
+                            else [y_name]
                         )
 
                     if not isinstance(y_entry_list, list):
@@ -457,7 +532,7 @@ class PlotApp(QWidget):
                             )
 
                         if data_y is None:
-                            if hasattr(dev[y_name], "_hints"):
+                            if hasattr(self.dev[y_name], "_hints"):
                                 raise ValueError(
                                     f"Incorrect entry '{y_entry}' specified for y in plot: {plot_name}, y name: {y_name}"
                                 )
@@ -496,7 +571,7 @@ class PlotApp(QWidget):
             except Exception as e:
                 print(f"An error occurred while saving the settings to {file_path}: {e}")
 
-    def load_settings_from_yaml(self):
+    def load_settings_from_yaml(self) -> dict:  # TODO can be replace by the utils function
         """Load settings from a .yaml file using a file dialog and update the current settings."""
         options = QFileDialog.Options()
         options |= QFileDialog.DontUseNativeDialog
@@ -507,16 +582,110 @@ class PlotApp(QWidget):
         if file_path:
             try:
                 with open(file_path, "r") as file:
-                    config = yaml.safe_load(file)
-
-                # YAML config
-                self.init_config(config)
-
-                print(f"Settings loaded from {file_path}")
+                    self.config = yaml.safe_load(file)
+                    self.load_config(self.config)  # validate new config
+                return config
             except FileNotFoundError:
                 print(f"The file {file_path} was not found.")
             except Exception as e:
                 print(f"An error occurred while loading the settings from {file_path}: {e}")
+                return None  # Return None on exception to indicate failure
+
+
+class ErrorHandler:
+    def __init__(self, parent=None):
+        self.parent = parent
+        self.errors = []
+        self.retry_action = None
+        logging.basicConfig(level=logging.ERROR)  # Configure logging
+
+    def set_retry_action(self, action):
+        self.retry_action = action  # Store a reference to the retry action
+
+    def handle_error(self, error_message: str):
+        # logging.error(f"{error_message}\n{traceback.format_exc()}") #TODO decide if useful
+
+        choice = QMessageBox.critical(
+            self.parent,
+            "Error",
+            f"{error_message}\n\nWould you like to retry?",
+            QMessageBox.Retry | QMessageBox.Cancel,
+        )
+        if choice == QMessageBox.Retry and self.retry_action is not None:
+            return self.retry_action()
+        else:
+            exit(1)  # Exit the program if the user selects Cancel or if no retry_action is provided
+
+    def validate_config_file(self, config: dict) -> None:
+        """
+        Validate the configuration dictionary.
+        Args:
+            config (dict): Configuration dictionary form .yaml file.
+
+        Returns:
+            None
+        """
+        self.errors = []
+
+        # Validate common keys
+        required_top_level_keys = ["plot_settings", "plot_data"]
+        for key in required_top_level_keys:
+            if key not in config:
+                self.errors.append(f"Missing required key: {key}")
+
+        # Only continue if no errors so far
+        if not self.errors:
+            # Determine the configuration mode (device or scan)
+            plot_settings = config.get("plot_settings", {})
+            scan_types = plot_settings.get("scan_types", False)
+
+            plot_data = config.get("plot_data", [])
+
+            if scan_types:
+                # Validate scan mode configuration
+                for scan_type, plots in plot_data.items():
+                    for i, plot_config in enumerate(plots):
+                        self.validate_plot_config(plot_config, i)
+            else:
+                # Validate device mode configuration
+                for i, plot_config in enumerate(plot_data):
+                    self.validate_plot_config(plot_config, i)
+
+        if self.errors != []:
+            self.handle_error("\n".join(self.errors))
+
+    def validate_plot_config(self, plot_config: dict, i: int):
+        """
+        Validate individual plot configuration.
+        Args:
+            plot_config (dict): Individual plot configuration.
+            i (int): Index of the plot configuration.
+
+        Returns:
+            None
+        """
+        for axis in ["x", "y"]:
+            axis_config = plot_config.get(axis)
+            plot_name = plot_config.get("plot_name", "")
+            if axis_config is None:
+                error_msg = f"Missing '{axis}' configuration in plot {i} - {plot_name}"
+                logging.error(error_msg)  # Log the error
+                self.errors.append(error_msg)
+
+            signals_config = axis_config.get("signals")
+            if signals_config is None:
+                error_msg = (
+                    f"Missing 'signals' configuration for {axis} axis in plot {i} - '{plot_name}'"
+                )
+                logging.error(error_msg)  # Log the error
+                self.errors.append(error_msg)
+            elif not isinstance(signals_config, list) or len(signals_config) == 0:
+                error_msg = (
+                    f"'signals' configuration for {axis} axis in plot {i} must be a non-empty list"
+                )
+                logging.error(error_msg)  # Log the error
+                self.errors.append(error_msg)
+            # TODO add condition for name and entry
 
 
 if __name__ == "__main__":
@@ -524,11 +693,12 @@ if __name__ == "__main__":
     import argparse
 
     # from bec_widgets import ctrl_c
-    from bec_widgets.bec_dispatcher import bec_dispatcher
-
     parser = argparse.ArgumentParser(description="Plotting App")
     parser.add_argument(
-        "--config", "-c", help="Path to the .yaml configuration file", default="config_example.yaml"
+        "--config",
+        "-c",
+        help="Path to the .yaml configuration file",
+        default="config_example.yaml",
     )
     args = parser.parse_args()
 
@@ -544,15 +714,12 @@ if __name__ == "__main__":
         exit(1)
 
     # BECclient global variables
+    bec_dispatcher = BECDispatcher()
     client = bec_dispatcher.client
     client.start()
 
-    dev = client.device_manager.devices
-    scans = client.scans
-    queue = client.queue
-
     app = QApplication([])
-    plotApp = PlotApp(config=config)
+    plotApp = PlotApp(config=config, client=client)
 
     # Connecting signals from bec_dispatcher
     bec_dispatcher.connect_slot(plotApp.on_scan_segment, MessageEndpoints.scan_segment())
@@ -560,4 +727,4 @@ if __name__ == "__main__":
 
     window = plotApp
     window.show()
-    app.exec_()
+    app.exec()

bec_widgets/examples/stream_plot/stream_plot.py

@@ -1,32 +1,26 @@
 import os
 import threading
 import time
-import warnings
-from typing import Any
 
 import numpy as np
 import pyqtgraph
 import pyqtgraph as pg
-from bec_lib.core import BECMessage
-from PyQt5.QtCore import pyqtSlot
-from PyQt5.QtWidgets import QCheckBox, QTableWidgetItem
-from pyqtgraph import mkBrush, mkColor, mkPen
+from bec_lib import messages, MessageEndpoints
+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.bec_dispatcher import bec_dispatcher
-from bec_lib.core.redis_connector import MessageObject, RedisConnector
-
-from qt_utils import Crosshair
-
-client = bec_dispatcher.client
+from bec_widgets.utils import Crosshair, Colors
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 
-class BasicPlot(QtWidgets.QWidget):
+class StreamPlot(QtWidgets.QWidget):
     update_signal = pyqtSignal()
     roi_signal = pyqtSignal(tuple)
 
-    def __init__(self, name="", y_value_list=["gauss_bpm"]) -> None:
+    def __init__(self, name="", y_value_list=["gauss_bpm"], client=None, parent=None) -> None:
         """
         Basic plot widget for displaying scan data.
 
@@ -35,7 +29,10 @@ class BasicPlot(QtWidgets.QWidget):
             y_value_list (list, optional): List of signals to be plotted. Defaults to ["gauss_bpm"].
         """
 
-        super(BasicPlot, self).__init__()
+        # Client and device manager from BEC
+        self.client = BECDispatcher().client if client is None else client
+
+        super(StreamPlot, self).__init__()
         # Set style for pyqtgraph plots
         pg.setConfigOption("background", "w")
         pg.setConfigOption("foreground", "k")
@@ -57,23 +54,23 @@ class BasicPlot(QtWidgets.QWidget):
 
         self.proxy_update = pg.SignalProxy(self.update_signal, rateLimit=25, slot=self.update)
 
-        self.data_retriever = threading.Thread(target=self.on_projection, daemon=True)
+        self._data_retriever_thread_exit_event = threading.Event()
+        self.data_retriever = threading.Thread(
+            target=self.on_projection, args=(self._data_retriever_thread_exit_event,), daemon=True
+        )
         self.data_retriever.start()
 
-        # self.comboBox.currentIndexChanged.connect(lambda : print(f'current comboText: {self.comboBox.currentText()}'))
-        # self.comboBox.currentIndexChanged.connect(lambda: print(f'current comboIndex: {self.comboBox.currentIndex()}'))
-        #
-        # self.doubleSpinBox.valueChanged.connect(lambda : print('Spin Changed'))
-
-        # self.splitterH_main.setSizes([1, 1])
-
         ##########################
         # UI
         ##########################
         self.init_ui()
         self.init_curves()
         self.hook_crosshair()
-        self.pushButton_generate.clicked.connect(self.generate_data)
+
+    def close(self):
+        super().close()
+        self._data_retriever_thread_exit_event.set()
+        self.data_retriever.join()
 
     def init_ui(self):
         """Setup all ui elements"""
@@ -153,9 +150,7 @@ class BasicPlot(QtWidgets.QWidget):
         self.pens = []
         self.brushs = []
 
-        self.color_list = BasicPlot.golden_angle_color(
-            colormap="CET-R2", num=len(self.y_value_list)
-        )
+        self.color_list = Colors.golden_angle_color(colormap="CET-R2", num=len(self.y_value_list))
 
         for ii, y_value in enumerate(self.y_value_list):
             pen = mkPen(color=self.color_list[ii], width=2, style=QtCore.Qt.DashLine)
@@ -209,34 +204,6 @@ class BasicPlot(QtWidgets.QWidget):
         # ROI
         self.roi_selector.sigRegionChangeFinished.connect(self.get_roi_region)
 
-    def generate_data(self):
-        def gauss(x, mu, sigma):
-            return (1 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)
-
-        self.plotter_data_x = np.linspace(0, 10, 1000)
-        self.plotter_data_y = [
-            gauss(self.plotter_data_x, 1, 1),
-            gauss(self.plotter_data_x, 1.5, 3),
-            np.sin(self.plotter_data_x),
-            np.cos(self.plotter_data_x),
-            np.sin(2 * self.plotter_data_x),
-        ]  # List of y-values for multiple curves
-        self.y_value_list = ["Gauss (1,1)", "Gauss (1.5,3)"]  # ["Sine"]#, "Cosine", "Sine2x"]
-
-        # Curves
-        color_list = ["#384c6b", "#e28a2b", "#5E3023", "#e41a1c", "#984e83", "#4daf4a"]
-
-        self.init_curves()
-
-        for ii in range(len(self.y_value_list)):
-            self.curves[ii].setData(self.plotter_data_x, self.plotter_data_y[ii])
-
-        self.data_2D = np.random.random((150, 30))
-        self.img.setImage(self.data_2D)
-
-        if self.roi_selector not in self.plot.items:
-            self.plot.addItem(self.roi_selector)
-
     def get_roi_region(self):
         """For testing purpose now, get roi region and print it to self.label as tuple"""
         region = self.roi_selector.getRegion()
@@ -247,7 +214,7 @@ class BasicPlot(QtWidgets.QWidget):
                 np.where(self.plotter_data_x[0] < 10 ** region[1])[0][-1],
             ]
         }
-        msg = BECMessage.DeviceMessage(signals=return_dict).dumps()
+        msg = messages.DeviceMessage(signals=return_dict).dumps()
         self.producer.set_and_publish("px_stream/gui_event", msg=msg)
         self.roi_signal.emit(region)
 
@@ -298,59 +265,14 @@ class BasicPlot(QtWidgets.QWidget):
         # else:
         #     return
 
-    @staticmethod
-    def golden_ratio(num: int) -> list:
-        """Calculate the golden ratio for a given number of angles.
-
-        Args:
-            num (int): Number of angles
-        """
-        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
-        angles = []
-        for ii in range(num):
-            x = np.cos(ii * phi)
-            y = np.sin(ii * phi)
-            angle = np.arctan2(y, x)
-            angles.append(angle)
-        return angles
-
-    @staticmethod
-    def golden_angle_color(colormap: str, num: int) -> list:
-        """
-        Extract num colors for from the specified colormap following golden angle distribution.
-
-        Args:
-            colormap (str): Name of the colormap
-            num (int): Number of requested colors
-
-        Returns:
-            list: List of colors with length <num>
-
-        Raises:
-            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
-        """
-
-        cmap = pg.colormap.get(colormap)
-        cmap_colors = cmap.color
-        if num > len(cmap_colors):
-            raise ValueError(
-                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
-            )
-        angles = BasicPlot.golden_ratio(len(cmap_colors))
-        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
-        colors = [
-            mkColor(tuple((cmap_colors[int(ii)] * 255).astype(int))) for ii in color_selection[:num]
-        ]
-        return colors
-
-    def on_projection(self):
-        while True:
+    def on_projection(self, exit_event):
+        while not exit_event.is_set():
             if self._current_proj is None:
                 time.sleep(0.1)
                 continue
             endpoint = f"px_stream/projection_{self._current_proj}/data"
-            msgs = client.producer.lrange(topic=endpoint, start=-1, end=-1)
-            data = [BECMessage.DeviceMessage.loads(msg) for msg in msgs]
+            msgs = self.client.producer.lrange(topic=endpoint, start=-1, end=-1)
+            data = [messages.DeviceMessage.loads(msg) for msg in msgs]
             if not data:
                 continue
             with np.errstate(divide="ignore", invalid="ignore"):
@@ -366,18 +288,16 @@ class BasicPlot(QtWidgets.QWidget):
 
     @pyqtSlot(dict, dict)
     def on_dap_update(self, data: dict, metadata: dict):
-        data_test = data
-
-        flipped_data = self.flip_even_rows(data["z"])
+        flipped_data = self.flip_even_rows(data["data"]["z"])
 
         self.img.setImage(flipped_data)
 
-    @pyqtSlot(dict)
-    def new_proj(self, data):
-        proj_nr = data["proj_nr"]
+    @pyqtSlot(dict, dict)
+    def new_proj(self, content: dict, _metadata: dict):
+        proj_nr = content["signals"]["proj_nr"]
         endpoint = f"px_stream/projection_{proj_nr}/metadata"
-        msg_raw = client.producer.get(topic=endpoint)
-        msg = BECMessage.DeviceMessage.loads(msg_raw)
+        msg_raw = self.client.producer.get(topic=endpoint)
+        msg = messages.DeviceMessage.loads(msg_raw)
         self._current_q = msg.content["signals"]["q"]
         self._current_norm = msg.content["signals"]["norm_sum"]
         self._current_metadata = msg.content["signals"]["metadata"]
@@ -389,26 +309,28 @@ class BasicPlot(QtWidgets.QWidget):
 if __name__ == "__main__":
     import argparse
 
-    from bec_widgets import ctrl_c
-    from bec_widgets.bec_dispatcher import bec_dispatcher
+    # from bec_widgets import ctrl_c  # TODO uncomment when ctrl_c is ready to be compatible with qtpy
 
     parser = argparse.ArgumentParser()
     parser.add_argument(
-        "--signals",
-        help="specify recorded signals",
-        nargs="+",
-        default=["gauss_bpm"],
+        "--signals", help="specify recorded signals", nargs="+", default=["gauss_bpm"]
     )
     # default = ["gauss_bpm", "bpm4i", "bpm5i", "bpm6i", "xert"],
-    # dispatcher = bec_dispatcher
     value = parser.parse_args()
     print(f"Plotting signals for: {', '.join(value.signals)}")
+
+    # Client from dispatcher
+    bec_dispatcher = BECDispatcher()
     client = bec_dispatcher.client
+
     app = QtWidgets.QApplication([])
-    ctrl_c.setup(app)
-    plot = BasicPlot(y_value_list=value.signals)
-    bec_dispatcher.connect_proj_id(plot.new_proj)
-    bec_dispatcher.connect_dap_slot(plot.on_dap_update, "px_dap_worker")
+    # ctrl_c.setup(app) # TODO uncomment when ctrl_c is ready to be compatible with qtpy
+    plot = StreamPlot(y_value_list=value.signals, client=client)
+
+    bec_dispatcher.connect_slot(plot.new_proj, "px_stream/proj_nr")
+    bec_dispatcher.connect_slot(
+        plot.on_dap_update, MessageEndpoints.processed_data("px_dap_worker")
+    )
     plot.show()
     # client.callbacks.register("scan_segment", plot, sync=False)
-    app.exec_()
+    app.exec()

bec_widgets/line_plot_legacy.py

@@ -1,360 +0,0 @@
-import os
-import warnings
-from typing import Any
-
-import numpy as np
-import pyqtgraph
-import pyqtgraph as pg
-from PyQt5.QtCore import pyqtSlot
-from PyQt5.QtWidgets import QTableWidgetItem, QCheckBox
-
-from bec_lib import BECClient
-from pyqtgraph import mkBrush, mkColor, mkPen
-from pyqtgraph.Qt import QtCore, QtWidgets, uic
-from pyqtgraph.Qt.QtCore import pyqtSignal
-
-
-class BasicPlot(QtWidgets.QWidget):
-    update_signal = pyqtSignal()
-    roi_signal = pyqtSignal(tuple)
-
-    def __init__(self, name="", y_value_list=["gauss_bpm"]) -> None:
-        """
-        Basic plot widget for displaying scan data.
-
-        Args:
-            name (str, optional): Name of the plot. Defaults to "".
-            y_value_list (list, optional): List of signals to be plotted. Defaults to ["gauss_bpm"].
-        """
-
-        super(BasicPlot, self).__init__()
-        # Set style for pyqtgraph plots
-        pg.setConfigOption("background", "w")
-        pg.setConfigOption("foreground", "k")
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "line_plot.ui"), self)
-
-        # Set splitter distribution of widgets
-        self.splitter.setSizes([5, 2])
-
-        self._idle_time = 100
-        self.title = ""
-        self.label_bottom = ""
-        self.label_left = ""
-
-        self.scan_motors = []
-        self.y_value_list = y_value_list
-        self.previous_y_value_list = None
-        self.plotter_data_x = []
-        self.plotter_data_y = []
-        self.curves = []
-        self.pens = []
-        self.brushs = []
-
-        self.plotter_scan_id = None
-
-        # TODO to be moved to utils function
-        plotstyles = {
-            "symbol": "o",
-            "symbolSize": 10,
-        }
-        color_list = ["#384c6b", "#e28a2b", "#5E3023", "#e41a1c", "#984e83", "#4daf4a"]
-        color_list = BasicPlot.golden_angle_color(colormap="CET-R2", num=len(self.y_value_list))
-
-        # setup plots - GraphicsLayoutWidget
-        # LabelItem
-        self.label = pg.LabelItem(justify="center")
-        self.glw.addItem(self.label)
-        self.label.setText("test label")
-
-        # PlotItem - main window
-        self.glw.nextRow()
-        self.plot = pg.PlotItem()
-        self.glw.addItem(self.plot)
-        self.plot.addLegend()
-
-        # PlotItem - ROI window - disabled for now #TODO add 2D plot for ROI and 1D plot for mouse click
-        # self.glw.nextRow()
-        # self.plot_roi = pg.PlotItem()
-        # self.glw.addItem(self.plot_roi)
-
-        # ROI selector - so far from [-1,1] #TODO update to scale with xrange
-        self.roi_selector = pg.LinearRegionItem([-1, 1])
-
-        for ii, y_value in enumerate(self.y_value_list):
-            pen = mkPen(color=color_list[ii], width=2, style=QtCore.Qt.DashLine)
-            brush = mkBrush(color=color_list[ii])
-            curve = pg.PlotDataItem(
-                **plotstyles, symbolBrush=brush, pen=pen, skipFiniteCheck=True, name=y_value
-            )
-            self.plot.addItem(curve)
-            self.curves.append(curve)
-            self.pens.append(pen)
-            self.brushs.append(brush)
-
-        self.crosshair_v = pg.InfiniteLine(angle=90, movable=False)
-        self.crosshair_h = pg.InfiniteLine(angle=0, movable=False)
-        self.plot.addItem(self.crosshair_v, ignoreBounds=True)
-        self.plot.addItem(self.crosshair_h, ignoreBounds=True)
-
-        # Add textItems
-        self.add_text_items()
-
-        # Manage signals
-        self.proxy = pg.SignalProxy(
-            self.plot.scene().sigMouseMoved, rateLimit=60, slot=self.mouse_moved
-        )
-        self.proxy_update = pg.SignalProxy(self.update_signal, rateLimit=25, slot=self.update)
-        self.roi_selector.sigRegionChangeFinished.connect(self.get_roi_region)
-        self.pushButton_debug.clicked.connect(self.debug)
-
-    def debug(self):
-        """
-        Debug button just for quick testing
-        """
-
-    def get_roi_region(self):
-        """For testing purpose now, get roi region and print it to self.label as tuple"""
-        region = self.roi_selector.getRegion()
-        self.label.setText(f"x = {region[0]:.4f}, y ={region[1]:.4f}")
-        self.roi_signal.emit(region)
-
-    def add_text_items(self):  # TODO probably can be removed
-        """Add text items to the plot"""
-
-        # self.mouse_box_data.setText("Mouse cursor")
-        # TODO Via StyleSheet, one may set the color of the full QLabel
-        # self.mouse_box_data.setStyleSheet(f"QLabel {{color : rgba{self.pens[0].color().getRgb()}}}")
-
-    def mouse_moved(self, event: tuple) -> None:
-        """
-        Update the mouse table with the current mouse position and the corresponding data.
-
-        Args:
-            event (tuple):  Mouse event containing the position of the mouse cursor.
-                            The position is stored in first entry as horizontal, vertical pixel.
-        """
-        pos = event[0]
-        if not self.plot.sceneBoundingRect().contains(pos):
-            return
-        mousePoint = self.plot.vb.mapSceneToView(pos)
-        self.crosshair_v.setPos(mousePoint.x())
-        self.crosshair_h.setPos(mousePoint.y())
-        if not self.plotter_data_x:
-            return
-
-        for ii, y_value in enumerate(self.y_value_list):
-            closest_point = self.closest_x_y_value(
-                mousePoint.x(), self.plotter_data_x, self.plotter_data_y[ii]
-            )
-            # TODO fix text wobble in plot, see plot when it crosses 0
-            x_data = f"{closest_point[0]:.{self.precision}f}"
-            y_data = f"{closest_point[1]:.{self.precision}f}"
-
-            # Write coordinate to QTable
-            self.mouse_table.setItem(ii, 1, QTableWidgetItem(str(y_value)))
-            self.mouse_table.setItem(ii, 2, QTableWidgetItem(str(x_data)))
-            self.mouse_table.setItem(ii, 3, QTableWidgetItem(str(y_data)))
-
-            self.mouse_table.resizeColumnsToContents()
-
-    def closest_x_y_value(self, input_value, list_x, list_y) -> tuple:
-        """
-        Find the closest x and y value to the input value.
-
-        Args:
-            input_value (float): Input value
-            list_x (list): List of x values
-            list_y (list): List of y values
-
-        Returns:
-            tuple: Closest x and y value
-        """
-        arr = np.asarray(list_x)
-        i = (np.abs(arr - input_value)).argmin()
-        return list_x[i], list_y[i]
-
-    def update(self):
-        """Update the plot with the new data."""
-        # check if roi selector is in the plot
-        if self.roi_selector not in self.plot.items:
-            self.plot.addItem(self.roi_selector)
-
-        # check if QTable was initialised and if list of devices was changed
-        if self.y_value_list != self.previous_y_value_list:
-            self.setup_cursor_table()
-            self.previous_y_value_list = self.y_value_list.copy() if self.y_value_list else None
-
-        if len(self.plotter_data_x) <= 1:
-            return
-        self.plot.setLabel("bottom", self.label_bottom)
-        self.plot.setLabel("left", self.label_left)
-        for ii in range(len(self.y_value_list)):
-            self.curves[ii].setData(self.plotter_data_x, self.plotter_data_y[ii])
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, data: dict, metadata: dict) -> None:
-        """Update function that is called during the scan callback. To avoid
-        too many renderings, the GUI is only processing events every <_idle_time> ms.
-
-        Args:
-            data (dict): Dictionary containing a new scan segment
-            metadata (dict): Scan metadata
-
-        """
-        if metadata["scanID"] != self.plotter_scan_id:
-            self.plotter_scan_id = metadata["scanID"]
-            self._reset_plot_data()
-
-        self.title = f"Scan {metadata['scan_number']}"
-
-        self.scan_motors = scan_motors = metadata.get("scan_report_devices")
-        # client = BECClient()
-        remove_y_value_index = [
-            index
-            for index, y_value in enumerate(self.y_value_list)
-            if y_value not in client.device_manager.devices
-        ]
-        if remove_y_value_index:
-            for ii in sorted(remove_y_value_index, reverse=True):
-                # TODO Use bec warning message??? to be discussed with Klaus
-                warnings.warn(
-                    f"Warning: no matching signal for {self.y_value_list[ii]} found in list of devices. Removing from plot."
-                )
-                self.remove_curve_by_name(self.plot, self.y_value_list[ii])
-                self.y_value_list.pop(ii)
-
-        self.precision = client.device_manager.devices[scan_motors[0]]._info["describe"][
-            scan_motors[0]
-        ]["precision"]
-        # TODO after update of bec_lib, this will be new way to access data
-        # self.precision = client.device_manager.devices[scan_motors[0]].precision
-
-        x = data["data"][scan_motors[0]][scan_motors[0]]["value"]
-        self.plotter_data_x.append(x)
-        for ii, y_value in enumerate(self.y_value_list):
-            y = data["data"][y_value][y_value]["value"]
-            self.plotter_data_y[ii].append(y)
-        self.label_bottom = scan_motors[0]
-        self.label_left = f"{', '.join(self.y_value_list)}"
-
-        # print(f'metadata scan N{metadata["scan_number"]}') #TODO put as label on top of plot
-        # print(f'Data point = {data["point_id"]}') #TODO can be used for progress bar
-
-        if len(self.plotter_data_x) <= 1:
-            return
-        self.update_signal.emit()
-
-    def _reset_plot_data(self):
-        """Reset the plot data."""
-        self.plotter_data_x = []
-        self.plotter_data_y = []
-        for ii in range(len(self.y_value_list)):
-            self.curves[ii].setData([], [])
-            self.plotter_data_y.append([])
-
-    def setup_cursor_table(self):
-        """QTable formatting according to N of devices displayed in plot."""
-
-        # Init number of rows in table according to n of devices
-        self.mouse_table.setRowCount(len(self.y_value_list))
-
-        for ii, y_value in enumerate(self.y_value_list):
-            checkbox = QCheckBox()
-            checkbox.setChecked(True)
-            # TODO just for testing, will be replaced by removing/adding curve
-            checkbox.stateChanged.connect(lambda: print("status Changed"))
-            # checkbox.stateChanged.connect(lambda: self.remove_curve_by_name(plot=self.plot, checkbox=checkbox, name=y_value))
-            self.mouse_table.setCellWidget(ii, 0, checkbox)
-            self.mouse_table.setItem(ii, 1, QTableWidgetItem(str(y_value)))
-
-            self.mouse_table.resizeColumnsToContents()
-
-    @staticmethod
-    def remove_curve_by_name(plot: pyqtgraph.PlotItem, name: str) -> None:
-        # def remove_curve_by_name(plot: pyqtgraph.PlotItem, checkbox: QtWidgets.QCheckBox, name: str) -> None:
-        """Removes a curve from the given plot by the specified name.
-
-        Args:
-            plot (pyqtgraph.PlotItem): The plot from which to remove the curve.
-            name (str): The name of the curve to remove.
-        """
-        # if checkbox.isChecked():
-        for item in plot.items:
-            if isinstance(item, pg.PlotDataItem) and getattr(item, "opts", {}).get("name") == name:
-                plot.removeItem(item)
-                return
-
-        # else:
-        #     return
-
-    @staticmethod
-    def golden_ratio(num: int) -> list:
-        """Calculate the golden ratio for a given number of angles.
-
-        Args:
-            num (int): Number of angles
-        """
-        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
-        angles = []
-        for ii in range(num):
-            x = np.cos(ii * phi)
-            y = np.sin(ii * phi)
-            angle = np.arctan2(y, x)
-            angles.append(angle)
-        return angles
-
-    @staticmethod
-    def golden_angle_color(colormap: str, num: int) -> list:
-        """
-        Extract num colors for from the specified colormap following golden angle distribution.
-
-        Args:
-            colormap (str): Name of the colormap
-            num (int): Number of requested colors
-
-        Returns:
-            list: List of colors with length <num>
-
-        Raises:
-            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
-        """
-
-        cmap = pg.colormap.get(colormap)
-        cmap_colors = cmap.color
-        if num > len(cmap_colors):
-            raise ValueError(
-                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
-            )
-        angles = BasicPlot.golden_ratio(len(cmap_colors))
-        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
-        colors = [
-            mkColor(tuple((cmap_colors[int(ii)] * 255).astype(int))) for ii in color_selection[:num]
-        ]
-        return colors
-
-
-if __name__ == "__main__":
-    import argparse
-    from bec_widgets.bec_dispatcher import bec_dispatcher
-
-    from bec_widgets import ctrl_c
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--signals",
-        help="specify recorded signals",
-        nargs="+",
-        default=["gauss_bpm", "bpm4i", "bpm5i", "bpm6i", "xert"],
-    )
-    value = parser.parse_args()
-    print(f"Plotting signals for: {', '.join(value.signals)}")
-    client = bec_dispatcher.client
-    # client.start()
-    app = QtWidgets.QApplication([])
-    ctrl_c.setup(app)
-    plot = BasicPlot(y_value_list=value.signals)
-    bec_dispatcher.connect(plot)
-    plot.show()
-    # client.callbacks.register("scan_segment", plot, sync=False)
-    app.exec_()

bec_widgets/qtdesigner_plugins/scan2d_plot_plugin.py

@@ -1,7 +1,7 @@
-from PyQt5.QtDesigner import QPyDesignerCustomWidgetPlugin
-from PyQt5.QtGui import QIcon
+from qtpy.QtDesigner import QPyDesignerCustomWidgetPlugin
+from qtpy.QtGui import QIcon
 
-from bec_widgets.scan2d_plot import BECScanPlot2D
+from bec_widgets.widgets.scan_plot.scan2d_plot import BECScanPlot2D
 
 
 class BECScanPlot2DPlugin(QPyDesignerCustomWidgetPlugin):

bec_widgets/qtdesigner_plugins/scan_plot_plugin.py

@@ -1,7 +1,7 @@
-from PyQt5.QtDesigner import QPyDesignerCustomWidgetPlugin
-from PyQt5.QtGui import QIcon
+from qtpy.QtDesigner import QPyDesignerCustomWidgetPlugin
+from qtpy.QtGui import QIcon
 
-from bec_widgets.scan_plot import BECScanPlot
+from bec_widgets.widgets.scan_plot.scan_plot import BECScanPlot
 
 
 class BECScanPlotPlugin(QPyDesignerCustomWidgetPlugin):

bec_widgets/readme.md

@@ -1,12 +0,0 @@
-Add/modify the path in the following variable to make the plugin avaiable in Qt Designer:
-```
-$ export PYQTDESIGNERPATH=/<path to repo>/bec_widgets/qtdesigner_plugins
-```
-
-It can be done when activating a conda environment (run with the corresponding env already activated):
-```
-$ conda env config vars set PYQTDESIGNERPATH=/<path to repo>/bec_widgets/qtdesigner_plugins
-```
-
-All the available conda-forge `pyqt >=5.15` packages don't seem to support loading Qt Designer
-python plugins at the time of writing. Use `pyqt =5.12` to solve the issue for now.

bec_widgets/utils/__init__.py

@@ -1,3 +1,4 @@
 from .crosshair import Crosshair
 from .colors import Colors
 from .validator_delegate import DoubleValidationDelegate
+from .bec_table import BECTable

bec_widgets/utils/bec_dispatcher.py

@@ -0,0 +1,156 @@
+# TODO last backup
+
+# todo super last refactor
+
+from __future__ import annotations
+
+import argparse
+import itertools
+import os
+from collections.abc import Callable
+from typing import Union
+
+from bec_lib import BECClient, messages, ServiceConfig
+from bec_lib.redis_connector import RedisConsumerThreaded
+from qtpy.QtCore import QObject, Signal as pyqtSignal
+
+# Adding a new pyqt signal requires a class factory, as they must be part of the class definition
+# and cannot be dynamically added as class attributes after the class has been defined.
+_signal_class_factory = (
+    type(f"Signal{i}", (QObject,), dict(signal=pyqtSignal(dict, dict))) for i in itertools.count()
+)
+
+
+class _Connection:
+    """Utility class to keep track of slots connected to a particular redis consumer"""
+
+    def __init__(self, consumer) -> None:
+        self.consumer: RedisConsumerThreaded = consumer
+        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 consumer"""
+
+    def __init__(self, bec_config=None):
+        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.client.initialize(config=ServiceConfig(config_path=bec_config))
+        self._connections = {}
+
+    def connect_slot(
+        self, slot: Callable, topics: Union[str, list], single_callback_for_all_topics=False
+    ) -> None:
+        """Connect widget's pyqt slot, so that it is called on new pub/sub topic message.
+
+        Args:
+            slot (Callable): A slot method/function that accepts two inputs: content and metadata of
+                the corresponding pub/sub message
+            topics (str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
+            single_callback_for_all_topics (bool): If True, use the same callback for all topics, otherwise use
+                separate callbacks.
+        """
+        if isinstance(topics, str):
+            topics = [topics]
+
+        # Ensure topics_key is a tuple, whether single_callback_for_all_topics is True or False.
+        topics_key = tuple(sorted(topics)) if single_callback_for_all_topics else tuple(topics)
+
+        if topics_key not in self._connections:
+            self._connections[topics_key] = self._create_connection(topics)
+        connection = self._connections[topics_key]
+        if slot not in connection.slots:
+            connection.signal.connect(slot)
+            connection.slots.add(slot)
+
+    def _create_connection(self, topics: list) -> _Connection:
+        """Creates a new connection for given topics."""
+
+        def cb(msg):
+            msg = messages.MessageReader.loads(msg.value)
+            if not isinstance(msg, list):
+                msg = [msg]
+            for msg_i in msg:
+                for connection_key, connection in self._connections.items():
+                    if set(topics).intersection(
+                        connection_key if isinstance(connection_key, tuple) else [connection_key]
+                    ):
+                        connection.signal.emit(msg_i.content, msg_i.metadata)
+
+        consumer = self.client.connector.consumer(topics=topics, cb=cb)
+        consumer.start()
+        return _Connection(consumer)
+
+    def _do_disconnect_slot(self, topic, slot):
+        connection = self._connections[topic]
+        connection.signal.disconnect(slot)
+        connection.slots.remove(slot)
+        if not connection.slots:
+            print(f"{connection.consumer} is shutting down")
+            connection.consumer.shutdown()
+            connection.consumer.join()
+            del self._connections[topic]
+
+    def _disconnect_slot_from_topic(self, slot: Callable, topic: str) -> None:
+        """A helper method to disconnect a slot from a specific topic.
+
+        Args:
+            slot (Callable): A slot to be disconnected
+            topic (str): A corresponding topic that can typically be acquired via
+                bec_lib.MessageEndpoints
+        """
+        connection = self._connections.get(topic)
+        if connection and slot in connection.slots:
+            self._do_disconnect_slot(topic, slot)
+
+    def disconnect_slot(self, slot: Callable, topics: Union[str, list]) -> None:
+        """Disconnect widget's pyqt slot from pub/sub updates on a topic.
+
+        Args:
+            slot (Callable): A slot to be disconnected
+            topics (str | list): A corresponding topic or list of topics that can typically be acquired via
+                bec_lib.MessageEndpoints
+        """
+        if isinstance(topics, str):
+            topics = [topics]
+
+        for key, connection in list(self._connections.items()):
+            if slot in connection.slots:
+                common_topics = set(topics).intersection(key)
+                if common_topics:
+                    remaining_topics = set(key) - set(topics)
+                    # Disconnect slot from common topics
+                    self._do_disconnect_slot(key, slot)
+                    # Reconnect slot to remaining topics if any
+                    if remaining_topics:
+                        self.connect_slot(slot, list(remaining_topics), True)
+
+    def disconnect_all(self):
+        """Disconnect all slots from all topics."""
+        for key, connection in list(self._connections.items()):
+            for slot in list(connection.slots):
+                self._disconnect_slot_from_topic(slot, key)
+
+
+# variable holding the Singleton instance of BECDispatcher
+_bec_dispatcher = None
+
+
+def BECDispatcher():
+    global _bec_dispatcher
+    if _bec_dispatcher is None:
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--bec-config", default=None)
+        args, _ = parser.parse_known_args()
+
+        _bec_dispatcher = _BECDispatcher(args.bec_config)
+    return _bec_dispatcher

bec_widgets/utils/bec_table.py

@@ -0,0 +1,20 @@
+from qtpy.QtWidgets import QTableWidget
+from qtpy.QtCore import Qt
+
+
+class BECTable(QTableWidget):
+    """Table widget with custom keyPressEvent to delete rows with backspace or delete key"""
+
+    def keyPressEvent(self, event) -> None:
+        """
+        Delete selected rows with backspace or delete key
+        Args:
+            event: keyPressEvent
+        """
+        if event.key() in (Qt.Key_Backspace, Qt.Key_Delete):
+            selected_ranges = self.selectedRanges()
+            for selected_range in selected_ranges:
+                for row in range(selected_range.topRow(), selected_range.bottomRow() + 1):
+                    self.removeRow(row)
+        else:
+            super().keyPressEvent(event)

bec_widgets/utils/crosshair.py

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

bec_widgets/utils/ctrl_c.py

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

bec_widgets/utils/validator_delegate.py

@@ -1,5 +1,8 @@
-from PyQt5.QtGui import QDoubleValidator
-from PyQt5.QtWidgets import QStyledItemDelegate, QLineEdit
+# from qtpy.QtGui import QDoubleValidator
+# from qtpy.QtWidgets import QStyledItemDelegate, QLineEdit
+
+from qtpy.QtGui import QDoubleValidator
+from qtpy.QtWidgets import QStyledItemDelegate, QLineEdit
 
 
 class DoubleValidationDelegate(QStyledItemDelegate):

bec_widgets/utils/widget_io.py

@@ -0,0 +1,320 @@
+# pylint: disable=no-name-in-module
+from abc import ABC, abstractmethod
+
+from qtpy.QtWidgets import (
+    QApplication,
+    QWidget,
+    QLineEdit,
+    QComboBox,
+    QTableWidget,
+    QSpinBox,
+    QDoubleSpinBox,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QCheckBox,
+    QLabel,
+)
+
+
+class WidgetHandler(ABC):
+    """Abstract base class for all widget handlers."""
+
+    @abstractmethod
+    def get_value(self, widget: QWidget):
+        """Retrieve value from the widget instance."""
+
+    @abstractmethod
+    def set_value(self, widget: QWidget, value):
+        """Set a value on the widget instance."""
+
+
+class LineEditHandler(WidgetHandler):
+    """Handler for QLineEdit widgets."""
+
+    def get_value(self, widget: QLineEdit) -> str:
+        return widget.text()
+
+    def set_value(self, widget: QLineEdit, value: str) -> None:
+        widget.setText(value)
+
+
+class ComboBoxHandler(WidgetHandler):
+    """Handler for QComboBox widgets."""
+
+    def get_value(self, widget: QComboBox) -> int:
+        return widget.currentIndex()
+
+    def set_value(self, widget: QComboBox, value: int) -> None:
+        widget.setCurrentIndex(value)
+
+
+class TableWidgetHandler(WidgetHandler):
+    """Handler for QTableWidget widgets."""
+
+    def get_value(self, widget: QTableWidget) -> list:
+        return [
+            [
+                widget.item(row, col).text() if widget.item(row, col) else ""
+                for col in range(widget.columnCount())
+            ]
+            for row in range(widget.rowCount())
+        ]
+
+    def set_value(self, widget: QTableWidget, value) -> None:
+        for row, row_values in enumerate(value):
+            for col, cell_value in enumerate(row_values):
+                item = QTableWidgetItem(str(cell_value))
+                widget.setItem(row, col, item)
+
+
+class SpinBoxHandler(WidgetHandler):
+    """Handler for QSpinBox and QDoubleSpinBox widgets."""
+
+    def get_value(self, widget):
+        return widget.value()
+
+    def set_value(self, widget, value):
+        widget.setValue(value)
+
+
+class CheckBoxHandler(WidgetHandler):
+    """Handler for QCheckBox widgets."""
+
+    def get_value(self, widget):
+        return widget.isChecked()
+
+    def set_value(self, widget, value):
+        widget.setChecked(value)
+
+
+class LabelHandler(WidgetHandler):
+    """Handler for QLabel widgets."""
+
+    def get_value(self, widget):
+        return widget.text()
+
+    def set_value(self, widget, value):
+        widget.setText(value)
+
+
+class WidgetIO:
+    """Public interface for getting and setting values using handler mapping"""
+
+    _handlers = {
+        QLineEdit: LineEditHandler,
+        QComboBox: ComboBoxHandler,
+        QTableWidget: TableWidgetHandler,
+        QSpinBox: SpinBoxHandler,
+        QDoubleSpinBox: SpinBoxHandler,
+        QCheckBox: CheckBoxHandler,
+        QLabel: LabelHandler,
+    }
+
+    @staticmethod
+    def get_value(widget, ignore_errors=False):
+        """
+        Retrieve value from the widget instance.
+        Args:
+            widget: Widget instance.
+            ignore_errors(bool, optional): Whether to ignore if no handler is found.
+        """
+        handler_class = WidgetIO._handlers.get(type(widget))
+        if handler_class:
+            return handler_class().get_value(widget)  # Instantiate the handler
+        if not ignore_errors:
+            raise ValueError(f"No handler for widget type: {type(widget)}")
+        return None
+
+    @staticmethod
+    def set_value(widget, value, ignore_errors=False):
+        """
+        Set a value on the widget instance.
+        Args:
+            widget: Widget instance.
+            value: Value to set.
+            ignore_errors(bool, optional): Whether to ignore if no handler is found.
+        """
+        handler_class = WidgetIO._handlers.get(type(widget))
+        if handler_class:
+            handler_class().set_value(widget, value)  # Instantiate the handler
+        elif not ignore_errors:
+            raise ValueError(f"No handler for widget type: {type(widget)}")
+
+
+################## for exporting and importing widget hierarchies ##################
+
+
+class WidgetHierarchy:
+    @staticmethod
+    def print_widget_hierarchy(
+        widget,
+        indent: int = 0,
+        grab_values: bool = False,
+        prefix: str = "",
+        exclude_internal_widgets: bool = True,
+    ) -> None:
+        """
+        Print the widget hierarchy to the console.
+        Args:
+            widget: Widget to print the hierarchy of
+            indent(int, optional): Level of indentation.
+            grab_values(bool,optional): Whether to grab the values of the widgets.
+            prefix(stc,optional): Custom string prefix for indentation.
+            exclude_internal_widgets(bool,optional): Whether to exclude internal widgets (e.g. QComboBox in PyQt6).
+        """
+        widget_info = f"{widget.__class__.__name__} ({widget.objectName()})"
+        if grab_values:
+            value = WidgetIO.get_value(widget, ignore_errors=True)
+            value_str = f" [value: {value}]" if value is not None else ""
+            widget_info += value_str
+
+        print(prefix + widget_info)
+
+        children = widget.children()
+        for child in children:
+            if (
+                exclude_internal_widgets
+                and isinstance(widget, QComboBox)
+                and child.__class__.__name__ in ["QFrame", "QBoxLayout", "QListView"]
+            ):
+                continue
+            child_prefix = prefix + "  "
+            arrow = "├─ " if child != children[-1] else "└─ "
+            WidgetHierarchy.print_widget_hierarchy(
+                child, indent + 1, grab_values, prefix=child_prefix + arrow
+            )
+
+    @staticmethod
+    def export_config_to_dict(
+        widget: QWidget,
+        config: dict = None,
+        indent: int = 0,
+        grab_values: bool = False,
+        print_hierarchy: bool = False,
+        save_all: bool = True,
+        exclude_internal_widgets: bool = True,
+    ) -> dict:
+        """
+        Export the widget hierarchy to a dictionary.
+        Args:
+            widget: Widget to print the hierarchy of.
+            config(dict,optional): Dictionary to export the hierarchy to.
+            indent(int,optional): Level of indentation.
+            grab_values(bool,optional): Whether to grab the values of the widgets.
+            print_hierarchy(bool,optional): Whether to print the hierarchy to the console.
+            save_all(bool,optional): Whether to save all widgets or only those with values.
+            exclude_internal_widgets(bool,optional): Whether to exclude internal widgets (e.g. QComboBox in PyQt6).
+        Returns:
+            config(dict): Dictionary containing the widget hierarchy.
+        """
+        if config is None:
+            config = {}
+        widget_info = f"{widget.__class__.__name__} ({widget.objectName()})"
+
+        # if grab_values and type(widget) in WidgetIO._handlers:
+        if grab_values:
+            value = WidgetIO.get_value(widget, ignore_errors=True)
+            if value is not None or save_all:
+                if widget_info not in config:
+                    config[widget_info] = {}
+                if value is not None:
+                    config[widget_info]["value"] = value
+
+        if print_hierarchy:
+            WidgetHierarchy.print_widget_hierarchy(widget, indent, grab_values)
+
+        for child in widget.children():
+            # Skip internal widgets of QComboBox in PyQt6
+            if (
+                exclude_internal_widgets
+                and isinstance(widget, QComboBox)
+                and child.__class__.__name__ in ["QFrame", "QBoxLayout", "QListView"]
+            ):
+                continue
+            child_config = WidgetHierarchy.export_config_to_dict(
+                child, None, indent + 1, grab_values, print_hierarchy, save_all
+            )
+            if child_config or save_all:
+                if widget_info not in config:
+                    config[widget_info] = {}
+                config[widget_info].update(child_config)
+
+        return config
+
+    @staticmethod
+    def import_config_from_dict(widget, config: dict, set_values: bool = False) -> None:
+        """
+        Import the widget hierarchy from a dictionary.
+        Args:
+            widget: Widget to import the hierarchy to.
+            config:
+            set_values:
+        """
+        widget_name = f"{widget.__class__.__name__} ({widget.objectName()})"
+        widget_config = config.get(widget_name, {})
+        for child in widget.children():
+            child_name = f"{child.__class__.__name__} ({child.objectName()})"
+            child_config = widget_config.get(child_name)
+            if child_config is not None:
+                value = child_config.get("value")
+                if set_values and value is not None:
+                    WidgetIO.set_value(child, value)
+                WidgetHierarchy.import_config_from_dict(child, widget_config, set_values)
+
+
+# Example application to demonstrate the usage of the functions
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication([])
+
+    # Create instance of WidgetHierarchy
+    widget_hierarchy = WidgetHierarchy()
+
+    # Create a simple widget hierarchy for demonstration purposes
+    main_widget = QWidget()
+    layout = QVBoxLayout(main_widget)
+    line_edit = QLineEdit(main_widget)
+    combo_box = QComboBox(main_widget)
+    table_widget = QTableWidget(2, 2, main_widget)
+    spin_box = QSpinBox(main_widget)
+    layout.addWidget(line_edit)
+    layout.addWidget(combo_box)
+    layout.addWidget(table_widget)
+    layout.addWidget(spin_box)
+
+    # Add text items to the combo box
+    combo_box.addItems(["Option 1", "Option 2", "Option 3"])
+
+    main_widget.show()
+
+    # Hierarchy of original widget
+    print(30 * "#")
+    print(f"Widget hierarchy for {main_widget.objectName()}:")
+    print(30 * "#")
+    config_dict = widget_hierarchy.export_config_to_dict(
+        main_widget, grab_values=True, print_hierarchy=True
+    )
+    print(30 * "#")
+    print(f"Config dict: {config_dict}")
+
+    # Hierarchy of new widget and set values
+    new_config_dict = {
+        "QWidget ()": {
+            "QLineEdit ()": {"value": "New Text"},
+            "QComboBox ()": {"value": 1},
+            "QTableWidget ()": {"value": [["a", "b"], ["c", "d"]]},
+            "QSpinBox ()": {"value": 10},
+        }
+    }
+    widget_hierarchy.import_config_from_dict(main_widget, new_config_dict, set_values=True)
+    print(30 * "#")
+    config_dict_new = widget_hierarchy.export_config_to_dict(
+        main_widget, grab_values=True, print_hierarchy=True
+    )
+    config_dict_new_reduced = widget_hierarchy.export_config_to_dict(
+        main_widget, grab_values=True, print_hierarchy=True, save_all=False
+    )
+    print(30 * "#")
+    print(f"Config dict new FULL: {config_dict_new}")
+    print(f"Config dict new REDUCED: {config_dict_new_reduced}")
+
+    app.exec()

bec_widgets/utils/yaml_dialog.py

@@ -0,0 +1,61 @@
+# pylint: disable=no-name-in-module
+
+from typing import Union
+import yaml
+from qtpy.QtWidgets import QFileDialog
+
+
+def load_yaml(instance) -> Union[dict, None]:
+    """
+    Load YAML file from disk.
+    Args:
+        instance: Instance of the calling widget.
+
+    Returns:
+        dict: Configuration data loaded from the YAML file.
+    """
+    options = QFileDialog.Options()
+    file_path, _ = QFileDialog.getOpenFileName(
+        instance, "Load Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
+    )
+
+    if not file_path:
+        return None
+    try:
+        with open(file_path, "r") as file:
+            config = yaml.safe_load(file)
+        return config
+
+    except FileNotFoundError:
+        print(f"The file {file_path} was not found.")
+    except PermissionError:
+        print(f"Permission denied for file {file_path}.")
+    except yaml.YAMLError as e:
+        print(f"Error parsing YAML file {file_path}: {e}")
+    except Exception as e:
+        print(f"An error occurred while loading the settings from {file_path}: {e}")
+
+
+def save_yaml(instance, config: dict) -> None:
+    """
+    Save YAML file to disk.
+    Args:
+        instance: Instance of the calling widget.
+        config: Configuration data to be saved.
+    """
+    options = QFileDialog.Options()
+    file_path, _ = QFileDialog.getSaveFileName(
+        instance, "Save Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
+    )
+
+    if not file_path:
+        return
+    try:
+        if not (file_path.endswith(".yaml") or file_path.endswith(".yml")):
+            file_path += ".yaml"
+
+        with open(file_path, "w") as file:
+            yaml.dump(config, file)
+            print(f"Settings saved to {file_path}")
+    except Exception as e:
+        print(f"An error occurred while saving the settings to {file_path}: {e}")

bec_widgets/validation/__init__.py

@@ -0,0 +1,2 @@
+# from .monitor_config import validate_monitor_config, ValidationError
+from .monitor_config_validator import MonitorConfigValidator

bec_widgets/validation/monitor_config_validator.py

@@ -0,0 +1,257 @@
+from typing import Optional, Union, Literal
+
+from pydantic import BaseModel, Field, field_validator, model_validator, ValidationError
+from pydantic_core import PydanticCustomError
+
+
+class Signal(BaseModel):
+    """
+    Represents a signal in a plot configuration.
+
+    Attributes:
+        name (str): The name of the signal.
+        entry (Optional[str]): The entry point of the signal, optional.
+    """
+
+    name: str
+    entry: Optional[str] = Field(None, validate_default=True)
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_fields(cls, values):
+        """Validate the fields of the model.
+        First validate the 'name' field, then validate the 'entry' field.
+        Args:
+            values (dict): The values to be validated."""
+        devices = MonitorConfigValidator.devices
+
+        # Validate 'name'
+        name = values.get("name")
+
+        # Check if device name provided
+        if name is None:
+            raise PydanticCustomError(
+                "no_device_name", "Device name must be provided", {"wrong_value": name}
+            )
+        # Check if device exists in BEC
+        if name not in devices:
+            raise PydanticCustomError(
+                "no_device_bec",
+                'Device "{wrong_value}" not found in current BEC session',
+                {"wrong_value": name},
+            )
+
+        device = devices[name]  # get the device to check if it has signals
+
+        # Get device description
+        description = device.describe()
+
+        # Validate 'entry'
+        entry = values.get("entry")
+
+        # Set entry based on hints if not provided
+        if entry is None:
+            entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
+        if entry not in description:
+            raise PydanticCustomError(
+                "no_entry_for_device",
+                'Entry "{wrong_value}" not found in device "{device_name}" signals',
+                {"wrong_value": entry, "device_name": name},
+            )
+
+        values["entry"] = entry
+        return values
+
+
+class AxisSignal(BaseModel):
+    """
+    Configuration signal axis for a single plot.
+    Attributes:
+        x (list): Signal for the X axis.
+        y (list): Signals for the Y axis.
+    """
+
+    x: list[Signal] = Field(default_factory=list)
+    y: list[Signal] = Field(default_factory=list)
+
+    @field_validator("x")
+    @classmethod
+    def validate_x_signals(cls, v):
+        """Ensure that there is only one signal for x-axis."""
+        if len(v) != 1:
+            raise PydanticCustomError(
+                "x_axis_multiple_signals",
+                'There must be exactly one signal for x axis. Number of x signals: "{wrong_value}"',
+                {"wrong_value": v},
+            )
+
+        return v
+
+
+class SourceHistoryValidator(BaseModel):
+    """History source validator
+    Attributes:
+        type (str): type of source - history
+        scanID (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
+    signals: AxisSignal
+
+
+class SourceSegmentValidator(BaseModel):
+    """Scan Segment source validator
+    Attributes:
+        type (str): type of source - scan_segment
+        signals (AxisSignal): Signal for the source.
+    """
+
+    type: Literal["scan_segment"]
+    signals: AxisSignal
+
+
+class SourceRedisValidator(BaseModel):
+    """Scan Segment source validator
+    Attributes:
+        type (str): type of source - scan_segment
+        endpoint (str): Endpoint reference in redis.
+        update (str): Update type.
+    """
+
+    type: Literal["redis"]
+    endpoint: str
+    update: str
+    signals: dict
+
+
+class Source(BaseModel):  # TODO decide if it should stay for general Source validation
+    """
+    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.
+        signals (Optional[AxisSignal]): Signal for the source.
+    """
+
+    type: Literal["scan_segment", "history", "redis"]
+    scanID: Optional[str] = None
+    signals: Optional[dict] = None
+
+
+class PlotConfig(BaseModel):
+    """
+    Configuration for a single plot.
+
+    Attributes:
+        plot_name (Optional[str]): Name of the plot.
+        x_label (Optional[str]): The label for the x-axis.
+        y_label (Optional[str]): The label for the y-axis.
+        sources (list): A list of sources to be plotted on this axis.
+    """
+
+    plot_name: Optional[str] = None
+    x_label: Optional[str] = None
+    y_label: Optional[str] = None
+    sources: list = Field(default_factory=list)
+
+    @field_validator("sources")
+    @classmethod
+    def validate_sources(cls, values):
+        """Validate the sources of the plot configuration, based on the type of source."""
+        validated_sources = []
+        for source in values:
+            # Check if source type is supported
+            Source(**source)
+            source_type = source.get("type", None)
+
+            # Validate source based on type
+            if source_type == "scan_segment":
+                validated_sources.append(SourceSegmentValidator(**source))
+            elif source_type == "history":
+                validated_sources.append(SourceHistoryValidator(**source))
+            elif source_type == "redis":
+                validated_sources.append(SourceRedisValidator(**source))
+        return validated_sources
+
+
+class PlotSettings(BaseModel):
+    """
+    Global settings for plotting affecting mostly visuals.
+
+    Attributes:
+        background_color (str): Color of the plot background. Default is black.
+        axis_width (Optional[int]): Width of the plot axes. Default is 2.
+        axis_color (Optional[str]): Color of the plot axes. Default is None.
+        num_columns (int): Number of columns in the plot layout. Default is 1.
+        colormap (str): Colormap to be used. Default is magma.
+        scan_types (bool): Indicates if the configuration is for different scan types. Default is False.
+    """
+
+    background_color: Literal["black", "white"] = "black"
+    axis_width: Optional[int] = 2
+    axis_color: Optional[str] = None
+    num_columns: Optional[int] = 1
+    colormap: Optional[str] = "magma"
+    scan_types: Optional[bool] = False
+
+
+class DeviceMonitorConfig(BaseModel):
+    """
+    Configuration model for the device monitor mode.
+
+    Attributes:
+        plot_settings (PlotSettings): Global settings for plotting.
+        plot_data (list[PlotConfig]): List of plot configurations.
+    """
+
+    plot_settings: PlotSettings
+    plot_data: list[PlotConfig]
+
+
+class ScanModeConfig(BaseModel):
+    """
+    Configuration model for scan mode.
+
+    Attributes:
+        plot_settings (PlotSettings): Global settings for plotting.
+        plot_data (dict[str, list[PlotConfig]]): Dictionary of plot configurations,
+                                                 keyed by scan type.
+    """
+
+    plot_settings: PlotSettings
+    plot_data: dict[str, list[PlotConfig]]
+
+
+class MonitorConfigValidator:
+    """Validates the configuration data for the BECMonitor."""
+
+    devices = None
+
+    def __init__(self, devices):
+        # self.device_manager = device_manager
+        MonitorConfigValidator.devices = devices
+
+    def validate_monitor_config(
+        self, config_data: dict
+    ) -> Union[DeviceMonitorConfig, ScanModeConfig]:
+        """
+        Validates the configuration data based on the provided schema.
+
+        Args:
+            config_data (dict): Configuration data to be validated.
+
+        Returns:
+            Union[DeviceMonitorConfig, ScanModeConfig]: Validated configuration object.
+
+        Raises:
+            ValidationError: If the configuration data does not conform to the schema.
+        """
+        config_type = config_data.get("plot_settings", {}).get("scan_types", False)
+        if config_type:
+            validated_config = ScanModeConfig(**config_data)
+        else:
+            validated_config = DeviceMonitorConfig(**config_data)
+
+        return validated_config

bec_widgets/widgets/__init__.py

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

bec_widgets/widgets/editor/__init__.py

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

bec_widgets/widgets/editor/editor.py

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

bec_widgets/widgets/monitor/__init__.py

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

bec_widgets/widgets/monitor/config_dialog.py

@@ -0,0 +1,534 @@
+import os
+
+from qtpy import uic
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtWidgets import (
+    QApplication,
+    QWidget,
+    QVBoxLayout,
+    QTableWidget,
+    QTabWidget,
+    QTableWidgetItem,
+    QLineEdit,
+)
+
+from bec_widgets.utils.yaml_dialog import load_yaml, save_yaml
+
+current_path = os.path.dirname(__file__)
+Ui_Form, BaseClass = uic.loadUiType(os.path.join(current_path, "config_dialog.ui"))
+Tab_Ui_Form, Tab_BaseClass = uic.loadUiType(os.path.join(current_path, "tab_template.ui"))
+
+# test configs for demonstration purpose
+
+# Configuration for default mode when only devices are monitored
+CONFIG_DEFAULT = {
+    "plot_settings": {
+        "background_color": "black",
+        "num_columns": 1,
+        "colormap": "plasma",
+        "scan_types": False,
+    },
+    "plot_data": [
+        {
+            "plot_name": "BPM4i plots vs samx",
+            "x_label": "Motor Y",
+            "y_label": "bpm4i",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": [{"name": "samx", "entry": "samx"}],
+                        "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                    },
+                }
+            ],
+        },
+        {
+            "plot_name": "Gauss plots vs samx",
+            "x_label": "Motor X",
+            "y_label": "Gauss",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": [{"name": "samx", "entry": "samx"}],
+                        "y": [
+                            {"name": "gauss_bpm"},
+                            {"name": "gauss_adc1"},
+                            {"name": "gauss_adc2"},
+                        ],
+                    },
+                }
+            ],
+        },
+    ],
+}
+
+# Configuration which is dynamically changing depending on the scan type
+CONFIG_SCAN_MODE = {
+    "plot_settings": {
+        "background_color": "white",
+        "num_columns": 3,
+        "colormap": "plasma",
+        "scan_types": True,
+    },
+    "plot_data": {
+        "grid_scan": [
+            {
+                "plot_name": "Grid plot 1",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_bpm"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 2",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_adc1"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 3",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy"}],
+                            "y": [{"name": "gauss_adc2"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 4",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy", "entry": "samy"}],
+                            "y": [{"name": "gauss_adc3"}],
+                        },
+                    }
+                ],
+            },
+        ],
+        "line_scan": [
+            {
+                "plot_name": "BPM plots vs samx",
+                "x_label": "Motor X",
+                "y_label": "Gauss",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "bpm4i"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Gauss plots vs samx",
+                "x_label": "Motor X",
+                "y_label": "Gauss",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
+                        },
+                    }
+                ],
+            },
+        ],
+    },
+}
+
+
+class ConfigDialog(QWidget, Ui_Form):
+    config_updated = pyqtSignal(dict)
+
+    def __init__(self, default_config=None):
+        super(ConfigDialog, self).__init__()
+        self.setupUi(self)
+
+        # Connect the Ok/Apply/Cancel buttons
+        self.pushButton_ok.clicked.connect(self.apply_and_close)
+        self.pushButton_apply.clicked.connect(self.apply_config)
+        self.pushButton_cancel.clicked.connect(self.close)
+
+        # Hook signals top level
+        self.pushButton_new_scan_type.clicked.connect(
+            lambda: self.generate_empty_scan_tab(
+                self.tabWidget_scan_types, self.lineEdit_scan_type.text()
+            )
+        )
+
+        # Load/save yaml file buttons
+        self.pushButton_import.clicked.connect(self.load_config_from_yaml)
+        self.pushButton_export.clicked.connect(self.save_config_to_yaml)
+
+        # Scan Types changed
+        self.comboBox_scanTypes.currentIndexChanged.connect(self._init_default)
+
+        # Make scan tabs closable
+        self.tabWidget_scan_types.tabCloseRequested.connect(self.handle_tab_close_request)
+
+        # Init functions to make a default dialog
+        if default_config is None:
+            self._init_default()
+        else:
+            self.load_config(default_config)
+
+    def _init_default(self):
+        """Init default dialog"""
+
+        if self.comboBox_scanTypes.currentText() == "Disabled":  # Default mode
+            self.add_new_scan_tab(self.tabWidget_scan_types, "Default")
+            self.add_new_plot_tab(self.tabWidget_scan_types.widget(0))
+            self.pushButton_new_scan_type.setEnabled(False)
+            self.lineEdit_scan_type.setEnabled(False)
+        else:  # Scan mode with clear tab
+            self.pushButton_new_scan_type.setEnabled(True)
+            self.lineEdit_scan_type.setEnabled(True)
+            self.tabWidget_scan_types.clear()
+
+    def add_new_scan_tab(
+        self, parent_tab: QTabWidget, scan_name: str, closable: bool = False
+    ) -> QWidget:
+        """
+        Add a new scan tab to the parent tab widget
+
+        Args:
+            parent_tab(QTabWidget): Parent tab widget, where to add scan tab
+            scan_name(str): Scan name
+            closable(bool): If True, the scan tab will be closable
+
+        Returns:
+            scan_tab(QWidget): Scan tab widget
+        """
+        # Check for an existing tab with the same name
+        for index in range(parent_tab.count()):
+            if parent_tab.tabText(index) == scan_name:
+                print(f'Scan name "{scan_name}" already exists.')
+                return None  # or return the existing tab: return parent_tab.widget(index)
+
+        # Create a new scan tab
+        scan_tab = QWidget()
+        scan_tab_layout = QVBoxLayout(scan_tab)
+
+        # Set a tab widget for plots
+        tabWidget_plots = QTabWidget()
+        tabWidget_plots.setObjectName("tabWidget_plots")  # TODO decide if needed to give a name
+        tabWidget_plots.setTabsClosable(True)
+        tabWidget_plots.tabCloseRequested.connect(self.handle_tab_close_request)
+        scan_tab_layout.addWidget(tabWidget_plots)
+
+        # Add scan tab
+        parent_tab.addTab(scan_tab, scan_name)
+
+        # Make tabs closable
+        if closable:
+            parent_tab.setTabsClosable(closable)
+
+        return scan_tab
+
+    def add_new_plot_tab(self, scan_tab: QWidget) -> QWidget:
+        """
+        Add a new plot tab to the scan tab
+
+        Args:
+            scan_tab (QWidget): Scan tab widget
+
+        Returns:
+            plot_tab (QWidget): Plot tab
+        """
+
+        # Create a new plot tab from .ui template
+        plot_tab = QWidget()
+        plot_tab_ui = Tab_Ui_Form()
+        plot_tab_ui.setupUi(plot_tab)
+        plot_tab.ui = plot_tab_ui
+
+        # Add plot to current scan tab
+        tabWidget_plots = scan_tab.findChild(
+            QTabWidget, "tabWidget_plots"
+        )  # TODO decide if putting name is needed
+        plot_name = f"Plot {tabWidget_plots.count() + 1}"
+        tabWidget_plots.addTab(plot_tab, plot_name)
+
+        # Hook signal
+        self.hook_plot_tab_signals(scan_tab=scan_tab, plot_tab=plot_tab.ui)
+
+        return plot_tab
+
+    def hook_plot_tab_signals(self, scan_tab: QTabWidget, plot_tab: Tab_Ui_Form) -> None:
+        """
+        Hook signals of the plot tab
+        Args:
+            scan_tab(QTabWidget): Scan tab widget
+            plot_tab(Tab_Ui_Form): Plot tab widget
+        """
+        plot_tab.pushButton_add_new_plot.clicked.connect(
+            lambda: self.add_new_plot_tab(scan_tab=scan_tab)
+        )
+        plot_tab.pushButton_y_new.clicked.connect(
+            lambda: self.add_new_signal(plot_tab.tableWidget_y_signals)
+        )
+
+    def add_new_signal(self, table: QTableWidget) -> None:
+        """
+        Add a new signal to the table
+
+        Args:
+            table(QTableWidget): Table widget
+        """
+
+        row_position = table.rowCount()
+        table.insertRow(row_position)
+        table.setItem(row_position, 0, QTableWidgetItem(""))
+        table.setItem(row_position, 1, QTableWidgetItem(""))
+
+    def handle_tab_close_request(self, index: int) -> None:
+        """
+        Handle tab close request
+
+        Args:
+            index(int): Index of the tab to be closed
+        """
+
+        parent_tab = self.sender()
+        if parent_tab.count() > 1:  # ensure there is at least one tab
+            parent_tab.removeTab(index)
+
+    def generate_empty_scan_tab(self, parent_tab: QTabWidget, scan_name: str):
+        """
+        Generate an empty scan tab
+
+        Args:
+            parent_tab (QTabWidget): Parent tab widget where to add the scan tab
+            scan_name(str): name of the scan tab
+        """
+
+        scan_tab = self.add_new_scan_tab(parent_tab, scan_name, closable=True)
+        if scan_tab is not None:
+            self.add_new_plot_tab(scan_tab)
+
+    def get_plot_config(self, plot_tab: QWidget) -> dict:
+        """
+        Get plot configuration from the plot tab adn send it as dict
+
+        Args:
+            plot_tab(QWidget): Plot tab widget
+
+        Returns:
+            dict: Plot configuration
+        """
+
+        ui = plot_tab.ui
+        table = ui.tableWidget_y_signals
+
+        x_signals = [
+            {
+                "name": self.safe_text(ui.lineEdit_x_name),
+                "entry": self.safe_text(ui.lineEdit_x_entry),
+            }
+        ]
+
+        y_signals = [
+            {
+                "name": self.safe_text(table.item(row, 0)),
+                "entry": self.safe_text(table.item(row, 1)),
+            }
+            for row in range(table.rowCount())
+        ]
+
+        plot_data = {
+            "plot_name": self.safe_text(ui.lineEdit_plot_title),
+            "x_label": self.safe_text(ui.lineEdit_x_label),
+            "y_label": self.safe_text(ui.lineEdit_y_label),
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": x_signals,
+                        "y": y_signals,
+                    },
+                }
+            ],
+        }
+
+        return plot_data
+
+    def apply_config(self) -> dict:
+        """
+        Apply configuration from the whole configuration window
+
+        Returns:
+            dict: Current configuration
+
+        """
+
+        # General settings
+        config = {
+            "plot_settings": {
+                "background_color": self.comboBox_appearance.currentText(),
+                "num_columns": self.spinBox_n_column.value(),
+                "colormap": self.comboBox_colormap.currentText(),
+                "scan_types": True if self.comboBox_scanTypes.currentText() == "Enabled" else False,
+            },
+            "plot_data": {} if self.comboBox_scanTypes.currentText() == "Enabled" else [],
+        }
+
+        # Iterate through the plot tabs - Device monitor mode
+        if config["plot_settings"]["scan_types"] == False:
+            plot_tab = self.tabWidget_scan_types.widget(0).findChild(QTabWidget)
+            for index in range(plot_tab.count()):
+                plot_data = self.get_plot_config(plot_tab.widget(index))
+                config["plot_data"].append(plot_data)
+
+        # Iterate through the scan tabs - Scan mode
+        elif config["plot_settings"]["scan_types"] == True:
+            # Iterate through the scan tabs
+            for index in range(self.tabWidget_scan_types.count()):
+                scan_tab = self.tabWidget_scan_types.widget(index)
+                scan_name = self.tabWidget_scan_types.tabText(index)
+                plot_tab = scan_tab.findChild(QTabWidget)
+                config["plot_data"][scan_name] = []
+                # Iterate through the plot tabs
+                for index in range(plot_tab.count()):
+                    plot_data = self.get_plot_config(plot_tab.widget(index))
+                    config["plot_data"][scan_name].append(plot_data)
+
+        return config
+
+    def load_config(self, config: dict) -> None:
+        """
+        Load configuration to the configuration window
+
+        Args:
+            config(dict): Configuration to be loaded
+        """
+
+        # Plot setting General box
+        plot_settings = config.get("plot_settings", {})
+
+        self.comboBox_appearance.setCurrentText(plot_settings.get("background_color", "black"))
+        self.spinBox_n_column.setValue(plot_settings.get("num_columns", 1))
+        self.comboBox_colormap.setCurrentText(
+            plot_settings.get("colormap", "magma")
+        )  # TODO make logic to allow also different colormaps -> validation of incoming dict
+        self.comboBox_scanTypes.setCurrentText(
+            "Enabled" if plot_settings.get("scan_types", False) else "Disabled"
+        )
+
+        # Clear exiting scan tabs
+        self.tabWidget_scan_types.clear()
+
+        # Get what mode is active - scan vs default device monitor
+        scan_mode = plot_settings.get("scan_types", False)
+
+        if scan_mode is False:  # default mode:
+            plot_data = config.get("plot_data", [])
+            self.add_new_scan_tab(self.tabWidget_scan_types, "Default")
+            for plot_config in plot_data:  # Create plot tab for each plot and populate GUI
+                plot = self.add_new_plot_tab(self.tabWidget_scan_types.widget(0))
+                self.load_plot_setting(plot, plot_config)
+        elif scan_mode is True:  # scan mode
+            plot_data = config.get("plot_data", {})
+            for scan_name, scan_config in plot_data.items():
+                scan_tab = self.add_new_scan_tab(self.tabWidget_scan_types, scan_name)
+                for plot_config in scan_config:
+                    plot = self.add_new_plot_tab(scan_tab)
+                    self.load_plot_setting(plot, plot_config)
+
+    def load_plot_setting(self, plot: QWidget, plot_config: dict) -> None:
+        """
+        Load plot setting from config
+
+        Args:
+            plot (QWidget): plot tab widget
+            plot_config (dict): config for single plot tab
+        """
+        sources = plot_config.get("sources", [{}])[0]
+        x_signals = sources.get("signals", {}).get("x", [{}])[0]
+        y_signals = sources.get("signals", {}).get("y", [])
+
+        # LabelBox
+        plot.ui.lineEdit_plot_title.setText(plot_config.get("plot_name", ""))
+        plot.ui.lineEdit_x_label.setText(plot_config.get("x_label", ""))
+        plot.ui.lineEdit_y_label.setText(plot_config.get("y_label", ""))
+
+        # X axis
+        plot.ui.lineEdit_x_name.setText(x_signals.get("name", ""))
+        plot.ui.lineEdit_x_entry.setText(x_signals.get("entry", ""))
+
+        # Y axis
+        for y_signal in y_signals:
+            row_position = plot.ui.tableWidget_y_signals.rowCount()
+            plot.ui.tableWidget_y_signals.insertRow(row_position)
+            plot.ui.tableWidget_y_signals.setItem(
+                row_position, 0, QTableWidgetItem(y_signal.get("name", ""))
+            )
+            plot.ui.tableWidget_y_signals.setItem(
+                row_position, 1, QTableWidgetItem(y_signal.get("entry", ""))
+            )
+
+    def load_config_from_yaml(self):
+        """
+        Load configuration from yaml file
+        """
+        config = load_yaml(self)
+        self.load_config(config)
+
+    def save_config_to_yaml(self):
+        """
+        Save configuration to yaml file
+        """
+        config = self.apply_config()
+        save_yaml(self, config)
+
+    @staticmethod
+    def safe_text(line_edit: QLineEdit) -> str:
+        """
+        Get text from a line edit, if it is None, return empty string
+        Args:
+            line_edit(QLineEdit): Line edit widget
+
+        Returns:
+            str: Text from the line edit
+        """
+        return "" if line_edit is None else line_edit.text()
+
+    def apply_and_close(self):
+        new_config = self.apply_config()
+        self.config_updated.emit(new_config)
+        self.close()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication([])
+    main_app = ConfigDialog()
+    main_app.show()
+    main_app.load_config(CONFIG_SCAN_MODE)
+    app.exec()

bec_widgets/widgets/monitor/config_dialog.ui

@@ -0,0 +1,210 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>597</width>
+    <height>769</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Plot Configuration</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QGroupBox" name="groupBox_plot_setting">
+       <property name="title">
+        <string>Plot Layout Settings</string>
+       </property>
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <item>
+         <layout class="QGridLayout" name="gridLayout">
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_5">
+            <property name="text">
+             <string>Number of Columns</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_6">
+            <property name="text">
+             <string>Scan Types</string>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="0">
+           <widget class="QPushButton" name="pushButton_new_scan_type">
+            <property name="text">
+             <string>New Scan Type</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1">
+           <widget class="QComboBox" name="comboBox_scanTypes">
+            <item>
+             <property name="text">
+              <string>Disabled</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Enabled</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item row="0" column="1">
+           <widget class="QSpinBox" name="spinBox_n_column">
+            <property name="minimum">
+             <number>1</number>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="1">
+           <widget class="QLineEdit" name="lineEdit_scan_type"/>
+          </item>
+         </layout>
+        </item>
+        <item>
+         <widget class="Line" name="line">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <layout class="QVBoxLayout" name="verticalLayout_3">
+          <item>
+           <widget class="QLabel" name="label_4">
+            <property name="text">
+             <string>Appearance</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QComboBox" name="comboBox_appearance">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <item>
+             <property name="text">
+              <string>black</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>white</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="label_3">
+            <property name="text">
+             <string>Default Color Palette</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QComboBox" name="comboBox_colormap">
+            <item>
+             <property name="text">
+              <string>magma</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>plasma</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>viridis</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>reds</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="groupBox_config">
+       <property name="title">
+        <string>Configuration</string>
+       </property>
+       <layout class="QVBoxLayout" name="verticalLayout">
+        <item>
+         <widget class="QPushButton" name="pushButton_import">
+          <property name="text">
+           <string>Import</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="pushButton_export">
+          <property name="text">
+           <string>Export</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QTabWidget" name="tabWidget_scan_types">
+     <property name="tabPosition">
+      <enum>QTabWidget::West</enum>
+     </property>
+     <property name="tabShape">
+      <enum>QTabWidget::Rounded</enum>
+     </property>
+     <property name="currentIndex">
+      <number>-1</number>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="confirm_layout">
+     <item>
+      <widget class="QPushButton" name="pushButton_cancel">
+       <property name="text">
+        <string>Cancel</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_apply">
+       <property name="text">
+        <string>Apply</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_ok">
+       <property name="text">
+        <string>OK</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/monitor/example_configs/config_device.yaml

@@ -0,0 +1,60 @@
+plot_settings:
+  background_color: "black"
+  num_columns: 2
+  colormap: "viridis"
+  scan_types: False
+
+plot_data:
+  - plot_name: "BPM4i plots vs samy"
+    x:
+      label: 'Motor Y'
+      signals:
+        - name: "samy"
+          entry: "samy"
+    y:
+      label: 'bpm4i'
+      signals:
+        - name: "bpm4i"
+          entry: "bpm4i"
+
+  - plot_name: "BPM4i plots vs samx"
+    x:
+      label: 'Motor X'
+      signals:
+        - name: "samx"
+          entry: "samx"
+    y:
+      label: 'bpm6b'
+      signals:
+        - name: "bpm6b"
+          entry: "bpm6b"
+        - name: "samy"
+          entry: "samy"
+
+  - plot_name: "Multiple Gaussian"
+    x:
+      label: 'Motor X'
+      signals:
+        - name: "samx"
+          entry: "samx"
+    y:
+      label: 'Gauss ADC'
+      signals:
+        - name: "gauss_adc1"
+          entry: "gauss_adc1"
+        - name: "gauss_adc2"
+          entry: "gauss_adc2"
+        - name: "gauss_adc3"
+          entry: "gauss_adc3"
+
+  - plot_name: "Linear Signals"
+    x:
+      label: 'Motor X'
+      signals:
+        - name: "samy"
+          entry: "samy"
+    y:
+      label: 'Motor Y'
+      signals:
+        - name: "samy"
+          entry: "samy"

bec_widgets/widgets/monitor/example_configs/config_scans.yaml

@@ -0,0 +1,92 @@
+plot_settings:
+  background_color: "black"
+  num_columns: 2
+  colormap: "plasma"
+  scan_types: True
+
+plot_data:
+  line_scan:
+
+    - plot_name: "BPM plot"
+      x:
+        label: 'Motor X'
+        signals:
+          - name: "samx"
+            entry: "samx"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+          - name: "gauss_adc1"
+            entry: "gauss_adc1"
+          - name: "gauss_adc2"
+            entry: "gauss_adc2"
+
+    - plot_name: "Multi"
+      x:
+        label: 'Motor X'
+        signals:
+          - name: "samx"
+            entry: "samx"
+      y:
+        label: 'Multi'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+          - name: "samx"
+            entry: "samx"
+
+  grid_scan:
+    - plot_name: "Grid plot 1"
+      x:
+        label: 'Motor X'
+        signals:
+          - name: "samx"
+            entry: "samx"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+          - name: "gauss_adc1"
+            entry: "gauss_adc1"
+
+    - plot_name: "Grid plot 2"
+      x:
+        label: 'Motor X'
+        signals:
+          - name: "samx"
+            entry: "samx"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+          - name: "gauss_adc1"
+            entry: "gauss_adc1"
+
+    - plot_name: "Grid plot 3"
+      x:
+        label: 'Motor Y'
+        signals:
+          - name: "samy"
+            entry: "samy"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+
+    - plot_name: "Grid plot 4"
+      x:
+        label: 'Motor Y'
+        signals:
+          - name: "samy"
+            entry: "samy"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_adc3"
+            entry: "gauss_adc3"
+

bec_widgets/widgets/monitor/monitor.py

@@ -0,0 +1,843 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+import time
+
+import pyqtgraph as pg
+from bec_lib import MessageEndpoints
+from pydantic import ValidationError
+from pyqtgraph import mkBrush, mkPen
+from qtpy import QtCore
+from qtpy.QtCore import Signal as pyqtSignal
+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
+
+# just for demonstration purposes if script run directly
+CONFIG_SCAN_MODE = {
+    "plot_settings": {
+        "background_color": "white",
+        "num_columns": 3,
+        "colormap": "plasma",
+        "scan_types": True,
+    },
+    "plot_data": {
+        "grid_scan": [
+            {
+                "plot_name": "Grid plot 1",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_bpm"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 2",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_adc1"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 3",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy"}],
+                            "y": [{"name": "gauss_adc2"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 4",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy", "entry": "samy"}],
+                            "y": [{"name": "gauss_adc3"}],
+                        },
+                    }
+                ],
+            },
+        ],
+        "line_scan": [
+            {
+                "plot_name": "BPM plots vs samx",
+                "x_label": "Motor X",
+                "y_label": "Gauss",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "bpm4i"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Gauss plots vs samx",
+                "x_label": "Motor X",
+                "y_label": "Gauss",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
+                        },
+                    }
+                ],
+            },
+        ],
+    },
+}
+
+
+CONFIG_WRONG = {
+    "plot_settings": {
+        "background_color": "black",
+        "num_columns": 2,
+        "colormap": "plasma",
+        "scan_types": False,
+    },
+    "plot_data": [
+        {
+            "plot_name": "BPM4i plots vs samx",
+            "x_label": "Motor Y",
+            "y_label": "bpm4i",
+            "sources": [
+                {
+                    "type": "non_existing_source",
+                    "signals": {
+                        "x": [{"name": "samy"}],
+                        "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                    },
+                },
+                {
+                    "type": "history",
+                    "scanID": "<scanID>",
+                    "signals": {
+                        "x": [{"name": "samy"}],
+                        "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                    },
+                },
+            ],
+        },
+        {
+            "plot_name": "Gauss plots vs samx",
+            "x_label": "Motor X",
+            "y_label": "Gauss",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": [{"name": "samx", "entry": "non_sense_entry"}],
+                        "y": [
+                            {"name": "non_existing_name"},
+                            {"name": "samy", "entry": "non_existing_entry"},
+                        ],
+                    },
+                }
+            ],
+        },
+        {
+            "plot_name": "Gauss plots vs samx",
+            "x_label": "Motor X",
+            "y_label": "Gauss",
+            "sources": [
+                {
+                    "signals": {
+                        "x": [{"name": "samx", "entry": "samx"}],
+                        "y": [
+                            {"name": "samx"},
+                            {"name": "samy", "entry": "samx"},
+                        ],
+                    },
+                }
+            ],
+        },
+    ],
+}
+
+
+CONFIG_SIMPLE = {
+    "plot_settings": {
+        "background_color": "black",
+        "num_columns": 2,
+        "colormap": "plasma",
+        "scan_types": False,
+    },
+    "plot_data": [
+        {
+            "plot_name": "BPM4i plots vs samx",
+            "x_label": "Motor X",
+            "y_label": "bpm4i",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": [{"name": "samx"}],
+                        "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                    },
+                },
+                # {
+                #     "type": "history",
+                #     "signals": {
+                #         "x": [{"name": "samx"}],
+                #         "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                #     },
+                # },
+                # {
+                #     "type": "dap",
+                #     'worker':'some_worker',
+                #     "signals": {
+                #         "x": [{"name": "samx"}],
+                #         "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                #     },
+                # },
+            ],
+        },
+        {
+            "plot_name": "Gauss plots vs samx",
+            "x_label": "Motor X",
+            "y_label": "Gauss",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": [{"name": "samx", "entry": "samx"}],
+                        "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
+                    },
+                }
+            ],
+        },
+    ],
+}
+
+CONFIG_REDIS = {
+    "plot_settings": {
+        "background_color": "white",
+        "axis_width": 2,
+        "num_columns": 5,
+        "colormap": "plasma",
+        "scan_types": False,
+    },
+    "plot_data": [
+        {
+            "plot_name": "BPM4i plots vs samx",
+            "x_label": "Motor Y",
+            "y_label": "bpm4i",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {"x": [{"name": "samx"}], "y": [{"name": "gauss_bpm"}]},
+                },
+                {
+                    "type": "redis",
+                    "endpoint": "public/gui/data/6cd5ea3f-a9a9-4736-b4ed-74ab9edfb996",
+                    "update": "append",
+                    "signals": {"x": [{"name": "x_default_tag"}], "y": [{"name": "y_default_tag"}]},
+                },
+            ],
+        }
+    ],
+}
+
+
+class BECMonitor(pg.GraphicsLayoutWidget):
+    update_signal = pyqtSignal()
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        config: dict = None,
+        enable_crosshair: bool = True,
+        gui_id=None,
+        skip_validation: bool = False,
+    ):
+        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 = MonitorConfigValidator(self.dev)
+        self.gui_id = gui_id
+
+        if self.gui_id is None:
+            self.gui_id = self.__class__.__name__ + str(time.time())
+
+        # Connect slots dispatcher
+        bec_dispatcher.connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+        bec_dispatcher.connect_slot(self.on_config_update, MessageEndpoints.gui_config(self.gui_id))
+        bec_dispatcher.connect_slot(
+            self.on_instruction, MessageEndpoints.gui_instructions(self.gui_id)
+        )
+        bec_dispatcher.connect_slot(self.on_data_from_redis, MessageEndpoints.gui_data(self.gui_id))
+
+        # 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
+
+        # TODO make colors accessible to users
+        self.user_colors = {}  # key: (plot_name, y_name, y_entry), value: color
+
+        # Connect the update signal to the update plot method
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self.update_scan_segment_plot
+        )
+
+        # Init UI
+        if self.config is None:
+            print("No initial config found for BECDeviceMonitor")
+        else:
+            self.on_config_update(self.config)
+
+    def _init_config(self):
+        """
+        Initializes or update the configuration settings for the PlotApp.
+        """
+
+        # Separate configs
+        self.plot_settings = self.config.get("plot_settings", {})
+        self.plot_data_config = self.config.get("plot_data", {})
+        self.scan_types = self.plot_settings.get("scan_types", False)
+
+        if self.scan_types is False:  # Device tracking mode
+            self.plot_data = self.plot_data_config  # TODO logic has to be improved
+        else:  # without incoming data setup the first configuration to the first scan type sorted alphabetically by name
+            self.plot_data = self.plot_data_config[min(list(self.plot_data_config.keys()))]
+
+        # Initialize the database
+        self.database = self._init_database(self.plot_data)
+
+        # Initialize the UI
+        self._init_ui(self.plot_settings["num_columns"])
+
+    def _init_database(self, plot_data_config: dict, source_type_to_init=None) -> dict:
+        """
+        Initializes or updates the database for the PlotApp.
+        Args:
+            plot_data_config(dict): Configuration settings for plots.
+            source_type_to_init(str, optional): Specific source type to initialize. If None, initialize all.
+        Returns:
+            dict: Updated or new database dictionary.
+        """
+        database = {} if source_type_to_init is None else self.database.copy()
+
+        for plot in plot_data_config:
+            for source in plot["sources"]:
+                source_type = source["type"]
+                if source_type_to_init and source_type != source_type_to_init:
+                    continue  # Skip if not the specified source type
+
+                if source_type not in database:
+                    database[source_type] = {}
+
+                for axis, signals in source["signals"].items():
+                    for signal in signals:
+                        name = signal["name"]
+                        entry = signal.get("entry", name)
+                        if name not in database[source_type]:
+                            database[source_type][name] = {}
+                        if entry not in database[source_type][name]:
+                            database[source_type][name][entry] = []
+
+        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.clear()
+        self.plots = {}
+        self.grid_coordinates = []
+
+        num_plots = len(self.plot_data)
+
+        # Check if num_columns exceeds the number of plots
+        if num_columns >= num_plots:
+            num_columns = num_plots
+            self.plot_settings["num_columns"] = num_columns  # Update the settings
+            print(
+                "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.addPlot(row=row, col=col, colspan=colspan, title=plot_name)
+            plot.setLabel("bottom", x_label)
+            plot.setLabel("left", y_label)
+            plot.addLegend()
+            self._set_plot_colors(plot, self.plot_settings)
+
+            self.plots[plot_name] = plot
+            self.grid_coordinates.append((row, col))
+
+        # Initialize curves
+        self.init_curves()
+
+    def _set_plot_colors(self, plot: pg.PlotItem, plot_settings: dict) -> None:
+        """
+        Set the plot colors based on the plot config.
+
+        Args:
+            plot (pg.PlotItem): Plot object to set the colors.
+            plot_settings (dict): Plot settings dictionary.
+        """
+        if plot_settings.get("show_grid", False):
+            plot.showGrid(x=True, y=True, alpha=0.5)
+        pen_width = plot_settings.get("axis_width")
+        color = plot_settings.get("axis_color")
+        if color is None:
+            if plot_settings["background_color"].lower() == "black":
+                color = "w"
+                self.setBackground("k")
+            elif plot_settings["background_color"].lower() == "white":
+                color = "k"
+                self.setBackground("w")
+            else:
+                raise ValueError(
+                    f"Invalid background color {plot_settings['background_color']}. Allowed values"
+                    " are 'white' or 'black'."
+                )
+        pen = pg.mkPen(color=color, width=pen_width)
+        x_axis = plot.getAxis("bottom")  # 'bottom' corresponds to the x-axis
+        x_axis.setPen(pen)
+        x_axis.setTextPen(pen)
+        x_axis.setTickPen(pen)
+
+        y_axis = plot.getAxis("left")  # 'left' corresponds to the y-axis
+        y_axis.setPen(pen)
+        y_axis.setTextPen(pen)
+        y_axis.setTickPen(pen)
+
+    def init_curves(self) -> None:
+        """
+        Initialize curve data and properties for each plot and data source.
+        """
+        self.curves_data = {}
+
+        for idx, plot_config in enumerate(self.plot_data):
+            plot_name = plot_config.get("plot_name", "")
+            plot = self.plots[plot_name]
+            plot.clear()
+
+            for source in plot_config["sources"]:
+                source_type = source["type"]
+                y_signals = source["signals"].get("y", [])
+                colors_ys = Colors.golden_angle_color(
+                    colormap=self.plot_settings["colormap"], num=len(y_signals)
+                )
+
+                if source_type not in self.curves_data:
+                    self.curves_data[source_type] = {}
+                if plot_name not in self.curves_data[source_type]:
+                    self.curves_data[source_type][plot_name] = []
+
+                for i, (y_signal, color) in enumerate(zip(y_signals, colors_ys)):
+                    y_name = y_signal["name"]
+                    y_entry = y_signal.get("entry", y_name)
+                    curve_name = f"{y_name} ({y_entry})-{source_type[0].upper()}"
+                    curve_data = self.create_curve(curve_name, color)
+                    plot.addItem(curve_data)
+                    self.curves_data[source_type][plot_name].append((y_name, y_entry, curve_data))
+
+        # Render static plot elements
+        self.update_plot()
+        # # Hook Crosshair #TODO enable later, currently not working
+        if self.enable_crosshair is True:
+            self.hook_crosshair()
+
+    def create_curve(self, curve_name: str, color: str) -> pg.PlotDataItem:
+        """
+        Create
+        Args:
+            curve_name: Name of the curve
+            color(str): Color of the curve
+
+        Returns:
+            pg.PlotDataItem: Assigned curve object
+        """
+        user_color = self.user_colors.get(curve_name, None)
+        color_to_use = user_color if user_color else color
+        pen_curve = mkPen(color=color_to_use, width=2, style=QtCore.Qt.DashLine)
+        brush_curve = mkBrush(color=color_to_use)
+
+        return pg.PlotDataItem(
+            symbolSize=5,
+            symbolBrush=brush_curve,
+            pen=pen_curve,
+            skipFiniteCheck=True,
+            name=curve_name,
+        )
+
+    def hook_crosshair(self) -> None:
+        """Hook the crosshair to all plots."""
+        # TODO can be extended to hook crosshair signal for mouse move/clicked
+        self.crosshairs = {}
+        for plot_name, plot in self.plots.items():
+            crosshair = Crosshair(plot, precision=3)
+            self.crosshairs[plot_name] = crosshair
+
+    def update_scan_segment_plot(self):
+        """
+        Update the plot with the latest scan segment data.
+        """
+        self.update_plot(source_type="scan_segment")
+
+    def update_plot(self, source_type=None) -> None:
+        """
+        Update the plot data based on the stored data dictionary.
+        Only updates data for the specified source_type if provided.
+        """
+        for src_type, plots in self.curves_data.items():
+            if source_type and src_type != source_type:
+                continue
+
+            for plot_name, curve_list in plots.items():
+                plot_config = next(
+                    (pc for pc in self.plot_data if pc.get("plot_name") == plot_name), None
+                )
+                if not plot_config:
+                    continue
+
+                x_name, x_entry = self.extract_x_config(plot_config, src_type)
+
+                for y_name, y_entry, curve in curve_list:
+                    data_x = self.database.get(src_type, {}).get(x_name, {}).get(x_entry, [])
+                    data_y = self.database.get(src_type, {}).get(y_name, {}).get(y_entry, [])
+                    curve.setData(data_x, data_y)
+
+    def extract_x_config(self, plot_config: dict, source_type: str) -> tuple:
+        """Extract the signal configurations for x and y axes from plot_config.
+        Args:
+            plot_config (dict): Plot configuration.
+        Returns:
+            tuple: Tuple containing the x name and x entry.
+        """
+        x_name, x_entry = None, None
+
+        for source in plot_config["sources"]:
+            if source["type"] == source_type and "x" in source["signals"]:
+                x_signal = source["signals"]["x"][0]
+                x_name = x_signal.get("name")
+                x_entry = x_signal.get("entry", x_name)
+                return x_name, x_entry
+
+    def get_config(self):
+        """Return the current configuration settings."""
+        return self.config
+
+    def show_config_dialog(self):
+        """Show the configuration dialog."""
+        from bec_widgets.widgets import ConfigDialog
+
+        dialog = ConfigDialog(default_config=self.config)
+        dialog.config_updated.connect(self.on_config_update)
+        dialog.show()
+
+    def update_client(self, client) -> None:
+        """Update the client and device manager from BEC.
+        Args:
+            client: BEC client
+        """
+        self.client = client
+        self.dev = self.client.device_manager.devices
+
+    def _close_all_plots(self):
+        """Close all plots."""
+        for plot in self.plots.values():
+            plot.clear()
+
+    @pyqtSlot(dict)
+    def on_instruction(self, msg_content: dict) -> None:
+        """
+        Handle instructions sent to the GUI.
+        Possible actions are:
+            - clear: Clear the plots
+            - close: Close the GUI
+            - config_dialog: Open the configuration dialog
+
+        Args:
+            msg_content (dict): Message content with the instruction and parameters.
+        """
+        action = msg_content.get("action", None)
+        parameters = msg_content.get("parameters", None)
+
+        if action == "clear":
+            self.flush()
+            self._close_all_plots()
+        elif action == "close":
+            self.close()
+        elif action == "config_dialog":
+            self.show_config_dialog()
+        else:
+            print(f"Unknown instruction received: {msg_content}")
+
+    @pyqtSlot(dict)
+    def on_config_update(self, config: dict) -> None:
+        """
+        Validate and update the configuration settings for the PlotApp.
+        Args:
+            config(dict): Configuration settings
+        """
+        # 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:
+            try:
+                validated_config = self.validator.validate_monitor_config(config)
+                self.config = validated_config.model_dump()
+                self._init_config()
+            except ValidationError as e:
+                error_str = str(e)
+                formatted_error_message = BECMonitor.format_validation_error(error_str)
+
+                # Display the formatted error message in a popup
+                QMessageBox.critical(self, "Configuration Error", formatted_error_message)
+
+    @staticmethod
+    def format_validation_error(error_str: str) -> str:
+        """
+        Format the validation error string to be displayed in a popup.
+        Args:
+            error_str(str): Error string from the validation error.
+        """
+        error_lines = error_str.split("\n")
+        # The first line contains the number of errors.
+        error_header = f"<p><b>{error_lines[0]}</b></p><hr>"
+
+        formatted_error_message = error_header
+        # Skip the first line as it's the header.
+        error_details = error_lines[1:]
+
+        # Iterate through pairs of lines (each error's two lines).
+        for i in range(0, len(error_details), 2):
+            location = error_details[i]
+            message = error_details[i + 1] if i + 1 < len(error_details) else ""
+
+            formatted_error_message += f"<p><b>{location}</b><br>{message}</p><hr>"
+
+        return formatted_error_message
+
+    def flush(self, flush_all=False, source_type_to_flush=None) -> None:
+        """Update or reset the database to match the current configuration.
+
+        Args:
+            flush_all (bool): If True, reset the entire database.
+            source_type_to_flush (str): Specific source type to reset. Ignored if flush_all is True.
+        """
+        if flush_all:
+            self.database = self._init_database(self.plot_data)
+            self.init_curves()
+        else:
+            if source_type_to_flush in self.database:
+                # TODO maybe reinit the database from config again instead of cycle through names/entries
+                # Reset only the specified source type
+                for name in self.database[source_type_to_flush]:
+                    for entry in self.database[source_type_to_flush][name]:
+                        self.database[source_type_to_flush][name][entry] = []
+                # Reset curves for the specified source type
+                if source_type_to_flush in self.curves_data:
+                    self.init_curves()
+
+    @pyqtSlot(dict, dict)
+    def on_scan_segment(self, msg: dict, metadata: dict):
+        """
+        Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
+
+        Args:
+            msg (dict): Message received with scan data.
+            metadata (dict): Metadata of the scan.
+        """
+        current_scanID = msg.get("scanID", None)
+        if current_scanID is None:
+            return
+
+        if current_scanID != self.scanID:
+            if self.scan_types is False:
+                self.plot_data = self.plot_data_config
+            elif self.scan_types is True:
+                current_name = metadata.get("scan_name")
+                if current_name is None:
+                    raise ValueError(
+                        "Scan name not found in metadata. Please check the scan_name in the YAML"
+                        " config or in bec configuration."
+                    )
+                self.plot_data = self.plot_data_config.get(current_name, None)
+                if not self.plot_data:
+                    raise ValueError(
+                        f"Scan name {current_name} not found in the YAML config. Please check the scan_name in the "
+                        "YAML config or in bec configuration."
+                    )
+
+                # 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)
+            if not self.scan_data:
+                print(f"No data found for scanID: {self.scanID}")  # TODO better error
+                return
+            self.flush(source_type_to_flush="scan_segment")
+
+        self.scan_segment_update()
+
+        self.update_signal.emit()
+
+    def scan_segment_update(self):
+        """
+        Update the database with data from scan storage based on the provided scanID.
+        """
+        scan_data = self.scan_data.data
+        for device_name, device_entries in self.database.get("scan_segment", {}).items():
+            for entry in device_entries.keys():
+                dataset = scan_data[device_name][entry].val
+                if dataset:
+                    self.database["scan_segment"][device_name][entry] = dataset
+                else:
+                    print(f"No data found for {device_name} {entry}")
+
+    @pyqtSlot(dict)
+    def on_data_from_redis(self, msg) -> None:
+        """
+        Handle new data sent from redis.
+        Args:
+            msg (dict): Message received with  data.
+        """
+
+        # wait until new config is loaded
+        while "redis" not in self.database:
+            time.sleep(0.1)
+        self._init_database(
+            self.plot_data, source_type_to_init="redis"
+        )  # add database entry for redis dataset
+
+        data = msg.get("data", {})
+        x_data = data.get("x", {})
+        y_data = data.get("y", {})
+
+        # Update x data
+        if x_data:
+            x_tag = x_data.get("tag")
+            self.database["redis"][x_tag][x_tag] = x_data["data"]
+
+        # Update y data
+        for y_tag, y_info in y_data.items():
+            self.database["redis"][y_tag][y_tag] = y_info["data"]
+
+        # Trigger plot update
+        self.update_plot(source_type="redis")
+        print(f"database after: {self.database}")
+
+
+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_SIMPLE
+
+    client = BECDispatcher().client
+    client.start()
+    app = QApplication(sys.argv)
+    monitor = BECMonitor(
+        config=config,
+        gui_id=args.id,
+        skip_validation=False,
+    )
+    monitor.show()
+    # just to test redis data
+    # redis_data = {
+    #     "x": {"data": [1, 2, 3], "tag": "x_default_tag"},
+    #     "y": {"y_default_tag": {"data": [1, 2, 3]}},
+    # }
+    # monitor.on_data_from_redis({"data": redis_data})
+    sys.exit(app.exec())

bec_widgets/widgets/monitor/tab_template.ui

@@ -0,0 +1,180 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>506</width>
+    <height>592</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2">
+   <item>
+    <widget class="QGroupBox" name="groupBox_general">
+     <property name="title">
+      <string>General</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout">
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_5">
+        <property name="text">
+         <string>X Label</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0" colspan="5">
+       <widget class="Line" name="line_2">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="4">
+       <widget class="QLineEdit" name="lineEdit_y_label"/>
+      </item>
+      <item row="2" column="3">
+       <widget class="QLabel" name="label_11">
+        <property name="text">
+         <string>Y Label</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1" colspan="4">
+       <widget class="QLineEdit" name="lineEdit_plot_title"/>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLineEdit" name="lineEdit_x_label"/>
+      </item>
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_4">
+        <property name="text">
+         <string>Plot Title</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="2">
+       <widget class="Line" name="line_3">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <layout class="QVBoxLayout" name="verticalLayout">
+     <item>
+      <widget class="QGroupBox" name="groupBox_x_axis">
+       <property name="title">
+        <string>X Axis</string>
+       </property>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QLabel" name="label_6">
+          <property name="text">
+           <string>Name:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="lineEdit_x_name"/>
+        </item>
+        <item>
+         <widget class="Line" name="line">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="label_7">
+          <property name="text">
+           <string>Entry:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="lineEdit_x_entry"/>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="groupBox_y_signals">
+       <property name="title">
+        <string>Y Signals</string>
+       </property>
+       <layout class="QVBoxLayout" name="verticalLayout_3">
+        <item>
+         <widget class="BECTable" name="tableWidget_y_signals">
+          <column>
+           <property name="text">
+            <string>Name</string>
+           </property>
+          </column>
+          <column>
+           <property name="text">
+            <string>Entries</string>
+           </property>
+          </column>
+          <column>
+           <property name="text">
+            <string>Color</string>
+           </property>
+          </column>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <layout class="QHBoxLayout" name="horizontalLayout_2">
+       <item>
+        <widget class="QPushButton" name="pushButton_add_new_plot">
+         <property name="text">
+          <string>Add New Plot</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <spacer name="horizontalSpacer_3">
+         <property name="orientation">
+          <enum>Qt::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item>
+        <widget class="QPushButton" name="pushButton_y_new">
+         <property name="text">
+          <string>Add New Signal</string>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>BECTable</class>
+   <extends>QTableWidget</extends>
+   <header>bec_widgets.utils.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/monitor_scatter_2D/__init__.py

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

bec_widgets/widgets/monitor_scatter_2D/monitor_scatter_2D.py

@@ -0,0 +1,382 @@
+# 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_map/__init__.py

@@ -0,0 +1 @@
+from .motor_map import MotorMap

bec_widgets/widgets/motor_map/motor_map.py

@@ -0,0 +1,556 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+from __future__ import annotations
+
+import time
+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.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
+
+CONFIG_DEFAULT = {
+    "plot_settings": {
+        "colormap": "Greys",
+        "scatter_size": 5,
+        "max_points": 1000,
+        "num_dim_points": 100,
+        "precision": 2,
+        "num_columns": 1,
+        "background_value": 25,
+    },
+    "motors": [
+        {
+            "plot_name": "Motor Map",
+            "x_label": "Motor X",
+            "y_label": "Motor Y",
+            "signals": {
+                "x": [{"name": "samx", "entry": "samx"}],
+                "y": [{"name": "samy", "entry": "samy"}],
+            },
+        },
+        {
+            "plot_name": "Motor Map 2 ",
+            "x_label": "Motor X",
+            "y_label": "Motor Y",
+            "signals": {
+                "x": [{"name": "aptrx", "entry": "aptrx"}],
+                "y": [{"name": "aptry", "entry": "aptry"}],
+            },
+        },
+    ],
+}
+
+
+class MotorMap(pg.GraphicsLayoutWidget):
+    update_signal = pyqtSignal()
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        config: dict = None,
+        gui_id=None,
+        skip_validation: bool = True,
+    ):
+        super().__init__(parent=parent)
+
+        # Import BEC related stuff
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.dev = self.client.device_manager.devices
+
+        # TODO import validator when prepared
+        self.gui_id = gui_id
+
+        if self.gui_id is None:
+            self.gui_id = self.__class__.__name__ + str(time.time())
+
+        # Current configuration
+        self.config = config
+        self.skip_validation = skip_validation  # TODO implement validation when validator is ready
+
+        # Connect the update signal to the update plot method
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self._update_plots
+        )
+
+        # Config related variables
+        self.plot_data = None
+        self.plot_settings = None
+        self.max_points = None
+        self.num_dim_points = None
+        self.scatter_size = None
+        self.precision = None
+        self.background_value = None
+        self.database = {}
+        self.device_mapping = {}
+        self.plots = {}
+        self.grid_coordinates = []
+        self.curves_data = {}
+
+        # Init UI with config
+        if self.config is None:
+            print("No initial config found for MotorMap. Using default config.")
+        else:
+            self.on_config_update(self.config)
+
+    @pyqtSlot(dict)
+    def on_config_update(self, config: dict) -> None:
+        """
+        Validate and update the configuration settings for the PlotApp.
+        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 _init_config(self):
+        """Initiate the configuration."""
+
+        # Global widget settings
+        self._get_global_settings()
+
+        # Motor settings
+        self.plot_data = self.config.get("motors", {})
+
+        # Include motor limits into the config
+        self._add_limits_to_plot_data()
+
+        # Initialize the database
+        self.database = self._init_database()
+
+        # Create device mapping for x/y motor pairs
+        self.device_mapping = self._create_device_mapping()
+
+        # Initialize the plot UI
+        self._init_ui()
+
+        # Connect motors to slots
+        self._connect_motors_to_slots()
+
+    def _get_global_settings(self):
+        """Get global settings from the config."""
+        self.plot_settings = self.config.get("plot_settings", {})
+
+        self.max_points = self.plot_settings.get("max_points", 5000)
+        self.num_dim_points = self.plot_settings.get("num_dim_points", 100)
+        self.scatter_size = self.plot_settings.get("scatter_size", 5)
+        self.precision = self.plot_settings.get("precision", 2)
+        self.background_value = self.plot_settings.get("background_value", 25)
+
+    def _create_device_mapping(self):
+        """
+        Create a mapping of device names to their corresponding x/y devices.
+        """
+        mapping = {}
+        for motor in self.config.get("motors", []):
+            for axis in ["x", "y"]:
+                for signal in motor["signals"][axis]:
+                    other_axis = "y" if axis == "x" else "x"
+                    corresponding_device = motor["signals"][other_axis][0]["name"]
+                    mapping[signal["name"]] = corresponding_device
+        return mapping
+
+    def _connect_motors_to_slots(self):
+        """Connect motors to slots."""
+
+        # Disconnect all slots before connecting a new ones
+        bec_dispatcher = BECDispatcher()
+        bec_dispatcher.disconnect_all()
+
+        # Get list of all unique motors
+        unique_motors = []
+        for motor_config in self.plot_data:
+            for axis in ["x", "y"]:
+                for signal in motor_config["signals"][axis]:
+                    unique_motors.append(signal["name"])
+        unique_motors = list(set(unique_motors))
+
+        # Create list of endpoint
+        endpoints = []
+        for motor in unique_motors:
+            endpoints.append(MessageEndpoints.device_readback(motor))
+
+        # Connect all topics to a single slot
+        bec_dispatcher.connect_slot(
+            self.on_device_readback,
+            endpoints,
+            single_callback_for_all_topics=True,
+        )
+
+    def _add_limits_to_plot_data(self):
+        """
+        Add limits to each motor signal in the plot_data.
+        """
+        for motor_config in self.plot_data:
+            for axis in ["x", "y"]:
+                for signal in motor_config["signals"][axis]:
+                    motor_name = signal["name"]
+                    motor_limits = self._get_motor_limit(motor_name)
+                    signal["limits"] = motor_limits
+
+    def _get_motor_limit(self, motor: str) -> Union[list | None]:
+        """
+        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 _init_database(self):
+        """Initiate the database according the config."""
+        database = {}
+
+        for plot in self.plot_data:
+            for axis, signals in plot["signals"].items():
+                for signal in signals:
+                    name = signal["name"]
+                    entry = signal.get("entry", name)
+                    if name not in database:
+                        database[name] = {}
+                    if entry not in database[name]:
+                        database[name][entry] = [self.get_coordinate(name, entry)]
+        return database
+
+    def get_coordinate(self, name, entry):
+        """Get the initial coordinate value for a motor."""
+        try:
+            return self.dev[name].read()[entry]["value"]
+        except Exception as e:
+            print(f"Error getting initial value for {name}: {e}")
+            return None
+
+    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.clear()
+        self.plots = {}
+        self.grid_coordinates = []
+        self.curves_data = {}  # TODO moved from init_curves
+
+        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
+
+            if "plot_name" not in plot_config:
+                plot_name = f"Plot ({row}, {col})"
+                plot_config["plot_name"] = plot_name
+            else:
+                plot_name = plot_config["plot_name"]
+
+            x_label = plot_config.get("x_label", "")
+            y_label = plot_config.get("y_label", "")
+
+            plot = self.addPlot(row=row, col=col, colspan=colspan, title="Motor position: (X, Y)")
+            plot.setLabel("bottom", f"{x_label} ({plot_config['signals']['x'][0]['name']})")
+            plot.setLabel("left", f"{y_label} ({plot_config['signals']['y'][0]['name']})")
+            plot.addLegend()
+            # self._set_plot_colors(plot, self.plot_settings) #TODO implement colors
+
+            self.plots[plot_name] = plot
+            self.grid_coordinates.append((row, col))
+
+            self._init_motor_map(plot_config)
+
+    def _init_motor_map(self, plot_config: dict) -> None:
+        """
+        Initialize the motor map.
+        Args:
+            plot_config(dict): Plot configuration.
+        """
+
+        # Get plot name to find appropriate plot
+        plot_name = plot_config.get("plot_name", "")
+
+        # Reset the curves data
+        plot = self.plots[plot_name]
+        plot.clear()
+
+        limits_x, limits_y = plot_config["signals"]["x"][0].get("limits", None), plot_config[
+            "signals"
+        ]["y"][0].get("limits", None)
+        if limits_x is not None and limits_y is not None:
+            self._make_limit_map(plot, [limits_x, limits_y])
+
+        # Initiate ScatterPlotItem for motor coordinates
+        self.curves_data[plot_name] = {
+            "pos": pg.ScatterPlotItem(
+                size=self.scatter_size, pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 255, 255)
+            )
+        }
+
+        # Add the scatter plot to the plot
+        plot.addItem(self.curves_data[plot_name]["pos"])
+        # Set the point map to be always on the top
+        self.curves_data[plot_name]["pos"].setZValue(0)
+
+        # Add all layers to the plot
+        plot.showGrid(x=True, y=True)
+
+        # Add the crosshair for motor coordinates
+        init_position_x = self._get_motor_init_position(
+            plot_config["signals"]["x"][0]["name"], plot_config["signals"]["x"][0]["entry"]
+        )
+        init_position_y = self._get_motor_init_position(
+            plot_config["signals"]["y"][0]["name"], plot_config["signals"]["y"][0]["entry"]
+        )
+        self._add_coordinantes_crosshair(plot_name, init_position_x, init_position_y)
+
+    def _add_coordinantes_crosshair(self, plot_name: str, x: float, y: float) -> None:
+        """
+        Add crosshair to the plot to highlight the current position.
+        Args:
+            plot_name(str): Name of the plot.
+            x(float): X coordinate.
+            y(float): Y coordinate.
+        """
+        # find the current plot
+        plot = self.plots[plot_name]
+
+        # 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.curves_data[plot_name]["highlight_H"] = highlight_H
+        self.curves_data[plot_name]["highlight_V"] = highlight_V
+
+        # Add crosshair to the plot
+        plot.addItem(highlight_H)
+        plot.addItem(highlight_V)
+
+        highlight_H.setPos(x)
+        highlight_V.setPos(y)
+
+    def _make_limit_map(self, plot: pg.PlotItem, limits: list):
+        """
+        Make a limit map from the limits list.
+
+        Args:
+            plot(pg.PlotItem): Plot to add the limit map to.
+            limits(list): List of limits.
+        """
+        # Define the size of the image map based on the motor's limits
+        limit_x_min, limit_x_max = limits[0]
+        limit_y_min, limit_y_max = limits[1]
+
+        map_width = int(limit_x_max - limit_x_min + 1)
+        map_height = int(limit_y_max - limit_y_min + 1)
+
+        limit_map_data = np.full((map_width, map_height), self.background_value, dtype=np.float32)
+
+        # Create the image map
+        limit_map = pg.ImageItem()
+        limit_map.setImage(limit_map_data)
+        plot.addItem(limit_map)
+
+        # 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)
+
+    def _get_motor_init_position(self, name: str, entry: str) -> float:
+        """
+        Get the motor initial position from the config.
+        Args:
+            name(str): Motor name.
+            entry(str): Motor entry.
+        Returns:
+            float: Motor initial position.
+        """
+        init_position = round(self.dev[name].read()[entry]["value"], self.precision)
+        return init_position
+
+    def _update_plots(self):
+        """Update the motor position on plots."""
+        for plot_name, curve_list in self.curves_data.items():
+            plot_config = next(
+                (pc for pc in self.plot_data if pc.get("plot_name") == plot_name), None
+            )
+            if not plot_config:
+                continue
+
+            # Get the motor coordinates
+            x_motor_name = plot_config["signals"]["x"][0]["name"]
+            x_motor_entry = plot_config["signals"]["x"][0]["entry"]
+            y_motor_name = plot_config["signals"]["y"][0]["name"]
+            y_motor_entry = plot_config["signals"]["y"][0]["entry"]
+
+            # update motor position only if there is data
+            if (
+                len(self.database[x_motor_name][x_motor_entry]) >= 1
+                and len(self.database[y_motor_name][y_motor_entry]) >= 1
+            ):
+                # Relevant data for the plot
+                motor_x_data = self.database[x_motor_name][x_motor_entry]
+                motor_y_data = self.database[y_motor_name][y_motor_entry]
+
+                # Setup gradient brush for history
+                brushes = [pg.mkBrush(50, 50, 50, 255)] * len(motor_x_data)
+
+                # Calculate the decrement step based on self.num_dim_points
+                decrement_step = (255 - 50) / self.num_dim_points
+
+                for i in range(1, min(self.num_dim_points + 1, len(motor_x_data) + 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
+
+                # Update the scatter plot
+                self.curves_data[plot_name]["pos"].setData(
+                    x=motor_x_data,
+                    y=motor_y_data,
+                    brush=brushes,
+                    pen=None,
+                    size=self.scatter_size,
+                )
+
+                # Get last know position for crosshair
+                current_x = motor_x_data[-1]
+                current_y = motor_y_data[-1]
+
+                # Update plot title
+                self.plots[plot_name].setTitle(
+                    f"Motor position: ({round(current_x,self.precision)}, {round(current_y,self.precision)})"
+                )
+
+                # Update the crosshair
+                self.curves_data[plot_name]["highlight_V"].setPos(current_x)
+                self.curves_data[plot_name]["highlight_H"].setPos(current_y)
+
+    @pyqtSlot(dict)
+    def on_device_readback(self, msg: dict):
+        """
+        Update the motor coordinates on the plots.
+        Args:
+            msg (dict): Message received with device readback data.
+        """
+
+        for device_name, device_info in msg["signals"].items():
+            # Check if the device is relevant to our current context
+            if device_name in self.device_mapping:
+                self._update_device_data(device_name, device_info["value"])
+
+        self.update_signal.emit()
+
+    def _update_device_data(self, device_name: str, value: float):
+        """
+        Update the device data.
+        Args:
+            device_name (str): Device name.
+            value (float): Device value.
+        """
+        if device_name in self.database:
+            self.database[device_name][device_name].append(value)
+
+            corresponding_device = self.device_mapping.get(device_name)
+            if corresponding_device and corresponding_device in self.database:
+                last_value = (
+                    self.database[corresponding_device][corresponding_device][-1]
+                    if self.database[corresponding_device][corresponding_device]
+                    else None
+                )
+                self.database[corresponding_device][corresponding_device].append(last_value)
+
+
+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 = load_yaml(args.config_file)
+    else:
+        config = CONFIG_DEFAULT
+
+    client = BECDispatcher().client
+    client.start()
+    app = QApplication(sys.argv)
+    motor_map = MotorMap(
+        config=config,
+        gui_id=args.id,
+        skip_validation=True,
+    )
+    motor_map.show()
+
+    sys.exit(app.exec())

bec_widgets/widgets/scan_control/__init__.py

@@ -0,0 +1 @@
+from .scan_control import ScanControl

bec_widgets/widgets/scan_control/scan_control.py

@@ -0,0 +1,440 @@
+import msgpack
+from qtpy.QtWidgets import (
+    QApplication,
+    QWidget,
+    QComboBox,
+    QPushButton,
+    QVBoxLayout,
+    QGroupBox,
+    QLabel,
+    QLineEdit,
+    QDoubleSpinBox,
+    QSpinBox,
+    QCheckBox,
+    QFrame,
+    QHBoxLayout,
+    QLayout,
+    QGridLayout,
+    QTableWidget,
+    QTableWidgetItem,
+    QHeaderView,
+)
+
+from bec_lib import MessageEndpoints
+from bec_widgets.utils.widget_io import WidgetIO
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+
+class ScanArgType:
+    DEVICE = "device"
+    FLOAT = "float"
+    INT = "int"
+    BOOL = "bool"
+    STR = "str"
+
+
+class ScanControl(QWidget):
+    WIDGET_HANDLER = {
+        ScanArgType.DEVICE: QLineEdit,
+        ScanArgType.FLOAT: QDoubleSpinBox,
+        ScanArgType.INT: QSpinBox,
+        ScanArgType.BOOL: QCheckBox,
+        ScanArgType.STR: QLineEdit,
+    }
+
+    def __init__(self, parent=None, client=None, allowed_scans=None):
+        super().__init__(parent)
+
+        # Client from BEC + shortcuts to device manager and scans
+        self.client = BECDispatcher().client if client is None else client
+        self.dev = self.client.device_manager.devices
+        self.scans = self.client.scans
+
+        # Scan list - allowed scans for the GUI
+        self.allowed_scans = allowed_scans
+
+        # Create and set main layout
+        self._init_UI()
+
+    def _init_UI(self):
+        self.verticalLayout = QVBoxLayout(self)
+
+        # Scan selection group box
+        self.scan_selection_group = QGroupBox("Scan Selection", self)
+        self.scan_selection_layout = QVBoxLayout(self.scan_selection_group)
+        self.comboBox_scan_selection = QComboBox(self.scan_selection_group)
+        self.button_run_scan = QPushButton("Run Scan", self.scan_selection_group)
+        self.scan_selection_layout.addWidget(self.comboBox_scan_selection)
+        self.scan_selection_layout.addWidget(self.button_run_scan)
+        self.verticalLayout.addWidget(self.scan_selection_group)
+
+        # Scan control group box
+        self.scan_control_group = QGroupBox("Scan Control", self)
+        self.scan_control_layout = QVBoxLayout(self.scan_control_group)
+        self.verticalLayout.addWidget(self.scan_control_group)
+
+        # Kwargs layout - just placeholder
+        self.kwargs_layout = QGridLayout()
+        self.scan_control_layout.addLayout(self.kwargs_layout)
+
+        # 1st Separator
+        self.add_horizontal_separator(self.scan_control_layout)
+
+        # Buttons
+        self.button_layout = QHBoxLayout()
+        self.pushButton_add_bundle = QPushButton("Add Bundle", self.scan_control_group)
+        self.pushButton_add_bundle.clicked.connect(self.add_bundle)
+        self.pushButton_remove_bundle = QPushButton("Remove Bundle", self.scan_control_group)
+        self.pushButton_remove_bundle.clicked.connect(self.remove_bundle)
+        self.button_layout.addWidget(self.pushButton_add_bundle)
+        self.button_layout.addWidget(self.pushButton_remove_bundle)
+        self.scan_control_layout.addLayout(self.button_layout)
+
+        # 2nd Separator
+        self.add_horizontal_separator(self.scan_control_layout)
+
+        # Initialize the QTableWidget for args
+        self.args_table = QTableWidget()
+        self.args_table.verticalHeader().setSectionResizeMode(QHeaderView.Fixed)
+
+        self.scan_control_layout.addWidget(self.args_table)
+
+        # Connect signals
+        self.comboBox_scan_selection.currentIndexChanged.connect(self.on_scan_selected)
+        self.button_run_scan.clicked.connect(self.run_scan)
+
+        # Initialize scan selection
+        self.populate_scans()
+
+    def add_horizontal_separator(self, layout) -> None:
+        """
+        Adds a horizontal separator to the given layout
+        Args:
+            layout: Layout to add the separator to
+        """
+        separator = QFrame(self.scan_control_group)
+        separator.setFrameShape(QFrame.HLine)
+        separator.setFrameShadow(QFrame.Sunken)
+        layout.addWidget(separator)
+
+    def populate_scans(self):
+        """Populates the scan selection combo box with available scans"""
+        msg = self.client.producer.get(MessageEndpoints.available_scans())
+        self.available_scans = msgpack.loads(msg)
+        if self.allowed_scans is None:
+            allowed_scans = self.available_scans.keys()
+        else:
+            allowed_scans = self.allowed_scans
+        # TODO check parent class is ScanBase -> filter out the scans not relevant for GUI
+        self.comboBox_scan_selection.addItems(allowed_scans)
+
+    def on_scan_selected(self):
+        """Callback for scan selection combo box"""
+        selected_scan_name = self.comboBox_scan_selection.currentText()
+        selected_scan_info = self.available_scans.get(selected_scan_name, {})
+
+        print(selected_scan_info)  # TODO remove when widget will be more mature
+        # Generate kwargs input
+        self.generate_kwargs_input_fields(selected_scan_info)
+
+        # Args section
+        self.generate_args_input_fields(selected_scan_info)
+
+    def add_labels_to_layout(self, labels: list, grid_layout: QGridLayout) -> None:
+        """
+        Adds labels to the given grid layout as a separate row.
+        Args:
+            labels (list): List of label names to add.
+            grid_layout (QGridLayout): The grid layout to which labels will be added.
+        """
+        row_index = grid_layout.rowCount()  # Get the next available row
+        for column_index, label_name in enumerate(labels):
+            label = QLabel(label_name.capitalize(), self.scan_control_group)
+            # Add the label to the grid layout at the calculated row and current column
+            grid_layout.addWidget(label, row_index, column_index)
+
+    def add_labels_to_table(
+        self, labels: list, table: QTableWidget
+    ) -> None:  # TODO could be moved to BECTable
+        """
+        Adds labels to the given table widget as a header row.
+        Args:
+            labels(list): List of label names to add.
+            table(QTableWidget): The table widget to which labels will be added.
+        """
+        table.setColumnCount(len(labels))
+        table.setHorizontalHeaderLabels(labels)
+
+    def generate_args_input_fields(self, scan_info: dict) -> None:
+        """
+        Generates input fields for args
+        Args:
+            scan_info(dict): Scan signature dictionary from BEC.
+        """
+
+        # Setup args table limits
+        self.set_args_table_limits(self.args_table, scan_info)
+
+        # Get arg_input from selected scan
+        self.arg_input = scan_info.get("arg_input", {})
+
+        # Generate labels for table
+        self.add_labels_to_table(list(self.arg_input.keys()), self.args_table)
+
+        # add minimum number of args rows
+        if self.arg_size_min is not None:
+            for i in range(self.arg_size_min):
+                self.add_bundle()
+
+    def generate_kwargs_input_fields(self, scan_info: dict) -> None:
+        """
+        Generates input fields for kwargs
+        Args:
+            scan_info(dict): Scan signature dictionary from BEC.
+        """
+        # Create a new kwarg layout to replace the old one - this is necessary because otherwise row count is not reseted
+        self.clear_and_delete_layout(self.kwargs_layout)
+        self.kwargs_layout = self.create_new_grid_layout()  # Create new grid layout
+        self.scan_control_layout.insertLayout(0, self.kwargs_layout)
+
+        # Get signature
+        signature = scan_info.get("signature", [])
+
+        # Extract kwargs from the converted signature
+        kwargs = [param["name"] for param in signature if param["kind"] == "KEYWORD_ONLY"]
+
+        # Add labels
+        self.add_labels_to_layout(kwargs, self.kwargs_layout)
+
+        # Add widgets
+        widgets = self.generate_widgets_from_signature(kwargs, signature)
+
+        self.add_widgets_row_to_layout(self.kwargs_layout, widgets)
+
+    def generate_widgets_from_signature(self, items: list, signature: dict = None) -> list:
+        """
+        Generates widgets from the given list of items.
+        Args:
+            items(list): List of items to create widgets for.
+            signature(dict, optional): Scan signature dictionary from BEC.
+
+        Returns:
+
+        """
+        widgets = []  # Initialize an empty list to hold the widgets
+
+        for item in items:
+            if signature:
+                # If a signature is provided, extract type and name from it
+                kwarg_info = next((info for info in signature if info["name"] == item), None)
+                if kwarg_info:
+                    item_type = kwarg_info.get("annotation", "_empty")
+                    item_name = item
+            else:
+                # If no signature is provided, assume the item is a tuple of (name, type)
+                item_name, item_type = item
+
+            widget_class = self.WIDGET_HANDLER.get(item_type, None)
+            if widget_class is None:
+                print(f"Unsupported annotation '{item_type}' for parameter '{item_name}'")
+                continue
+
+            # Instantiate the widget and set some properties if necessary
+            widget = widget_class()
+
+            # set high default range for spin boxes #TODO can be linked to motor/device limits from BEC
+            if isinstance(widget, (QSpinBox, QDoubleSpinBox)):
+                widget.setRange(-9999, 9999)
+                widget.setValue(0)
+            # Add the widget to the list
+            widgets.append(widget)
+
+        return widgets
+
+    def set_args_table_limits(self, table: QTableWidget, scan_info: dict) -> None:
+        # Get bundle info
+        arg_bundle_size = scan_info.get("arg_bundle_size", {})
+        self.arg_size_min = arg_bundle_size.get("min", 1)
+        self.arg_size_max = arg_bundle_size.get("max", None)
+
+        # Clear the previous input fields
+        table.setRowCount(0)  # Wipe table
+
+    def add_widgets_row_to_layout(
+        self, grid_layout: QGridLayout, widgets: list, row_index: int = None
+    ) -> None:
+        """
+        Adds a row of widgets to the given grid layout.
+
+        Args:
+            grid_layout (QGridLayout): The grid layout to which widgets will be added.
+            items (list): List of parameter names to create widgets for.
+            row_index (int): The row index where the widgets should be added.
+        """
+        # If row_index is not specified, add to the next available row
+        if row_index is None:
+            row_index = grid_layout.rowCount()
+
+        for column_index, widget in enumerate(widgets):
+            # Add the widget to the grid layout at the specified row and column
+            grid_layout.addWidget(widget, row_index, column_index)
+
+    def add_widgets_row_to_table(
+        self, table_widget: QTableWidget, widgets: list, row_index: int = None
+    ) -> None:
+        """
+        Adds a row of widgets to the given QTableWidget.
+
+        Args:
+            table_widget (QTableWidget): The table widget to which widgets will be added.
+            widgets (list): List of widgets to add to the table.
+            row_index (int): The row index where the widgets should be added. If None, add to the end.
+        """
+        # If row_index is not specified, add to the end of the table
+        if row_index is None or row_index > table_widget.rowCount():
+            row_index = table_widget.rowCount()
+            if self.arg_size_max is not None:  # ensure the max args size is not exceeded
+                if row_index >= self.arg_size_max:
+                    return
+            table_widget.insertRow(row_index)
+
+        for column_index, widget in enumerate(widgets):
+            # If the widget is a subclass of QWidget, use setCellWidget
+            if issubclass(type(widget), QWidget):
+                table_widget.setCellWidget(row_index, column_index, widget)
+            else:
+                # Otherwise, assume it's a string or some other value that should be displayed as text
+                item = QTableWidgetItem(str(widget))
+                table_widget.setItem(row_index, column_index, item)
+
+        # Optionally, adjust the row height based on the content #TODO decide if needed
+        table_widget.setRowHeight(
+            row_index,
+            max(widget.sizeHint().height() for widget in widgets if isinstance(widget, QWidget)),
+        )
+
+    def remove_last_row_from_table(self, table_widget: QTableWidget) -> None:
+        """
+        Removes the last row from the given QTableWidget until only one row is left.
+
+        Args:
+            table_widget (QTableWidget): The table widget from which the last row will be removed.
+        """
+        row_count = table_widget.rowCount()
+        if (
+            row_count > self.arg_size_min
+        ):  # Check to ensure there is a minimum number of rows remaining
+            table_widget.removeRow(row_count - 1)
+
+    def create_new_grid_layout(self):
+        new_layout = QGridLayout()
+        # TODO maybe setup other layouts properties here?
+        return new_layout
+
+    def clear_and_delete_layout(self, layout: QLayout):
+        """
+        Clears and deletes the given layout and all its child widgets.
+        Args:
+            layout(QLayout): Layout to clear and delete
+        """
+        if layout is not None:
+            while layout.count():
+                item = layout.takeAt(0)
+                widget = item.widget()
+                if widget:
+                    widget.deleteLater()
+                else:
+                    sub_layout = item.layout()
+                    if sub_layout:
+                        self.clear_and_delete_layout(sub_layout)
+            layout.deleteLater()
+
+    def add_bundle(self) -> None:
+        """Adds a new bundle to the scan control layout"""
+        # Get widgets used for particular scan and save them to be able to use for adding bundles
+        args_widgets = self.generate_widgets_from_signature(
+            self.arg_input.items()
+        )  # TODO decide if make sense to put widget list into method parameters
+
+        # Add first widgets row to the table
+        self.add_widgets_row_to_table(self.args_table, args_widgets)
+
+    def remove_bundle(self) -> None:
+        """Removes the last bundle from the scan control layout"""
+        self.remove_last_row_from_table(self.args_table)
+
+    def extract_kwargs_from_grid_row(self, grid_layout: QGridLayout, row: int) -> dict:
+        kwargs = {}
+        for column in range(grid_layout.columnCount()):
+            label_item = grid_layout.itemAtPosition(row, column)
+            if label_item is not None:
+                label_widget = label_item.widget()
+                if isinstance(label_widget, QLabel):
+                    key = label_widget.text()
+
+                    # The corresponding value widget is in the next row
+                    value_item = grid_layout.itemAtPosition(row + 1, column)
+                    if value_item is not None:
+                        value_widget = value_item.widget()
+                        # Use WidgetIO.get_value to extract the value
+                        value = WidgetIO.get_value(value_widget)
+                        kwargs[key] = value
+        return kwargs
+
+    def extract_args_from_table(self, table: QTableWidget) -> list:
+        """
+        Extracts the arguments from the given table widget.
+        Args:
+            table(QTableWidget): Table widget from which to extract the arguments
+        """
+        args = []
+        for row in range(table.rowCount()):
+            row_args = []
+            for column in range(table.columnCount()):
+                widget = table.cellWidget(row, column)
+                if widget:
+                    if isinstance(widget, QLineEdit):  # special case for QLineEdit for Devices
+                        value = widget.text().lower()
+                        if value in self.dev:
+                            value = getattr(self.dev, value)
+                        else:
+                            raise ValueError(f"The device '{value}' is not recognized.")
+                    else:
+                        value = WidgetIO.get_value(widget)
+                    row_args.append(value)
+            args.extend(row_args)
+        return args
+
+    def run_scan(self):
+        # Extract kwargs for the scan
+        kwargs = {
+            k.lower(): v
+            for k, v in self.extract_kwargs_from_grid_row(self.kwargs_layout, 1).items()
+        }
+
+        # Extract args from the table
+        args = self.extract_args_from_table(self.args_table)
+
+        # Convert args to lowercase if they are strings
+        args = [arg.lower() if isinstance(arg, str) else arg for arg in args]
+
+        # Execute the scan
+        scan_function = getattr(self.scans, self.comboBox_scan_selection.currentText())
+        if callable(scan_function):
+            scan_function(*args, **kwargs)
+
+
+# Application example
+if __name__ == "__main__":  # pragma: no cover
+    # BECclient global variables
+    client = BECDispatcher().client
+    client.start()
+
+    app = QApplication([])
+    scan_control = ScanControl(
+        client=client,
+    )  # allowed_scans=["line_scan", "grid_scan"])
+
+    window = scan_control
+    window.show()
+    app.exec()

bec_widgets/widgets/scan_plot/scan2d_plot.py

@@ -1,9 +1,12 @@
+from threading import RLock
+
 import numpy as np
 import pyqtgraph as pg
-from bec_lib.core.logger import bec_logger
-from PyQt5.QtCore import pyqtProperty, pyqtSlot
+from bec_lib import MessageEndpoints
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import Property as pyqtProperty, Slot as pyqtSlot
 
-from bec_widgets.bec_dispatcher import bec_dispatcher
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 logger = bec_logger.logger
 
@@ -14,7 +17,10 @@ pg.setConfigOptions(background="w", foreground="k", antialias=True)
 class BECScanPlot2D(pg.GraphicsView):
     def __init__(self, parent=None, background="default"):
         super().__init__(parent, background)
-        bec_dispatcher.connect(self)
+        BECDispatcher().connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+
+        self._scanID = None
+        self._scanID_lock = RLock()
 
         self._x_channel = ""
         self._y_channel = ""
@@ -33,8 +39,7 @@ class BECScanPlot2D(pg.GraphicsView):
         self.imageItem = pg.ImageItem()
         self.plot_item.addItem(self.imageItem)
 
-    @pyqtSlot(dict, dict)
-    def on_new_scan(self, _scan_segment, metadata):
+    def reset_plots(self, _scan_segment, metadata):
         # TODO: Do we reset in case of a scan type change?
         self.imageItem.clear()
 
@@ -79,6 +84,13 @@ class BECScanPlot2D(pg.GraphicsView):
 
     @pyqtSlot(dict, dict)
     def on_scan_segment(self, scan_segment, metadata):
+        # reset plots on scanID change
+        with self._scanID_lock:
+            scan_id = scan_segment["scanID"]
+            if self._scanID != scan_id:
+                self._scanID = scan_id
+                self.reset_plots(scan_segment, metadata)
+
         if not self.z_channel or metadata["scan_name"] != "grid_scan":
             return
 
@@ -127,7 +139,7 @@ class BECScanPlot2D(pg.GraphicsView):
 if __name__ == "__main__":
     import sys
 
-    from PyQt5.QtWidgets import QApplication
+    from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
 
@@ -137,4 +149,4 @@ if __name__ == "__main__":
 
     plot.show()
 
-    sys.exit(app.exec_())
+    sys.exit(app.exec())

bec_widgets/widgets/scan_plot/scan_plot.py

@@ -1,10 +1,12 @@
 import itertools
+from threading import RLock
 
 import pyqtgraph as pg
-from bec_lib.core.logger import bec_logger
-from PyQt5.QtCore import pyqtProperty, pyqtSlot
+from bec_lib import MessageEndpoints
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import Property as pyqtProperty, Slot as pyqtSlot
 
-from bec_widgets.bec_dispatcher import bec_dispatcher
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 logger = bec_logger.logger
 
@@ -16,24 +18,33 @@ COLORS = ["#fd7f6f", "#7eb0d5", "#b2e061", "#bd7ebe", "#ffb55a"]
 class BECScanPlot(pg.GraphicsView):
     def __init__(self, parent=None, background="default"):
         super().__init__(parent, background)
-        bec_dispatcher.connect(self)
+        BECDispatcher().connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
 
         self.view = pg.PlotItem()
         self.setCentralItem(self.view)
 
+        self._scanID = None
+        self._scanID_lock = RLock()
+
         self._x_channel = ""
         self._y_channel_list = []
 
         self.scan_curves = {}
         self.dap_curves = {}
 
-    @pyqtSlot(dict, dict)
-    def on_new_scan(self, _scan_segment, _metadata):
+    def reset_plots(self, _scan_segment, _metadata):
         for plot_curve in {**self.scan_curves, **self.dap_curves}.values():
             plot_curve.setData(x=[], y=[])
 
     @pyqtSlot(dict, dict)
-    def on_scan_segment(self, scan_segment, _metadata):
+    def on_scan_segment(self, scan_segment, metadata):
+        # reset plots on scanID change
+        with self._scanID_lock:
+            scan_id = scan_segment["scanID"]
+            if self._scanID != scan_id:
+                self._scanID = scan_id
+                self.reset_plots(scan_segment, metadata)
+
         if not self.x_channel:
             return
 
@@ -62,7 +73,8 @@ class BECScanPlot(pg.GraphicsView):
             plot_curve.setData(x=[*x, x_new], y=[*y, y_new])
 
     @pyqtSlot(dict, dict)
-    def redraw_dap(self, data, _metadata):
+    def redraw_dap(self, content, _metadata):
+        data = content["data"]
         for chan, plot_curve in self.dap_curves.items():
             if not chan:
                 continue
@@ -82,11 +94,13 @@ class BECScanPlot(pg.GraphicsView):
 
     @y_channel_list.setter
     def y_channel_list(self, new_list):
+        bec_dispatcher = BECDispatcher()
         # TODO: do we want to care about dap/not dap here?
         chan_removed = [chan for chan in self._y_channel_list if chan not in new_list]
         if chan_removed and chan_removed[0].startswith("dap."):
             chan_removed = chan_removed[0].partition("dap.")[-1]
-            bec_dispatcher.disconnect_dap_slot(self.redraw_dap, chan_removed)
+            chan_removed_ep = MessageEndpoints.processed_data(chan_removed)
+            bec_dispatcher.disconnect_slot(self.redraw_dap, chan_removed_ep)
 
         self._y_channel_list = new_list
 
@@ -100,7 +114,8 @@ class BECScanPlot(pg.GraphicsView):
             if y_chan.startswith("dap."):
                 y_chan = y_chan.partition("dap.")[-1]
                 curves = self.dap_curves
-                bec_dispatcher.connect_dap_slot(self.redraw_dap, y_chan)
+                y_chan_ep = MessageEndpoints.processed_data(y_chan)
+                bec_dispatcher.connect_slot(self.redraw_dap, y_chan_ep)
             else:
                 curves = self.scan_curves
 
@@ -124,7 +139,7 @@ class BECScanPlot(pg.GraphicsView):
 if __name__ == "__main__":
     import sys
 
-    from PyQt5.QtWidgets import QApplication
+    from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
 
@@ -134,4 +149,4 @@ if __name__ == "__main__":
 
     plot.show()
 
-    sys.exit(app.exec_())
+    sys.exit(app.exec())

bec_widgets/widgets/toolbar/__init__.py

@@ -0,0 +1 @@
+from .toolbar import ModularToolBar

bec_widgets/widgets/toolbar/toolbar.py

@@ -0,0 +1,145 @@
+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.QtGui import QAction
+from qtpy.QtWidgets import QWidget
+
+
+class ToolBarAction(ABC):
+    """Abstract base class for action creators for the toolbar."""
+
+    @abstractmethod
+    def create(self, target: QWidget):
+        """Creates and returns an action to be added to a toolbar.
+
+        This method must be implemented by subclasses.
+
+        Args:
+            target (QWidget): The widget that the action will target.
+
+        Returns:
+            QAction: The action created for the toolbar.
+        """
+
+
+class OpenFileAction:  # (ToolBarAction):
+    """Action creator for the 'Open File' action in the toolbar."""
+
+    def create(self, target: QWidget):
+        """Creates an 'Open File' action for the toolbar.
+
+        Args:
+            target (QWidget): The widget that the 'Open File' action will be targeted.
+
+        Returns:
+            QAction: The 'Open File' action created for the toolbar.
+        """
+        icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogOpenButton)
+        action = QAction(icon, "Open File", target)
+        # action = QAction("Open File", target)
+        action.triggered.connect(target.open_file)
+        return action
+
+
+class SaveFileAction:
+    """Action creator for the 'Save File' action in the toolbar."""
+
+    def create(self, target):
+        """Creates a 'Save File' action for the toolbar.
+
+        Args:
+            target (QWidget): The widget that the 'Save File' action will be targeted.
+
+        Returns:
+            QAction: The 'Save File' action created for the toolbar.
+        """
+        icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogSaveButton)
+        action = QAction(icon, "Save File", target)
+        # action = QAction("Save File", target)
+        action.triggered.connect(target.save_file)
+        return action
+
+
+class RunScriptAction:
+    """Action creator for the 'Run Script' action in the toolbar."""
+
+    def create(self, target):
+        """Creates a 'Run Script' action for the toolbar.
+
+        Args:
+            target (QWidget): The widget that the 'Run Script' action will be targeted.
+
+        Returns:
+            QAction: The 'Run Script' action created for the toolbar.
+        """
+        icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay)
+        action = QAction(icon, "Run Script", target)
+        # action = QAction("Run Script", target)
+        action.triggered.connect(target.run_script)
+        return action
+
+
+class ModularToolBar(QToolBar):
+    """Modular toolbar with optional automatic initialization.
+    Args:
+        parent (QWidget, optional): The parent widget of the toolbar. Defaults to None.
+        auto_init (bool, optional): If True, automatically populates the toolbar based on the parent widget.
+    """
+
+    def __init__(self, parent=None, auto_init=True):
+        super().__init__(parent)
+        self.auto_init = auto_init
+        self.handler = {
+            "BECEditor": [OpenFileAction(), SaveFileAction(), RunScriptAction()],
+            # BECMonitor: [SomeOtherAction(), AnotherAction()],  # Example for another widget
+        }
+        self.setStyleSheet("QToolBar { background: transparent; }")
+        # Set the icon size for the toolbar
+        self.setIconSize(QSize(20, 20))
+
+        if self.auto_init:
+            QTimer.singleShot(0, self.auto_detect_and_populate)
+
+    def auto_detect_and_populate(self):
+        """Automatically detects the parent widget and populates the toolbar with relevant actions."""
+        if not self.auto_init:
+            return
+
+        parent_widget = self.parent()
+        if parent_widget is None:
+            return
+
+        parent_widget_class_name = type(parent_widget).__name__
+        for widget_type_name, actions in self.handler.items():
+            if parent_widget_class_name == widget_type_name:
+                self.populate_toolbar(actions, parent_widget)
+                return
+
+    def populate_toolbar(self, actions, target_widget):
+        """Populates the toolbar with a set of actions.
+
+        Args:
+            actions (list[ToolBarAction]): A list of action creators to populate the toolbar.
+            target_widget (QWidget): The widget that the actions will target.
+        """
+        self.clear()
+        for action_creator in actions:
+            action = action_creator.create(target_widget)
+            self.addAction(action)
+
+    def set_manual_actions(self, actions, target_widget):
+        """Manually sets the actions for the toolbar.
+
+        Args:
+            actions (list[QAction or ToolBarAction]): A list of actions or action creators to populate the toolbar.
+            target_widget (QWidget): The widget that the actions will target.
+        """
+        self.clear()
+        for action in actions:
+            if isinstance(action, QAction):
+                self.addAction(action)
+            elif isinstance(action, ToolBarAction):
+                self.addAction(action.create(target_widget))

docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/_templates/custom-class-template.rst

@@ -0,0 +1,34 @@
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ module }}
+
+.. autoclass:: {{ objname }}
+   :members:
+   :show-inheritance:
+   :inherited-members:
+   :special-members: __call__, __add__, __mul__
+
+   {% block methods %}
+   {% if methods %}
+   .. rubric:: {{ _('Methods') }}
+
+   .. autosummary::
+      :nosignatures:
+   {% for item in methods %}
+      {%- if not item.startswith('_') %}
+      ~{{ name }}.{{ item }}
+      {%- endif -%}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
+
+   {% block attributes %}
+   {% if attributes %}
+   .. rubric:: {{ _('Attributes') }}
+
+   .. autosummary::
+   {% for item in attributes %}
+      ~{{ name }}.{{ item }}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}

docs/_templates/custom-module-template.rst

@@ -0,0 +1,66 @@
+{{ fullname | escape | underline}}
+
+.. automodule:: {{ fullname }}
+
+   {% block attributes %}
+   {% if attributes %}
+   .. rubric:: Module attributes
+
+   .. autosummary::
+      :toctree:
+   {% for item in attributes %}
+      {{ item }}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
+
+   {% block functions %}
+   {% if functions %}
+   .. rubric:: {{ _('Functions') }}
+
+   .. autosummary::
+      :toctree:
+      :nosignatures:
+   {% for item in functions %}
+      {{ item }}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
+
+   {% block classes %}
+   {% if classes %}
+   .. rubric:: {{ _('Classes') }}
+
+   .. autosummary::
+      :toctree:
+      :template: custom-class-template.rst
+      :nosignatures:
+   {% for item in classes %}
+      {{ item }}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
+
+   {% block exceptions %}
+   {% if exceptions %}
+   .. rubric:: {{ _('Exceptions') }}
+
+   .. autosummary::
+      :toctree:
+   {% for item in exceptions %}
+      {{ item }}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
+
+{% block modules %}
+{% if modules %}
+.. autosummary::
+   :toctree:
+   :template: custom-module-template.rst
+   :recursive:
+{% for item in modules %}
+   {{ item }}
+{%- endfor %}
+{% endif %}
+{% endblock %}

docs/conf.py

@@ -0,0 +1,85 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+import os
+import pathlib
+
+project = "BEC Widgets"
+copyright = "2023, Paul Scherrer Institute"
+author = "Paul Scherrer Institute"
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+current_path = pathlib.Path(__file__).parent.parent.resolve()
+
+
+def get_version():
+    """load the version from the version file"""
+    version_file = os.path.join(current_path, "setup.py")
+    with open(version_file, "r", encoding="utf-8") as file:
+        res = file.readline()
+        while not res.startswith("__version__"):
+            res = file.readline()
+        version = res.split("=")[1]
+    return version.strip().strip('"')
+
+
+release = get_version()
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    # "sphinx.ext.coverage",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.napoleon",
+    "sphinx_toolbox.collapse",
+    "sphinx_copybutton",
+    "myst_parser",
+    "sphinx_design",
+]
+
+myst_enable_extensions = [
+    "amsmath",
+    "attrs_inline",
+    "colon_fence",
+    "deflist",
+    "dollarmath",
+    "fieldlist",
+    "html_admonition",
+    "html_image",
+    "replacements",
+    "smartquotes",
+    "strikethrough",
+    "substitution",
+    "tasklist",
+]
+
+autosummary_generate = True  # Turn on sphinx.ext.autosummary
+add_module_names = False  # Remove namespaces from class/method signatures
+autodoc_inherit_docstrings = True  # If no docstring, inherit from base class
+set_type_checking_flag = True  # Enable 'expensive' imports for sphinx_autodoc_typehints
+autoclass_content = "both"  # Include both class docstring and __init__
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+language = "Python"
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "pydata_sphinx_theme"
+html_static_path = ["_static"]
+html_css_files = ["css/custom.css"]
+html_logo = "_static/bec.png"
+html_theme_options = {
+    "show_nav_level": 1,
+    "navbar_align": "content",
+}

docs/developer/developer.md

@@ -0,0 +1,16 @@
+(developer)=
+# Development
+
+To contribute to the development of BEC Widgets, start by setting up the development environment:
+
+1. **Clone the Repository**: 
+```bash
+git clone https://gitlab.psi.ch/bec/bec-widgets
+cd bec-widgets
+```
+2. **Install in Editable Mode**:
+
+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/index.md

@@ -0,0 +1,39 @@
+# BEC Widgets documentation
+
+<br><br>
+
+````{grid} 3
+:gutter: 5
+
+```{grid-item-card}  Introduction
+:link: introduction
+:link-type: ref
+
+General information.
+```
+
+```{grid-item-card}  User
+:link: user
+:link-type: ref
+
+Information for users.
+```
+
+```{grid-item-card}  Developer
+:link: developer
+:link-type: ref
+
+Information for developers.
+```
+````
+
+
+```{toctree}
+---
+numbered: true
+maxdepth: 1
+---
+
+introduction/introduction
+user/user
+developer/developer

docs/introduction/introduction.md

@@ -0,0 +1,18 @@
+(introduction)=
+# Introduction
+
+## Overview
+
+BEC Widgets is a GUI framework developed with beamline scientists in mind, aiming to provide a modern and modular environment for interacting with experiments. This package offers a suite of widgets specifically designed to enhance the workflow of beamline experiments, including features for running scans and data visualization.
+
+Targeting the unique needs of beamline scientists, BEC Widgets stands out with its modular approach to widget design and high customizability. This flexibility allows for tailored solutions that meet the specific requirements of each beamline.
+
+**Key Features**:
+
+- **Integration:** Seamlessly integrates with [BEC (Beamline Experiment Control)](https://gitlab.psi.ch/bec/bec), ensuring a cohesive and efficient experiment control experience.
+- **Support for PyQt5 and PyQt6:** Provides compatibility with both PyQt5 and PyQt6, offering versatility in your development environment.
+- **Widget Modularity:** Features modular widgets that can be easily combined to create customized applications, perfectly aligning with the diverse needs of beamline experiments.
+
+## Getting Started
+
+For detailed usage instructions and examples showcasing the practical applications of BEC Widgets, please refer to the [User](#user) section. Developers interested in contributing or customizing BEC Widgets can find more information in the [Developer](#developer) section.

docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/requirements.txt

@@ -0,0 +1,9 @@
+sphinx
+sphinx_copybutton
+recommonmark
+sphinx-toolbox
+pydata-sphinx-theme
+sphinx-copybutton
+myst-parser
+sphinx-design
+bec-widgets

docs/user/apps.md

@@ -0,0 +1,39 @@
+(user.apps)=
+# Applications
+
+In the `bec_widgets/examples` directory, you will find practical applications that demonstrate the capabilities of BEC Widgets in real-world scenarios. These applications showcase the adaptability and functionality of the framework for various beamline experiment needs.
+
+**Motor Alignment Tool**
+
+This tool assists in aligning motors with samples during experiments. It enables users to move motors, visually track their movement, and record positions for precise alignment.
+
+- **Location:** `bec_widgets/examples/motor_movement`
+- **Further Details:** [Motor Alignment Tool Documentation](#user.apps.motor_app) 
+
+**General Plotting Live Acquisition Tool**
+
+This application is designed for live data visualization. It allows users to view real-time signals from detectors in a multi-grid layout, facilitating immediate analysis during experiments.
+
+- **Location:** `bec_widgets/examples/plot_app`
+- **Further Details:** [General Plotting Live Acquisition Tool Documentation](#user.apps.plot_app) 
+
+
+**Modular Application**
+
+A bespoke application built entirely using BEC Widgets' modular components. This example illustrates the framework's flexibility in creating customized GUIs tailored to specific experimental setups.
+
+- **Location:** `bec_widgets/examples/modular_app`
+- **Further Details:** [Modular Application](#user.apps.modular_app) 
+
+---
+Note: The documentation for these applications is currently under development. The provided links will direct you to their respective pages once the documentation is complete.
+
+```{toctree}
+---
+maxdepth: 1
+hidden: true
+---
+
+apps/motor_app
+apps/plot_app
+apps/modular_app

docs/user/apps/modular_app.md

@@ -0,0 +1,6 @@
+(user.apps.modular_app)=
+
+# Modular Application
+
+
+_to be added..._

docs/user/apps/motor_app.md

@@ -0,0 +1,4 @@
+(user.apps.motor_app)=
+# Motor Alignment
+
+_to be added..._

docs/user/apps/plot_app.md

@@ -0,0 +1,6 @@
+(user.apps.plot_app)=
+
+# General Plotting Tool
+
+
+_to be added..._

docs/user/customisation.md

@@ -0,0 +1,13 @@
+(user.customisation)=
+# Customisation
+
+BEC Widgets are designed to be used with QtDesigner to quicly design GUI.
+
+
+## Example of promoting widgets in Qt Designer
+
+_Work in progress_
+
+## Implementation of plugins into Qt Designer
+
+_Work in progress_

docs/user/installation.md

@@ -0,0 +1,46 @@
+(user.installation)=
+# Installation
+
+
+**Prerequisites**
+
+Before installing BEC Widgets, please ensure the following requirements are met:
+
+1. **Python Version:** BEC Widgets requires Python version 3.9 or higher. Verify your Python version to ensure compatibility.
+2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).
+
+**Standard Installation**
+
+Install BEC Widgets using the pip package manager. Open your terminal and execute:
+
+```bash
+pip install bec-widgets
+```
+
+This command installs BEC Widgets along with its dependencies, including the default PyQt6.
+
+**Selecting a PyQt Version**
+
+BEC Widgets supports both PyQt5 and PyQt6. To install a specific version, use:
+
+For PyQt6:
+
+```bash
+pip install bec-widgets[pyqt6]
+```
+
+For PyQt5:
+
+```bash
+pip install bec-widgets[pyqt5]
+```
+
+**Troubleshooting**
+
+If you encounter issues during installation, particularly with PyQt, try purging the pip cache:
+
+```bash
+pip cache purge
+```
+
+This can resolve conflicts or issues with package installations.

docs/user/user.md

@@ -0,0 +1,38 @@
+(user)=
+# User
+
+**Overview**
+
+Welcome to the User section of the BEC Widgets documentation! BEC Widgets is a versatile GUI framework tailored for beamline scientists, enabling efficient and intuitive interaction with beamline experiments. This section is designed to guide both new and experienced users through the essential aspects of utilizing BEC Widgets.
+
+**Key Topics**
+
+- [Installing BEC Widgets](#user.installation): Instructions for installing BEC Widgets on your system.
+
+- [Example Applications](#user.apps): Overview of bespoke applications and demonstrations of BEC Widgets in action, showcasing its use in real-world beamline scenarios.
+
+- [Widgets Overview](#user.widgets): Detailed information on the variety of widgets available, their functions, and how to use them effectively.
+
+- [Customization and Configuration](#user.customisation): Tips on customizing and configuring BEC Widgets to suit your specific experimental needs using Qt Designer.
+
+**Bug Reports and Feature Requests**
+
+We value your feedback and contributions to improving BEC Widgets. If you encounter any issues or have ideas for new features, we encourage you to report them.
+
+- **Bug Reports:** If you find a bug or an issue, please report it on our repository's [Issues page](https://gitlab.psi.ch/bec/bec-widgets/-/issues?sort=created_date&state=opened). We have a template for bug reporting to help you provide all necessary information.
+- **Feature Requests:** Have an idea for a new feature or an enhancement? Share it with us on the [Issues page](https://gitlab.psi.ch/bec/bec-widgets/-/issues?sort=created_date&state=opened) of our repository. We have a feature request template that you can use to describe your proposal.
+
+**Development**
+
+For advanced details about BEC Widgets’ internal architecture, development contributions, or customization techniques, please explore the [Developer](#developer) section. 
+
+```{toctree}
+---
+maxdepth: 3
+hidden: true
+---
+
+installation
+apps
+widgets
+customisation

docs/user/widgets.md

@@ -0,0 +1,6 @@
+(user.widgets)=
+# Widgets
+
+Guide to use widgets.
+
+_work in progress_

setup.cfg

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

setup.py

@@ -1,10 +1,40 @@
+# pylint: disable= missing-module-docstring
 from setuptools import setup
 
-__version__ = "0.27.0"
+__version__ = "0.38.0"
+
+# Default to PyQt6 if no other Qt binding is installed
+QT_DEPENDENCY = "PyQt6>=6.0"
+QSCINTILLA_DEPENDENCY = "PyQt6-QScintilla"
+
+# pylint: disable=unused-import
+try:
+    import PyQt5
+except ImportError:
+    pass
+else:
+    QT_DEPENDENCY = "PyQt5>=5.9"
+    QSCINTILLA_DEPENDENCY = "QScintilla"
 
 if __name__ == "__main__":
     setup(
-        install_requires=["pyqt5", "pyqtgraph", "bec_lib", "zmq", "h5py"],
-        extras_require={"dev": ["pytest", "pytest-random-order", "coverage", "pytest-qt", "black"]},
+        install_requires=[
+            "pydantic",
+            "qtconsole",
+            QT_DEPENDENCY,
+            QSCINTILLA_DEPENDENCY,
+            "jedi",
+            "qtpy",
+            "pyqtgraph",
+            "bec_lib",
+            "zmq",
+            "h5py",
+            "pyqtdarktheme",
+        ],
+        extras_require={
+            "dev": ["pytest", "pytest-random-order", "coverage", "pytest-qt", "black"],
+            "pyqt5": ["PyQt5>=5.9"],
+            "pyqt6": ["PyQt6>=6.0"],
+        },
         version=__version__,
     )

tests/conftest.py

@@ -0,0 +1,35 @@
+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/test_basic_plot.py

@@ -1,152 +0,0 @@
-from unittest import mock
-
-import numpy as np
-from pytestqt import qtbot
-
-from bec_widgets import basic_plot
-
-
-def test_basic_plot_emits_no_signal(qtbot):
-    """Test LinePlot emits no signal when only one data entry is present."""
-
-    y_value_list = ["y1", "y2"]
-    plot = basic_plot.BasicPlot(y_value_list=y_value_list)
-    data = {
-        "data": {
-            "x": {"x": {"value": 1}},
-            "y1": {"y1": {"value": 1}},
-            "y2": {"y2": {"value": 3}},
-        }
-    }
-    metadata = {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]}
-    with mock.patch("bec_widgets.basic_plot.client") as mock_client:
-        with mock.patch.object(plot, "update_signal") as mock_update_signal:
-            plot.on_scan_segment(data=data, metadata=metadata)
-            mock_update_signal.emit.assert_not_called()
-
-
-def test_basic_plot_emits_signal(qtbot):
-    """Test LinePlot emits signal."""
-
-    y_value_list = ["y1", "y2"]
-    plot = basic_plot.BasicPlot(y_value_list=y_value_list)
-    data = {
-        "data": {
-            "x": {"x": {"value": 1}},
-            "y1": {"y1": {"value": 1}},
-            "y2": {"y2": {"value": 3}},
-        }
-    }
-    plotter_data_y = [[1, 1], [3, 3]]
-    metadata = {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]}
-    with mock.patch("bec_widgets.basic_plot.client") as mock_client:
-        # mock_client.device_manager.devices.keys.return_value = ["y1"]
-        with mock.patch.object(plot, "update_signal") as mock_update_signal:
-            mock_update_signal.emit()
-            plot.on_scan_segment(data=data, metadata=metadata)
-            plot.on_scan_segment(data=data, metadata=metadata)
-            mock_update_signal.emit.assert_called()
-            # TODO allow mock_client to create return values for device_manager_devices
-            # assert plot.plotter_data_y == plotter_data_y
-
-
-def test_basic_plot_raise_warning_wrong_signal_request(qtbot):
-    """Test LinePlot raises warning and skips signal when entry not present in data."""
-
-    y_value_list = ["y1", "y22"]
-    plot = basic_plot.BasicPlot(y_value_list=y_value_list)
-    data = {
-        "data": {
-            "x": {"x": {"value": [1, 2, 3, 4, 5]}},
-            "y1": {"y1": {"value": [1, 2, 3, 4, 5]}},
-            "y2": {"y2": {"value": [1, 2, 3, 4, 5]}},
-        }
-    }
-    metadata = {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]}
-    with mock.patch("bec_widgets.basic_plot.client") as mock_client:
-        # TODO fix mock_client
-        mock_dict = {"y1": [1, 2]}
-        mock_client.device_manager.devices.__contains__.side_effect = mock_dict.__contains__
-
-        # = {"y1": [1, 2]}
-        with mock.patch.object(plot, "update_signal") as mock_update_signal:
-            mock_update_signal.emit()
-            plot.on_scan_segment(data=data, metadata=metadata)
-            assert plot.y_value_list == ["y1"]
-
-
-# def test_basic_plot_update(qtbot):
-#     """Test LinePlot update."""
-
-#     y_value_list = ["y1", "y2"]
-#     plot = basic_plot.BasicPlot(y_value_list=y_value_list)
-#     plot.label_bottom = "x"
-#     plot.label_left = f"{', '.join(y_value_list)}"
-#     plot.plotter_data_x = [1, 2, 3, 4, 5]
-#     plot.plotter_data_y = [[1, 2, 3, 4, 5], [3, 4, 5, 6, 7]]
-#     plot.update()
-
-#     assert all(plot.curves[0].getData()[0] == np.array([1, 2, 3, 4, 5]))
-#     assert all(plot.curves[0].getData()[1] == np.array([1, 2, 3, 4, 5]))
-#     assert all(plot.curves[1].getData()[1] == np.array([3, 4, 5, 6, 7]))
-
-
-# # TODO Outputting the wrong data, e.g. motor is not in list of devices
-# def test_basic_plot_update(qtbot):
-#     """Test LinePlot update."""
-
-#     y_value_list = ["y1", "y2"]
-#     plot = basic_plot.BasicPlot(y_value_list=y_value_list)
-#     plot.label_bottom = "x"
-#     plot.label_left = f"{', '.join(y_value_list)}"
-#     plot.plotter_data_x = [1, 2, 3, 4, 5]
-#     plot.plotter_data_y = [[1, 2, 3, 4, 5], [3, 4, 5, 6, 7]]
-#     plot.update()
-
-#     assert all(plot.curves[0].getData()[0] == np.array([1, 2, 3, 4, 5]))
-#     assert all(plot.curves[0].getData()[1] == np.array([1, 2, 3, 4, 5]))
-#     assert all(plot.curves[1].getData()[1] == np.array([3, 4, 5, 6, 7]))
-
-
-# def test_basic_plot_mouse_moved(qtbot):
-#     """Test LinePlot mouse_moved."""
-
-#     y_value_list = ["y1", "y2"]
-#     plot = basic_plot.BasicPlot(y_value_list=y_value_list)
-#     plot.plotter_data_x = [1, 2, 3, 4, 5]
-#     plot.plotter_data_y = [[1, 2, 3, 4, 5], [3, 4, 5, 6, 7]]
-#     plot.precision = 3
-#     string_cap = 10
-#     x_data = f"{3:.{plot.precision}f}"
-#     y_data = f"{3:.{plot.precision}f}"
-#     output_string = "".join(
-#         [
-#             "Mouse cursor",
-#             "\n",
-#             f"{y_value_list[0]}",
-#             "\n",
-#             f"X_data:   {x_data:>{string_cap}}",
-#             "\n",
-#             f"Y_data: {y_data:>{string_cap}}",
-#         ]
-#     )
-#     x_data = f"{3:.{plot.precision}f}"
-#     y_data = f"{5:.{plot.precision}f}"
-#     output_string = "".join(
-#         [
-#             output_string,
-#             "\n",
-#             f"{y_value_list[1]}",
-#             "\n",
-#             f"X_data:   {x_data:>{string_cap}}",
-#             "\n",
-#             f"Y_data: {y_data:>{string_cap}}",
-#         ]
-#     )
-#     with mock.patch.object(
-#         plot, "plot"
-#     ) as mock_plot:  # TODO change test to simulate QTable instead of QLabel
-#         mock_plot.sceneBoundingRect.contains.return_value = True
-#         mock_plot.vb.mapSceneToView((20, 10)).x.return_value = 2.8
-#         plot.mouse_moved((20, 10))
-#         assert plot.mouse_box_data.text() == output_string

tests/test_bec_dispatcher.py

@@ -0,0 +1,241 @@
+# pylint: disable=missing-function-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={}).dumps())
+
+
+@pytest.fixture(name="consumer")
+def _consumer(bec_dispatcher):
+    bec_dispatcher.client.connector.consumer = Mock()
+    consumer = bec_dispatcher.client.connector.consumer
+    yield consumer
+
+
+@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.assert_called_once()
+    # trigger consumer callback as if a message was published
+    consumer.call_args.kwargs["cb"](msg)
+    slot1.assert_called_once()
+    consumer.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.assert_called_once()
+
+    consumer.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.assert_called_once()
+    bec_dispatcher.connect_slot(slot=slot2, topics="topic0")
+    consumer.assert_called_once()
+    # trigger consumer callback as if a message was published
+    consumer.call_args.kwargs["cb"](msg)
+    slot1.assert_called_once()
+    slot2.assert_called_once()
+    consumer.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.call_count == 1
+    bec_dispatcher.connect_slot(slot=slot1, topics="topic1")
+    assert consumer.call_count == 2
+    # trigger consumer callback as if a message was published
+    consumer.call_args_list[0].kwargs["cb"](msg)
+    slot1.assert_called_once()
+    consumer.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.call_args.kwargs["cb"](msg)
+    assert slot1.call_count == 1
+
+    # disconnect using a different slot
+    bec_dispatcher.disconnect_slot(slot=slot2, topics="topic0")
+    consumer.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 0 for slot
+    slot1.reset_mock()
+    consumer.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.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.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.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.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.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.call_args_list[0].kwargs["cb"](msg)
+    assert slot1.call_count == 1
+    consumer.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.call_args_list[0].kwargs["cb"](msg)
+    assert slot1.call_count == 3
+    consumer.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.call_args_list[0].kwargs["cb"](msg)
+    assert slot1.call_count == 4
+    # Calling topic1 should still call slot1
+    consumer.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.call_args_list[0].kwargs["cb"](msg)
+    consumer.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.call_args_list[0].kwargs["cb"](msg)
+    consumer.call_args_list[1].kwargs["cb"](msg)
+    consumer.call_args_list[2].kwargs["cb"](msg)
+
+    # Ensure that the slots have not been called
+    assert slot1.call_count == 0
+    assert slot2.call_count == 0
+    assert slot3.call_count == 0
+
+    # Also, check that the consumer for each topic is shutdown
+    assert "topic0" not in bec_dispatcher._connections
+    assert "topic1" not in bec_dispatcher._connections
+    assert "topic2" not in bec_dispatcher._connections
+
+
+def test_connect_one_slot_multiple_topics_single_callback(bec_dispatcher, consumer):
+    slot1 = Mock()
+
+    # Connect the slot to multiple topics using a single callback
+    topics = ["topic1", "topic2"]
+    bec_dispatcher.connect_slot(slot=slot1, topics=topics, single_callback_for_all_topics=True)
+
+    # Verify the initial state
+    assert len(bec_dispatcher._connections) == 1  # One connection for all topics
+    assert len(bec_dispatcher._connections[tuple(sorted(topics))].slots) == 1  # One slot connected
+
+    # Simulate messages being published on each topic
+    for topic in topics:
+        msg_with_topic = MessageObject(
+            topic=topic, value=ScanMessage(point_id=0, scanID=0, data={}).dumps()
+        )
+        consumer.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.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.call_args.kwargs["cb"](msg)
+    assert slot1.call_count == 0  # Slot has not been called

tests/test_bec_monitor.py

@@ -0,0 +1,288 @@
+import os
+import yaml
+
+import pytest
+from unittest.mock import MagicMock
+
+from bec_widgets.widgets import BECMonitor
+
+
+def load_test_config(config_name):
+    """Helper function to load config from yaml file."""
+    config_path = os.path.join(os.path.dirname(__file__), "test_configs", f"{config_name}.yaml")
+    with open(config_path, "r") as f:
+        config = yaml.safe_load(f)
+    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(qtbot, mocked_client):
+    # client = MagicMock()
+    widget = BECMonitor(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+@pytest.mark.parametrize(
+    "config_name, scan_type, number_of_plots",
+    [
+        ("config_device", False, 2),
+        ("config_device_no_entry", False, 2),
+        # ("config_scan", True, 4),
+    ],
+)
+def test_initialization_with_device_config(monitor, config_name, scan_type, number_of_plots):
+    config = load_test_config(config_name)
+    monitor.on_config_update(config)
+    assert isinstance(monitor, BECMonitor)
+    assert monitor.client is not None
+    assert len(monitor.plot_data) == number_of_plots
+    assert monitor.scan_types == scan_type
+
+
+@pytest.mark.parametrize(
+    "config_initial,config_update",
+    [("config_device", "config_scan"), ("config_scan", "config_device")],
+)
+def test_on_config_update(monitor, config_initial, config_update):
+    config_initial = load_test_config(config_initial)
+    config_update = load_test_config(config_update)
+    # validated config has to be compared
+    config_initial_validated = monitor.validator.validate_monitor_config(
+        config_initial
+    ).model_dump()
+    config_update_validated = monitor.validator.validate_monitor_config(config_update).model_dump()
+    monitor.on_config_update(config_initial)
+    assert monitor.config == config_initial_validated
+    monitor.on_config_update(config_update)
+    assert monitor.config == config_update_validated
+
+
+@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_scan",
+            3,
+            ["Grid plot 1", "Grid plot 2", "Grid plot 3", "Grid plot 4"],
+            [(0, 0), (0, 1), (0, 2), (1, 0)],
+        ),
+    ],
+)
+def test_render_initial_plots(
+    monitor, config_name, expected_num_columns, expected_plot_names, expected_coordinates
+):
+    config = load_test_config(config_name)
+    monitor.on_config_update(config)
+
+    # Validate number of columns
+    assert monitor.plot_settings["num_columns"] == expected_num_columns
+
+    # Validate the plots are created correctly
+    for expected_name in expected_plot_names:
+        assert expected_name in monitor.plots.keys()
+
+    # Validate the grid_coordinates
+    assert monitor.grid_coordinates == expected_coordinates
+
+
+def mock_getitem(dev_name):
+    """Helper function to mock the __getitem__ method of the 'dev'."""
+    mock_instance = MagicMock()
+    if dev_name == "samx":
+        mock_instance._hints = "samx"
+    elif dev_name == "bpm4i":
+        mock_instance._hints = "bpm4i"
+    elif dev_name == "gauss_bpm":
+        mock_instance._hints = "gauss_bpm"
+
+    return mock_instance
+
+
+def mock_get_scan_storage(scan_id, data):
+    """Helper function to mock the __getitem__ method of the 'dev'."""
+    mock_instance = MagicMock()
+    mock_instance.get_scan_storage.return_value = data
+    return mock_instance
+
+
+# mocked messages and metadata
+msg_1 = {
+    "data": {
+        "samx": {"samx": {"value": 10}},
+        "bpm4i": {"bpm4i": {"value": 5}},
+        "gauss_bpm": {"gauss_bpm": {"value": 6}},
+        "gauss_adc1": {"gauss_adc1": {"value": 8}},
+        "gauss_adc2": {"gauss_adc2": {"value": 9}},
+    },
+    "scanID": 1,
+}
+metadata_grid = {"scan_name": "grid_scan"}
+metadata_line = {"scan_name": "line_scan"}
+
+
+@pytest.mark.parametrize(
+    "config_name, msg, metadata, expected_data",
+    [
+        # case: msg does not have 'scanID'
+        (
+            "config_device",
+            {"data": {}},
+            {},
+            {
+                "scan_segment": {
+                    "bpm4i": {"bpm4i": []},
+                    "gauss_adc1": {"gauss_adc1": []},
+                    "gauss_adc2": {"gauss_adc2": []},
+                    "samx": {"samx": []},
+                }
+            },
+        ),
+        # case: scan_types is false, msg contains all valid fields, and entry is present in config
+        (
+            "config_device",
+            msg_1,
+            {},
+            {
+                "scan_segment": {
+                    "bpm4i": {"bpm4i": [5]},
+                    "gauss_adc1": {"gauss_adc1": [8]},
+                    "gauss_adc2": {"gauss_adc2": [9]},
+                    "samx": {"samx": [10]},
+                }
+            },
+        ),
+        # case: scan_types is false, msg contains all valid fields and entry is missing in config, should use hints
+        (
+            "config_device_no_entry",
+            msg_1,
+            {},
+            {
+                "scan_segment": {
+                    "bpm4i": {"bpm4i": [5]},
+                    "gauss_bpm": {"gauss_bpm": [6]},
+                    "samx": {"samx": [10]},
+                }
+            },
+        ),
+        # case: scan_types is true, msg contains all valid fields, metadata contains scan "line_scan:"
+        (
+            "config_scan",
+            msg_1,
+            metadata_line,
+            {
+                "scan_segment": {
+                    "bpm4i": {"bpm4i": [5]},
+                    "gauss_adc1": {"gauss_adc1": [8]},
+                    "gauss_adc2": {"gauss_adc2": [9]},
+                    "gauss_bpm": {"gauss_bpm": [6]},
+                    "samx": {"samx": [10]},
+                }
+            },
+        ),
+        (
+            "config_scan",
+            msg_1,
+            metadata_grid,
+            {
+                "scan_segment": {
+                    "bpm4i": {"bpm4i": [5]},
+                    "gauss_adc1": {"gauss_adc1": [8]},
+                    "gauss_adc2": {"gauss_adc2": [9]},
+                    "gauss_bpm": {"gauss_bpm": [6]},
+                    "samx": {"samx": [10]},
+                }
+            },
+        ),
+    ],
+)
+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 = {
+        device_name: {
+            entry: MagicMock(val=[msg["data"][device_name][entry]["value"]])
+            for entry in msg["data"][device_name]
+        }
+        for device_name in msg["data"]
+    }
+    monitor.queue.scan_storage.find_scan_by_ID.return_value = mock_scan_data
+
+    monitor.on_scan_segment(msg, metadata)
+    assert monitor.database == expected_data

tests/test_bec_monitor_scatter2D.py

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

tests/test_config_dialog.py

@@ -0,0 +1,177 @@
+import os
+import yaml
+
+import pytest
+from qtpy.QtWidgets import QTabWidget, QTableWidgetItem
+
+from bec_widgets.widgets import ConfigDialog
+
+
+def load_test_config(config_name):
+    """Helper function to load config from yaml file."""
+    config_path = os.path.join(os.path.dirname(__file__), "test_configs", f"{config_name}.yaml")
+    with open(config_path, "r") as f:
+        config = yaml.safe_load(f)
+    return config
+
+
+@pytest.fixture(scope="function")
+def config_dialog(qtbot):
+    widget = ConfigDialog()
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+@pytest.mark.parametrize("config_name", ["config_device", "config_scan"])
+def test_load_config(config_dialog, config_name):
+    config = load_test_config(config_name)
+    config_dialog.load_config(config)
+
+    assert (
+        config_dialog.comboBox_appearance.currentText()
+        == config["plot_settings"]["background_color"]
+    )
+    assert config_dialog.spinBox_n_column.value() == config["plot_settings"]["num_columns"]
+    assert config_dialog.comboBox_colormap.currentText() == config["plot_settings"]["colormap"]
+
+
+@pytest.mark.parametrize(
+    "config_name, scan_mode",
+    [
+        ("config_device", False),
+        ("config_scan", True),
+        ("config_device_no_entry", False),
+    ],
+)
+def test_initialization(config_dialog, config_name, scan_mode):
+    config = load_test_config(config_name)
+    config_dialog.load_config(config)
+
+    assert isinstance(config_dialog, ConfigDialog)
+    assert (
+        config_dialog.comboBox_appearance.currentText()
+        == config["plot_settings"]["background_color"]
+    )
+    assert config_dialog.spinBox_n_column.value() == config["plot_settings"]["num_columns"]
+    assert (config_dialog.comboBox_scanTypes.currentText() == "Enabled") == scan_mode
+    assert (
+        config_dialog.tabWidget_scan_types.count() > 0
+    )  # Ensures there's at least one tab created
+
+    # If there's a need to check the contents of the first tab (there has to be always at least one tab)
+    first_tab = config_dialog.tabWidget_scan_types.widget(0)
+    if scan_mode:
+        assert (
+            first_tab.findChild(QTabWidget, "tabWidget_plots") is not None
+        )  # Ensures plot tab widget exists in scan mode
+    else:
+        assert (
+            first_tab.findChild(QTabWidget) is not None
+        )  # Ensures plot tab widget exists in default mode
+
+
+def test_edit_and_apply_config(config_dialog):
+    config_device = load_test_config("config_device")
+    config_dialog.load_config(config_device)
+
+    config_dialog.comboBox_appearance.setCurrentText("white")
+    config_dialog.spinBox_n_column.setValue(2)
+    config_dialog.comboBox_colormap.setCurrentText("viridis")
+
+    applied_config = config_dialog.apply_config()
+
+    assert applied_config["plot_settings"]["background_color"] == "white"
+    assert applied_config["plot_settings"]["num_columns"] == 2
+    assert applied_config["plot_settings"]["colormap"] == "viridis"
+
+
+def test_edit_and_apply_config_scan_mode(config_dialog):
+    config_scan = load_test_config("config_scan")
+    config_dialog.load_config(config_scan)
+
+    config_dialog.comboBox_appearance.setCurrentText("white")
+    config_dialog.spinBox_n_column.setValue(2)
+    config_dialog.comboBox_colormap.setCurrentText("viridis")
+    config_dialog.comboBox_scanTypes.setCurrentText("Enabled")
+
+    applied_config = config_dialog.apply_config()
+
+    assert applied_config["plot_settings"]["background_color"] == "white"
+    assert applied_config["plot_settings"]["num_columns"] == 2
+    assert applied_config["plot_settings"]["colormap"] == "viridis"
+    assert applied_config["plot_settings"]["scan_types"] is True
+
+
+def test_add_new_scan(config_dialog):
+    # Ensure the tab count is initially 1 (from the default config)
+    assert config_dialog.tabWidget_scan_types.count() == 1
+
+    # Add a new scan tab
+    config_dialog.add_new_scan_tab(config_dialog.tabWidget_scan_types, "Test Scan Tab")
+
+    # Ensure the tab count is now 2
+    assert config_dialog.tabWidget_scan_types.count() == 2
+
+    # Ensure the new tab has the correct name
+    assert config_dialog.tabWidget_scan_types.tabText(1) == "Test Scan Tab"
+
+
+def test_add_new_plot_and_modify(config_dialog):
+    # Ensure the tab count is initially 1 and it is called "Default"
+    assert config_dialog.tabWidget_scan_types.count() == 1
+    assert config_dialog.tabWidget_scan_types.tabText(0) == "Default"
+
+    # Get the first tab (which should be a scan tab)
+    scan_tab = config_dialog.tabWidget_scan_types.widget(0)
+
+    # Ensure the plot tab count is initially 1 and it is called "Plot 1"
+    tabWidget_plots = scan_tab.findChild(QTabWidget)
+    assert tabWidget_plots.count() == 1
+    assert tabWidget_plots.tabText(0) == "Plot 1"
+
+    # Add a new plot tab
+    config_dialog.add_new_plot_tab(scan_tab)
+
+    # Ensure the plot tab count is now 2
+    assert tabWidget_plots.count() == 2
+
+    # Ensure the new tab has the correct name
+    assert tabWidget_plots.tabText(1) == "Plot 2"
+
+    # Access the new plot tab
+    new_plot_tab = tabWidget_plots.widget(1)
+
+    # Modify the line edits within the new plot tab
+    new_plot_tab.ui.lineEdit_plot_title.setText("Modified Plot Title")
+    new_plot_tab.ui.lineEdit_x_label.setText("Modified X Label")
+    new_plot_tab.ui.lineEdit_y_label.setText("Modified Y Label")
+    new_plot_tab.ui.lineEdit_x_name.setText("Modified X Name")
+    new_plot_tab.ui.lineEdit_x_entry.setText("Modified X Entry")
+
+    # Modify the table for signals
+    config_dialog.add_new_signal(new_plot_tab.ui.tableWidget_y_signals)
+
+    table = new_plot_tab.ui.tableWidget_y_signals
+    assert table.rowCount() == 1  # Ensure the new row is added
+
+    row_position = table.rowCount() - 1
+
+    # Modify the first row
+    table.setItem(row_position, 0, QTableWidgetItem("New Signal Name"))
+    table.setItem(row_position, 1, QTableWidgetItem("New Signal Entry"))
+
+    # Apply the configuration
+    config = config_dialog.apply_config()
+
+    # Check if the modifications are reflected in the configuration
+    modified_plot_config = config["plot_data"][1]  # Access the second plot in the plot_data list
+    sources = modified_plot_config["sources"][0]  # Access the first source in the sources list
+
+    assert modified_plot_config["plot_name"] == "Modified Plot Title"
+    assert modified_plot_config["x_label"] == "Modified X Label"
+    assert modified_plot_config["y_label"] == "Modified Y Label"
+    assert sources["signals"]["x"][0]["name"] == "Modified X Name"
+    assert sources["signals"]["x"][0]["entry"] == "Modified X Entry"
+    assert sources["signals"]["y"][0]["name"] == "New Signal Name"
+    assert sources["signals"]["y"][0]["entry"] == "New Signal Entry"

tests/test_config_plotter.py

@@ -1,45 +0,0 @@
-import pyqtgraph as pg
-from pytestqt import qtbot
-
-from bec_widgets import config_plotter
-
-
-def test_config_plotter(qtbot):
-    """Test ConfigPlotter"""
-
-    config = [
-        {
-            "cols": 1,
-            "rows": 1,
-            "y": 0,
-            "x": 0,
-            "config": {"channels": ["a"], "label_xy": ["", "a"], "item": "PlotItem"},
-        }
-    ]
-    plotter = config_plotter.ConfigPlotter(config)
-
-    assert isinstance(plotter.plots["a"]["item"], pg.PlotItem)
-
-
-def test_config_plotter_image(qtbot):
-    """Test ConfigPlotter"""
-
-    config = [
-        {
-            "cols": 1,
-            "rows": 1,
-            "y": 0,
-            "x": 0,
-            "config": {"channels": ["a"], "label_xy": ["", "a"], "item": "PlotItem"},
-        },
-        {
-            "cols": 1,
-            "rows": 1,
-            "y": 1,
-            "x": 0,
-            "config": {"channels": ["b"], "label_xy": ["", "b"], "item": "ImageItem"},
-        },
-    ]
-    plotter = config_plotter.ConfigPlotter(config)
-
-    assert isinstance(plotter.plots["a"]["item"], pg.PlotItem)