fix(test): add a temporary test

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,289 @@
 
 <!--next-version-placeholder-->
 
+## v0.41.1 (2024-02-26)
+
+### Fix
+
+* **bec_dispatcher:** Handle redis connection errors more gracefully ([`a2ed2eb`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a2ed2ebe00c623eb183b03f8182ffd672fbf9e1e))
+* **bec_dispatcher:** Adapt code to redis connector refactoring ([`8127fc2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/8127fc2960bebd3e862dbe55ac9401af4a6dccb6))
+
+## v0.41.0 (2024-02-26)
+
+### Feature
+
+* **widgets/waveform1d:** Data can be exported from rendered curve ([`5fc8047`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5fc8047c8ff971cdc2807d02743eae56d288f4d7))
+* **widgets/figure:** Clear_all method for BECFigure ([`0363fd5`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0363fd5194320a7ea868ef883f8022ea464d0298))
+* **widgets/Waveform1D:** Waveform1D can be fully constructed by config ([`9a5c86e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9a5c86ea35178b9cab270fc35e668dd22f3ec8da))
+* **widgets/figure.py:** Dark/light theme changer ([`08534a4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/08534a4739ec8e85d82a00ab639411dd0198e9d8))
+* **utils/entry_validator:** Possibility to validate add_scan_curve with current BEC session ([`1db77b9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1db77b969bcf9b38716ae3d38bf4695b2b8c1f37))
+* **cli:** Added cli interface, rebased ([`a61bf36`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a61bf36df5d54ad44f78479c2474c4e38e68ed26))
+* Curve can be modified after adding to the plot ([`684592a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/684592ae37e9dd5328a96018c78ca242e10395b2))
+* Waveform1d.py curves can be removed by identifier by order(int) or by curve_id(str) ([`f0ed243`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f0ed243c9197b7d1aab0d99a15e9ba175708ec90))
+* Waveform1d.py curves can be stylised; access scan history by index or scanID ([`cba3863`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cba3863e5a9ac1187ea643be67db6cfc36b44ee2))
+* Start method for BECFigure, jupyter console .ui added to git ([`1d26b23`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1d26b2322147d9ea5a6a245e1648c00986f80881))
+* Added @user_access from bec_lib.utils ([`b827e9e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b827e9eaa77f8b64433bb7a54e40ab5ccd86f4b6))
+* Plot can be removed from BECFigure ([`60d150a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/60d150a41193aa7659285cf3612965f1a3c57244))
+* Figure.py create widget factory ([`c781b1b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c781b1b4e4121c4ec6fc8871a4cdf6f494913138))
+* Waveform1d.py draft ([`565e475`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/565e475ace72ccc103d71ea98af1dcaf04f37861))
+* Rpc decorator to add methods to USER_ACCESS ([`b676877`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b6768772424a3ad5ee7e271de19131f8065eef09))
+* BECFigure and BECPlotBase created ([`9ef331c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9ef331c272b88f725de9b8497fdf906056c0738b))
+* BECConnector -> mixin class for all BEC Widget to hook them to BEC client ([`91447a2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/91447a2d6234de1e8f2bac792e822bfda556abba))
+
+### Fix
+
+* **cli/client_utils:** "__rpc__" pop from msg_results ([`ebb36f6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ebb36f62ddc1c5013435f9e7727648b977b6b732))
+* **tests:** BECDispatcher fixture putted back ([`644f103`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/644f1031f6ff27064111565b0882cb8b2544aa2f))
+* **cli/rpc:** Rpc client can return any type of object + config dict of the widgets ([`fd711b4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fd711b475f268fbdb59739da0a428f0355b25bac))
+* **cli/rpc:** Server access children widget.find_widget_by_id(gui_id) ([`57132a4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/57132a472165c55bf99e1994d09f5fe3586c24da))
+* **cli:** Fixed property access, rebased ([`f71dc5c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f71dc5c5abdd6b8b585cb9b502b11ef513d7813e))
+* **rpc_server:** Fixed gui_id lookup ([`4630d78`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4630d78fc28109da7daf53e49dd3cdb9b8084941))
+* **cli:** Fixed rpc construction of nested widgets ([`da640e8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/da640e888d575b536fdd5d7adbf1df3eda802219))
+* **plots/waveform1d:** Pandas import clean up, export curves with none skipped ([`35cd4fd`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/35cd4fd6f176ba670fad5d9fec44b305094280d6))
+* **widgets/plots:** Added placeholder for cleanup method to BECPlotBase ([`24c7737`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/24c77376b232c3846a1d6be360ec46acc077b48d))
+* **widget/figure:** Add cleanup method to disconnect all slots before removing Waveform1D from layout ([`a28b9c8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a28b9c8981d1058e4dc4146463f16c53413e8db9))
+* **rpc:** Added annotations to pass py3.9 tests ([`c6bdf0b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c6bdf0b6a5b12c054863b101a3944efc366686cb))
+* **rpc:** Connection to on_rpc_update done through bec_dispatcher ([`1c2fb8b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1c2fb8b972d4cb28cead11989461aea010c4571d))
+* After removing plot from BECFigure, the coordinates are correctly resigned ([`d678a85`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d678a85957c13c1fda2b52692c0d3b9b7ff40834))
+* Removed DI references, fixed set when adding plot by fig ([`7c15d75`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/7c15d750117aec9e75111853074630a44dca87ae))
+
+## v0.40.1 (2024-02-23)
+
+### Fix
+
+* **utils/bec_dispatcher:** _do_disconnect_slot will shutdown consumer of slots/signals which were already disconnected ([`feca7a3`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/feca7a3dcde6d0befa415db64fc8f9bbf0c06e52))
+
+## v0.40.0 (2024-02-16)
+
+### Feature
+
+* **utils.colors:** Golden_angle_color utility can return colors as a  list of QColor, RGB or HEC ([`5125909`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/51259097fa23ff861eac3f7c63624ea591bf1bd3))
+
+## v0.39.0 (2024-02-12)
+
+### Feature
+
+* Added full app with all motor movement related widgets into motor_control_compilations.py ([`fa4ca93`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fa4ca935bb39fdba4c6500ce9569d47400190e65))
+* MotorCoordinateTable mode_switch added for "Individual" and "Start/Stop" modes ([`2f96e10`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/2f96e10b9deb76eedd8f6b6e201ba3b0e526a6f0))
+* Motor_control.py MotorCoordinateTable added basic version to store coordinates and show them in motor_map.py ([`031cb09`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/031cb094e7f8a7be4a295bea99b7ca8e095db8d7))
+* Active motors from motor_map.py can be changed by slot without changing the whole config ([`17f1458`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/17f14581d7c4662a2f5814ea477dfae8ef6de555))
+* Control panels compilations ([`8361736`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/83617366796ce2926650e38a1a9cec296befd3c6))
+* Comboboxes of motor selection are changed to orange if the motors are not connected yet ([`0b9927f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0b9927fcf5f46410d05187b2e5a83f97a6ca9246))
+* Motor_control.py MotorControl widgets - Absolute + Relative movement, MotorSelection, ErrorMessage popups ([`6fe08e6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/6fe08e6b8206bcaaa292b7ff0e6b0d32b883f24f))
+
+## v0.38.2 (2024-02-07)
+
+### Fix
+
+* Adapt code to BEC 1.0 ([`b36131e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b36131eed5c3a3ea58c0fa4d083e63a3717cdf22))
+
+## v0.38.1 (2024-01-26)
+
+### Fix
+
+* Monitor.py replots last scan after changing config with new signals; config_dialog.py checks if the new config is valid with BEC ([`ab275b8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ab275b8e5f226d6c5d22a844c4c0fae0fdc66108))
+
+### Documentation
+
+* 2D waveform scatter plot changed to 2D scatter plot ([`812ffaf`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/812ffaf8eafc3f8c3a6973717149e4befba2c395))
+* Documentation for example apps and widgets updated ([`f7a4967`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f7a496723c3fd113867a712928e06636e3212e1a))
+
+## 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

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/bec_dispatcher.py

@@ -1,100 +0,0 @@
-import argparse
-import itertools
-import os
-from typing import Callable
-
-from bec_lib import BECClient
-from bec_lib.core import BECMessage, ServiceConfig
-from bec_lib.core.redis_connector import RedisConsumerThreaded
-from PyQt5.QtCore import QObject, pyqtSignal
-
-# 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()
-)
-
-
-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):
-    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, topic: str) -> None:
-        """Connect widget's pyqt slot, so that it is called on new pub/sub topic message
-
-        Args:
-            slot (Callable): A slot method/function that accepts two inputs: content and metadata of
-                the corresponding pub/sub message
-            topic (str): A topic that can typically be acquired via bec_lib.core.MessageEndpoints
-        """
-        # 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)
-                # TODO: this can could be replaced with a simple
-                # self._connections[topic].signal.emit(msg.content, msg.metadata)
-                # once all dispatcher.connect_slot calls are made with a single topic only
-                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: Callable, topic: str) -> None:
-        """Disconnect widget's pyqt slot from pub/sub updates on a topic.
-
-        Args:
-            slot (Callable): A slot to be disconnected
-            topic (str): A corresponding topic that can typically be acquired via
-                bec_lib.core.MessageEndpoints
-        """
-        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]
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--bec-config", default=None)
-args, _ = parser.parse_known_args()
-
-bec_dispatcher = _BECDispatcher(args.bec_config)

bec_widgets/cli/client.py

@@ -0,0 +1,386 @@
+# This file was automatically generated by generate_cli.py
+
+from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
+from typing import Literal, Optional, overload
+
+
+class BECPlotBase(RPCBase):
+    @rpc_call
+    def set(self, **kwargs) -> "None":
+        """
+        Set the properties of the plot widget.
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - title: str
+            - x_label: str
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+        """
+
+    @rpc_call
+    def set_title(self, title: "str"):
+        """
+        Set the title of the plot widget.
+        Args:
+            title(str): Title of the plot widget.
+        """
+
+    @rpc_call
+    def set_x_label(self, label: "str"):
+        """
+        Set the label of the x-axis.
+        Args:
+            label(str): Label of the x-axis.
+        """
+
+    @rpc_call
+    def set_y_label(self, label: "str"):
+        """
+        Set the label of the y-axis.
+        Args:
+            label(str): Label of the y-axis.
+        """
+
+    @rpc_call
+    def set_x_scale(self, scale: "Literal['linear', 'log']" = "linear"):
+        """
+        Set the scale of the x-axis.
+        Args:
+            scale(Literal["linear", "log"]): Scale of the x-axis.
+        """
+
+    @rpc_call
+    def set_y_scale(self, scale: "Literal['linear', 'log']" = "linear"):
+        """
+        Set the scale of the y-axis.
+        Args:
+            scale(Literal["linear", "log"]): Scale of the y-axis.
+        """
+
+    @rpc_call
+    def set_x_lim(self, *args) -> "None":
+        """
+        Set the limits of the x-axis. This method can accept either two separate arguments
+        for the minimum and maximum x-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_x_lim(x_min, x_max)
+            set_x_lim((x_min, x_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (x_min and x_max)
+                   or a single tuple with two integers.
+        """
+
+    @rpc_call
+    def set_y_lim(self, *args) -> "None":
+        """
+        Set the limits of the y-axis. This method can accept either two separate arguments
+        for the minimum and maximum y-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_y_lim(y_min, y_max)
+            set_y_lim((y_min, y_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (y_min and y_max)
+                   or a single tuple with two integers.
+        """
+
+    @rpc_call
+    def set_grid(self, x: "bool" = False, y: "bool" = False):
+        """
+        Set the grid of the plot widget.
+        Args:
+            x(bool): Show grid on the x-axis.
+            y(bool): Show grid on the y-axis.
+        """
+
+    @rpc_call
+    def plot_data(self, data_x: "list | np.ndarray", data_y: "list | np.ndarray", **kwargs):
+        """
+        Plot custom data on the plot widget. These data are not saved in config.
+        Args:
+            data_x(list|np.ndarray): x-axis data
+            data_y(list|np.ndarray): y-axis data
+            **kwargs: Keyword arguments for the plot.
+        """
+
+    @rpc_call
+    def remove(self):
+        """
+        Remove the plot widget from the figure.
+        """
+
+
+class BECWaveform1D(RPCBase):
+    @rpc_call
+    def add_curve_scan(
+        self,
+        x_name: "str",
+        y_name: "str",
+        x_entry: "Optional[str]" = None,
+        y_entry: "Optional[str]" = None,
+        color: "Optional[str]" = None,
+        label: "Optional[str]" = None,
+        validate_bec: "bool" = True,
+        **kwargs
+    ) -> "BECCurve":
+        """
+        Add a curve to the plot widget from the scan segment.
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            label(str, optional): Label of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+    @rpc_call
+    def add_curve_custom(
+        self,
+        x: "list | np.ndarray",
+        y: "list | np.ndarray",
+        label: "str" = None,
+        color: "str" = None,
+        **kwargs
+    ) -> "BECCurve":
+        """
+        Add a custom data curve to the plot widget.
+        Args:
+            x(list|np.ndarray): X data of the curve.
+            y(list|np.ndarray): Y data of the curve.
+            label(str, optional): Label of the curve. Defaults to None.
+            color(str, optional): Color of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+    @rpc_call
+    def remove_curve(self, *identifiers):
+        """
+        Remove a curve from the plot widget.
+        Args:
+            *identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
+        """
+
+    @rpc_call
+    def scan_history(self, scan_index: "int" = None, scanID: "str" = None):
+        """
+        Update the scan curves with the data from the scan storage.
+        Provide only one of scanID or scan_index.
+        Args:
+            scanID(str, optional): ScanID of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+        """
+
+    @property
+    @rpc_call
+    def curves(self) -> "list[BECCurve]":
+        """
+        Get the curves of the plot widget as a list
+        Returns:
+            list: List of curves.
+        """
+
+    @property
+    @rpc_call
+    def curves_data(self) -> "dict":
+        """
+        Get the curves data of the plot widget as a dictionary
+        Returns:
+            dict: Dictionary of curves data.
+        """
+
+    @rpc_call
+    def get_curve(self, identifier) -> "BECCurve":
+        """
+        Get the curve by its index or ID.
+        Args:
+            identifier(int|str): Identifier of the curve. Can be either an integer (index) or a string (curve_id).
+        Returns:
+            BECCurve: The curve object.
+        """
+
+    @rpc_call
+    def get_curve_config(self, curve_id: "str", dict_output: "bool" = True) -> "CurveConfig | dict":
+        """
+        Get the configuration of a curve by its ID.
+        Args:
+            curve_id(str): ID of the curve.
+        Returns:
+            CurveConfig|dict: Configuration of the curve.
+        """
+
+    @rpc_call
+    def apply_config(self, config: "dict | WidgetConfig", replot_last_scan: "bool" = False):
+        """
+        Apply the configuration to the 1D waveform widget.
+        Args:
+            config(dict|WidgetConfig): Configuration settings.
+            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
+        """
+
+    @rpc_call
+    def get_all_data(self, output: "Literal['dict', 'pandas']" = "dict") -> "dict | pd.DataFrame":
+        """
+        Extract all curve data into a dictionary or a pandas DataFrame.
+        Args:
+            output (Literal["dict", "pandas"]): Format of the output data.
+        Returns:
+            dict | pd.DataFrame: Data of all curves in the specified format.
+        """
+
+
+class BECFigure(RPCBase, BECFigureClientMixin):
+    @rpc_call
+    def add_plot(
+        self,
+        widget_id: "str" = None,
+        row: "int" = None,
+        col: "int" = None,
+        config=None,
+        **axis_kwargs
+    ) -> "BECWaveform1D":
+        """
+        Add a Waveform1D plot to the figure at the specified position.
+        Args:
+            widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Additional configuration for the widget.
+            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
+        """
+
+    @rpc_call
+    def remove(
+        self,
+        row: "int" = None,
+        col: "int" = None,
+        widget_id: "str" = None,
+        coordinates: "tuple[int, int]" = None,
+    ) -> "None":
+        """
+        Remove a widget from the figure. Can be removed by its unique identifier or by its coordinates.
+        Args:
+            row(int): The row coordinate of the widget to remove.
+            col(int): The column coordinate of the widget to remove.
+            widget_id(str): The unique identifier of the widget to remove.
+            coordinates(tuple[int, int], optional): The coordinates of the widget to remove.
+        """
+
+    @rpc_call
+    def change_layout(self, max_columns=None, max_rows=None):
+        """
+        Reshuffle the layout of the figure to adjust to a new number of max_columns or max_rows.
+        If both max_columns and max_rows are provided, max_rows is ignored.
+
+        Args:
+            max_columns (Optional[int]): The new maximum number of columns in the figure.
+            max_rows (Optional[int]): The new maximum number of rows in the figure.
+        """
+
+    @rpc_call
+    def change_theme(self, theme: "Literal['dark', 'light']") -> "None":
+        """
+        Change the theme of the figure widget.
+        Args:
+            theme(Literal["dark","light"]): The theme to set for the figure widget.
+        """
+
+    @rpc_call
+    def clear_all(self):
+        """
+        Clear all widgets from the figure and reset to default state
+        """
+
+
+class BECCurve(RPCBase):
+    @rpc_call
+    def set(self, **kwargs):
+        """
+        Set the properties of the curve.
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - color: str
+            - symbol: str
+            - symbol_color: str
+            - symbol_size: int
+            - pen_width: int
+            - pen_style: Literal["solid", "dash", "dot", "dashdot"]
+        """
+
+    @rpc_call
+    def set_data(self, x, y):
+        """
+        None
+        """
+
+    @rpc_call
+    def set_color(self, color: "str", symbol_color: "Optional[str]" = None):
+        """
+        Change the color of the curve.
+        Args:
+            color(str): Color of the curve.
+            symbol_color(str, optional): Color of the symbol. Defaults to None.
+        """
+
+    @rpc_call
+    def set_symbol(self, symbol: "str"):
+        """
+        Change the symbol of the curve.
+        Args:
+            symbol(str): Symbol of the curve.
+        """
+
+    @rpc_call
+    def set_symbol_color(self, symbol_color: "str"):
+        """
+        Change the symbol color of the curve.
+        Args:
+            symbol_color(str): Color of the symbol.
+        """
+
+    @rpc_call
+    def set_symbol_size(self, symbol_size: "int"):
+        """
+        Change the symbol size of the curve.
+        Args:
+            symbol_size(int): Size of the symbol.
+        """
+
+    @rpc_call
+    def set_pen_width(self, pen_width: "int"):
+        """
+        Change the pen width of the curve.
+        Args:
+            pen_width(int): Width of the pen.
+        """
+
+    @rpc_call
+    def set_pen_style(self, pen_style: "Literal['solid', 'dash', 'dot', 'dashdot']"):
+        """
+        Change the pen style of the curve.
+        Args:
+            pen_style(Literal["solid", "dash", "dot", "dashdot"]): Style of the pen.
+        """
+
+    @rpc_call
+    def get_data(self) -> "tuple[np.ndarray, np.ndarray]":
+        """
+        Get the data of the curve.
+        Returns:
+            tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
+        """

bec_widgets/cli/client_utils.py

@@ -0,0 +1,175 @@
+import importlib
+import select
+import subprocess
+import uuid
+
+from functools import wraps
+
+from qtpy.QtCore import QCoreApplication
+
+import bec_widgets.cli.client as client
+from bec_lib import MessageEndpoints, messages
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+
+def rpc_call(func):
+    """
+    A decorator for calling a function on the server.
+
+    Args:
+        func: The function to call.
+
+    Returns:
+        The result of the function call.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        return self._run_rpc(func.__name__, *args, **kwargs)
+
+    return wrapper
+
+
+class BECFigureClientMixin:
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._process = None
+
+    def show(self) -> None:
+        """
+        Show the figure.
+        """
+        if self._process is None or self._process.poll() is not None:
+            self._start_plot_process()
+
+    def close(self) -> None:
+        """
+        Close the figure.
+        """
+        if self._process is None:
+            return
+        self._run_rpc("close", (), wait_for_rpc_response=False)
+        self._process.kill()
+        self._process = None
+
+    def _start_plot_process(self) -> None:
+        """
+        Start the plot in a new process.
+        """
+        # pylint: disable=subprocess-run-check
+        monitor_module = importlib.import_module("bec_widgets.cli.server")
+        monitor_path = monitor_module.__file__
+
+        command = f"python {monitor_path} --id {self._gui_id}"
+        self._process = subprocess.Popen(
+            command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+
+    def print_log(self) -> None:
+        """
+        Print the log of the plot process.
+        """
+        if self._process is None:
+            return
+        print(self._get_stderr_output())
+
+    def _get_stderr_output(self) -> str:
+        stderr_output = []
+        while self._process.poll() is not None:
+            readylist, _, _ = select.select([self._process.stderr], [], [], 0.1)
+            if not readylist:
+                break
+            line = self._process.stderr.readline()
+            if not line:
+                break
+            stderr_output.append(line.decode("utf-8"))
+        return "".join(stderr_output)
+
+    def __del__(self) -> None:
+        self.close()
+
+
+class RPCBase:
+    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
+        self._client = BECDispatcher().client
+        self._config = config if config is not None else {}
+        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())
+        self._parent = parent
+        super().__init__()
+        print(f"RPCBase: {self._gui_id}")
+
+    @property
+    def _root(self):
+        """
+        Get the root widget. This is the BECFigure widget that holds
+        the anchor gui_id.
+        """
+        parent = self
+        # pylint: disable=protected-access
+        while parent._parent is not None:
+            parent = parent._parent
+        return parent
+
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, **kwargs):
+        """
+        Run the RPC call.
+
+        Args:
+            method: The method to call.
+            args: The arguments to pass to the method.
+            wait_for_rpc_response: Whether to wait for the RPC response.
+            kwargs: The keyword arguments to pass to the method.
+
+        Returns:
+            The result of the RPC call.
+        """
+        request_id = str(uuid.uuid4())
+        rpc_msg = messages.GUIInstructionMessage(
+            action=method,
+            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
+            metadata={"request_id": request_id},
+        )
+        print(f"RPCBase: {rpc_msg}")
+        # pylint: disable=protected-access
+        receiver = self._root._gui_id
+        self._client.connector.send(MessageEndpoints.gui_instructions(receiver), rpc_msg)
+
+        if not wait_for_rpc_response:
+            return None
+        response = self._wait_for_response(request_id)
+        # get class name
+        if not response.content["accepted"]:
+            raise ValueError(response.content["message"]["error"])
+        msg_result = response.content["message"].get("result")
+        return self._create_widget_from_msg_result(msg_result)
+
+    def _create_widget_from_msg_result(self, msg_result):
+        if msg_result is None:
+            return None
+        if isinstance(msg_result, list):
+            return [self._create_widget_from_msg_result(res) for res in msg_result]
+        if isinstance(msg_result, dict):
+            if "__rpc__" not in msg_result:
+                return msg_result
+            cls = msg_result.pop("widget_class", None)
+            msg_result.pop("__rpc__", None)
+
+            if not cls:
+                return msg_result
+
+            cls = getattr(client, cls)
+            print(msg_result)
+            return cls(parent=self, **msg_result)
+        return msg_result
+
+    def _wait_for_response(self, request_id):
+        """
+        Wait for the response from the server.
+        """
+        response = None
+        while response is None:
+            response = self._client.connector.get(
+                MessageEndpoints.gui_instruction_response(request_id)
+            )
+            QCoreApplication.processEvents()  # keep UI responsive (and execute signals/slots)
+        return response

bec_widgets/cli/generate_cli.py

@@ -0,0 +1,96 @@
+import inspect
+import typing
+
+
+class ClientGenerator:
+    def __init__(self):
+        self.header = """# This file was automatically generated by generate_cli.py\n
+from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
+from typing import Literal, Optional, overload"""
+
+        self.content = ""
+
+    def generate_client(self, published_classes: list):
+        """
+        Generate the client for the published classes.
+
+        Args:
+            published_classes(list): The list of published classes (e.g. [BECWaveform1D, BECFigure]).
+        """
+        for cls in published_classes:
+            self.content += "\n\n"
+            self.generate_content_for_class(cls)
+
+    def generate_content_for_class(self, cls):
+        """
+        Generate the content for the class.
+        Args:
+            cls: The class for which to generate the content.
+        """
+
+        class_name = cls.__name__
+        module = cls.__module__
+
+        # Generate the header
+        #         self.header += f"""
+        # from {module} import {class_name}"""
+
+        # Generate the content
+        if cls.__name__ == "BECFigure":
+            self.content += f"""
+class {class_name}(RPCBase, BECFigureClientMixin):"""
+        else:
+            self.content += f"""
+class {class_name}(RPCBase):"""
+        for method in cls.USER_ACCESS:
+            obj = getattr(cls, method)
+            if isinstance(obj, property):
+                self.content += """
+    @property
+    @rpc_call"""
+                sig = str(inspect.signature(obj.fget))
+                doc = inspect.getdoc(obj.fget)
+            else:
+                sig = str(inspect.signature(obj))
+                doc = inspect.getdoc(obj)
+                overloads = typing.get_overloads(obj)
+                for overload in overloads:
+                    sig_overload = str(inspect.signature(overload))
+                    self.content += f"""
+    @overload
+    def {method}{str(sig_overload)}: ...
+    """
+
+                self.content += """
+    @rpc_call"""
+            self.content += f"""
+    def {method}{str(sig)}:
+        \"\"\"
+{doc}
+        \"\"\""""
+
+    def write(self, file_name: str):
+        """
+        Write the content to a file.
+
+        Args:
+            file_name(str): The name of the file to write to.
+        """
+        with open(file_name, "w", encoding="utf-8") as file:
+            file.write(self.header)
+            file.write(self.content)
+
+
+if __name__ == "__main__":
+    import os
+
+    from bec_widgets.widgets.figure import BECFigure
+    from bec_widgets.widgets.plots import BECPlotBase, BECWaveform1D  # ,BECCurve
+    from bec_widgets.widgets.plots.waveform1d import BECCurve
+
+    current_path = os.path.dirname(__file__)
+    client_path = os.path.join(current_path, "client.py")
+    clss = [BECPlotBase, BECWaveform1D, BECFigure, BECCurve]
+    generator = ClientGenerator()
+    generator.generate_client(clss)
+    generator.write(client_path)

bec_widgets/cli/server.py

@@ -0,0 +1,110 @@
+import inspect
+
+from bec_lib import MessageEndpoints, messages
+
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.plots import BECCurve, BECWaveform1D
+
+
+class BECWidgetsCLIServer:
+    WIDGETS = [BECWaveform1D, BECFigure, BECCurve]
+
+    def __init__(self, gui_id: str = None, dispatcher: BECDispatcher = None) -> None:
+        self.dispatcher = BECDispatcher() if dispatcher is None else dispatcher
+        self.client = self.dispatcher.client
+        self.client.start()
+        self.gui_id = gui_id
+        self.fig = BECFigure(gui_id=self.gui_id)
+        print(f"Server started with gui_id {self.gui_id}")
+
+        self.dispatcher.connect_slot(
+            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
+        )
+
+    def start(self):
+        """Start the figure window."""
+        self.fig.start()
+
+    def on_rpc_update(self, msg: dict, metadata: dict):
+        request_id = metadata.get("request_id")
+        try:
+            method = msg["action"]
+            args = msg["parameter"].get("args", [])
+            kwargs = msg["parameter"].get("kwargs", {})
+            obj = self.get_object_from_config(msg["parameter"])
+            res = self.run_rpc(obj, method, args, kwargs)
+        except Exception as e:
+            print(e)
+            self.send_response(request_id, False, {"error": str(e)})
+        else:
+            self.send_response(request_id, True, {"result": res})
+
+    def send_response(self, request_id: str, accepted: bool, msg: dict):
+        self.client.connector.set(
+            MessageEndpoints.gui_instruction_response(request_id),
+            messages.RequestResponseMessage(accepted=accepted, message=msg),
+            expire=60,
+        )
+
+    def get_object_from_config(self, config: dict):
+        gui_id = config.get("gui_id")
+        # check if the object is the figure
+        if gui_id == self.fig.gui_id:
+            return self.fig
+        # check if the object is a widget
+        if gui_id in self.fig.widgets:
+            obj = self.fig.widgets[config["gui_id"]]
+            return obj
+        if self.fig.widgets:
+            for widget in self.fig.widgets.values():
+                item = widget.find_widget_by_id(gui_id)
+                if item:
+                    return item
+                raise NotImplementedError(
+                    f"gui_id lookup for widget of type {widget.__class__.__name__} not implemented"
+                )
+
+        raise ValueError(f"Object with gui_id {gui_id} not found")
+
+    def run_rpc(self, obj, method, args, kwargs):
+        method_obj = getattr(obj, method)
+        # check if the method accepts args and kwargs
+        if not callable(method_obj):
+            res = method_obj
+        else:
+            sig = inspect.signature(method_obj)
+            if sig.parameters:
+                res = method_obj(*args, **kwargs)
+            else:
+                res = method_obj()
+
+        if isinstance(res, list):
+            res = [self.serialize_object(obj) for obj in res]
+        else:
+            res = self.serialize_object(res)
+        return res
+
+    def serialize_object(self, obj):
+        if isinstance(obj, BECConnector):
+            return {
+                "gui_id": obj.gui_id,
+                "widget_class": obj.__class__.__name__,
+                "config": obj.config.model_dump(),
+                "__rpc__": True,
+            }
+        return obj
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
+    parser.add_argument("--id", type=str, help="The id of the server")
+
+    args = parser.parse_args()
+
+    server = BECWidgetsCLIServer(gui_id=args.id)
+    # server = BECWidgetsCLIServer(gui_id="test")
+    server.start()

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/__init__.py

@@ -0,0 +1,9 @@
+from .motor_movement import (
+    MotorControlApp,
+    MotorControlMap,
+    MotorControlPanel,
+    MotorControlPanelRelative,
+    MotorControlPanelAbsolute,
+    MotorCoordinateTable,
+    MotorThread,
+)

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):
@@ -102,7 +102,7 @@ class StreamApp(QWidget):
 
     @staticmethod
     def _streamer_cb(msg, *, parent, **_kwargs) -> None:
-        msgMCS = BECMessage.DeviceMessage.loads(msg.value)
+        msgMCS = msg.value
         print(msgMCS)
         row = msgMCS.content["signals"][parent.sub_device]
         metadata = msgMCS.metadata
@@ -123,7 +123,7 @@ class StreamApp(QWidget):
     def _device_cv(msg, *, parent, **_kwargs) -> None:
         print("Getting ScanID")
 
-        msgDEV = BECMessage.ScanStatusMessage.loads(msg.value)
+        msgDEV = msg.value
 
         current_scanID = msgDEV.content["scanID"]
 
@@ -143,7 +143,7 @@ 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")
@@ -158,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,8 +1,7 @@
-from bec_lib.core import BECMessage, MessageEndpoints, RedisConnector
+from bec_lib import messages, MessageEndpoints, RedisConnector
 import time
 
 connector = RedisConnector("localhost:6379")
-producer = connector.producer()
 metadata = {}
 
 scanID = "ScanID1"
@@ -15,18 +14,16 @@ 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()
 
-    # producer.send(topic=MessageEndpoints.device_status(device="mca"), msg=msg)
-
-    producer.xadd(
+    connector.xadd(
         topic=MessageEndpoints.device_async_readback(
             scanID=scanID, device="mca"
         ),  # scanID will be different for each scan
-        msg={"data": msg},
+        msg={"data": msg},  # TODO should be msg_dict
         expire=1800,
     )
 

bec_widgets/examples/modular_app/modular.ui

@@ -15,16 +15,40 @@
   </property>
   <widget class="QWidget" name="centralwidget">
    <layout class="QGridLayout" name="gridLayout">
-    <item row="2" column="1">
-     <widget class="QGraphicsView" name="glw_2"/>
-    </item>
-    <item row="1" column="1">
+    <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">
@@ -32,19 +56,16 @@
       </property>
      </widget>
     </item>
-    <item row="2" column="0">
-     <widget class="QGraphicsView" name="glw_1"/>
-    </item>
-    <item row="2" column="2">
-     <widget class="QGraphicsView" name="glw_3"/>
-    </item>
-    <item row="1" column="2">
-     <widget class="QLabel" name="label_2">
+    <item row="1" column="5">
+     <widget class="QPushButton" name="pushButton_setting_3">
       <property name="text">
-       <string>Plot Scan Types = True</string>
+       <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">
@@ -53,18 +74,19 @@
      <x>0</x>
      <y>0</y>
      <width>1433</width>
-     <height>24</height>
+     <height>37</height>
     </rect>
    </property>
-   <widget class="QMenu" name="menuSettings">
-    <property name="title">
-     <string>Settings</string>
-    </property>
-   </widget>
-   <addaction name="menuSettings"/>
   </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

@@ -1,42 +1,13 @@
 import os
-from PyQt5 import uic
-from PyQt5.QtWidgets import QMainWindow, QApplication, QVBoxLayout
-from bec_widgets.widgets.device_monitor import BECDeviceMonitor
 
-config_1 = {
-    "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",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "bpm4i",
-                "signals": [{"name": "bpm4i", "entry": "bpm4i"}],
-            },
-        },
-        {
-            "plot_name": "Gauss plots vs samx",
-            "x": {
-                "label": "Motor X",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "Gauss",
-                "signals": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-            },
-        },
-    ],
-}
+from qtpy import uic
+from qtpy.QtWidgets import QMainWindow, QApplication
 
-config_2 = {
+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,
@@ -46,29 +17,52 @@ config_2 = {
     "plot_data": [
         {
             "plot_name": "BPM4i plots vs samx",
-            "x": {
-                "label": "Motor Y",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "bpm4i",
-                "signals": [{"name": "samy", "entry": "samy"}],
-            },
+            "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",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "Gauss ADC",
-                "signals": [{"name": "gauss_adc1", "entry": "gauss_adc1"}],
-            },
+            "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 = config = {
+
+
+CONFIG_SCAN_MODE = {
     "plot_settings": {
         "background_color": "white",
         "num_columns": 3,
@@ -79,77 +73,89 @@ config_scan_mode = config = {
         "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"},
-                    ],
-                },
+                "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", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "gauss_adc1", "entry": "gauss_adc1"},
-                    ],
-                },
+                "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 Y", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-                },
+                "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 Y", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [{"name": "gauss_adc3", "entry": "gauss_adc3"}],
-                },
+                "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 plot",
-                "x": {"label": "Motor X", "signals": [{"name": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "gauss_adc1", "entry": "gauss_adc1"},
-                        {"name": "gauss_adc2", "entry": "gauss_adc2"},
-                    ],
-                },
+                "plot_name": "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": "Multi",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "Multi",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "samx", "entry": ["samx", "samx_setpoint"]},
-                    ],
-                },
-            },
-            {
-                "plot_name": "Multi",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "Multi",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "samx", "entry": ["samx", "samx_setpoint"]},
-                    ],
-                },
+                "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"}],
+                        },
+                    }
+                ],
             },
         ],
     },
@@ -161,7 +167,7 @@ class ModularApp(QMainWindow):
         super(ModularApp, self).__init__(parent)
 
         # Client and device manager from BEC
-        self.client = bec_dispatcher.client if client is None else client
+        self.client = BECDispatcher().client if client is None else client
 
         # Loading UI
         current_path = os.path.dirname(__file__)
@@ -170,24 +176,20 @@ class ModularApp(QMainWindow):
         self._init_plots()
 
     def _init_plots(self):
-        self.glw_1_layout = QVBoxLayout(self.glw_1)  # Create a new QVBoxLayout
-        self.bec_device_monitor_1 = BECDeviceMonitor(parent=self, config=config_1)
-        self.glw_1_layout.addWidget(self.bec_device_monitor_1)  # Add BECDeviceMonitor to the layout
+        """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]
 
-        self.glw_2_layout = QVBoxLayout(self.glw_2)  # Create a new QVBoxLayout
-        self.bec_device_monitor_2 = BECDeviceMonitor(parent=self, config=config_2)
-        self.glw_2_layout.addWidget(self.bec_device_monitor_2)  # Add BECDeviceMonitor to the layout
-
-        self.glw_3_layout = QVBoxLayout(self.glw_3)  # Create a new QVBoxLayout
-        self.bec_device_monitor_3 = BECDeviceMonitor(parent=self, config=config_scan_mode)
-        self.glw_3_layout.addWidget(self.bec_device_monitor_3)  # Add BECDeviceMonitor to the layout
+        # 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__":
-    from bec_widgets.bec_dispatcher import bec_dispatcher
-
     # BECclient global variables
-    client = bec_dispatcher.client
+    client = BECDispatcher().client
     client.start()
 
     app = QApplication([])
@@ -195,4 +197,4 @@ if __name__ == "__main__":
 
     window = modularApp
     window.show()
-    app.exec_()
+    app.exec()

bec_widgets/examples/motor_movement/__init__.py

@@ -0,0 +1,9 @@
+from .motor_control_compilations import (
+    MotorControlApp,
+    MotorControlMap,
+    MotorControlPanel,
+    MotorControlPanelRelative,
+    MotorControlPanelAbsolute,
+    MotorCoordinateTable,
+    MotorThread,
+)

bec_widgets/examples/motor_movement/motor_control_compilations.py

@@ -0,0 +1,260 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+
+import qdarktheme
+from qtpy.QtWidgets import QApplication
+from qtpy.QtWidgets import QVBoxLayout
+from qtpy.QtWidgets import (
+    QWidget,
+    QSplitter,
+)
+from qtpy.QtCore import Qt
+
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.widgets import (
+    MotorControlAbsolute,
+    MotorControlRelative,
+    MotorControlSelection,
+    MotorThread,
+    MotorMap,
+    MotorCoordinateTable,
+)
+
+CONFIG_DEFAULT = {
+    "motor_control": {
+        "motor_x": "samx",
+        "motor_y": "samy",
+        "step_size_x": 3,
+        "step_size_y": 3,
+        "precision": 4,
+        "step_x_y_same": False,
+        "move_with_arrows": False,
+    },
+    "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"}],
+            },
+        },
+    ],
+}
+
+
+class MotorControlApp(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        # Widgets
+        self.motor_control_panel = MotorControlPanel(client=self.client, config=self.config)
+        # Create MotorMap
+        self.motion_map = MotorMap(client=self.client, config=self.config)
+        # Create MotorCoordinateTable
+        self.motor_table = MotorCoordinateTable(client=self.client, config=self.config)
+
+        # Create the splitter and add MotorMap and MotorControlPanel
+        splitter = QSplitter(Qt.Horizontal)
+        splitter.addWidget(self.motion_map)
+        splitter.addWidget(self.motor_control_panel)
+        splitter.addWidget(self.motor_table)
+
+        # Set the main layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(splitter)
+        self.setLayout(layout)
+
+        # Connecting signals and slots
+        self.motor_control_panel.selection_widget.selected_motors_signal.connect(
+            lambda x, y: self.motion_map.change_motors(x, y, 0)
+        )
+        self.motor_control_panel.absolute_widget.coordinates_signal.connect(
+            self.motor_table.add_coordinate
+        )
+        self.motor_control_panel.relative_widget.precision_signal.connect(
+            self.motor_table.set_precision
+        )
+        self.motor_control_panel.relative_widget.precision_signal.connect(
+            self.motor_control_panel.absolute_widget.set_precision
+        )
+
+        self.motor_table.plot_coordinates_signal.connect(self.motion_map.plot_saved_coordinates)
+
+
+class MotorControlMap(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        # Widgets
+        self.motor_control_panel = MotorControlPanel(client=self.client, config=self.config)
+        # Create MotorMap
+        self.motion_map = MotorMap(client=self.client, config=self.config)
+
+        # Create the splitter and add MotorMap and MotorControlPanel
+        splitter = QSplitter(Qt.Horizontal)
+        splitter.addWidget(self.motion_map)
+        splitter.addWidget(self.motor_control_panel)
+
+        # Set the main layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(splitter)
+        self.setLayout(layout)
+
+        # Connecting signals and slots
+        self.motor_control_panel.selection_widget.selected_motors_signal.connect(
+            lambda x, y: self.motion_map.change_motors(x, y, 0)
+        )
+
+
+class MotorControlPanel(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        self.motor_thread = MotorThread(client=self.client)
+
+        self.selection_widget = MotorControlSelection(
+            client=self.client, config=self.config, motor_thread=self.motor_thread
+        )
+        self.relative_widget = MotorControlRelative(
+            client=self.client, config=self.config, motor_thread=self.motor_thread
+        )
+        self.absolute_widget = MotorControlAbsolute(
+            client=self.client, config=self.config, motor_thread=self.motor_thread
+        )
+
+        layout = QVBoxLayout(self)
+
+        layout.addWidget(self.selection_widget)
+        layout.addWidget(self.relative_widget)
+        layout.addWidget(self.absolute_widget)
+
+        # Connecting signals and slots
+        self.selection_widget.selected_motors_signal.connect(self.relative_widget.change_motors)
+        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)
+
+        # Set the window to a fixed size based on its contents
+        self.layout().setSizeConstraint(layout.SetFixedSize)
+
+
+class MotorControlPanelAbsolute(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        self.motor_thread = MotorThread(client=self.client)
+
+        self.selection_widget = MotorControlSelection(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+        self.absolute_widget = MotorControlAbsolute(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.selection_widget)
+        layout.addWidget(self.absolute_widget)
+
+        # Connecting signals and slots
+        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)
+
+        # Set the window to a fixed size based on its contents
+        self.layout().setSizeConstraint(layout.SetFixedSize)
+
+
+class MotorControlPanelRelative(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        self.motor_thread = MotorThread(client=self.client)
+
+        self.selection_widget = MotorControlSelection(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+        self.relative_widget = MotorControlRelative(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.selection_widget)
+        layout.addWidget(self.relative_widget)
+
+        # Connecting signals and slots
+        self.selection_widget.selected_motors_signal.connect(self.relative_widget.change_motors)
+
+        # Set the window to a fixed size based on its contents
+        self.layout().setSizeConstraint(layout.SetFixedSize)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="Run various Motor Control Widgets compositions.")
+    parser.add_argument(
+        "-v",
+        "--variant",
+        type=str,
+        choices=["app", "map", "panel", "panel_abs", "panel_rel"],
+        help="Select the variant of the motor control to run. "
+        "'app' for the full application, "
+        "'map' for MotorMap, "
+        "'panel' for the MotorControlPanel, "
+        "'panel_abs' for MotorControlPanel with absolute control, "
+        "'panel_rel' for MotorControlPanel with relative control.",
+    )
+
+    args = parser.parse_args()
+
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+    client.start()
+
+    app = QApplication([])
+    qdarktheme.setup_theme("auto")
+
+    if args.variant == "app":
+        window = MotorControlApp(client=client, config=CONFIG_DEFAULT)
+    elif args.variant == "map":
+        window = MotorControlMap(client=client, config=CONFIG_DEFAULT)
+    elif args.variant == "panel":
+        window = MotorControlPanel(client=client, config=CONFIG_DEFAULT)
+    elif args.variant == "panel_abs":
+        window = MotorControlPanelAbsolute(client=client, config=CONFIG_DEFAULT)
+    elif args.variant == "panel_rel":
+        window = MotorControlPanelRelative(client=client, config=CONFIG_DEFAULT)
+    else:
+        print("Please specify a valid variant to run. Use -h for help.")
+        print("Running the full application by default.")
+        window = MotorControlApp(client=client, config=CONFIG_DEFAULT)
+
+    window.show()
+    sys.exit(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 = 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,15 +1,17 @@
 import os
 
 import numpy as np
-import PyQt5.QtWidgets
+import qtpy.QtWidgets
 import pyqtgraph as pg
-from bec_lib.core import MessageEndpoints
-from PyQt5.QtCore import pyqtSignal, pyqtSlot
-from PyQt5.QtWidgets import QApplication, QTableWidgetItem, QWidget
+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_widgets.utils import Crosshair, ctrl_c
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
 
 # TODO implement:
 #   - implement scanID database for visualizing previous scans
@@ -123,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})"))
@@ -238,9 +240,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)
 
@@ -251,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()
 
@@ -268,4 +268,4 @@ if __name__ == "__main__":
 
     window = plotApp
     window.show()
-    app.exec_()
+    app.exec()

bec_widgets/examples/plot_app/plot_app.py

@@ -5,8 +5,10 @@ import os
 
 import pyqtgraph
 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,
     QWidget,
     QTableWidgetItem,
@@ -19,8 +21,9 @@ 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:
@@ -90,12 +93,12 @@ class PlotApp(QWidget):
         self.error_handler = ErrorHandler(parent=self)
 
         # Client and device manager from BEC
-        self.client = bec_dispatcher.client if client is None else client
+        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 = {}
 
@@ -435,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.
 
@@ -566,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) -> dict:
+    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
@@ -688,8 +693,6 @@ 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",
@@ -711,6 +714,7 @@ if __name__ == "__main__":
         exit(1)
 
     # BECclient global variables
+    bec_dispatcher = BECDispatcher()
     client = bec_dispatcher.client
     client.start()
 
@@ -723,4 +727,4 @@ if __name__ == "__main__":
 
     window = plotApp
     window.show()
-    app.exec_()
+    app.exec()

bec_widgets/examples/stream_plot/stream_plot.py

@@ -1,23 +1,19 @@
 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, MessageEndpoints
-from bec_lib.core.redis_connector import MessageObject, RedisConnector
-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.qt_utils import Crosshair, Colors
-from bec_widgets.bec_dispatcher import bec_dispatcher
-
-# client = bec_dispatcher.client
+from bec_widgets.utils import Crosshair, Colors
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 
 class StreamPlot(QtWidgets.QWidget):
@@ -34,7 +30,7 @@ class StreamPlot(QtWidgets.QWidget):
         """
 
         # Client and device manager from BEC
-        self.client = bec_dispatcher.client if client is None else client
+        self.client = BECDispatcher().client if client is None else client
 
         super(StreamPlot, self).__init__()
         # Set style for pyqtgraph plots
@@ -44,7 +40,7 @@ class StreamPlot(QtWidgets.QWidget):
         uic.loadUi(os.path.join(current_path, "line_plot.ui"), self)
 
         self._idle_time = 100
-        self.producer = RedisConnector(["localhost:6379"]).producer()
+        self.connector = RedisConnector(["localhost:6379"])
 
         self.y_value_list = y_value_list
         self.previous_y_value_list = None
@@ -58,7 +54,10 @@ class StreamPlot(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()
 
         ##########################
@@ -68,6 +67,11 @@ class StreamPlot(QtWidgets.QWidget):
         self.init_curves()
         self.hook_crosshair()
 
+    def close(self):
+        super().close()
+        self._data_retriever_thread_exit_event.set()
+        self.data_retriever.join()
+
     def init_ui(self):
         """Setup all ui elements"""
         ##########################
@@ -171,8 +175,7 @@ class StreamPlot(QtWidgets.QWidget):
         self.hook_crosshair()
         self.init_table()
 
-    def splitter_sizes(self):
-        ...
+    def splitter_sizes(self): ...
 
     def hook_crosshair(self):
         self.crosshair_1d = Crosshair(self.plot, precision=4)
@@ -210,8 +213,8 @@ class StreamPlot(QtWidgets.QWidget):
                 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)
+        msg = messages.DeviceMessage(signals=return_dict).dumps()
+        self.connector.set_and_publish("px_stream/gui_event", msg=msg)
         self.roi_signal.emit(region)
 
     def init_table(self):
@@ -261,14 +264,14 @@ class StreamPlot(QtWidgets.QWidget):
         # else:
         #     return
 
-    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 = self.client.producer.lrange(topic=endpoint, start=-1, end=-1)
-            data = [BECMessage.DeviceMessage.loads(msg) for msg in msgs]
+            msgs = self.client.connector.lrange(topic=endpoint, start=-1, end=-1)
+            data = msgs
             if not data:
                 continue
             with np.errstate(divide="ignore", invalid="ignore"):
@@ -292,8 +295,8 @@ class StreamPlot(QtWidgets.QWidget):
     def new_proj(self, content: dict, _metadata: dict):
         proj_nr = content["signals"]["proj_nr"]
         endpoint = f"px_stream/projection_{proj_nr}/metadata"
-        msg_raw = self.client.producer.get(topic=endpoint)
-        msg = BECMessage.DeviceMessage.loads(msg_raw)
+        msg_raw = self.client.connector.get(topic=endpoint)
+        msg = messages.DeviceMessage.loads(msg_raw)
         self._current_q = msg.content["signals"]["q"]
         self._current_norm = msg.content["signals"]["norm_sum"]
         self._current_metadata = msg.content["signals"]["metadata"]
@@ -305,7 +308,7 @@ class StreamPlot(QtWidgets.QWidget):
 if __name__ == "__main__":
     import argparse
 
-    from bec_widgets import ctrl_c
+    # from bec_widgets import ctrl_c  # TODO uncomment when ctrl_c is ready to be compatible with qtpy
 
     parser = argparse.ArgumentParser()
     parser.add_argument(
@@ -316,10 +319,11 @@ if __name__ == "__main__":
     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)
+    # 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")
@@ -328,4 +332,4 @@ if __name__ == "__main__":
     )
     plot.show()
     # client.callbacks.register("scan_segment", plot, sync=False)
-    app.exec_()
+    app.exec()

bec_widgets/qt_utils/__init__.py

@@ -1,3 +0,0 @@
-from .crosshair import Crosshair
-from .colors import Colors
-from .validator_delegate import DoubleValidationDelegate

bec_widgets/qt_utils/colors.py

@@ -1,50 +0,0 @@
-import numpy as np
-import pyqtgraph as pg
-from pyqtgraph import mkColor
-
-
-class Colors:
-    @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 = Colors.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

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

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

bec_widgets/utils/bec_connector.py

@@ -0,0 +1,108 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+from __future__ import annotations
+
+import time
+from typing import Type, Optional
+
+from pydantic import BaseModel, Field, field_validator
+from qtpy.QtCore import Slot as pyqtSlot
+
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+
+class ConnectionConfig(BaseModel):
+    """Configuration for BECConnector mixin class"""
+
+    widget_class: str = Field(default="NonSpecifiedWidget", description="The class of the widget.")
+    gui_id: Optional[str] = Field(
+        default=None, validate_default=True, description="The GUI ID of the widget."
+    )
+
+    @field_validator("gui_id")
+    def generate_gui_id(cls, v, values):
+        """Generate a GUI ID if none is provided."""
+        if v is None:
+            widget_class = values.data["widget_class"]
+            v = f"{widget_class}_{str(time.time())}"
+            return v
+        return v
+
+
+class BECConnector:
+    """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
+
+    def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
+        # BEC related connections
+        self.bec_dispatcher = BECDispatcher()
+        self.client = self.bec_dispatcher.client if client is None else client
+
+        if config:
+            self.config = config
+        else:
+            print(
+                f"No initial config found for {self.__class__.__name__}.\n"
+                f"Initializing with default config."
+            )
+            self.config = ConnectionConfig(widget_class=self.__class__.__name__)
+
+        if gui_id:
+            self.config.gui_id = gui_id
+            self.gui_id = gui_id
+        else:
+            self.gui_id = self.config.gui_id
+
+    @pyqtSlot(str)
+    def set_gui_id(self, gui_id: str) -> None:
+        """
+        Set the GUI ID for the widget.
+        Args:
+            gui_id(str): GUI ID
+        """
+        self.config.gui_id = gui_id
+        self.gui_id = gui_id
+
+    def get_obj_by_id(self, obj_id: str):
+        if obj_id == self.gui_id:
+            return self
+
+    def get_bec_shortcuts(self):
+        """Get BEC shortcuts for the widget."""
+        self.dev = self.client.device_manager.devices
+        self.scans = self.client.scans
+        self.queue = self.client.queue
+        self.scan_storage = self.queue.scan_storage
+        self.dap = self.client.dap
+
+    def update_client(self, client) -> None:
+        """Update the client and device manager from BEC and create object for BEC shortcuts.
+        Args:
+            client: BEC client
+        """
+        self.client = client
+        self.get_bec_shortcuts()
+
+    @pyqtSlot(ConnectionConfig)  # TODO can be also dict
+    def on_config_update(self, config: ConnectionConfig | dict) -> None:
+        """
+        Update the configuration for the widget.
+        Args:
+            config(ConnectionConfig): Configuration settings.
+        """
+        if isinstance(config, dict):
+            config = ConnectionConfig(**config)
+            # TODO add error handler
+
+        self.config = config
+
+    def get_config(self, dict_output: bool = True) -> dict | BaseModel:
+        """
+        Get the configuration of the widget.
+        Args:
+            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
+        Returns:
+            dict: The configuration of the plot widget.
+        """
+        if dict_output:
+            return self.config.model_dump()
+        else:
+            return self.config

bec_widgets/utils/bec_dispatcher.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import argparse
+import itertools
+import os
+from collections.abc import Callable
+from typing import Union
+
+import redis
+from bec_lib import BECClient, ServiceConfig
+from qtpy.QtCore import QObject
+from qtpy.QtCore import Signal as pyqtSignal
+
+# Adding a new pyqt signal requires a class factory, as they must be part of the class definition
+# and cannot be dynamically added as class attributes after the class has been defined.
+_signal_class_factory = (
+    type(f"Signal{i}", (QObject,), dict(signal=pyqtSignal(dict, dict))) for i in itertools.count()
+)
+
+
+class _Connection:
+    """Utility class to keep track of slots connected to a particular redis connector"""
+
+    def __init__(self, callback) -> None:
+        self.callback = callback
+
+        self.slots = set()
+        # keep a reference to a new signal class, so it is not gc'ed
+        self._signal_container = next(_signal_class_factory)()
+        self.signal: pyqtSignal = self._signal_container.signal
+
+
+class _BECDispatcher(QObject):
+    """Utility class to keep track of slots connected to a particular redis connector"""
+
+    def __init__(self, bec_config=None):
+        super().__init__()
+        self.client = BECClient(forced=True)  # make a new instance
+
+        # 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"
+
+        try:
+            self.client.initialize(config=ServiceConfig(config_path=bec_config))
+        except redis.exceptions.ConnectionError as e:
+            print(f"Failed to initialize BECClient: {e}")
+        self._connections = {}
+
+    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 = msg.value
+            for connection_key, connection in self._connections.items():
+                if set(topics).intersection(connection_key):
+                    connection.signal.emit(msg.content, msg.metadata)
+
+        try:
+            self.client.connector.register(topics=topics, cb=cb)
+        except redis.exceptions.ConnectionError:
+            print("Could not connect to Redis, skipping registration of topics.")
+
+        return _Connection(cb)
+
+    def _do_disconnect_slot(self, topic, slot):
+        print(f"Disconnecting {slot} from {topic}")
+        connection = self._connections[topic]
+        try:
+            connection.signal.disconnect(slot)
+        except TypeError:
+            print(f"Could not disconnect slot:'{slot}' from topic:'{topic}'")
+            print("Continue to remove slot:'{slot}' from 'connection.slots'.")
+        connection.slots.remove(slot)
+        if not connection.slots:
+            del self._connections[topic]
+
+    def _disconnect_slot_from_topic(self, slot: Callable, topic: str) -> None:
+        """A helper method to disconnect a slot from a specific topic.
+
+        Args:
+            slot (Callable): A slot to be disconnected
+            topic (str): A corresponding topic that can typically be acquired via
+                bec_lib.MessageEndpoints
+        """
+        connection = self._connections.get(topic)
+        if connection and slot in connection.slots:
+            self._do_disconnect_slot(topic, slot)
+
+    def disconnect_slot(self, slot: Callable, topics: Union[str, list]) -> None:
+        """Disconnect widget's pyqt slot from pub/sub updates on a topic.
+
+        Args:
+            slot (Callable): A slot to be disconnected
+            topics (str | list): A corresponding topic or list of topics that can typically be acquired via
+                bec_lib.MessageEndpoints
+        """
+        if isinstance(topics, str):
+            topics = [topics]
+
+        for key, connection in list(self._connections.items()):
+            if slot in connection.slots:
+                common_topics = set(topics).intersection(key)
+                if common_topics:
+                    remaining_topics = set(key) - set(topics)
+                    # Disconnect slot from common topics
+                    self._do_disconnect_slot(key, slot)
+                    # Reconnect slot to remaining topics if any
+                    if remaining_topics:
+                        self.connect_slot(slot, list(remaining_topics), True)
+
+    def disconnect_all(self):
+        """Disconnect all slots from all topics."""
+        for key, connection in list(self._connections.items()):
+            for slot in list(connection.slots):
+                self._disconnect_slot_from_topic(slot, key)
+
+
+# variable holding the Singleton instance of BECDispatcher
+_bec_dispatcher = None
+
+
+def BECDispatcher():
+    global _bec_dispatcher
+    if _bec_dispatcher is None:
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--bec-config", default=None)
+        args, _ = parser.parse_known_args()
+
+        _bec_dispatcher = _BECDispatcher(args.bec_config)
+    return _bec_dispatcher

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/colors.py

@@ -0,0 +1,65 @@
+from typing import Literal
+
+import numpy as np
+import pyqtgraph as pg
+from qtpy.QtGui import QColor
+
+
+class Colors:
+    @staticmethod
+    def golden_ratio(num: int) -> list:
+        """Calculate the golden ratio for a given number of angles.
+
+        Args:
+            num (int): Number of angles
+
+        Returns:
+            list: List of angles calculated using the golden ratio.
+        """
+        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, format: Literal["QColor", "HEX", "RGB"] = "QColor"
+    ) -> list:
+        """
+        Extract num colors from the specified colormap following golden angle distribution and return them in the specified format.
+
+        Args:
+            colormap (str): Name of the colormap.
+            num (int): Number of requested colors.
+            format (Literal["QColor","HEX","RGB"]): The format of the returned colors ('RGB', 'HEX', 'QColor').
+
+        Returns:
+            list: List of colors in the specified format.
+
+        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.getColors(mode="float")
+        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 = Colors.golden_ratio(len(cmap_colors))
+        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
+        colors = []
+        for ii in color_selection[:num]:
+            color = cmap_colors[int(ii)]
+            if format.upper() == "HEX":
+                colors.append(QColor.fromRgbF(*color).name())
+            elif format.upper() == "RGB":
+                colors.append(tuple((np.array(color) * 255).astype(int)))
+            elif format.upper() == "QCOLOR":
+                colors.append(QColor.fromRgbF(*color))
+            else:
+                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
+        return colors

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/entry_validator.py

@@ -0,0 +1,17 @@
+class EntryValidator:
+    def __init__(self, devices):
+        self.devices = devices
+
+    def validate_signal(self, name: str, entry: str = None) -> str:
+        if name not in self.devices:
+            raise ValueError(f"Device '{name}' not found in current BEC session")
+
+        device = self.devices[name]
+        description = device.describe()
+
+        if entry is None:
+            entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
+        if entry not in description:
+            raise ValueError(f"Entry '{entry}' not found in device '{name}' signals")
+
+        return entry

bec_widgets/utils/rpc_decorator.py

@@ -0,0 +1,15 @@
+def rpc_public(func):
+    func.rpc_public = True  # Mark the function for later processing by the class decorator
+    return func
+
+
+def register_rpc_methods(cls):
+    """
+    Class decorator to scan for rpc_public methods and add them to USER_ACCESS.
+    """
+    if not hasattr(cls, "USER_ACCESS"):
+        cls.USER_ACCESS = set()
+    for name, method in cls.__dict__.items():
+        if getattr(method, "rpc_public", False):
+            cls.USER_ACCESS.add(name)
+    return cls

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,15 @@
+from .monitor import BECMonitor, ConfigDialog
+from .motor_map import MotorMap
+from .scan_control import ScanControl
+from .toolbar import ModularToolBar
+from .editor import BECEditor
+from .monitor_scatter_2D import BECMonitor2DScatter
+from .motor_control import (
+    MotorControlRelative,
+    MotorControlAbsolute,
+    MotorControlSelection,
+    MotorThread,
+    MotorCoordinateTable,
+)
+from .figure import FigureConfig, BECFigure
+from .plots import BECWaveform1D, BECCurve, BECPlotBase

bec_widgets/widgets/device_monitor.py

@@ -1,347 +0,0 @@
-import pyqtgraph as pg
-from bec_lib.core import MessageEndpoints
-from PyQt5 import QtCore
-from PyQt5.QtCore import pyqtSignal, pyqtSlot
-from PyQt5.QtWidgets import QApplication
-from pyqtgraph import mkPen, mkBrush
-
-from bec_widgets.bec_dispatcher import bec_dispatcher
-
-from bec_widgets.qt_utils import Crosshair, Colors
-
-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 Y",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "bpm4i",
-                "signals": [{"name": "bpm4i", "entry": "bpm4i"}],
-            },
-        },
-        {
-            "plot_name": "Gauss plots vs samx",
-            "x": {
-                "label": "Motor X",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "Gauss",
-                "signals": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-            },
-        },
-    ],
-}
-
-
-class BECDeviceMonitor(pg.GraphicsLayoutWidget):
-    update_signal = pyqtSignal()
-
-    def __init__(self, config: dict = config_simple, client=None, parent=None):
-        super(BECDeviceMonitor, self).__init__(parent=None)
-
-        # Client and device manager from BEC
-        self.client = bec_dispatcher.client if client is None else client
-        self.dev = self.client.device_manager.devices
-
-        # Connect slots dispatcher
-        bec_dispatcher.connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
-
-        # Current configuration
-        self.config = config
-
-        # Displayed Data
-        self.data = {}
-
-        self.crosshairs = None
-        self.plots = None
-        self.curves_data = None
-        self.grid_coordinates = None
-        self.scanID = None
-
-        self.user_colors = {}  # key: (plot_name, y_name, y_entry), value: color
-
-        # Connect the update signal to the update plot method #TODO enable when update is fixed
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=25, slot=self.update_plot
-        )
-
-        # Init UI
-        self._init_config()
-        # self._init_ui() #TODO could be removed
-        # self._init_curves()
-
-    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:  # 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]]
-
-        # TODO init plot background -> so far not used, I don;t like how it is done in extreme.py
-
-        # Initialize the UI
-        self._init_ui(self.plot_settings["num_columns"])
-
-    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(
-                f"Warning: num_columns in the YAML file was greater than the number of plots. Resetting num_columns to number of plots:{num_columns}."
-            )
-        else:
-            self.plot_settings["num_columns"] = num_columns  # Update the settings
-
-        num_rows = num_plots // num_columns
-        last_row_cols = num_plots % num_columns
-        remaining_space = num_columns - last_row_cols
-
-        for i, plot_config in enumerate(self.plot_data):
-            row, col = i // num_columns, i % num_columns
-            colspan = 1
-
-            if row == num_rows and remaining_space > 0:
-                if last_row_cols == 1:
-                    colspan = num_columns
-                else:
-                    colspan = remaining_space // last_row_cols + 1
-                    remaining_space -= colspan - 1
-                    last_row_cols -= 1
-
-            plot_name = plot_config.get("plot_name", "")
-            x_label = plot_config["x"].get("label", "")
-            y_label = plot_config["y"].get("label", "")
-
-            plot = self.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):
-        """
-        Initialize curve data and properties, and update table row labels.
-
-        This method initializes a nested dictionary `self.curves_data` to store
-        the curve objects for each x and y signal pair. It also updates the row labels
-        in `self.tableWidget_crosshair` to include the grid position for each y-value.
-        """
-        self.curves_data = {}
-        row_labels = []
-
-        for idx, plot_config in enumerate(self.plot_data):
-            plot_name = plot_config.get("plot_name", "")
-            plot = self.plots[plot_name]
-            plot.clear()
-
-            y_configs = plot_config["y"]["signals"]
-            colors_ys = Colors.golden_angle_color(
-                colormap=self.plot_settings["colormap"], num=len(y_configs)
-            )
-
-            curve_list = []
-            for i, (y_config, color) in enumerate(zip(y_configs, colors_ys)):
-                # print(y_config)
-                y_name = y_config["name"]
-                y_entries = y_config.get("entry", [y_name])
-
-                if not isinstance(y_entries, list):
-                    y_entries = [y_entries]
-
-                for y_entry in y_entries:
-                    user_color = self.user_colors.get((plot_name, y_name, y_entry), None)
-                    color_to_use = user_color if user_color else color
-
-                    pen_curve = mkPen(color=color_to_use, width=2, style=QtCore.Qt.DashLine)
-                    brush_curve = mkBrush(color=color_to_use)
-
-                    curve_data = pg.PlotDataItem(
-                        symbolSize=5,
-                        symbolBrush=brush_curve,
-                        pen=pen_curve,
-                        skipFiniteCheck=True,
-                        name=f"{y_name} ({y_entry})",
-                    )
-
-                    curve_list.append((y_name, y_entry, curve_data))
-                    plot.addItem(curve_data)
-                    row_labels.append(f"{y_name} ({y_entry}) - {plot_name}")
-
-            self.curves_data[plot_name] = curve_list
-
-    # TODO hook crosshairs here
-
-    def update_plot(self) -> None:
-        """Update the plot data based on the stored data dictionary."""
-        for plot_name, curve_list in self.curves_data.items():
-            for y_name, y_entry, curve in curve_list:
-                x_config = next(
-                    (pc["x"] for pc in self.plot_data if pc.get("plot_name") == plot_name), {}
-                )
-                x_signal_config = x_config["signals"][0]
-                x_name = x_signal_config.get("name", "")
-                x_entry = x_signal_config.get("entry", x_name)
-
-                key = (x_name, x_entry, y_name, y_entry)
-                data_x = self.data.get(key, {}).get("x", [])
-                data_y = self.data.get(key, {}).get("y", [])
-
-                curve.setData(data_x, data_y)
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, msg, metadata):
-        """
-        Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
-
-        Args:
-            msg (dict): Message received with scan data.
-            metadata (dict): Metadata of the scan.
-        """
-        current_scanID = msg.get("scanID", None)
-        if current_scanID is None:
-            return
-
-        if current_scanID != self.scanID:
-            if self.scan_types is False:
-                self.plot_data = self.plot_data_config
-            elif self.scan_types is True:
-                currentName = metadata.get("scan_name")
-                if currentName is None:
-                    raise ValueError(
-                        f"Scan name not found in metadata. Please check the scan_name in the YAML config or in bec "
-                        f"configuration."
-                    )
-                self.plot_data = self.plot_data_config.get(currentName, [])
-                if self.plot_data == []:
-                    raise ValueError(
-                        f"Scan name {currentName} not found in the YAML config. Please check the scan_name in the "
-                        f"YAML config or in bec configuration."
-                    )
-
-                # Init UI
-                self._init_ui(self.plot_settings["num_columns"])
-
-            self.scanID = current_scanID
-            self.data = {}
-            self.init_curves()
-
-        for plot_config in self.plot_data:
-            plot_name = plot_config.get("plot_name", "Unnamed Plot")
-            x_config = plot_config["x"]
-            x_signal_config = x_config["signals"][0]  # Assuming there's at least one signal for x
-
-            x_name = x_signal_config.get("name", "")
-            if not x_name:
-                raise ValueError(f"Name for x signal must be specified in plot: {plot_name}.")
-
-            x_entry_list = x_signal_config.get("entry", [])
-            if not x_entry_list:
-                x_entry_list = (
-                    self.dev[x_name]._hints if hasattr(self.dev[x_name], "_hints") else [x_name]
-                )
-
-            if not isinstance(x_entry_list, list):
-                x_entry_list = [x_entry_list]
-
-            y_configs = plot_config["y"]["signals"]
-
-            for x_entry in x_entry_list:
-                for y_config in y_configs:
-                    y_name = y_config.get("name", "")
-                    if not y_name:
-                        raise ValueError(
-                            f"Name for y signal must be specified in plot: {plot_name}."
-                        )
-
-                    y_entry_list = y_config.get("entry", [])
-                    if not y_entry_list:
-                        y_entry_list = (
-                            self.dev[y_name]._hints
-                            if hasattr(self.dev[y_name], "_hints")
-                            else [y_name]
-                        )
-
-                    if not isinstance(y_entry_list, list):
-                        y_entry_list = [y_entry_list]
-
-                    for y_entry in y_entry_list:
-                        key = (x_name, x_entry, y_name, y_entry)
-
-                        data_x = msg["data"].get(x_name, {}).get(x_entry, {}).get("value", None)
-                        data_y = msg["data"].get(y_name, {}).get(y_entry, {}).get("value", None)
-
-                        if data_x is None:
-                            raise ValueError(
-                                f"Incorrect entry '{x_entry}' specified for x in plot: {plot_name}, x name: {x_name}"
-                            )
-
-                        if data_y is None:
-                            if hasattr(self.dev[y_name], "_hints"):
-                                raise ValueError(
-                                    f"Incorrect entry '{y_entry}' specified for y in plot: {plot_name}, y name: {y_name}"
-                                )
-                            else:
-                                raise ValueError(
-                                    f"No hints available for y in plot: {plot_name}, and name '{y_name}' did not work as entry"
-                                )
-
-                        if data_x is not None:
-                            self.data.setdefault(key, {}).setdefault("x", []).append(data_x)
-
-                        if data_y is not None:
-                            self.data.setdefault(key, {}).setdefault("y", []).append(data_y)
-
-        self.update_signal.emit()
-
-
-if __name__ == "__main__":
-    import sys
-    from bec_widgets.bec_dispatcher import bec_dispatcher
-
-    client = bec_dispatcher.client
-    client.start()
-
-    app = QApplication(sys.argv)
-    monitor = BECDeviceMonitor()
-    monitor.show()
-    sys.exit(app.exec_())

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/figure/__init__.py

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

bec_widgets/widgets/figure/figure.py

@@ -0,0 +1,524 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+from __future__ import annotations
+
+import itertools
+import os
+from collections import defaultdict
+from typing import Literal, Optional
+
+import numpy as np
+import pyqtgraph as pg
+import qdarktheme
+from pydantic import Field
+from pyqtgraph.Qt import uic
+from qtpy.QtWidgets import QApplication, QWidget
+from qtpy.QtWidgets import QVBoxLayout, QMainWindow
+
+from bec_widgets.utils import BECConnector, BECDispatcher, ConnectionConfig
+from bec_widgets.widgets.plots import BECPlotBase, BECWaveform1D, Waveform1DConfig, WidgetConfig
+
+
+class FigureConfig(ConnectionConfig):
+    """Configuration for BECFigure. Inheriting from ConnectionConfig widget_class and gui_id"""
+
+    theme: Literal["dark", "light"] = Field("dark", description="The theme of the figure widget.")
+    num_cols: int = Field(1, description="The number of columns in the figure widget.")
+    num_rows: int = Field(1, description="The number of rows in the figure widget.")
+    widgets: dict[str, WidgetConfig] = Field(
+        {}, description="The list of widgets to be added to the figure widget."
+    )
+
+
+class WidgetHandler:
+    """Factory for creating and configuring BEC widgets for BECFigure."""
+
+    def __init__(self):
+        self.widget_factory = {
+            "PlotBase": (BECPlotBase, WidgetConfig),
+            "Waveform1D": (BECWaveform1D, Waveform1DConfig),
+        }
+
+    def create_widget(
+        self,
+        widget_type: str,
+        widget_id: str,
+        parent_figure,
+        parent_id: str,
+        config: dict = None,
+        **axis_kwargs,
+    ) -> BECPlotBase:
+        """
+        Create and configure a widget based on its type.
+
+        Args:
+            widget_type (str): The type of the widget to create.
+            widget_id (str): Unique identifier for the widget.
+            parent_id (str): Identifier of the parent figure.
+            config (dict, optional): Additional configuration for the widget.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECPlotBase: The created and configured widget instance.
+        """
+        entry = self.widget_factory.get(widget_type)
+        if not entry:
+            raise ValueError(f"Unsupported widget type: {widget_type}")
+
+        widget_class, config_class = entry
+        widget_config_dict = {
+            "widget_class": widget_class.__name__,
+            "parent_id": parent_id,
+            "gui_id": widget_id,
+            **(config if config is not None else {}),
+        }
+        widget_config = config_class(**widget_config_dict)
+        widget = widget_class(
+            config=widget_config, parent_figure=parent_figure, client=parent_figure.client
+        )
+
+        if axis_kwargs:
+            widget.set(**axis_kwargs)
+
+        return widget
+
+
+class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
+    USER_ACCESS = ["add_plot", "remove", "change_layout", "change_theme", "clear_all"]
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        config: Optional[FigureConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ) -> None:
+        if config is None:
+            config = FigureConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = FigureConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        pg.GraphicsLayoutWidget.__init__(self, parent)
+
+        self.widget_handler = WidgetHandler()
+
+        # Widget container to reference widgets by 'widget_id'
+        self.widgets = defaultdict(dict)
+
+        # Container to keep track of the grid
+        self.grid = []
+
+    def change_theme(self, theme: Literal["dark", "light"]) -> None:
+        """
+        Change the theme of the figure widget.
+        Args:
+            theme(Literal["dark","light"]): The theme to set for the figure widget.
+        """
+        qdarktheme.setup_theme(theme)
+        self.setBackground("k" if theme == "dark" else "w")
+        self.config.theme = theme
+
+    def add_plot(
+        self, widget_id: str = None, row: int = None, col: int = None, config=None, **axis_kwargs
+    ) -> BECWaveform1D:
+        """
+        Add a Waveform1D plot to the figure at the specified position.
+        Args:
+            widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Additional configuration for the widget.
+            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
+        """
+        return self.add_widget(
+            widget_type="Waveform1D",
+            widget_id=widget_id,
+            row=row,
+            col=col,
+            config=config,
+            **axis_kwargs,
+        )
+
+    def add_widget(
+        self,
+        widget_type: Literal["PlotBase", "Waveform1D"] = "PlotBase",
+        widget_id: str = None,
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> BECPlotBase:
+        """
+        Add a widget to the figure at the specified position.
+        Args:
+            widget_type(Literal["PlotBase","Waveform1D"]): The type of the widget to add.
+            widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Additional configuration for the widget.
+            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
+        """
+        if not widget_id:
+            widget_id = self._generate_unique_widget_id()
+        if widget_id in self.widgets:
+            raise ValueError(f"Widget with ID '{widget_id}' already exists.")
+
+        widget = self.widget_handler.create_widget(
+            widget_type=widget_type,
+            widget_id=widget_id,
+            parent_figure=self,
+            parent_id=self.gui_id,
+            config=config,
+            **axis_kwargs,
+        )
+
+        # Check if position is occupied
+        if row is not None and col is not None:
+            if self.getItem(row, col):
+                raise ValueError(f"Position at row {row} and column {col} is already occupied.")
+            else:
+                widget.config.row = row
+                widget.config.col = col
+
+                # Add widget to the figure
+                self.addItem(widget, row=row, col=col)
+        else:
+            row, col = self._find_next_empty_position()
+            widget.config.row = row
+            widget.config.col = col
+
+            # Add widget to the figure
+            self.addItem(widget, row=row, col=col)
+
+        # Update num_cols and num_rows based on the added widget
+        self.config.num_rows = max(self.config.num_rows, row + 1)
+        self.config.num_cols = max(self.config.num_cols, col + 1)
+
+        # Saving config for future referencing
+        self.config.widgets[widget_id] = widget.config
+        self.widgets[widget_id] = widget
+
+        # Reflect the grid coordinates
+        self._change_grid(widget_id, row, col)
+
+        return widget
+
+    def remove(
+        self,
+        row: int = None,
+        col: int = None,
+        widget_id: str = None,
+        coordinates: tuple[int, int] = None,
+    ) -> None:
+        """
+        Remove a widget from the figure. Can be removed by its unique identifier or by its coordinates.
+        Args:
+            row(int): The row coordinate of the widget to remove.
+            col(int): The column coordinate of the widget to remove.
+            widget_id(str): The unique identifier of the widget to remove.
+            coordinates(tuple[int, int], optional): The coordinates of the widget to remove.
+        """
+        if widget_id:
+            self._remove_by_id(widget_id)
+        elif row is not None and col is not None:
+            self._remove_by_coordinates(row, col)
+        elif coordinates:
+            self._remove_by_coordinates(*coordinates)
+        else:
+            raise ValueError("Must provide either widget_id or coordinates for removal.")
+
+    def _remove_by_coordinates(self, row: int, col: int) -> None:
+        """
+        Remove a widget from the figure by its coordinates.
+        Args:
+            row(int): The row coordinate of the widget to remove.
+            col(int): The column coordinate of the widget to remove.
+        """
+        widget = self._get_widget_by_coordinates(row, col)
+        if widget:
+            widget_id = widget.config.gui_id
+            if widget_id in self.widgets:
+                self._remove_by_id(widget_id)
+
+    def _remove_by_id(self, widget_id: str) -> None:
+        """
+        Remove a widget from the figure by its unique identifier.
+        Args:
+            widget_id(str): The unique identifier of the widget to remove.
+        """
+        if widget_id in self.widgets:
+            widget = self.widgets.pop(widget_id)
+            widget.cleanup()
+            self.removeItem(widget)
+            self.grid[widget.config.row][widget.config.col] = None
+            self._reindex_grid()
+            if widget_id in self.config.widgets:
+                self.config.widgets.pop(widget_id)
+            print(f"Removed widget {widget_id}.")
+        else:
+            raise ValueError(f"Widget with ID '{widget_id}' does not exist.")
+
+    def __getitem__(self, key: tuple | str):
+        if isinstance(key, tuple) and len(key) == 2:
+            return self._get_widget_by_coordinates(*key)
+        elif isinstance(key, str):
+            widget = self.widgets.get(key)
+            if widget is None:
+                raise KeyError(f"No widget with ID {key}")
+            return self.widgets.get(key)
+        else:
+            raise TypeError(
+                "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
+            )
+
+    def _get_widget_by_coordinates(self, row: int, col: int) -> BECPlotBase:
+        """
+        Get widget by its coordinates in the figure.
+        Args:
+            row(int): the row coordinate
+            col(int): the column coordinate
+
+        Returns:
+            BECPlotBase: the widget at the given coordinates
+        """
+        widget = self.getItem(row, col)
+        if widget is None:
+            raise ValueError(f"No widget at coordinates ({row}, {col})")
+        return widget
+
+    def _find_next_empty_position(self):
+        """Find the next empty position (new row) in the figure."""
+        row, col = 0, 0
+        while self.getItem(row, col):
+            row += 1
+        return row, col
+
+    def _generate_unique_widget_id(self):
+        """Generate a unique widget ID."""
+        existing_ids = set(self.widgets.keys())
+        for i in itertools.count(1):
+            widget_id = f"widget_{i}"
+            if widget_id not in existing_ids:
+                return widget_id
+
+    def _change_grid(self, widget_id: str, row: int, col: int):
+        """
+        Change the grid to reflect the new position of the widget.
+        Args:
+            widget_id(str): The unique identifier of the widget.
+            row(int): The new row coordinate of the widget in the figure.
+            col(int): The new column coordinate of the widget in the figure.
+        """
+        while len(self.grid) <= row:
+            self.grid.append([])
+        row = self.grid[row]
+        while len(row) <= col:
+            row.append(None)
+        row[col] = widget_id
+
+    def _reindex_grid(self):
+        """Reindex the grid to remove empty rows and columns."""
+        print(f"old grid: {self.grid}")
+        new_grid = []
+        for row in self.grid:
+            new_row = [widget for widget in row if widget is not None]
+            if new_row:
+                new_grid.append(new_row)
+        #
+        # Update the config of each object to reflect its new position
+        for row_idx, row in enumerate(new_grid):
+            for col_idx, widget in enumerate(row):
+                self.widgets[widget].config.row, self.widgets[widget].config.col = row_idx, col_idx
+
+        self.grid = new_grid
+        self._replot_layout()
+
+    def _replot_layout(self):
+        """Replot the layout based on the current grid configuration."""
+        self.clear()
+        for row_idx, row in enumerate(self.grid):
+            for col_idx, widget in enumerate(row):
+                self.addItem(self.widgets[widget], row=row_idx, col=col_idx)
+
+    def change_layout(self, max_columns=None, max_rows=None):
+        """
+        Reshuffle the layout of the figure to adjust to a new number of max_columns or max_rows.
+        If both max_columns and max_rows are provided, max_rows is ignored.
+
+        Args:
+            max_columns (Optional[int]): The new maximum number of columns in the figure.
+            max_rows (Optional[int]): The new maximum number of rows in the figure.
+        """
+        # Calculate total number of widgets
+        total_widgets = len(self.widgets)
+
+        if max_columns:
+            # Calculate the required number of rows based on max_columns
+            required_rows = (total_widgets + max_columns - 1) // max_columns
+            new_grid = [[None for _ in range(max_columns)] for _ in range(required_rows)]
+        elif max_rows:
+            # Calculate the required number of columns based on max_rows
+            required_columns = (total_widgets + max_rows - 1) // max_rows
+            new_grid = [[None for _ in range(required_columns)] for _ in range(max_rows)]
+        else:
+            # If neither max_columns nor max_rows is specified, just return without changing the layout
+            return
+
+        # Populate the new grid with widgets' IDs
+        current_idx = 0
+        for widget_id, widget in self.widgets.items():
+            row = current_idx // len(new_grid[0])
+            col = current_idx % len(new_grid[0])
+            new_grid[row][col] = widget_id
+            current_idx += 1
+
+        self.config.num_rows = row
+        self.config.num_cols = col
+
+        # Update widgets' positions and replot them according to the new grid
+        self.grid = new_grid
+        self._reindex_grid()  # This method should be updated to handle reshuffling correctly
+        self._replot_layout()  # Assumes this method re-adds widgets to the layout based on self.grid
+
+    def clear_all(self):
+        """Clear all widgets from the figure and reset to default state"""
+        self.clear()
+        self.widgets = defaultdict(dict)
+        self.grid = []
+        theme = self.config.theme
+        self.config = FigureConfig(
+            widget_class=self.__class__.__name__, gui_id=self.gui_id, theme=theme
+        )
+
+    def start(self):
+        import sys
+
+        app = QApplication(sys.argv)
+        win = QMainWindow()
+        win.setCentralWidget(self)
+        win.show()
+
+        sys.exit(app.exec_())
+
+
+##################################################
+##################################################
+# Debug window
+##################################################
+##################################################
+
+from qtconsole.inprocess import QtInProcessKernelManager
+from qtconsole.rich_jupyter_widget import RichJupyterWidget
+
+
+class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
+    def __init__(self):
+        super().__init__()
+
+        self.kernel_manager = QtInProcessKernelManager()
+        self.kernel_manager.start_kernel(show_banner=False)
+        self.kernel_client = self.kernel_manager.client()
+        self.kernel_client.start_channels()
+
+        self.kernel_manager.kernel.shell.push({"np": np, "pg": pg})
+
+    def shutdown_kernel(self):
+        self.kernel_client.stop_channels()
+        self.kernel_manager.shutdown_kernel()
+
+
+class DebugWindow(QWidget):  # pragma: no cover:
+    """Debug window for BEC widgets"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        current_path = os.path.dirname(__file__)
+        uic.loadUi(os.path.join(current_path, "figure_debug_minimal.ui"), self)
+
+        self._init_ui()
+
+        self.splitter.setSizes([200, 100])
+
+        # console push
+        self.console.kernel_manager.kernel.shell.push(
+            {"fig": self.figure, "w1": self.w1, "w2": self.w2}
+        )
+
+    def _init_ui(self):
+        # Plotting window
+        self.glw_1_layout = QVBoxLayout(self.glw)  # Create a new QVBoxLayout
+        self.figure = BECFigure(parent=self)  # Create a new BECDeviceMonitor
+        self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout
+
+        # add stuff to figure
+        self._init_figure()
+
+        self.console_layout = QVBoxLayout(self.widget_console)
+        self.console = JupyterConsoleWidget()
+        self.console_layout.addWidget(self.console)
+        self.console.set_default_style("linux")
+
+    def _init_figure(self):
+        self.figure.add_widget(widget_type="Waveform1D", row=0, col=0, title="Widget 1")
+        self.figure.add_widget(widget_type="Waveform1D", row=1, col=0, title="Widget 2")
+        self.figure.add_widget(widget_type="Waveform1D", row=0, col=1, title="Widget 3")
+        self.figure.add_widget(widget_type="Waveform1D", row=1, col=1, title="Widget 4")
+
+        self.w1 = self.figure[0, 0]
+        self.w2 = self.figure[1, 0]
+        self.w3 = self.figure[0, 1]
+        self.w4 = self.figure[1, 1]
+
+        # curves for w1
+        self.w1.add_curve_scan("samx", "bpm4i", pen_style="dash")
+        self.w1.add_curve_custom(
+            x=[1, 2, 3, 4, 5],
+            y=[1, 2, 3, 4, 5],
+            label="curve-custom",
+            color="blue",
+            pen_style="dashdot",
+        )
+        self.c1 = self.w1.get_config()
+
+        # curves for w2
+        self.w2.add_curve_scan("samx", "bpm3a", pen_style="solid")
+        self.w2.add_curve_scan("samx", "bpm4d", pen_style="dot")
+        self.w2.add_curve_custom(
+            x=[1, 2, 3, 4, 5], y=[5, 4, 3, 2, 1], color="red", pen_style="dashdot"
+        )
+
+        # curves for w3
+        self.w3.add_curve_scan("samx", "bpm4i", pen_style="dash")
+        self.w3.add_curve_custom(
+            x=[1, 2, 3, 4, 5],
+            y=[1, 2, 3, 4, 5],
+            label="curve-custom",
+            color="blue",
+            pen_style="dashdot",
+        )
+
+        # curves for w4
+        self.w4.add_curve_scan("samx", "bpm4i", pen_style="dash")
+        self.w4.add_curve_custom(
+            x=[1, 2, 3, 4, 5],
+            y=[1, 2, 3, 4, 5],
+            label="curve-custom",
+            color="blue",
+            pen_style="dashdot",
+        )
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+    client.start()
+
+    app = QApplication(sys.argv)
+    win = DebugWindow()
+    win.show()
+
+    sys.exit(app.exec_())

bec_widgets/widgets/figure/figure_debug_minimal.ui

@@ -0,0 +1,35 @@
+<?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>901</width>
+    <height>1000</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_3">
+   <item>
+    <widget class="QSplitter" name="splitter_2">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <widget class="QSplitter" name="splitter">
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+      <widget class="QWidget" name="glw" native="true"/>
+     </widget>
+     <widget class="QWidget" name="widget_console" native="true"/>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

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,591 @@
+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
+from bec_widgets.validation import MonitorConfigValidator
+from pydantic import ValidationError
+from qtpy.QtWidgets import QApplication, QMessageBox
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+
+current_path = os.path.dirname(__file__)
+Ui_Form, BaseClass = uic.loadUiType(os.path.join(current_path, "config_dialog.ui"))
+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,
+        client=None,
+        default_config=None,
+        skip_validation: bool = False,
+    ):
+        super(ConfigDialog, self).__init__()
+        self.setupUi(self)
+
+        # Client
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.dev = self.client.device_manager.devices
+
+        # Init validator
+        self.skip_validation = skip_validation
+        if self.skip_validation is False:
+            self.validator = MonitorConfigValidator(self.dev)
+
+        # 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()
+        if self.skip_validation is True:
+            self.config_updated.emit(new_config)
+            self.close()
+        else:
+            try:
+                validated_config = self.validator.validate_monitor_config(new_config)
+                approved_config = validated_config.model_dump()
+                self.config_updated.emit(approved_config)
+                self.close()
+            except ValidationError as e:
+                error_str = str(e)
+                formatted_error_message = ConfigDialog.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
+
+
+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,855 @@
+# 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": "bpm4i"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 2",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "bpm4i"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 3",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy"}],
+                            "y": [{"name": "bpm4i"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 4",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy", "entry": "samy"}],
+                            "y": [{"name": "bpm4i"}],
+                        },
+                    }
+                ],
+            },
+        ],
+        "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": "bpm4i"}, {"name": "bpm4i"}],
+                        },
+                    }
+                ],
+            },
+        ],
+    },
+}
+
+
+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": "bpm4i"}, {"name": "bpm4i"}],
+                    },
+                }
+            ],
+        },
+    ],
+}
+
+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 = None
+
+        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"])
+
+        if self.scanID is not None:
+            self.replot_last_scan()
+
+    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(
+            client=self.client, default_config=self.config, skip_validation=self.skip_validation
+        )
+        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}")
+
+    def replot_last_scan(self):
+        """
+        Replot the last scan.
+        """
+        self.scan_segment_update()
+        self.update_plot(source_type="scan_segment")
+
+    @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_control/__init__.py

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

bec_widgets/widgets/motor_control/motor_control_absolute.ui

@@ -0,0 +1,149 @@
+<?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>285</width>
+    <height>220</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>285</width>
+    <height>220</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>285</width>
+    <height>220</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Move Movement Absolute</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2">
+   <item>
+    <widget class="QGroupBox" name="motorControl_absolute">
+     <property name="minimumSize">
+      <size>
+       <width>261</width>
+       <height>195</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>261</width>
+       <height>195</height>
+      </size>
+     </property>
+     <property name="title">
+      <string>Move Movement Absolute</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout">
+      <item>
+       <widget class="QCheckBox" name="checkBox_save_with_go">
+        <property name="text">
+         <string>Save position with Go</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <layout class="QGridLayout" name="gridLayout_3">
+        <item row="1" column="1">
+         <widget class="QDoubleSpinBox" name="spinBox_absolute_y">
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+          <property name="minimum">
+           <double>-500.000000000000000</double>
+          </property>
+          <property name="maximum">
+           <double>500.000000000000000</double>
+          </property>
+          <property name="singleStep">
+           <double>0.100000000000000</double>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QDoubleSpinBox" name="spinBox_absolute_x">
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+          <property name="minimum">
+           <double>-500.000000000000000</double>
+          </property>
+          <property name="maximum">
+           <double>500.000000000000000</double>
+          </property>
+          <property name="singleStep">
+           <double>0.100000000000000</double>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <widget class="QLabel" name="label_7">
+          <property name="text">
+           <string>Y</string>
+          </property>
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="0">
+         <widget class="QLabel" name="label_6">
+          <property name="text">
+           <string>X</string>
+          </property>
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <item>
+         <widget class="QPushButton" name="pushButton_save">
+          <property name="text">
+           <string>Save</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="pushButton_set">
+          <property name="text">
+           <string>Set</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="pushButton_go_absolute">
+          <property name="text">
+           <string>Go</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <widget class="QPushButton" name="pushButton_stop">
+        <property name="text">
+         <string>Stop Movement</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/motor_control/motor_control_relative.ui

@@ -0,0 +1,298 @@
+<?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>285</width>
+    <height>405</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>285</width>
+    <height>405</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Motor Control Relative</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QGroupBox" name="motorControl">
+     <property name="minimumSize">
+      <size>
+       <width>261</width>
+       <height>394</height>
+      </size>
+     </property>
+     <property name="title">
+      <string>Motor Control Relative</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_5">
+      <item>
+       <widget class="QCheckBox" name="checkBox_enableArrows">
+        <property name="text">
+         <string>Move with arrow keys</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QCheckBox" name="checkBox_same_xy">
+        <property name="text">
+         <string>Step [X] = Step [Y]</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <layout class="QGridLayout" name="step_grid">
+        <item row="2" column="0">
+         <widget class="QLabel" name="label_step_y">
+          <property name="minimumSize">
+           <size>
+            <width>111</width>
+            <height>19</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>Step [Y]</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="0">
+         <widget class="QLabel" name="label_2">
+          <property name="minimumSize">
+           <size>
+            <width>111</width>
+            <height>19</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>Decimal</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="QDoubleSpinBox" name="spinBox_step_x">
+          <property name="minimumSize">
+           <size>
+            <width>110</width>
+            <height>19</height>
+           </size>
+          </property>
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+          <property name="minimum">
+           <double>0.000000000000000</double>
+          </property>
+          <property name="maximum">
+           <double>99.000000000000000</double>
+          </property>
+          <property name="singleStep">
+           <double>0.100000000000000</double>
+          </property>
+          <property name="value">
+           <double>1.000000000000000</double>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QLabel" name="label_step_x">
+          <property name="minimumSize">
+           <size>
+            <width>111</width>
+            <height>19</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>Step [X]</string>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="1">
+         <widget class="QDoubleSpinBox" name="spinBox_step_y">
+          <property name="minimumSize">
+           <size>
+            <width>110</width>
+            <height>19</height>
+           </size>
+          </property>
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+          <property name="minimum">
+           <double>0.000000000000000</double>
+          </property>
+          <property name="maximum">
+           <double>99.000000000000000</double>
+          </property>
+          <property name="singleStep">
+           <double>0.100000000000000</double>
+          </property>
+          <property name="value">
+           <double>1.000000000000000</double>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <widget class="QSpinBox" name="spinBox_precision">
+          <property name="minimumSize">
+           <size>
+            <width>110</width>
+            <height>19</height>
+           </size>
+          </property>
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+          <property name="maximum">
+           <number>8</number>
+          </property>
+          <property name="value">
+           <number>2</number>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QGridLayout" name="direction_grid">
+        <property name="sizeConstraint">
+         <enum>QLayout::SetDefaultConstraint</enum>
+        </property>
+        <item row="1" column="2" alignment="Qt::AlignHCenter|Qt::AlignVCenter">
+         <widget class="QToolButton" name="toolButton_up">
+          <property name="minimumSize">
+           <size>
+            <width>26</width>
+            <height>26</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>...</string>
+          </property>
+          <property name="arrowType">
+           <enum>Qt::UpArrow</enum>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="4">
+         <spacer name="horizontalSpacer_2">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item row="3" column="2" alignment="Qt::AlignHCenter|Qt::AlignVCenter">
+         <widget class="QToolButton" name="toolButton_down">
+          <property name="minimumSize">
+           <size>
+            <width>26</width>
+            <height>26</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>...</string>
+          </property>
+          <property name="arrowType">
+           <enum>Qt::DownArrow</enum>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="1">
+         <widget class="QToolButton" name="toolButton_left">
+          <property name="minimumSize">
+           <size>
+            <width>26</width>
+            <height>26</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>...</string>
+          </property>
+          <property name="arrowType">
+           <enum>Qt::LeftArrow</enum>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="2">
+         <spacer name="verticalSpacer">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>40</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item row="2" column="3">
+         <widget class="QToolButton" name="toolButton_right">
+          <property name="minimumSize">
+           <size>
+            <width>26</width>
+            <height>26</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>...</string>
+          </property>
+          <property name="arrowType">
+           <enum>Qt::RightArrow</enum>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="0">
+         <spacer name="horizontalSpacer">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item row="4" column="2">
+         <spacer name="verticalSpacer_2">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>40</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <widget class="QPushButton" name="pushButton_stop">
+        <property name="text">
+         <string>Stop Movement</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/motor_control/motor_control_selection.ui

@@ -0,0 +1,69 @@
+<?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>285</width>
+    <height>156</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>285</width>
+    <height>156</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Motor Control Selection</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QGroupBox" name="motorSelection">
+     <property name="minimumSize">
+      <size>
+       <width>261</width>
+       <height>145</height>
+      </size>
+     </property>
+     <property name="title">
+      <string>Motor Selection</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_4">
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_5">
+        <property name="text">
+         <string>Motor X</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QComboBox" name="comboBox_motor_x"/>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_8">
+        <property name="text">
+         <string>Motor Y</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0" colspan="2">
+       <widget class="QPushButton" name="pushButton_connecMotors">
+        <property name="text">
+         <string>Connect Motors</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QComboBox" name="comboBox_motor_y"/>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/motor_control/motor_control_table.ui

@@ -0,0 +1,113 @@
+<?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>676</width>
+    <height>667</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Motor Coordinates Table</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
+     <item>
+      <spacer name="horizontalSpacer_4">
+       <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="QCheckBox" name="checkBox_resize_auto">
+       <property name="text">
+        <string>Resize Auto</string>
+       </property>
+       <property name="checked">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_editColumns">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string>Edit Custom Column</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="label">
+       <property name="text">
+        <string>Entries Mode:</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QComboBox" name="comboBox_mode">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
+       <item>
+        <property name="text">
+         <string>Individual</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Start/Stop</string>
+        </property>
+       </item>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QTableWidget" name="table">
+     <property name="gridStyle">
+      <enum>Qt::SolidLine</enum>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QPushButton" name="pushButton_importCSV">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string>Import CSV</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_exportCSV">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string>Export CSV</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

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,607 @@
+# 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")
+
+    @pyqtSlot(str, str, int)
+    def change_motors(self, motor_x: str, motor_y: str, subplot: int = 0) -> None:
+        """
+        Change the active motors for the plot.
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            subplot(int): Subplot number.
+        """
+        if subplot >= len(self.plot_data):
+            print(f"Invalid subplot index: {subplot}. Available subplots: {len(self.plot_data)}")
+            return
+
+        # Update the motor names in the plot configuration
+        self.config["motors"][subplot]["signals"]["x"][0]["name"] = motor_x
+        self.config["motors"][subplot]["signals"]["x"][0]["entry"] = motor_x
+        self.config["motors"][subplot]["signals"]["y"][0]["name"] = motor_y
+        self.config["motors"][subplot]["signals"]["y"][0]["entry"] = motor_y
+
+        # reinitialise the config and UI
+        self._init_config()
+
+    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()
+
+        # Render init position of selected motors
+        self._update_plots()
+
+    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(list, str, str)
+    def plot_saved_coordinates(self, coordinates: list, tag: str, color: str):
+        """
+        Plot saved coordinates on the map.
+        Args:
+            coordinates(list): List of coordinates to be plotted.
+            tag(str): Tag for the coordinates for future reference.
+            color(str): Color to plot coordinates in.
+        """
+        for plot_name in self.plots:
+            plot = self.plots[plot_name]
+
+            # Clear previous saved points
+            if tag in self.curves_data[plot_name]:
+                plot.removeItem(self.curves_data[plot_name][tag])
+
+            # Filter coordinates to be shown
+            visible_coords = [coord[:2] for coord in coordinates if coord[2]]
+
+            if visible_coords:
+                saved_points = pg.ScatterPlotItem(
+                    pos=np.array(visible_coords), brush=pg.mkBrush(color)
+                )
+                plot.addItem(saved_points)
+                self.curves_data[plot_name][tag] = saved_points
+
+    @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/plots/__init__.py

@@ -0,0 +1,2 @@
+from .plot_base import AxisConfig, WidgetConfig, BECPlotBase
+from .waveform1d import Waveform1DConfig, BECWaveform1D, BECCurve

bec_widgets/widgets/plots/plot_base.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+import numpy as np
+import pyqtgraph as pg
+
+from pydantic import BaseModel, Field
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+
+class AxisConfig(BaseModel):
+    title: Optional[str] = Field(None, description="The title of the axes.")
+    x_label: Optional[str] = Field(None, description="The label for the x-axis.")
+    y_label: Optional[str] = Field(None, description="The label for the y-axis.")
+    x_scale: Literal["linear", "log"] = Field("linear", description="The scale of the x-axis.")
+    y_scale: Literal["linear", "log"] = Field("linear", description="The scale of the y-axis.")
+    x_lim: Optional[tuple] = Field(None, description="The limits of the x-axis.")
+    y_lim: Optional[tuple] = Field(None, description="The limits of the y-axis.")
+    x_grid: bool = Field(False, description="Show grid on the x-axis.")
+    y_grid: bool = Field(False, description="Show grid on the y-axis.")
+
+
+class WidgetConfig(ConnectionConfig):
+    parent_id: Optional[str] = Field(None, description="The parent figure of the plot.")
+
+    # Coordinates in the figure
+    row: int = Field(0, description="The row coordinate in the figure.")
+    col: int = Field(0, description="The column coordinate in the figure.")
+
+    # Appearance settings
+    axis: AxisConfig = Field(
+        default_factory=AxisConfig, description="The axis configuration of the plot."
+    )
+
+
+class BECPlotBase(BECConnector, pg.PlotItem):
+    USER_ACCESS = [
+        "set",
+        "set_title",
+        "set_x_label",
+        "set_y_label",
+        "set_x_scale",
+        "set_y_scale",
+        "set_x_lim",
+        "set_y_lim",
+        "set_grid",
+        "plot_data",
+        "remove",
+    ]
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,  # TODO decide if needed for this class
+        parent_figure=None,
+        config: Optional[WidgetConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = WidgetConfig(widget_class=self.__class__.__name__)
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        pg.PlotItem.__init__(self, parent)
+
+        self.figure = parent_figure
+
+        self.add_legend()
+
+    def set(self, **kwargs) -> None:
+        """
+        Set the properties of the plot widget.
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - title: str
+            - x_label: str
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+        """
+        # Mapping of keywords to setter methods
+        method_map = {
+            "title": self.set_title,
+            "x_label": self.set_x_label,
+            "y_label": self.set_y_label,
+            "x_scale": self.set_x_scale,
+            "y_scale": self.set_y_scale,
+            "x_lim": self.set_x_lim,
+            "y_lim": self.set_y_lim,
+        }
+        for key, value in kwargs.items():
+            if key in method_map:
+                method_map[key](value)
+            else:
+                print(f"Warning: '{key}' is not a recognized property.")
+
+    def apply_axis_config(self):
+        """Apply the axis configuration to the plot widget."""
+        config_mappings = {
+            "title": self.config.axis.title,
+            "x_label": self.config.axis.x_label,
+            "y_label": self.config.axis.y_label,
+            "x_scale": self.config.axis.x_scale,
+            "y_scale": self.config.axis.y_scale,
+            "x_lim": self.config.axis.x_lim,
+            "y_lim": self.config.axis.y_lim,
+        }
+
+        self.set(**{k: v for k, v in config_mappings.items() if v is not None})
+
+    def set_title(self, title: str):
+        """
+        Set the title of the plot widget.
+        Args:
+            title(str): Title of the plot widget.
+        """
+        self.setTitle(title)
+        self.config.axis.title = title
+
+    def set_x_label(self, label: str):
+        """
+        Set the label of the x-axis.
+        Args:
+            label(str): Label of the x-axis.
+        """
+        self.setLabel("bottom", label)
+        self.config.axis.x_label = label
+
+    def set_y_label(self, label: str):
+        """
+        Set the label of the y-axis.
+        Args:
+            label(str): Label of the y-axis.
+        """
+        self.setLabel("left", label)
+        self.config.axis.y_label = label
+
+    def set_x_scale(self, scale: Literal["linear", "log"] = "linear"):
+        """
+        Set the scale of the x-axis.
+        Args:
+            scale(Literal["linear", "log"]): Scale of the x-axis.
+        """
+        self.setLogMode(x=(scale == "log"))
+        self.config.axis.x_scale = scale
+
+    def set_y_scale(self, scale: Literal["linear", "log"] = "linear"):
+        """
+        Set the scale of the y-axis.
+        Args:
+            scale(Literal["linear", "log"]): Scale of the y-axis.
+        """
+        self.setLogMode(y=(scale == "log"))
+        self.config.axis.y_scale = scale
+
+    def set_x_lim(self, *args) -> None:
+        """
+        Set the limits of the x-axis. This method can accept either two separate arguments
+        for the minimum and maximum x-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_x_lim(x_min, x_max)
+            set_x_lim((x_min, x_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (x_min and x_max)
+                   or a single tuple with two integers.
+        """
+        if len(args) == 1 and isinstance(args[0], tuple):
+            x_min, x_max = args[0]
+        elif len(args) == 2:
+            x_min, x_max = args
+        else:
+            raise ValueError("set_x_lim expects either two separate arguments or a single tuple")
+
+        self.setXRange(x_min, x_max)
+        self.config.axis.x_lim = (x_min, x_max)
+
+    def set_y_lim(self, *args) -> None:
+        """
+        Set the limits of the y-axis. This method can accept either two separate arguments
+        for the minimum and maximum y-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_y_lim(y_min, y_max)
+            set_y_lim((y_min, y_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (y_min and y_max)
+                   or a single tuple with two integers.
+        """
+        if len(args) == 1 and isinstance(args[0], tuple):
+            y_min, y_max = args[0]
+        elif len(args) == 2:
+            y_min, y_max = args
+        else:
+            raise ValueError("set_y_lim expects either two separate arguments or a single tuple")
+
+        self.setYRange(y_min, y_max)
+        self.config.axis.y_lim = (y_min, y_max)
+
+    def set_grid(self, x: bool = False, y: bool = False):
+        """
+        Set the grid of the plot widget.
+        Args:
+            x(bool): Show grid on the x-axis.
+            y(bool): Show grid on the y-axis.
+        """
+        self.showGrid(x, y)
+        self.config.axis.x_grid = x
+        self.config.axis.y_grid = y
+
+    def add_legend(self):
+        self.addLegend()
+
+    def plot_data(self, data_x: list | np.ndarray, data_y: list | np.ndarray, **kwargs):
+        """
+        Plot custom data on the plot widget. These data are not saved in config.
+        Args:
+            data_x(list|np.ndarray): x-axis data
+            data_y(list|np.ndarray): y-axis data
+            **kwargs: Keyword arguments for the plot.
+        """
+        # TODO very basic so far, add more options
+        # TODO decide name of the method
+        self.plot(data_x, data_y, **kwargs)
+
+    def remove(self):
+        """Remove the plot widget from the figure."""
+        if self.figure is not None:
+            self.figure.remove(widget_id=self.gui_id)
+
+    def cleanup(self):
+        """Cleanup the plot widget."""

bec_widgets/widgets/plots/waveform1d.py

@@ -0,0 +1,731 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Literal, Optional, Any
+
+import numpy as np
+import pyqtgraph as pg
+from pydantic import Field, BaseModel, ValidationError
+from pyqtgraph import mkBrush
+from qtpy import QtCore
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QWidget
+
+from bec_lib import MessageEndpoints
+from bec_lib.scan_data import ScanData
+from bec_widgets.utils import Colors, ConnectionConfig, BECConnector, EntryValidator
+from bec_widgets.widgets.plots import BECPlotBase, WidgetConfig
+
+
+class SignalData(BaseModel):
+    """The data configuration of a signal in the 1D waveform widget for x and y axis."""
+
+    # TODO add validator on name and entry
+    name: str
+    entry: str
+    unit: Optional[str] = None  # todo implement later
+    modifier: Optional[str] = None  # todo implement later
+
+
+class Signal(BaseModel):
+    """The configuration of a signal in the 1D waveform widget."""
+
+    source: str  # TODO add validator on the source type
+    x: SignalData
+    y: SignalData
+
+
+class CurveConfig(ConnectionConfig):
+    parent_id: Optional[str] = Field(None, description="The parent plot of the curve.")
+    label: Optional[str] = Field(None, description="The label of the curve.")
+    color: Optional[Any] = Field(None, description="The color of the curve.")
+    symbol: Optional[str] = Field("o", description="The symbol of the curve.")
+    symbol_color: Optional[str] = Field(None, description="The color of the symbol of the curve.")
+    symbol_size: Optional[int] = Field(5, description="The size of the symbol of the curve.")
+    pen_width: Optional[int] = Field(2, description="The width of the pen of the curve.")
+    pen_style: Optional[Literal["solid", "dash", "dot", "dashdot"]] = Field(
+        "solid", description="The style of the pen of the curve."
+    )
+    source: Optional[str] = Field(
+        None, description="The source of the curve."
+    )  # TODO here on or curve??
+    signals: Optional[Signal] = Field(None, description="The signal of the curve.")
+
+
+class Waveform1DConfig(WidgetConfig):
+    color_palette: Literal["plasma", "viridis", "inferno", "magma"] = Field(
+        "plasma", description="The color palette of the figure widget."
+    )
+    curves: dict[str, CurveConfig] = Field(
+        {}, description="The list of curves to be added to the 1D waveform widget."
+    )
+
+
+class BECCurve(BECConnector, pg.PlotDataItem):
+    USER_ACCESS = [
+        "set",
+        "set_data",
+        "set_color",
+        "set_symbol",
+        "set_symbol_color",
+        "set_symbol_size",
+        "set_pen_width",
+        "set_pen_style",
+        "get_data",
+    ]
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        config: Optional[CurveConfig] = None,
+        gui_id: Optional[str] = None,
+        **kwargs,
+    ):
+        if config is None:
+            config = CurveConfig(label=name, widget_class=self.__class__.__name__)
+            self.config = config
+        else:
+            self.config = config
+            # config.widget_class = self.__class__.__name__
+        super().__init__(config=config, gui_id=gui_id)
+        pg.PlotDataItem.__init__(self, name=name)
+
+        self.apply_config()
+        if kwargs:
+            self.set(**kwargs)
+
+    def apply_config(self):
+        pen_style_map = {
+            "solid": QtCore.Qt.SolidLine,
+            "dash": QtCore.Qt.DashLine,
+            "dot": QtCore.Qt.DotLine,
+            "dashdot": QtCore.Qt.DashDotLine,
+        }
+        pen_style = pen_style_map.get(self.config.pen_style, QtCore.Qt.SolidLine)
+
+        pen = pg.mkPen(color=self.config.color, width=self.config.pen_width, style=pen_style)
+        self.setPen(pen)
+
+        if self.config.symbol:
+            symbol_color = self.config.symbol_color or self.config.color
+            brush = mkBrush(color=symbol_color)
+            self.setSymbolBrush(brush)
+            self.setSymbolSize(self.config.symbol_size)
+            self.setSymbol(self.config.symbol)
+
+    def set_data(self, x, y):
+        if self.config.source == "custom":
+            self.setData(x, y)
+        else:
+            raise ValueError(f"Source {self.config.source} do not allow custom data setting.")
+
+    def set(self, **kwargs):
+        """
+        Set the properties of the curve.
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - color: str
+            - symbol: str
+            - symbol_color: str
+            - symbol_size: int
+            - pen_width: int
+            - pen_style: Literal["solid", "dash", "dot", "dashdot"]
+        """
+
+        # Mapping of keywords to setter methods
+        method_map = {
+            "color": self.set_color,
+            "symbol": self.set_symbol,
+            "symbol_color": self.set_symbol_color,
+            "symbol_size": self.set_symbol_size,
+            "pen_width": self.set_pen_width,
+            "pen_style": self.set_pen_style,
+        }
+        for key, value in kwargs.items():
+            if key in method_map:
+                method_map[key](value)
+            else:
+                print(f"Warning: '{key}' is not a recognized property.")
+
+    def set_color(self, color: str, symbol_color: Optional[str] = None):
+        """
+        Change the color of the curve.
+        Args:
+            color(str): Color of the curve.
+            symbol_color(str, optional): Color of the symbol. Defaults to None.
+        """
+        self.config.color = color
+        self.config.symbol_color = symbol_color or color
+        self.apply_config()
+
+    def set_symbol(self, symbol: str):
+        """
+        Change the symbol of the curve.
+        Args:
+            symbol(str): Symbol of the curve.
+        """
+        self.config.symbol = symbol
+        self.apply_config()
+
+    def set_symbol_color(self, symbol_color: str):
+        """
+        Change the symbol color of the curve.
+        Args:
+            symbol_color(str): Color of the symbol.
+        """
+        self.config.symbol_color = symbol_color
+        self.apply_config()
+
+    def set_symbol_size(self, symbol_size: int):
+        """
+        Change the symbol size of the curve.
+        Args:
+            symbol_size(int): Size of the symbol.
+        """
+        self.config.symbol_size = symbol_size
+        self.apply_config()
+
+    def set_pen_width(self, pen_width: int):
+        """
+        Change the pen width of the curve.
+        Args:
+            pen_width(int): Width of the pen.
+        """
+        self.config.pen_width = pen_width
+        self.apply_config()
+
+    def set_pen_style(self, pen_style: Literal["solid", "dash", "dot", "dashdot"]):
+        """
+        Change the pen style of the curve.
+        Args:
+            pen_style(Literal["solid", "dash", "dot", "dashdot"]): Style of the pen.
+        """
+        self.config.pen_style = pen_style
+        self.apply_config()
+
+    def get_data(self) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Get the data of the curve.
+        Returns:
+            tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
+        """
+        x_data, y_data = self.getData()
+        return x_data, y_data
+
+
+class BECWaveform1D(BECPlotBase):
+    USER_ACCESS = [
+        "add_curve_scan",
+        "add_curve_custom",
+        "remove_curve",
+        "scan_history",
+        "curves",
+        "curves_data",
+        "get_curve",
+        "get_curve_config",
+        "apply_config",
+        "get_all_data",
+    ]
+    scan_signal_update = pyqtSignal()
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        parent_figure=None,
+        config: Optional[Waveform1DConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = Waveform1DConfig(widget_class=self.__class__.__name__)
+        super().__init__(
+            parent=parent, parent_figure=parent_figure, config=config, client=client, gui_id=gui_id
+        )
+
+        self.curves_data = defaultdict(dict)
+        self.scanID = None
+
+        # Scan segment update proxy
+        self.proxy_update_plot = pg.SignalProxy(
+            self.scan_signal_update, rateLimit=25, slot=self._update_scan_segment_plot
+        )
+
+        # Get bec shortcuts dev, scans, queue, scan_storage, dap
+        self.get_bec_shortcuts()
+
+        # Connect dispatcher signals
+        self.bec_dispatcher.connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+
+        self.entry_validator = EntryValidator(self.dev)
+
+        self.addLegend()
+        self.apply_config(self.config)
+
+    # TODO check config assigning
+    # TODO check the functionality of config generator
+    def find_widget_by_id(
+        self, item_id: str
+    ):  # TODO implement this on level of BECConnector and all other widgets
+        for curve in self.curves:
+            if curve.gui_id == item_id:
+                return curve
+
+    def apply_config(self, config: dict | WidgetConfig, replot_last_scan: bool = False):
+        """
+        Apply the configuration to the 1D waveform widget.
+        Args:
+            config(dict|WidgetConfig): Configuration settings.
+            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
+        """
+        if isinstance(config, dict):
+            try:
+                config = Waveform1DConfig(**config)
+            except ValidationError as e:
+                print(f"Validation error when applying config to BECWaveform1D: {e}")
+                return
+
+        self.config = config
+        self.clear()
+
+        self.apply_axis_config()
+        # Reset curves
+        self._curves_data = defaultdict(dict)
+        self._curves = []
+        for curve_id, curve_config in self.config.curves.items():
+            self.add_curve_by_config(curve_config)
+        if replot_last_scan:
+            self.scan_history(scan_index=-1)
+
+    def change_gui_id(self, new_gui_id: str):
+        """
+        Change the GUI ID of the waveform widget and update the parent_id in all associated curves.
+
+        Args:
+            new_gui_id (str): The new GUI ID to be set for the waveform widget.
+        """
+        # Update the gui_id in the waveform widget itself
+        self.gui_id = new_gui_id
+        self.config.gui_id = new_gui_id
+
+        for curve in self.curves:
+            curve.config.parent_id = new_gui_id
+
+    def add_curve_by_config(self, curve_config: CurveConfig | dict) -> BECCurve:
+        """
+        Add a curve to the plot widget by its configuration.
+        Args:
+            curve_config(CurveConfig|dict): Configuration of the curve to be added.
+        Returns:
+            BECCurve: The curve object.
+        """
+        if isinstance(curve_config, dict):
+            curve_config = CurveConfig(**curve_config)
+        curve = self._add_curve_object(
+            name=curve_config.label, source=curve_config.source, config=curve_config
+        )
+        return curve
+
+    def get_curve_config(self, curve_id: str, dict_output: bool = True) -> CurveConfig | dict:
+        """
+        Get the configuration of a curve by its ID.
+        Args:
+            curve_id(str): ID of the curve.
+        Returns:
+            CurveConfig|dict: Configuration of the curve.
+        """
+        for source, curves in self.curves_data.items():
+            if curve_id in curves:
+                if dict_output:
+                    return curves[curve_id].config.model_dump()
+                else:
+                    return curves[curve_id].config
+
+    @property
+    def curves(self) -> list[BECCurve]:  # TODO discuss if it should be marked as @property for RPC
+        """
+        Get the curves of the plot widget as a list
+        Returns:
+            list: List of curves.
+        """
+        return self._curves
+
+    @curves.setter
+    def curves(self, value: list[BECCurve]):
+        self._curves = value
+
+    @property
+    def curves_data(self) -> dict:  # TODO discuss if it should be marked as @property for RPC
+        """
+        Get the curves data of the plot widget as a dictionary
+        Returns:
+            dict: Dictionary of curves data.
+        """
+        return self._curves_data
+
+    @curves_data.setter
+    def curves_data(self, value: dict):
+        self._curves_data = value
+
+    def get_curve(self, identifier) -> BECCurve:
+        """
+        Get the curve by its index or ID.
+        Args:
+            identifier(int|str): Identifier of the curve. Can be either an integer (index) or a string (curve_id).
+        Returns:
+            BECCurve: The curve object.
+        """
+        if isinstance(identifier, int):
+            return self.curves[identifier]
+        elif isinstance(identifier, str):
+            for source_type, curves in self.curves_data.items():
+                if identifier in curves:
+                    return curves[identifier]
+            raise ValueError(f"Curve with ID '{identifier}' not found.")
+        else:
+            raise ValueError("Identifier must be either an integer (index) or a string (curve_id).")
+
+    def add_curve_custom(
+        self,
+        x: list | np.ndarray,
+        y: list | np.ndarray,
+        label: str = None,
+        color: str = None,
+        **kwargs,
+    ) -> BECCurve:
+        """
+        Add a custom data curve to the plot widget.
+        Args:
+            x(list|np.ndarray): X data of the curve.
+            y(list|np.ndarray): Y data of the curve.
+            label(str, optional): Label of the curve. Defaults to None.
+            color(str, optional): Color of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        curve_source = "custom"
+        curve_id = label or f"Curve {len(self.curves) + 1}"
+
+        curve_exits = self._check_curve_id(curve_id, self.curves_data)
+        if curve_exits:
+            raise ValueError(
+                f"Curve with ID '{curve_id}' already exists in widget '{self.gui_id}'."
+            )
+
+        color = (
+            color
+            or Colors.golden_angle_color(
+                colormap=self.config.color_palette, num=len(self.curves) + 1, format="HEX"
+            )[-1]
+        )
+
+        # Create curve by config
+        curve_config = CurveConfig(
+            widget_class="BECCurve",
+            parent_id=self.gui_id,
+            label=curve_id,
+            color=color,
+            source=curve_source,
+            **kwargs,
+        )
+
+        curve = self._add_curve_object(
+            name=curve_id, source=curve_source, config=curve_config, data=(x, y)
+        )
+        return curve
+
+    def _add_curve_object(
+        self,
+        name: str,
+        source: str,
+        config: CurveConfig,
+        data: tuple[list | np.ndarray, list | np.ndarray] = None,
+    ) -> BECCurve:
+        """
+        Add a curve object to the plot widget.
+        Args:
+            name(str): ID of the curve.
+            source(str): Source of the curve.
+            config(CurveConfig): Configuration of the curve.
+            data(tuple[list|np.ndarray,list|np.ndarray], optional): Data (x,y) to be plotted. Defaults to None.
+        Returns:
+            BECCurve: The curve object.
+        """
+        curve = BECCurve(config=config, name=name)
+        self.curves_data[source][name] = curve
+        self.addItem(curve)
+        self.config.curves[name] = curve.config
+        if data is not None:
+            curve.setData(data[0], data[1])
+        return curve
+
+    def add_curve_scan(
+        self,
+        x_name: str,
+        y_name: str,
+        x_entry: Optional[str] = None,
+        y_entry: Optional[str] = None,
+        color: Optional[str] = None,
+        label: Optional[str] = None,
+        validate_bec: bool = True,
+        **kwargs,
+    ) -> BECCurve:
+        """
+        Add a curve to the plot widget from the scan segment.
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            label(str, optional): Label of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        # Check if curve already exists
+        curve_source = "scan_segment"
+
+        # Get entry if not provided and validate
+        x_entry, y_entry = self._validate_signal_entries(
+            x_name, y_name, x_entry, y_entry, validate_bec
+        )
+
+        label = label or f"{y_name}-{y_entry}"
+
+        curve_exits = self._check_curve_id(label, self.curves_data)
+        if curve_exits:
+            raise ValueError(f"Curve with ID '{label}' already exists in widget '{self.gui_id}'.")
+
+        color = (
+            color
+            or Colors.golden_angle_color(
+                colormap=self.config.color_palette, num=len(self.curves) + 1, format="HEX"
+            )[-1]
+        )
+
+        # Create curve by config
+        curve_config = CurveConfig(
+            widget_class="BECCurve",
+            parent_id=self.gui_id,
+            label=label,
+            color=color,
+            source=curve_source,
+            signals=Signal(
+                source=curve_source,
+                x=SignalData(name=x_name, entry=x_entry),
+                y=SignalData(name=y_name, entry=y_entry),
+            ),
+            **kwargs,
+        )
+        curve = self._add_curve_object(name=label, source=curve_source, config=curve_config)
+        return curve
+
+    def _validate_signal_entries(
+        self,
+        x_name: str,
+        y_name: str,
+        x_entry: str | None,
+        y_entry: str | None,
+        validate_bec: bool = True,
+    ) -> tuple[str, str]:
+        """
+        Validate the signal name and entry.
+        Args:
+            x_name(str): Name of the x signal.
+            y_name(str): Name of the y signal.
+            x_entry(str|None): Entry of the x signal.
+            y_entry(str|None): Entry of the y signal.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        Returns:
+            tuple[str,str]: Validated x and y entries.
+        """
+        if validate_bec:
+            x_entry = self.entry_validator.validate_signal(x_name, x_entry)
+            y_entry = self.entry_validator.validate_signal(y_name, y_entry)
+        else:
+            x_entry = x_name if x_entry is None else x_entry
+            y_entry = y_name if y_entry is None else y_entry
+        return x_entry, y_entry
+
+    def _check_curve_id(self, val: Any, dict_to_check: dict) -> bool:
+        """
+        Check if val is in the values of the dict_to_check or in the values of the nested dictionaries.
+        Args:
+            val(Any): Value to check.
+            dict_to_check(dict): Dictionary to check.
+
+        Returns:
+            bool: True if val is in the values of the dict_to_check or in the values of the nested dictionaries, False otherwise.
+        """
+        if val in dict_to_check.keys():
+            return True
+        for key in dict_to_check:
+            if isinstance(dict_to_check[key], dict):
+                if self._check_curve_id(val, dict_to_check[key]):
+                    return True
+        return False
+
+    def remove_curve(self, *identifiers):
+        """
+        Remove a curve from the plot widget.
+        Args:
+            *identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
+        """
+        for identifier in identifiers:
+            if isinstance(identifier, int):
+                self._remove_curve_by_order(identifier)
+            elif isinstance(identifier, str):
+                self._remove_curve_by_id(identifier)
+            else:
+                raise ValueError(
+                    "Each identifier must be either an integer (index) or a string (curve_id)."
+                )
+
+    def _remove_curve_by_id(self, curve_id):
+        """
+        Remove a curve by its ID from the plot widget.
+        Args:
+            curve_id(str): ID of the curve to be removed.
+        """
+        for source, curves in self.curves_data.items():
+            if curve_id in curves:
+                curve = curves.pop(curve_id)
+                self.removeItem(curve)
+                del self.config.curves[curve_id]
+                if curve in self.curves:
+                    self.curves.remove(curve)
+                return
+        raise KeyError(f"Curve with ID '{curve_id}' not found.")
+
+    def _remove_curve_by_order(self, N):
+        """
+        Remove a curve by its order from the plot widget.
+        Args:
+            N(int): Order of the curve to be removed.
+        """
+        if N < len(self.curves):
+            curve = self.curves[N]
+            curve_id = curve.name()  # Assuming curve's name is used as its ID
+            self.removeItem(curve)
+            del self.config.curves[curve_id]
+            # Remove from self.curve_data
+            for source, curves in self.curves_data.items():
+                if curve_id in curves:
+                    del curves[curve_id]
+                    break
+        else:
+            raise IndexError(f"Curve order {N} out of range.")
+
+    @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:
+            self.scanID = current_scanID
+            self.scan_segment_data = self.queue.scan_storage.find_scan_by_ID(
+                self.scanID
+            )  # TODO do scan access through BECFigure
+
+        self.scan_signal_update.emit()
+
+    def _update_scan_segment_plot(self):
+        """Update the plot with the data from the scan segment."""
+        data = self.scan_segment_data.data
+        self._update_scan_curves(data)
+
+    def _update_scan_curves(self, data: ScanData):
+        """
+        Update the scan curves with the data from the scan segment.
+        Args:
+            data(ScanData): Data from the scan segment.
+        """
+        for curve_id, curve in self.curves_data["scan_segment"].items():
+            x_name = curve.config.signals.x.name
+            x_entry = curve.config.signals.x.entry
+            y_name = curve.config.signals.y.name
+            y_entry = curve.config.signals.y.entry
+
+            try:
+                data_x = data[x_name][x_entry].val
+                data_y = data[y_name][y_entry].val
+            except TypeError:
+                continue
+
+            curve.setData(data_x, data_y)
+
+    def scan_history(self, scan_index: int = None, scanID: str = None):
+        """
+        Update the scan curves with the data from the scan storage.
+        Provide only one of scanID or scan_index.
+        Args:
+            scanID(str, optional): ScanID of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+        """
+        if scan_index is not None and scanID is not None:
+            raise ValueError("Only one of scanID or scan_index can be provided.")
+
+        if scan_index is not None:
+            self.scanID = self.queue.scan_storage.storage[scan_index].scanID
+            data = self.queue.scan_storage.find_scan_by_ID(self.scanID).data
+        elif scanID is not None:
+            self.scanID = scanID
+            data = self.queue.scan_storage.find_scan_by_ID(self.scanID).data
+
+        self._update_scan_curves(data)
+
+    def get_all_data(self, output: Literal["dict", "pandas"] = "dict") -> dict | pd.DataFrame:
+        """
+        Extract all curve data into a dictionary or a pandas DataFrame.
+        Args:
+            output (Literal["dict", "pandas"]): Format of the output data.
+        Returns:
+            dict | pd.DataFrame: Data of all curves in the specified format.
+        """
+
+        data = {}
+        try:
+            import pandas as pd
+        except ImportError:
+            pd = None
+            if output == "pandas":
+                print(
+                    "Pandas is not installed. "
+                    "Please install pandas using 'pip install pandas'."
+                    "Output will be dictionary instead."
+                )
+                output = "dict"
+
+        for curve in self.curves:
+            x_data, y_data = curve.get_data()
+            if x_data is not None or y_data is not None:
+                if output == "dict":
+                    data[curve.name()] = {"x": x_data.tolist(), "y": y_data.tolist()}
+                elif output == "pandas" and pd is not None:
+                    data[curve.name()] = pd.DataFrame({"x": x_data, "y": y_data})
+
+        if output == "pandas" and pd is not None:
+            combined_data = pd.concat(
+                [data[curve.name()] for curve in self.curves],
+                axis=1,
+                keys=[curve.name() for curve in self.curves],
+            )
+            return combined_data
+        return data
+
+    def cleanup(self):
+        """Cleanup the widget connection from BECDispatcher."""
+        self.bec_dispatcher.disconnect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())

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,439 @@
+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"""
+        self.available_scans = self.client.producer.get(MessageEndpoints.available_scans()).resource
+        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

@@ -2,11 +2,11 @@ from threading import RLock
 
 import numpy as np
 import pyqtgraph as pg
-from bec_lib.core import MessageEndpoints
-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
 
@@ -17,7 +17,7 @@ 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_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+        BECDispatcher().connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
 
         self._scanID = None
         self._scanID_lock = RLock()
@@ -139,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)
 
@@ -149,4 +149,4 @@ if __name__ == "__main__":
 
     plot.show()
 
-    sys.exit(app.exec_())
+    sys.exit(app.exec())

bec_widgets/widgets/scan_plot/scan_plot.py

@@ -2,11 +2,11 @@ import itertools
 from threading import RLock
 
 import pyqtgraph as pg
-from bec_lib.core import MessageEndpoints
-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
 
@@ -18,7 +18,7 @@ COLORS = ["#fd7f6f", "#7eb0d5", "#b2e061", "#bd7ebe", "#ffb55a"]
 class BECScanPlot(pg.GraphicsView):
     def __init__(self, parent=None, background="default"):
         super().__init__(parent, background)
-        bec_dispatcher.connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+        BECDispatcher().connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
 
         self.view = pg.PlotItem()
         self.setCentralItem(self.view)
@@ -94,6 +94,7 @@ 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."):
@@ -138,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)
 
@@ -148,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..._