fix: prel. support for config_plotter with widgets instead of items

.git_hooks/pre-commit

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

.gitlab-ci.yml

@@ -1,80 +1,29 @@
 # This file is a template, and might need editing before it works on your project.
 # Official language image. Look for the different tagged releases at:
 # https://hub.docker.com/r/library/python/tags/
-image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
+image: $CI_DOCKER_REGISTRY/python:3.9
 #commands to run in the Docker container before starting each job.
 variables:
   DOCKER_TLS_CERTDIR: ""
-  BEC_CORE_BRANCH: "main"
-  OPHYD_DEVICES_BRANCH: "main"
-  CHILD_PIPELINE_BRANCH: $CI_DEFAULT_BRANCH
-
-workflow:
-  rules:
-    - if: $CI_PIPELINE_SOURCE == "schedule"
-    - if: $CI_PIPELINE_SOURCE == "web"
-    - if: $CI_PIPELINE_SOURCE == "pipeline"
-    - if: $CI_PIPELINE_SOURCE == "parent_pipeline"
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-    - if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
-      when: never
-    - if: $CI_COMMIT_BRANCH
-
-include:
-  - template: Security/Secret-Detection.gitlab-ci.yml
-  - project: "bec/awi_utils"
-    file: "/templates/check-packages-job.yml"
-    inputs:
-      stage: test
-      path: "."
-      pytest_args: "-v --random-order tests/"
-      exclude_packages: ""
 
 # different stages in the pipeline
 stages:
   - Formatter
-  - test
-  - AdditionalTests
-  - End2End
+  - Unittests
   - Deploy
 
-.install-qt-webengine-deps: &install-qt-webengine-deps
-  - apt-get -y install libnss3 libxdamage1 libasound2 libatomic1 libxcursor1
-  - export QTWEBENGINE_DISABLE_SANDBOX=1
-
-.clone-repos: &clone-repos
-  - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-  - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-  - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-
-.install-os-packages: &install-os-packages
-  - apt-get update
-  - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-  - *install-qt-webengine-deps
-
-before_script:
-  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then
-    echo -e "\033[35;1m Using branch $CHILD_PIPELINE_BRANCH of BEC Widgets \033[0;m";
-    test -d bec_widgets || git clone --branch $CHILD_PIPELINE_BRANCH https://gitlab.psi.ch/bec/bec_widgets.git; cd bec_widgets;
-    fi
-
 formatter:
   stage: Formatter
   needs: []
   script:
-    - pip install black isort
-    - isort --check --diff ./
-    - black --check --diff --color ./
-  rules:
-    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
-
+    - pip install black
+    - black --check --diff --color --line-length=100 ./
 pylint:
   stage: Formatter
   needs: []
-  before_script:
-    - pip install pylint pylint-exit anybadge
-    - pip install -e .[dev,pyqt6]
   script:
+    - pip install pylint pylint-exit anybadge
+    - pip install -e .[dev]
     - 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)
@@ -84,135 +33,25 @@ pylint:
     paths:
       - ./pylint/
     expire_in: 1 week
-  rules:
-    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
-
-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:
-    - git fetch origin $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
-    # Identify changed Python files
-    - if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then
-      TARGET_BRANCH_COMMIT_SHA=$(git rev-parse origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
-      CHANGED_FILES=$(git diff --name-only $TARGET_BRANCH_COMMIT_SHA HEAD | 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
-
-    - echo "Changed Python files:"
-      - $CHANGED_FILES
-    # 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
-  rules:
-    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
 
 tests:
-  stage: test
+  stage: Unittests
   needs: []
   variables:
-    QT_QPA_PLATFORM: "offscreen"
+      QT_QPA_PLATFORM: "offscreen"
   script:
-    - *clone-repos
-    - *install-os-packages
-    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e ./bec/bec_ipython_client
-    - pip install -e .[dev,pyqt6]
-    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx x11-utils libxkbcommon-x11-0 
+    - pip install .[dev]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests
     - coverage report
     - coverage xml
   coverage: '/(?i)total.*? (100(?:\.0+)?\%|[1-9]?\d(?:\.\d+)?\%)$/'
   artifacts:
     reports:
       junit: report.xml
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
+      cobertura: coverage.xml
 
-test-matrix:
-  parallel:
-    matrix:
-      - PYTHON_VERSION:
-          - "3.10"
-          - "3.11"
-          - "3.12"
-        QT_PCKG:
-          - "pyside6"
-          - "pyqt6"
-
-  stage: AdditionalTests
-  needs: []
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-    PYTHON_VERSION: ""
-    QT_PCKG: ""
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:$PYTHON_VERSION
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e ./bec/bec_ipython_client
-    - pip install -e .[dev,$QT_PCKG]
-    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
-  allow_failure: true
-
-end-2-end-conda:
-  stage: End2End
-  needs: []
-  image: continuumio/miniconda3
-  allow_failure: false
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - conda config --prepend channels conda-forge
-    - conda config --set channel_priority strict
-    - conda config --set always_yes yes --set changeps1 no
-    - conda create -q -n test-environment python=3.11
-    - conda init bash
-    - source ~/.bashrc
-    - conda activate test-environment
-
-    - cd ./bec
-    - source ./bin/install_bec_dev.sh -t
-
-    - pip install -e ./bec_lib[dev]
-    - pip install -e ./bec_ipython_client[dev]
-    - cd ../
-    - pip install -e .[dev,pyqt6]
-    - cd ./tests/end-2-end
-    - pytest -v --start-servers --flush-redis --random-order
-
-  artifacts:
-    when: on_failure
-    paths:
-      - ./logs/*.log
-    expire_in: 1 week
-
-  rules:
-    - if: '$CI_PIPELINE_SOURCE == "schedule"'
-    - if: '$CI_PIPELINE_SOURCE == "web"'
-    - if: '$CI_PIPELINE_SOURCE == "pipeline"'
-    - if: '$CI_PIPELINE_SOURCE == "parent_pipeline"'
-    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
-    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
 
 semver:
   stage: Deploy
@@ -228,29 +67,31 @@ semver:
     - git fetch --tags
     - git tag
 
-    # build and publish package
-    - pip install python-semantic-release==9.* wheel build twine
+    # build
+    - pip install python-semantic-release wheel
     - export GL_TOKEN=$CI_UPDATES
-    - semantic-release -vv version
-
-    # check if any artifacts were created
-    - if [ ! -d dist ]; then echo No release will be made; exit 0; fi
-    - twine upload dist/* -u __token__ -p $CI_PYPI_TOKEN --skip-existing
-    - semantic-release publish
-
+    - export REPOSITORY_USERNAME=__token__
+    - export REPOSITORY_PASSWORD=$CI_PYPI_TOKEN
+    - >
+      semantic-release publish -v DEBUG 
+      -D version_variable=./setup.py:__version__  
+      -D hvcs=gitlab 
+      
   allow_failure: false
   rules:
-    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
+    - if: '$CI_COMMIT_REF_NAME == "master"'
 
-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 == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
-  script:
-    - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/bec-widgets/253243/
+# 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"'

.gitlab/issue_templates/bug_report_template.md

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

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

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

@@ -1,28 +0,0 @@
-## 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.
-

.pylintrc

@@ -1,581 +0,0 @@
-[MASTER]
-
-# A comma-separated list of package or module names from where C extensions may
-# be loaded. Extensions are loading into the active Python interpreter and may
-# run arbitrary code.
-extension-pkg-allow-list=PyQt6, PySide6, pyqtgraph
-
-# A comma-separated list of package or module names from where C extensions may
-# be loaded. Extensions are loading into the active Python interpreter and may
-# run arbitrary code. (This is an alternative name to extension-pkg-allow-list
-# for backward compatibility.)
-extension-pkg-whitelist=
-
-# Return non-zero exit code if any of these messages/categories are detected,
-# even if score is above --fail-under value. Syntax same as enable. Messages
-# specified are enabled, while categories only check already-enabled messages.
-fail-on=
-
-# Specify a score threshold to be exceeded before program exits with error.
-fail-under=8.0
-
-# Files or directories to be skipped. They should be base names, not paths.
-ignore=CVS
-
-# Add files or directories matching the regex patterns to the ignore-list. The
-# regex matches against paths and can be in Posix or Windows format.
-ignore-paths=
-
-# Files or directories matching the regex patterns are skipped. The regex
-# matches against base names, not paths.
-ignore-patterns=
-
-# Python code to execute, usually for sys.path manipulation such as
-# pygtk.require().
-#init-hook=
-
-# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
-# number of processors available to use.
-jobs=1
-
-# Control the amount of potential inferred values when inferring a single
-# object. This can help the performance when dealing with large functions or
-# complex, nested conditions.
-limit-inference-results=100
-
-# List of plugins (as comma separated values of python module names) to load,
-# usually to register additional checkers.
-load-plugins=
-
-# Pickle collected data for later comparisons.
-persistent=yes
-
-# Minimum Python version to use for version dependent checks. Will default to
-# the version used to run pylint.
-py-version=3.10
-
-# When enabled, pylint would attempt to guess common misconfiguration and emit
-# user-friendly hints instead of false-positive error messages.
-suggestion-mode=yes
-
-# Allow loading of arbitrary C extensions. Extensions are imported into the
-# active Python interpreter and may run arbitrary code.
-unsafe-load-any-extension=no
-
-
-[MESSAGES CONTROL]
-
-# Only show warnings with the listed confidence levels. Leave empty to show
-# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED.
-confidence=
-
-# Disable the message, report, category or checker with the given id(s). You
-# can either give multiple identifiers separated by comma (,) or put this
-# option multiple times (only on the command line, not in the configuration
-# file where it should appear only once). You can also use "--disable=all" to
-# disable everything first and then reenable specific checks. For example, if
-# you want to run only the similarities checker, you can use "--disable=all
-# --enable=similarities". If you want to run only the classes checker, but have
-# no Warning level messages displayed, use "--disable=all --enable=classes
-# --disable=W".
-disable=missing-module-docstring,
-        missing-class-docstring,
-        import-error,
-        no-name-in-module,
-        raw-checker-failed,
-        bad-inline-option,
-        locally-disabled,
-        file-ignored,
-        suppressed-message,
-        deprecated-pragma,
-        use-symbolic-message-instead,
-        unused-wildcard-import,
-        logging-fstring-interpolation,
-        line-too-long,
-        too-many-instance-attributes,
-        wrong-import-order
-
-# Enable the message, report, category or checker with the given id(s). You can
-# either give multiple identifier separated by comma (,) or put this option
-# multiple time (only on the command line, not in the configuration file where
-# it should appear only once). See also the "--disable" option for examples.
-enable=c-extension-no-member
-
-
-[REPORTS]
-
-# Python expression which should return a score less than or equal to 10. You
-# have access to the variables 'error', 'warning', 'refactor', and 'convention'
-# which contain the number of messages in each category, as well as 'statement'
-# which is the total number of statements analyzed. This score is used by the
-# global evaluation report (RP0004).
-evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
-
-# Template used to display messages. This is a python new-style format string
-# used to format the message information. See doc for all details.
-#msg-template=
-
-# Set the output format. Available formats are text, parseable, colorized, json
-# and msvs (visual studio). You can also give a reporter class, e.g.
-# mypackage.mymodule.MyReporterClass.
-output-format=text
-
-# Tells whether to display a full report or only the messages.
-reports=no
-
-# Activate the evaluation score.
-score=yes
-
-
-[REFACTORING]
-
-# Maximum number of nested blocks for function / method body
-max-nested-blocks=5
-
-# Complete name of functions that never returns. When checking for
-# inconsistent-return-statements if a never returning function is called then
-# it will be considered as an explicit return statement and no message will be
-# printed.
-never-returning-functions=sys.exit,argparse.parse_error
-
-
-[LOGGING]
-
-# The type of string formatting that logging methods do. `old` means using %
-# formatting, `new` is for `{}` formatting.
-logging-format-style=old
-
-# Logging modules to check that the string format arguments are in logging
-# function parameter format.
-logging-modules=logging
-
-
-[SPELLING]
-
-# Limits count of emitted suggestions for spelling mistakes.
-max-spelling-suggestions=4
-
-# Spelling dictionary name. Available dictionaries: none. To make it work,
-# install the 'python-enchant' package.
-spelling-dict=
-
-# List of comma separated words that should be considered directives if they
-# appear and the beginning of a comment and should not be checked.
-spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:
-
-# List of comma separated words that should not be checked.
-spelling-ignore-words=
-
-# A path to a file that contains the private dictionary; one word per line.
-spelling-private-dict-file=
-
-# Tells whether to store unknown words to the private dictionary (see the
-# --spelling-private-dict-file option) instead of raising a message.
-spelling-store-unknown-words=no
-
-
-[MISCELLANEOUS]
-
-# List of note tags to take in consideration, separated by a comma.
-notes=FIXME,
-      XXX,
-      TODO
-
-# Regular expression of note tags to take in consideration.
-#notes-rgx=
-
-
-[TYPECHECK]
-
-# List of decorators that produce context managers, such as
-# contextlib.contextmanager. Add to this list to register other decorators that
-# produce valid context managers.
-contextmanager-decorators=contextlib.contextmanager
-
-# List of members which are set dynamically and missed by pylint inference
-# system, and so shouldn't trigger E1101 when accessed. Python regular
-# expressions are accepted.
-generated-members=
-
-# Tells whether missing members accessed in mixin class should be ignored. A
-# class is considered mixin if its name matches the mixin-class-rgx option.
-ignore-mixin-members=yes
-
-# Tells whether to warn about missing members when the owner of the attribute
-# is inferred to be None.
-ignore-none=yes
-
-# This flag controls whether pylint should warn about no-member and similar
-# checks whenever an opaque object is returned when inferring. The inference
-# can return multiple potential results while evaluating a Python object, but
-# some branches might not be evaluated, which results in partial inference. In
-# that case, it might be useful to still emit no-member and other checks for
-# the rest of the inferred objects.
-ignore-on-opaque-inference=yes
-
-# List of class names for which member attributes should not be checked (useful
-# for classes with dynamically set attributes). This supports the use of
-# qualified names.
-ignored-classes=optparse.Values,thread._local,_thread._local
-
-# List of module names for which member attributes should not be checked
-# (useful for modules/projects where namespaces are manipulated during runtime
-# and thus existing member attributes cannot be deduced by static analysis). It
-# supports qualified module names, as well as Unix pattern matching.
-ignored-modules=
-
-# Show a hint with possible names when a member name was not found. The aspect
-# of finding the hint is based on edit distance.
-missing-member-hint=yes
-
-# The minimum edit distance a name should have in order to be considered a
-# similar match for a missing member name.
-missing-member-hint-distance=1
-
-# The total number of similar names that should be taken in consideration when
-# showing a hint for a missing member.
-missing-member-max-choices=1
-
-# Regex pattern to define which classes are considered mixins ignore-mixin-
-# members is set to 'yes'
-mixin-class-rgx=.*[Mm]ixin
-
-# List of decorators that change the signature of a decorated function.
-signature-mutators=
-
-
-[VARIABLES]
-
-# List of additional names supposed to be defined in builtins. Remember that
-# you should avoid defining new builtins when possible.
-additional-builtins=
-
-# Tells whether unused global variables should be treated as a violation.
-allow-global-unused-variables=yes
-
-# List of names allowed to shadow builtins
-allowed-redefined-builtins=
-
-# List of strings which can identify a callback function by name. A callback
-# name must start or end with one of those strings.
-callbacks=cb_,
-          _cb
-
-# A regular expression matching the name of dummy variables (i.e. expected to
-# not be used).
-dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
-
-# Argument names that match this expression will be ignored. Default to name
-# with leading underscore.
-ignored-argument-names=_.*|^ignored_|^unused_
-
-# Tells whether we should check for unused import in __init__ files.
-init-import=no
-
-# List of qualified module names which can have objects that can redefine
-# builtins.
-redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io
-
-
-[FORMAT]
-
-# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
-expected-line-ending-format=
-
-# Regexp for a line that is allowed to be longer than the limit.
-ignore-long-lines=^\s*(# )?<?https?://\S+>?$
-
-# Number of spaces of indent required inside a hanging or continued line.
-indent-after-paren=4
-
-# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
-# tab).
-indent-string='    '
-
-# Maximum number of characters on a single line.
-max-line-length=100
-
-# Maximum number of lines in a module.
-max-module-lines=1000
-
-# Allow the body of a class to be on the same line as the declaration if body
-# contains single statement.
-single-line-class-stmt=no
-
-# Allow the body of an if to be on the same line as the test if there is no
-# else.
-single-line-if-stmt=no
-
-
-[SIMILARITIES]
-
-# Comments are removed from the similarity computation
-ignore-comments=yes
-
-# Docstrings are removed from the similarity computation
-ignore-docstrings=yes
-
-# Imports are removed from the similarity computation
-ignore-imports=no
-
-# Signatures are removed from the similarity computation
-ignore-signatures=no
-
-# Minimum lines number of a similarity.
-min-similarity-lines=4
-
-
-[BASIC]
-
-# Naming style matching correct argument names.
-argument-naming-style=snake_case
-
-# Regular expression matching correct argument names. Overrides argument-
-# naming-style.
-#argument-rgx=
-
-# Naming style matching correct attribute names.
-attr-naming-style=snake_case
-
-# Regular expression matching correct attribute names. Overrides attr-naming-
-# style.
-#attr-rgx=
-
-# Bad variable names which should always be refused, separated by a comma.
-bad-names=foo,
-          bar,
-          baz,
-          toto,
-          tutu,
-          tata
-
-# Bad variable names regexes, separated by a comma. If names match any regex,
-# they will always be refused
-bad-names-rgxs=
-
-# Naming style matching correct class attribute names.
-class-attribute-naming-style=any
-
-# Regular expression matching correct class attribute names. Overrides class-
-# attribute-naming-style.
-#class-attribute-rgx=
-
-# Naming style matching correct class constant names.
-class-const-naming-style=UPPER_CASE
-
-# Regular expression matching correct class constant names. Overrides class-
-# const-naming-style.
-#class-const-rgx=
-
-# Naming style matching correct class names.
-class-naming-style=PascalCase
-
-# Regular expression matching correct class names. Overrides class-naming-
-# style.
-#class-rgx=
-
-# Naming style matching correct constant names.
-const-naming-style=UPPER_CASE
-
-# Regular expression matching correct constant names. Overrides const-naming-
-# style.
-#const-rgx=
-
-# Minimum line length for functions/classes that require docstrings, shorter
-# ones are exempt.
-docstring-min-length=-1
-
-# Naming style matching correct function names.
-function-naming-style=snake_case
-
-# Regular expression matching correct function names. Overrides function-
-# naming-style.
-#function-rgx=
-
-# Good variable names which should always be accepted, separated by a comma.
-good-names=i,
-           ii,
-           jj,
-           kk,
-           dr,
-           j,
-           k,
-           ex,
-           Run,
-           cb,
-           _
-
-# Good variable names regexes, separated by a comma. If names match any regex,
-# they will always be accepted
-good-names-rgxs=.*scanID.*,.*RID.*,.*pointID.*,.*ID.*,.*_2D.*,.*_1D.*
-
-# Include a hint for the correct naming format with invalid-name.
-include-naming-hint=no
-
-# Naming style matching correct inline iteration names.
-inlinevar-naming-style=any
-
-# Regular expression matching correct inline iteration names. Overrides
-# inlinevar-naming-style.
-#inlinevar-rgx=
-
-# Naming style matching correct method names.
-method-naming-style=snake_case
-
-# Regular expression matching correct method names. Overrides method-naming-
-# style.
-#method-rgx=
-
-# Naming style matching correct module names.
-module-naming-style=snake_case
-
-# Regular expression matching correct module names. Overrides module-naming-
-# style.
-#module-rgx=
-
-# Colon-delimited sets of names that determine each other's naming style when
-# the name regexes allow several styles.
-name-group=
-
-# Regular expression which should only match function or class names that do
-# not require a docstring.
-no-docstring-rgx=^_
-
-# List of decorators that produce properties, such as abc.abstractproperty. Add
-# to this list to register other decorators that produce valid properties.
-# These decorators are taken in consideration only for invalid-name.
-property-classes=abc.abstractproperty
-
-# Naming style matching correct variable names.
-variable-naming-style=snake_case
-
-# Regular expression matching correct variable names. Overrides variable-
-# naming-style.
-#variable-rgx=
-
-
-[STRING]
-
-# This flag controls whether inconsistent-quotes generates a warning when the
-# character used as a quote delimiter is used inconsistently within a module.
-check-quote-consistency=no
-
-# This flag controls whether the implicit-str-concat should generate a warning
-# on implicit string concatenation in sequences defined over several lines.
-check-str-concat-over-line-jumps=no
-
-
-[IMPORTS]
-
-# List of modules that can be imported at any level, not just the top level
-# one.
-allow-any-import-level=
-
-# Allow wildcard imports from modules that define __all__.
-allow-wildcard-with-all=no
-
-# Analyse import fallback blocks. This can be used to support both Python 2 and
-# 3 compatible code, which means that the block might have code that exists
-# only in one or another interpreter, leading to false positives when analysed.
-analyse-fallback-blocks=no
-
-# Deprecated modules which should not be used, separated by a comma.
-deprecated-modules=
-
-# Output a graph (.gv or any supported image format) of external dependencies
-# to the given file (report RP0402 must not be disabled).
-ext-import-graph=
-
-# Output a graph (.gv or any supported image format) of all (i.e. internal and
-# external) dependencies to the given file (report RP0402 must not be
-# disabled).
-import-graph=
-
-# Output a graph (.gv or any supported image format) of internal dependencies
-# to the given file (report RP0402 must not be disabled).
-int-import-graph=
-
-# Force import order to recognize a module as part of the standard
-# compatibility libraries.
-known-standard-library=
-
-# Force import order to recognize a module as part of a third party library.
-known-third-party=enchant
-
-# Couples of modules and preferred modules, separated by a comma.
-preferred-modules=
-
-
-[CLASSES]
-
-# Warn about protected attribute access inside special methods
-check-protected-access-in-special-methods=no
-
-# List of method names used to declare (i.e. assign) instance attributes.
-defining-attr-methods=__init__,
-                      __new__,
-                      setUp,
-                      __post_init__
-
-# List of member names, which should be excluded from the protected access
-# warning.
-exclude-protected=_asdict,
-                  _fields,
-                  _replace,
-                  _source,
-                  _make
-
-# List of valid names for the first argument in a class method.
-valid-classmethod-first-arg=cls
-
-# List of valid names for the first argument in a metaclass class method.
-valid-metaclass-classmethod-first-arg=cls
-
-
-[DESIGN]
-
-# List of regular expressions of class ancestor names to ignore when counting
-# public methods (see R0903)
-exclude-too-few-public-methods=
-
-# List of qualified class names to ignore when counting class parents (see
-# R0901)
-ignored-parents=
-
-# Maximum number of arguments for function / method.
-max-args=5
-
-# Maximum number of attributes for a class (see R0902).
-max-attributes=7
-
-# Maximum number of boolean expressions in an if statement (see R0916).
-max-bool-expr=5
-
-# Maximum number of branch for function / method body.
-max-branches=12
-
-# Maximum number of locals for function / method body.
-max-locals=15
-
-# Maximum number of parents for a class (see R0901).
-max-parents=7
-
-# Maximum number of public methods for a class (see R0904).
-max-public-methods=20
-
-# Maximum number of return / yield for function / method body.
-max-returns=6
-
-# Maximum number of statements in function / method body.
-max-statements=50
-
-# Minimum number of public methods for a class (see R0903).
-min-public-methods=2
-
-
-[EXCEPTIONS]
-
-# Exceptions that will emit a warning when being caught. Defaults to
-# "BaseException, Exception".
-overgeneral-exceptions=BaseException,
-                       Exception

.readthedocs.yaml

@@ -1,25 +0,0 @@
-# .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.10"
-
-# 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

@@ -1,141 +1,15 @@
-# CHANGELOG
+# Changelog
 
-## v0.81.2 (2024-07-07)
+<!--next-version-placeholder-->
 
-### Fix
-
-* fix(waveform): scan_history error check for IndexError ([`dd1875e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/dd1875ea5cc18bcef9aad743347a8accf144c08d))
-
-## v0.81.1 (2024-07-07)
-
-### Fix
-
-* fix(motor_control): temporary remove of motor control widgets ([`99114f1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/99114f14f62202e1fd8bf145616fa8c69937ada4))
-
-## v0.81.0 (2024-07-06)
+## v0.2.0 (2023-07-13)
 
 ### Feature
 
-* feat(color_button): can get colors in RGBA or HEX ([`9594be2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9594be260680d11c8550ff74ffb8d679e5a5b8f6))
+* Move ivan's qtwidgets to bec-widgets ([`34e5ed2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/34e5ed2cf7e6128a51c110db8870d9560f2b2831))
 
-## v0.80.1 (2024-07-06)
-
-### Fix
-
-* fix(entry_validator): check for entry == &#34;&#34; ([`61de7e9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/61de7e9e221c766b9fb3ec23246da6a11c96a986))
-
-## v0.80.0 (2024-07-06)
+## v0.1.0 (2023-07-11)
 
 ### Feature
 
-* feat(qt5): dropped support for qt5; pyside2 and pyqt5 ([`fadbf77`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fadbf77866903beff6580802bc203d53367fc7e7))
-
-* feat(plugins): moved plugin dict to dataclass and container ([`03819a3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/03819a3d902b4a51f3e882d52aedd971b2a8e127))
-
-* feat(plugins): added support for pyqt6 ui files ([`d6d0777`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d6d07771135335cb78dc648508ce573b8970261a))
-
-* feat(plugins): added bec widgets base class ([`1aa83e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1aa83e0ef1ffe45b01677b0b4590535cb0ca1cff))
-
-## v0.79.3 (2024-07-05)
-
-### Fix
-
-* fix: changed inheritance to adress qt designer bug in rendering ([`e403870`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e403870874bd5e45840a034d6f1b3dd576d9c846))
-
-* fix: add designer plugin classes ([`1586ce2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1586ce2d6cba2bb086b2ef596e724bb9e40ab4f2))
-
-### Refactor
-
-* refactor: simplify logic in bec_status_box ([`576353c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/576353cfe8c6fd64db561f0b6e2bc951300643d3))
-
-## v0.79.2 (2024-07-04)
-
-### Fix
-
-* fix: overwrite closeEvent and call super class ([`bc0ef78`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/bc0ef7893ef100b71b62101c459655509b534a56))
-
-## v0.79.1 (2024-07-03)
-
-### Fix
-
-* fix: use libdir env var to preload Python library, also for Linux platform ([`d7718d4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d7718d4dcb9728c050b6421388af4d484f3741f2))
-
-## v0.79.0 (2024-07-03)
-
-### Feature
-
-* feat(motor_map_widget): standalone MotorMap Widget with toolbar + plugin ([`6e75642`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6e756420907d7093557e945bc92bc4cfc0138d07))
-
-* feat(motor_map): method to reset history trace ([`5960918`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5960918137dd41cdeb94e50f8abc4f169cf45c11))
-
-### Fix
-
-* fix(toolbar): change default color to black to match BECFigure theme ([`b8774e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b8774e0b0bc43dcd00f94f42539a778e507ca27d))
-
-* fix(motor_map): fixed bug with residual trace after changing motors ([`aaa0d10`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/aaa0d1003d2e94b45bafe4f700852c2c05288aea))
-
-* fix(widget_io): widget handler adjusted for spinboxes and comboboxes ([`3dc0532`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3dc0532df05b6ec0a2522107fa0b1e210ce7d91b))
-
-### Refactor
-
-* refactor(toolbar): cleanup and adjusted colors ([`96863ad`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/96863adf53c15112645d20eb6200733617801c6d))
-
-## v0.78.1 (2024-07-02)
-
-### Fix
-
-* fix(ui_loader): ui loader is compatible with bec plugins ([`b787759`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b787759f44486dc7af2c03811efb156041e4b6cb))
-
-## v0.78.0 (2024-07-02)
-
-### Feature
-
-* feat(color_button): patched ColorButton from pyqtgraph to be able to be opened in another QDialog ([`c36bb80`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c36bb80d6a4939802a4a1c8e5452c7b94bac185e))
-
-## v0.77.0 (2024-07-02)
-
-### Feature
-
-* feat(bec_connector): export config to yaml ([`a391f30`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a391f3018c50fee6a4a06884491b957df80c3cd3))
-
-* feat(utils): colors added convertor for rgba to hex ([`572f2fb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/572f2fb8110d5cb0e80f3ca45ce57ef405572456))
-
-### Fix
-
-* fix(waveform): scatter 2D brush error ([`215d59c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/215d59c8bfe7fda9aff8cec8353bef9e1ce2eca1))
-
-* fix(figure): API cleanup ([`008a33a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/008a33a9b192473cc58e90cd6d98c5bcb5f7b8c0))
-
-* fix(figure): if/else logic corrected in subplot_factory ([`3e78723`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3e787234c7274b0698423d7bf9a4c54ec46bad5f))
-
-* fix(image): processing of already displayed data; closes #106 ([`1173510`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1173510105d2d70d7e498c2ac1e122cea3a16597))
-
-* fix(bec_figure): full reconstruction with config from other bec figure ([`b6e1e20`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b6e1e20b7c8549bb092e981062329e601411dda6))
-
-* fix(motor_map): API changes updates current visualisation; motor_map can be initialised from config ([`2e2d422`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2e2d422910685a2527a3d961a468c787f771ca44))
-
-* fix(image): image add_custom_image fixed, closes #225 ([`f0556e4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f0556e44113ffee66cf735aa2dd758c62cb634f4))
-
-* fix(figure): subplot methods consolidated; added subplot factory ([`4a97105`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4a97105e4bd2ce77d72dfe5f8307dd9ee65b21b0))
-
-* fix(image): image can be fully reconstructed from config ([`797f73c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/797f73c39aa73e07d6311f3de4baea53f6c380e0))
-
-* fix(image_item): vrange added int for pydantic model check ([`b8f796f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b8f796fd3fcc15641e8fc6a3ca75c344ce90fc45))
-
-* fix(bec_figure): waveforms can be initialised from the config; widgets are deleteLater after removal ([`78673ea`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/78673ea11a47aad878128197ae6213925228ed59))
-
-### Unknown
-
-* Resolve &#34;add VT100 console executing BEC as a widget&#34; ([`c6a14c0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c6a14c0768a90695567a83a7895247ed0c64f3ce))
-
-## v0.76.1 (2024-06-29)
-
-### Fix
-
-* fix(plugins): fixes and tests for auto-gen plugins ([`c42511d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c42511dd44cc13577e108a6cef3166376e594f54))
-
-## v0.76.0 (2024-06-28)
-
-### Fix
-
-* fix: fixed qwidget inheritance for ring progress bar ([`0610d2f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0610d2f9f027f8659e7149f2dfbb316ff30e337d))
+* Added config plotter ([`db274c6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/db274c644f643f830c35b6a92edd328bf7e24f59))

LICENSE

@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2023, bec
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -1,74 +1,2 @@
 # 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 PyQt6
-```
-
-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,pyqt6]
-```
-
-BEC Widgets currently supports both Pyside6 and PyQt6, however, no default distribution is specified. As a result, users must install one of the supported
-Python Qt distributions manually.
-
-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[pyside6]
-```
-## 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://bec.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/cli.py

@@ -0,0 +1,98 @@
+import argparse
+import os
+from threading import RLock
+
+from PyQt5 import uic
+from PyQt5.QtCore import pyqtSignal
+from PyQt5.QtWidgets import QApplication, QMainWindow
+from scan_plot import BECScanPlot
+
+from bec_lib.core import BECMessage, MessageEndpoints, RedisConnector
+
+
+class BEC_UI(QMainWindow):
+    new_scan_data = pyqtSignal(dict)
+    new_dap_data = pyqtSignal(dict)  # signal per proc instance?
+    new_scan = pyqtSignal()
+
+    def __init__(self, uipath):
+        super().__init__()
+        self._scan_channels = set()
+        self._dap_channels = set()
+
+        self._scan_thread = None
+        self._dap_threads = []
+
+        ui = uic.loadUi(uipath, self)
+
+        _, fname = os.path.split(uipath)
+        self.setWindowTitle(fname)
+
+        for sp in ui.findChildren(BECScanPlot):
+            for chan in (sp.x_channel, *sp.y_channel_list):
+                if chan.startswith("dap."):
+                    chan = chan.partition("dap.")[-1]
+                    self._dap_channels.add(chan)
+                else:
+                    self._scan_channels.add(chan)
+
+            sp.initialize()  # TODO: move this elsewhere?
+
+            self.new_scan_data.connect(sp.redraw_scan)  # TODO: merge
+            self.new_dap_data.connect(sp.redraw_dap)
+            self.new_scan.connect(sp.clearData)
+
+        # Scan setup
+        self._scan_id = None
+        scan_lock = RLock()
+
+        def _scan_cb(msg):
+            msg = BECMessage.ScanMessage.loads(msg.value)
+            with scan_lock:
+                scan_id = msg[0].content["scanID"]
+                if self._scan_id != scan_id:
+                    self._scan_id = scan_id
+                    self.new_scan.emit()
+            self.new_scan_data.emit(msg[0].content["data"])
+
+        bec_connector = RedisConnector("localhost:6379")
+
+        if self._scan_channels:
+            scan_readback = MessageEndpoints.scan_segment()
+            self._scan_thread = bec_connector.consumer(
+                topics=scan_readback,
+                cb=_scan_cb,
+            )
+            self._scan_thread.start()
+
+        # DAP setup
+        def _proc_cb(msg):
+            msg = BECMessage.ProcessedDataMessage.loads(msg.value)
+            self.new_dap_data.emit(msg.content["data"])
+
+        if self._dap_channels:
+            for chan in self._dap_channels:
+                proc_ep = MessageEndpoints.processed_data(chan)
+                dap_thread = bec_connector.consumer(topics=proc_ep, cb=_proc_cb)
+                dap_thread.start()
+                self._dap_threads.append(dap_thread)
+
+        self.show()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="bec-pyqt", formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument("uipath", type=str, help="Path to a BEC ui file")
+
+    args, rem = parser.parse_known_args()
+
+    app = QApplication(rem)
+    BEC_UI(args.uipath)
+    app.exec_()
+
+
+if __name__ == "__main__":
+    main()

bec_widgets/cli/__init__.py

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

bec_widgets/cli/auto_updates.py

@@ -1,153 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from pydantic import BaseModel
-
-if TYPE_CHECKING:
-    from .client import BECDockArea, BECFigure
-
-
-class ScanInfo(BaseModel):
-    scan_id: str
-    scan_number: int
-    scan_name: str
-    scan_report_devices: list
-    monitored_devices: list
-    status: str
-    model_config: dict = {"validate_assignment": True}
-
-
-class AutoUpdates:
-    create_default_dock: bool = False
-    enabled: bool = False
-    dock_name: str = None
-
-    def __init__(self, gui: BECDockArea):
-        self.gui = gui
-
-    def start_default_dock(self):
-        """
-        Create a default dock for the auto updates.
-        """
-        dock = self.gui.add_dock("default_figure")
-        dock.add_widget("BECFigure")
-        self.dock_name = "default_figure"
-
-    @staticmethod
-    def get_scan_info(msg) -> ScanInfo:
-        """
-        Update the script with the given data.
-        """
-        info = msg.info
-        status = msg.status
-        scan_id = msg.scan_id
-        scan_number = info.get("scan_number", 0)
-        scan_name = info.get("scan_name", "Unknown")
-        scan_report_devices = info.get("scan_report_devices", [])
-        monitored_devices = info.get("readout_priority", {}).get("monitored", [])
-        monitored_devices = [dev for dev in monitored_devices if dev not in scan_report_devices]
-        return ScanInfo(
-            scan_id=scan_id,
-            scan_number=scan_number,
-            scan_name=scan_name,
-            scan_report_devices=scan_report_devices,
-            monitored_devices=monitored_devices,
-            status=status,
-        )
-
-    def get_default_figure(self) -> BECFigure | None:
-        """
-        Get the default figure from the GUI.
-        """
-        dock = self.gui.panels.get(self.dock_name, [])
-        if not dock:
-            return None
-        widgets = dock.widget_list
-        if not widgets:
-            return None
-        return widgets[0]
-
-    def run(self, msg):
-        """
-        Run the update function if enabled.
-        """
-        if not self.enabled:
-            return
-        if msg.status != "open":
-            return
-        info = self.get_scan_info(msg)
-        self.handler(info)
-
-    @staticmethod
-    def get_selected_device(monitored_devices, selected_device):
-        """
-        Get the selected device for the plot. If no device is selected, the first
-        device in the monitored devices list is selected.
-        """
-        if selected_device:
-            return selected_device
-        if len(monitored_devices) > 0:
-            sel_device = monitored_devices[0]
-            return sel_device
-        return None
-
-    def handler(self, info: ScanInfo) -> None:
-        """
-        Default update function.
-        """
-        if info.scan_name == "line_scan" and info.scan_report_devices:
-            self.simple_line_scan(info)
-            return
-        if info.scan_name == "grid_scan" and info.scan_report_devices:
-            self.simple_grid_scan(info)
-            return
-        if info.scan_report_devices:
-            self.best_effort(info)
-            return
-
-    def simple_line_scan(self, info: ScanInfo) -> None:
-        """
-        Simple line scan.
-        """
-        fig = self.get_default_figure()
-        if not fig:
-            return
-        dev_x = info.scan_report_devices[0]
-        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
-        if not dev_y:
-            return
-        fig.clear_all()
-        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
-        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
-
-    def simple_grid_scan(self, info: ScanInfo) -> None:
-        """
-        Simple grid scan.
-        """
-        fig = self.get_default_figure()
-        if not fig:
-            return
-        dev_x = info.scan_report_devices[0]
-        dev_y = info.scan_report_devices[1]
-        dev_z = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
-        fig.clear_all()
-        plt = fig.plot(
-            x_name=dev_x, y_name=dev_y, z_name=dev_z, label=f"Scan {info.scan_number} - {dev_z}"
-        )
-        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
-
-    def best_effort(self, info: ScanInfo) -> None:
-        """
-        Best effort scan.
-        """
-        fig = self.get_default_figure()
-        if not fig:
-            return
-        dev_x = info.scan_report_devices[0]
-        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
-        if not dev_y:
-            return
-        fig.clear_all()
-        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
-        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)

bec_widgets/cli/client_utils.py

@@ -1,359 +0,0 @@
-from __future__ import annotations
-
-import importlib
-import importlib.metadata as imd
-import os
-import select
-import subprocess
-import sys
-import threading
-import time
-import uuid
-from functools import wraps
-from typing import TYPE_CHECKING
-
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.logger import bec_logger
-from bec_lib.utils.import_utils import isinstance_based_on_class_name, lazy_import, lazy_import_from
-from qtpy.QtCore import QEventLoop, QSocketNotifier, QTimer
-
-import bec_widgets.cli.client as client
-from bec_widgets.cli.auto_updates import AutoUpdates
-
-if TYPE_CHECKING:
-    from bec_lib.device import DeviceBase
-
-    from bec_widgets.cli.client import BECDockArea, BECFigure
-
-from bec_lib.serialization import MsgpackSerialization
-
-messages = lazy_import("bec_lib.messages")
-# from bec_lib.connector import MessageObject
-MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
-BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
-
-logger = bec_logger.logger
-
-
-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):
-        # we could rely on a strict type check here, but this is more flexible
-        # moreover, it would anyway crash for objects...
-        out = []
-        for arg in args:
-            if hasattr(arg, "name"):
-                arg = arg.name
-            out.append(arg)
-        args = tuple(out)
-        for key, val in kwargs.items():
-            if hasattr(val, "name"):
-                kwargs[key] = val.name
-        if not self.gui_is_alive():
-            raise RuntimeError("GUI is not alive")
-        return self._run_rpc(func.__name__, *args, **kwargs)
-
-    return wrapper
-
-
-def _get_output(process, logger) -> None:
-    log_func = {process.stdout: logger.debug, process.stderr: logger.error}
-    stream_buffer = {process.stdout: [], process.stderr: []}
-    try:
-        os.set_blocking(process.stdout.fileno(), False)
-        os.set_blocking(process.stderr.fileno(), False)
-        while process.poll() is None:
-            readylist, _, _ = select.select([process.stdout, process.stderr], [], [], 1)
-            for stream in (process.stdout, process.stderr):
-                buf = stream_buffer[stream]
-                if stream in readylist:
-                    buf.append(stream.read(4096))
-                output, _, remaining = "".join(buf).rpartition("\n")
-                if output:
-                    log_func[stream](output)
-                    buf.clear()
-                    buf.append(remaining)
-    except Exception as e:
-        print(f"Error reading process output: {str(e)}")
-
-
-def _start_plot_process(gui_id, gui_class, config, logger=None) -> None:
-    """
-    Start the plot in a new process.
-
-    Logger must be a logger object with "debug" and "error" functions,
-    or it can be left to "None" as default. None means output from the
-    process will not be captured.
-    """
-    # pylint: disable=subprocess-run-check
-    command = ["bec-gui-server", "--id", gui_id, "--gui_class", gui_class.__name__]
-    if config:
-        command.extend(["--config", config])
-
-    env_dict = os.environ.copy()
-    env_dict["PYTHONUNBUFFERED"] = "1"
-    if logger is None:
-        stdout_redirect = subprocess.DEVNULL
-        stderr_redirect = subprocess.DEVNULL
-    else:
-        stdout_redirect = subprocess.PIPE
-        stderr_redirect = subprocess.PIPE
-
-    process = subprocess.Popen(
-        command,
-        text=True,
-        start_new_session=True,
-        stdout=stdout_redirect,
-        stderr=stderr_redirect,
-        env=env_dict,
-    )
-    if logger is None:
-        process_output_processing_thread = None
-    else:
-        process_output_processing_thread = threading.Thread(
-            target=_get_output, args=(process, logger)
-        )
-        process_output_processing_thread.start()
-    return process, process_output_processing_thread
-
-
-class BECGuiClientMixin:
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self._process = None
-        self._process_output_processing_thread = None
-        self.auto_updates = self._get_update_script()
-        self._target_endpoint = MessageEndpoints.scan_status()
-        self._selected_device = None
-
-    def _get_update_script(self) -> AutoUpdates | None:
-        eps = imd.entry_points(group="bec.widgets.auto_updates")
-        for ep in eps:
-            if ep.name == "plugin_widgets_update":
-                try:
-                    spec = importlib.util.find_spec(ep.module)
-                    # if the module is not found, we skip it
-                    if spec is None:
-                        continue
-                    return ep.load()(gui=self)
-                except Exception as e:
-                    print(f"Error loading auto update script from plugin: {str(e)}")
-        return None
-
-    @property
-    def selected_device(self):
-        """
-        Selected device for the plot.
-        """
-        return self._selected_device
-
-    @selected_device.setter
-    def selected_device(self, device: str | DeviceBase):
-        if isinstance_based_on_class_name(device, "bec_lib.device.DeviceBase"):
-            self._selected_device = device.name
-        elif isinstance(device, str):
-            self._selected_device = device
-        else:
-            raise ValueError("Device must be a string or a device object")
-
-    def _start_update_script(self) -> None:
-        self._client.connector.register(
-            self._target_endpoint, cb=self._handle_msg_update, parent=self
-        )
-
-    @staticmethod
-    def _handle_msg_update(msg: MessageObject, parent: BECGuiClientMixin) -> None:
-        if parent.auto_updates is not None:
-            # pylint: disable=protected-access
-            parent._update_script_msg_parser(msg.value)
-
-    def _update_script_msg_parser(self, msg: messages.BECMessage) -> None:
-        if isinstance(msg, messages.ScanStatusMessage):
-            if not self.gui_is_alive():
-                return
-            self.auto_updates.run(msg)
-
-    def show(self) -> None:
-        """
-        Show the figure.
-        """
-        if self._process is None or self._process.poll() is not None:
-            self._start_update_script()
-            self._process, self._process_output_processing_thread = _start_plot_process(
-                self._gui_id, self.__class__, self._client._service_config.config_path
-            )
-        while not self.gui_is_alive():
-            print("Waiting for GUI to start...")
-            time.sleep(1)
-
-    def close(self) -> None:
-        """
-        Close the gui window.
-        """
-        if self._process is None:
-            return
-
-        self._client.shutdown()
-        if self._process:
-            self._process.terminate()
-            if self._process_output_processing_thread:
-                self._process_output_processing_thread.join()
-            self._process.wait()
-            self._process = None
-
-
-class RPCResponseTimeoutError(Exception):
-    """Exception raised when an RPC response is not received within the expected time."""
-
-    def __init__(self, request_id, timeout):
-        super().__init__(
-            f"RPC response not received within {timeout} seconds for request ID {request_id}"
-        )
-
-
-class QtRedisMessageWaiter:
-    def __init__(self, redis_connector, message_to_wait):
-        self.ev_loop = QEventLoop()
-        self.response = None
-        self.connector = redis_connector
-        self.message_to_wait = message_to_wait
-        self.pubsub = redis_connector._redis_conn.pubsub()
-        self.pubsub.subscribe(self.message_to_wait.endpoint)
-        fd = self.pubsub.connection._sock.fileno()
-        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
-        self.notifier.activated.connect(self._pubsub_readable)
-
-    def _msg_received(self, msg_obj):
-        self.response = msg_obj.value
-        self.ev_loop.quit()
-
-    def wait(self, timeout=1):
-        timer = QTimer()
-        timer.singleShot(timeout * 1000, self.ev_loop.quit)
-        self.ev_loop.exec_()
-        timer.stop()
-        self.notifier.setEnabled(False)
-        self.pubsub.close()
-        return self.response
-
-    def _pubsub_readable(self, fd):
-        while True:
-            msg = self.pubsub.get_message()
-            if msg:
-                if msg["type"] == "subscribe":
-                    # get_message buffers, so we may already have the answer
-                    # let's check...
-                    continue
-                else:
-                    break
-            else:
-                return
-        channel = msg["channel"].decode()
-        msg = MessageObject(topic=channel, value=MsgpackSerialization.loads(msg["data"]))
-        self.connector._execute_callback(self._msg_received, msg, {})
-
-
-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}")
-
-    def __repr__(self):
-        type_ = type(self)
-        qualname = type_.__qualname__
-        return f"<{qualname} object at {hex(id(self))}>"
-
-    @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, timeout=3, **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},
-        )
-
-        # pylint: disable=protected-access
-        receiver = self._root._gui_id
-        if wait_for_rpc_response:
-            redis_msg = QtRedisMessageWaiter(
-                self._client.connector, MessageEndpoints.gui_instruction_response(request_id)
-            )
-
-        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
-
-        if wait_for_rpc_response:
-            response = redis_msg.wait(timeout)
-
-            if response is None:
-                raise RPCResponseTimeoutError(request_id, timeout)
-
-            # get class name
-            if not response.accepted:
-                raise ValueError(response.message["error"])
-            msg_result = response.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 {
-                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
-                }
-            cls = msg_result.pop("widget_class", None)
-            msg_result.pop("__rpc__", None)
-
-            if not cls:
-                return msg_result
-
-            cls = getattr(client, cls)
-            # print(msg_result)
-            return cls(parent=self, **msg_result)
-        return msg_result
-
-    def gui_is_alive(self):
-        """
-        Check if the GUI is alive.
-        """
-        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
-        return heart is not None

bec_widgets/cli/generate_cli.py

@@ -1,189 +0,0 @@
-# pylint: disable=missing-module-docstring
-from __future__ import annotations
-
-import argparse
-import inspect
-import os
-import sys
-
-import black
-import isort
-
-from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator
-from bec_widgets.utils.plugin_utils import BECClassContainer, get_rpc_classes
-
-if sys.version_info >= (3, 11):
-    from typing import get_overloads
-else:
-    print(
-        "Python version is less than 3.11, using dummy function for get_overloads. "
-        "If you want to use the real function 'typing.get_overloads()', please use Python 3.11 or later."
-    )
-
-    def get_overloads(_obj):
-        """
-        Dummy function for Python versions before 3.11.
-        """
-        return []
-
-
-class ClientGenerator:
-    def __init__(self):
-        self.header = """# This file was automatically generated by generate_cli.py\n
-import enum
-from typing import Literal, Optional, overload
-
-from bec_widgets.cli.client_utils import RPCBase, rpc_call, BECGuiClientMixin
-
-# pylint: skip-file"""
-
-        self.content = ""
-
-    def generate_client(self, class_container: BECClassContainer):
-        """
-        Generate the client for the published classes.
-
-        Args:
-            class_container: The class container with the classes to generate the client for.
-        """
-        rpc_top_level_classes = class_container.rpc_top_level_classes
-        rpc_top_level_classes.sort(key=lambda x: x.__name__)
-        connector_classes = class_container.connector_classes
-        connector_classes.sort(key=lambda x: x.__name__)
-
-        self.write_client_enum(rpc_top_level_classes)
-        for cls in connector_classes:
-            self.content += "\n\n"
-            self.generate_content_for_class(cls)
-
-    def write_client_enum(self, published_classes: list[type]):
-        """
-        Write the client enum to the content.
-        """
-        self.content += """
-class Widgets(str, enum.Enum):
-    \"\"\"
-    Enum for the available widgets.
-    \"\"\"
-    """
-        for cls in published_classes:
-            self.content += f'{cls.__name__} = "{cls.__name__}"\n    '
-
-    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__
-
-        # Generate the content
-        if cls.__name__ == "BECDockArea":
-            self.content += f"""
-class {class_name}(RPCBase, BECGuiClientMixin):"""
-        else:
-            self.content += f"""
-class {class_name}(RPCBase):"""
-        if not cls.USER_ACCESS:
-            self.content += """...
-    """
-        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 = 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, automatically formatted with black.
-
-        Args:
-            file_name(str): The name of the file to write to.
-        """
-        # Combine header and content, then format with black
-        full_content = self.header + "\n" + self.content
-        try:
-            formatted_content = black.format_str(full_content, mode=black.FileMode(line_length=100))
-        except black.NothingChanged:
-            formatted_content = full_content
-
-        isort.Config(
-            profile="black",
-            line_length=100,
-            multi_line_output=3,
-            include_trailing_comma=True,
-            known_first_party=["bec_widgets"],
-        )
-        formatted_content = isort.code(formatted_content)
-
-        with open(file_name, "w", encoding="utf-8") as file:
-            file.write(formatted_content)
-
-
-def main():
-    """
-    Main entry point for the script, controlled by command line arguments.
-    """
-
-    parser = argparse.ArgumentParser(description="Auto-generate the client for RPC widgets")
-    parser.add_argument("--core", action="store_true", help="Whether to generate the core client")
-
-    args = parser.parse_args()
-
-    if args.core:
-        current_path = os.path.dirname(__file__)
-        client_path = os.path.join(current_path, "client.py")
-
-        rpc_classes = get_rpc_classes("bec_widgets")
-
-        generator = ClientGenerator()
-        generator.generate_client(rpc_classes)
-        generator.write(client_path)
-
-        for cls in rpc_classes.plugins:
-            plugin = DesignerPluginGenerator(cls)
-            if not hasattr(plugin, "info"):
-                continue
-
-            # if the class directory already has a register, plugin and pyproject file, skip
-            if os.path.exists(
-                os.path.join(plugin.info.base_path, f"register_{plugin.info.plugin_name_snake}.py")
-            ):
-                continue
-            if os.path.exists(
-                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}_plugin.py")
-            ):
-                continue
-            if os.path.exists(
-                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}.pyproject")
-            ):
-                continue
-            plugin.run()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    sys.argv = ["generate_cli.py", "--core"]
-    main()

bec_widgets/cli/rpc_register.py

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

bec_widgets/cli/rpc_wigdet_handler.py

@@ -1,53 +0,0 @@
-from bec_widgets.utils import BECConnector
-
-
-class RPCWidgetHandler:
-    """Handler class for creating widgets from RPC messages."""
-
-    def __init__(self):
-        self._widget_classes = None
-
-    @property
-    def widget_classes(self):
-        """
-        Get the available widget classes.
-
-        Returns:
-            dict: The available widget classes.
-        """
-        if self._widget_classes is None:
-            self.update_available_widgets()
-        return self._widget_classes
-
-    def update_available_widgets(self):
-        """
-        Update the available widgets.
-
-        Returns:
-            None
-        """
-        from bec_widgets.utils.plugin_utils import get_rpc_classes
-
-        clss = get_rpc_classes("bec_widgets")
-        self._widget_classes = {cls.__name__: cls for cls in clss.top_level_classes}
-
-    def create_widget(self, widget_type, **kwargs) -> BECConnector:
-        """
-        Create a widget from an RPC message.
-
-        Args:
-            widget_type(str): The type of the widget.
-            **kwargs: The keyword arguments for the widget.
-
-        Returns:
-            widget(BECConnector): The created widget.
-        """
-        if self._widget_classes is None:
-            self.update_available_widgets()
-        widget_class = self._widget_classes.get(widget_type)
-        if widget_class:
-            return widget_class(**kwargs)
-        raise ValueError(f"Unknown widget type: {widget_type}")
-
-
-widget_handler = RPCWidgetHandler()

bec_widgets/cli/server.py

@@ -1,219 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import signal
-import sys
-from contextlib import redirect_stderr, redirect_stdout
-from typing import Union
-
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.logger import bec_logger
-from bec_lib.service_config import ServiceConfig
-from bec_lib.utils.import_utils import lazy_import
-from qtpy.QtCore import QTimer
-
-from bec_widgets.cli.rpc_register import RPCRegister
-from bec_widgets.utils import BECDispatcher
-from bec_widgets.utils.bec_connector import BECConnector
-from bec_widgets.utils.bec_dispatcher import QtRedisConnector
-from bec_widgets.widgets.dock.dock_area import BECDockArea
-from bec_widgets.widgets.figure import BECFigure
-
-messages = lazy_import("bec_lib.messages")
-logger = bec_logger.logger
-
-
-class BECWidgetsCLIServer:
-
-    def __init__(
-        self,
-        gui_id: str = None,
-        dispatcher: BECDispatcher = None,
-        client=None,
-        config=None,
-        gui_class: Union[BECFigure, BECDockArea] = BECFigure,
-    ) -> None:
-        self.dispatcher = BECDispatcher(config=config) if dispatcher is None else dispatcher
-        self.client = self.dispatcher.client if client is None else client
-        self.client.start()
-        self.gui_id = gui_id
-        self.gui = gui_class(gui_id=self.gui_id)
-        self.rpc_register = RPCRegister()
-        self.rpc_register.add_rpc(self.gui)
-
-        self.dispatcher.connect_slot(
-            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
-        )
-
-        # Setup QTimer for heartbeat
-        self._shutdown_event = False
-        self._heartbeat_timer = QTimer()
-        self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
-        self._heartbeat_timer.start(200)
-
-    def on_rpc_update(self, msg: dict, metadata: dict):
-        request_id = metadata.get("request_id")
-        try:
-            obj = self.get_object_from_config(msg["parameter"])
-            method = msg["action"]
-            args = msg["parameter"].get("args", [])
-            kwargs = msg["parameter"].get("kwargs", {})
-            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_and_publish(
-            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")
-        obj = self.rpc_register.get_rpc_by_id(gui_id)
-        if obj is None:
-            raise ValueError(f"Object with gui_id {gui_id} not found")
-        return obj
-
-    def run_rpc(self, obj, method, args, kwargs):
-        method_obj = getattr(obj, method)
-        # 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]
-        elif isinstance(res, dict):
-            res = {key: self.serialize_object(val) for key, val in res.items()}
-        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
-
-    def emit_heartbeat(self):
-        if self._shutdown_event is False:
-            self.client.connector.set(
-                MessageEndpoints.gui_heartbeat(self.gui_id),
-                messages.StatusMessage(name=self.gui_id, status=1, info={}),
-                expire=1,
-            )
-
-    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
-        self._shutdown_event = True
-        self._heartbeat_timer.stop()
-        self.gui.close()
-        self.client.shutdown()
-
-
-class SimpleFileLikeFromLogOutputFunc:
-    def __init__(self, log_func):
-        self._log_func = log_func
-
-    def write(self, buffer):
-        for line in buffer.rstrip().splitlines():
-            line = line.rstrip()
-            if line:
-                self._log_func(line)
-
-    def flush(self):
-        return
-
-    def close(self):
-        return
-
-
-def main():
-    import argparse
-    import os
-    import sys
-
-    from qtpy.QtCore import QSize
-    from qtpy.QtGui import QIcon
-    from qtpy.QtWidgets import QApplication, QMainWindow
-
-    import bec_widgets
-
-    parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
-    parser.add_argument("--id", type=str, help="The id of the server")
-    parser.add_argument(
-        "--gui_class",
-        type=str,
-        help="Name of the gui class to be rendered. Possible values: \n- BECFigure\n- BECDockArea",
-    )
-    parser.add_argument("--config", type=str, help="Config file")
-
-    args = parser.parse_args()
-
-    if args.gui_class == "BECFigure":
-        gui_class = BECFigure
-    elif args.gui_class == "BECDockArea":
-        gui_class = BECDockArea
-    else:
-        print(
-            "Please specify a valid gui_class to run. Use -h for help."
-            "\n Starting with default gui_class BECFigure."
-        )
-        gui_class = BECFigure
-
-    with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.debug)):
-        with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):
-            app = QApplication(sys.argv)
-            app.setApplicationName("BEC Figure")
-            module_path = os.path.dirname(bec_widgets.__file__)
-            icon = QIcon()
-            icon.addFile(
-                os.path.join(module_path, "assets", "bec_widgets_icon.png"), size=QSize(48, 48)
-            )
-            app.setWindowIcon(icon)
-
-            win = QMainWindow()
-            win.setWindowTitle("BEC Widgets")
-
-            service_config = ServiceConfig(args.config)
-            bec_logger.configure(
-                service_config.redis,
-                QtRedisConnector,
-                service_name="BECWidgetsCLIServer",
-                service_config=service_config.service_config,
-            )
-            server = BECWidgetsCLIServer(gui_id=args.id, config=service_config, gui_class=gui_class)
-
-            gui = server.gui
-            win.setCentralWidget(gui)
-            win.resize(800, 600)
-            win.show()
-
-            app.aboutToQuit.connect(server.shutdown)
-
-            def sigint_handler(*args):
-                # display message, for people to let it terminate gracefully
-                print("Caught SIGINT, exiting")
-                app.quit()
-
-            signal.signal(signal.SIGINT, sigint_handler)
-            signal.signal(signal.SIGTERM, sigint_handler)
-
-            sys.exit(app.exec())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/config_plotter.py

@@ -0,0 +1,138 @@
+from typing import List
+
+import numpy as np
+import pyqtgraph as pg
+from PyQt5.QtWidgets import QApplication, QGridLayout, QSizePolicy, QWidget
+from pyqtgraph import mkPen
+from pyqtgraph.Qt import QtCore
+
+
+class ConfigPlotter(QWidget):
+    """
+    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(ConfigPlotter, self).__init__()
+        self.configs = configs
+        self.plots = {}
+        self._init_ui()
+        self._init_plots()
+
+    def _init_ui(self):
+        pg.setConfigOption("background", "w")
+        pg.setConfigOption("foreground", "k")
+        self.layout = QGridLayout()
+        self.setLayout(self.layout)
+        self.pen = mkPen(color=(56, 76, 107), width=4, style=QtCore.Qt.SolidLine)
+        self.show()
+
+    def _init_plots(self):
+        for config in self.configs:
+            channels = config["config"]["channels"]
+            for channel in channels:
+                # call the corresponding init function, e.g. init_plotitem
+                init_func = getattr(self, f"init_{config['config']['item']}")
+                init_func(channel, config)
+
+                # self.init_ImageItem(channel, config["config"], item)
+
+    def init_PlotItem(self, channel: str, config: dict):
+        """
+        Initialize a PlotItem
+
+        Args:
+            channel(str): channel to plot
+            config(dict): config dict for the channel
+        """
+        # pylint: disable=invalid-name
+        plot_widget = pg.PlotWidget()
+        plot_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        self.layout.addWidget(plot_widget, config["y"], config["x"], config["rows"], config["cols"])
+        plot_data = plot_widget.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):
+        """
+        Initialize an ImageItem
+
+        Args:
+            channel(str): channel to plot
+            config(dict): config dict for the channel
+        """
+        # pylint: disable=invalid-name
+        item = pg.PlotItem()
+        self.layout.addItem(
+            item,
+            row=config["y"],
+            col=config["x"],
+            rowspan=config["rows"],
+            colspan=config["cols"],
+        )
+        img = pg.ImageItem()
+        item.addItem(img)
+        img.setImage(np.random.rand(100, 100))
+        self.plots[channel] = {"item": item, "plot_data": img}
+
+    def init_ImageView(self, channel: str, config: dict):
+        """
+        Initialize an ImageView
+
+        Args:
+            channel(str): channel to plot
+            config(dict): config dict for the channel
+        """
+        # pylint: disable=invalid-name
+        img = pg.ImageView()
+        img.setImage(np.random.rand(100, 100))
+        self.layout.addWidget(img, config["y"], config["x"], config["rows"], config["cols"])
+        self.plots[channel] = {"item": img, "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": "ImageView"},
+        },
+    ]
+
+    app = QApplication(sys.argv)
+    win = ConfigPlotter(CONFIG)
+    pg.exec()

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -1,163 +0,0 @@
-import os
-
-import numpy as np
-import pyqtgraph as pg
-import qdarktheme
-from qtconsole.inprocess import QtInProcessKernelManager
-from qtconsole.rich_jupyter_widget import RichJupyterWidget
-from qtpy.QtCore import QSize
-from qtpy.QtGui import QIcon
-from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
-
-from bec_widgets.utils import BECDispatcher, UILoader
-from bec_widgets.widgets.dock.dock_area import BECDockArea
-from bec_widgets.widgets.figure import BECFigure
-from bec_widgets.widgets.jupyter_console.jupyter_console import BECJupyterConsole
-
-
-class JupyterConsoleWindow(QWidget):  # pragma: no cover:
-    """A widget that contains a Jupyter console linked to BEC Widgets with full API access (contains Qt and pyqtgraph API)."""
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-
-        current_path = os.path.dirname(__file__)
-        self.ui = UILoader().load_ui(os.path.join(current_path, "jupyter_console_window.ui"), self)
-
-        self._init_ui()
-
-        self.ui.splitter.setSizes([200, 100])
-        self.safe_close = False
-
-        # console push
-        if self.console.inprocess is True:
-            self.console.kernel_manager.kernel.shell.push(
-                {
-                    "np": np,
-                    "pg": pg,
-                    "fig": self.figure,
-                    "dock": self.dock,
-                    "w1": self.w1,
-                    "w2": self.w2,
-                    "w3": self.w3,
-                    "w1_c": self.w1_c,
-                    "w2_c": self.w2_c,
-                    "w3_c": self.w3_c,
-                    "w4": self.w4,
-                    "d0": self.d0,
-                    "d1": self.d1,
-                    "d2": self.d2,
-                    "plt": self.plt,
-                    "bar": self.bar,
-                }
-            )
-
-    def _init_ui(self):
-        # Plotting window
-        self.glw_1_layout = QVBoxLayout(self.ui.glw)  # Create a new QVBoxLayout
-        self.figure = BECFigure(parent=self, gui_id="remote")  # Create a new BECDeviceMonitor
-        self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout
-
-        self.dock_layout = QVBoxLayout(self.ui.dock_placeholder)
-        self.dock = BECDockArea(gui_id="remote")
-        self.dock_layout.addWidget(self.dock)
-
-        # add stuff to figure
-        self._init_figure()
-
-        # init dock for testing
-        self._init_dock()
-
-        self.console_layout = QVBoxLayout(self.ui.widget_console)
-        self.console = BECJupyterConsole(inprocess=True)
-        self.console_layout.addWidget(self.console)
-
-    def _init_figure(self):
-        self.figure.plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="cividis")
-        self.figure.motor_map("samx", "samy")
-        self.figure.image("eiger", color_map="viridis", vrange=(0, 100))
-        self.figure.plot(
-            x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="magma", new=True
-        )
-
-        self.figure.change_layout(2, 2)
-
-        self.w1 = self.figure[0, 0]
-        self.w2 = self.figure[0, 1]
-        self.w3 = self.figure[1, 0]
-        self.w4 = self.figure[1, 1]
-
-        # Plot Customisation
-        self.w1.set_title("Waveform 1")
-        self.w1.set_x_label("Motor Position (samx)")
-        self.w1.set_y_label("Intensity A.U.")
-
-        # Image Customisation
-        self.w3.set_title("Eiger Image")
-        self.w3.set_x_label("X")
-        self.w3.set_y_label("Y")
-
-        # Configs to try to pass
-        self.w1_c = self.w1._config_dict
-        self.w2_c = self.w2._config_dict
-        self.w3_c = self.w3._config_dict
-
-        # curves for w1
-        self.c1 = self.w1.get_config()
-
-        self.fig_c = self.figure._config_dict
-
-    def _init_dock(self):
-
-        self.d0 = self.dock.add_dock(name="dock_0")
-        self.fig0 = self.d0.add_widget("BECFigure")
-        data = np.random.rand(10, 2)
-        self.fig0.plot(data, label="2d Data")
-        self.fig0.image("eiger", vrange=(0, 100))
-
-        self.d1 = self.dock.add_dock(name="dock_1", position="right")
-        self.fig1 = self.d1.add_widget("BECFigure")
-        self.fig1.plot(x_name="samx", y_name="bpm4i")
-        self.fig1.plot(x_name="samx", y_name="bpm3a")
-
-        self.d2 = self.dock.add_dock(name="dock_2", position="bottom")
-        self.fig2 = self.d2.add_widget("BECFigure", row=0, col=0)
-        self.plt = self.fig2.plot(x_name="samx", y_name="bpm3a")
-        self.plt.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
-        self.bar = self.d2.add_widget("RingProgressBar", row=0, col=1)
-        self.bar.set_diameter(200)
-
-        self.dock.save_state()
-
-    def closeEvent(self, event):
-        """Override to handle things when main window is closed."""
-        self.dock.cleanup()
-        self.figure.clear_all()
-        self.figure.client.shutdown()
-        super().closeEvent(event)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    import bec_widgets
-
-    module_path = os.path.dirname(bec_widgets.__file__)
-
-    app = QApplication(sys.argv)
-    app.setApplicationName("Jupyter Console")
-    app.setApplicationDisplayName("Jupyter Console")
-    qdarktheme.setup_theme("auto")
-    icon = QIcon()
-    icon.addFile(os.path.join(module_path, "assets", "terminal_icon.png"), size=QSize(48, 48))
-    app.setWindowIcon(icon)
-
-    bec_dispatcher = BECDispatcher()
-    client = bec_dispatcher.client
-    client.start()
-
-    win = JupyterConsoleWindow()
-    win.show()
-
-    app.aboutToQuit.connect(win.close)
-    sys.exit(app.exec_())

bec_widgets/examples/jupyter_console/jupyter_console_window.ui

@@ -1,54 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>Form</class>
- <widget class="QWidget" name="Form">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>2104</width>
-    <height>966</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Plotting Console</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout_4">
-   <item>
-    <widget class="QSplitter" name="splitter">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <widget class="QTabWidget" name="tabWidget">
-      <property name="currentIndex">
-       <number>0</number>
-      </property>
-      <widget class="QWidget" name="tab_1">
-       <attribute name="title">
-        <string>BECDock</string>
-       </attribute>
-       <layout class="QVBoxLayout" name="verticalLayout">
-        <item>
-         <widget class="QWidget" name="dock_placeholder" native="true"/>
-        </item>
-       </layout>
-      </widget>
-      <widget class="QWidget" name="tab_2">
-       <attribute name="title">
-        <string>BECFigure</string>
-       </attribute>
-       <layout class="QVBoxLayout" name="verticalLayout_3">
-        <item>
-         <widget class="QWidget" name="glw" native="true"/>
-        </item>
-       </layout>
-      </widget>
-     </widget>
-     <widget class="QWidget" name="widget_console" native="true"/>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections/>
-</ui>

bec_widgets/examples/plugin_example_pyside/main.py

@@ -1,17 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-"""PySide6 port of the Qt Designer taskmenuextension example from Qt v6.x"""
-
-import sys
-
-from bec_ipython_client.main import BECIPythonClient
-from qtpy.QtWidgets import QApplication
-from tictactoe import TicTacToe
-
-if __name__ == "__main__":  # pragma: no cover
-    app = QApplication(sys.argv)
-    window = TicTacToe()
-    window.state = "-X-XO----"
-    window.show()
-    sys.exit(app.exec())

bec_widgets/examples/plugin_example_pyside/registertictactoe.py

@@ -1,12 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QPyDesignerCustomWidgetCollection
-from tictactoe import TicTacToe
-from tictactoeplugin import TicTacToePlugin
-
-# Set PYSIDE_DESIGNER_PLUGINS to point to this directory and load the plugin
-
-
-if __name__ == "__main__":  # pragma: no cover
-    QPyDesignerCustomWidgetCollection.addCustomWidget(TicTacToePlugin())

bec_widgets/examples/plugin_example_pyside/taskmenuextension.pyproject

@@ -1,4 +0,0 @@
-{
-    "files": ["tictactoe.py", "main.py", "registertictactoe.py", "tictactoeplugin.py",
-    "tictactoetaskmenu.py"]
-}

bec_widgets/examples/plugin_example_pyside/tictactoe.py

@@ -1,135 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtCore import Property, QPoint, QRect, QSize, Qt, Slot
-from qtpy.QtGui import QPainter, QPen
-from qtpy.QtWidgets import QWidget
-
-EMPTY = "-"
-CROSS = "X"
-NOUGHT = "O"
-DEFAULT_STATE = "---------"
-
-
-class TicTacToe(QWidget):  # pragma: no cover
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self._state = DEFAULT_STATE
-        self._turn_number = 0
-
-    def minimumSizeHint(self):
-        return QSize(200, 200)
-
-    def sizeHint(self):
-        return QSize(200, 200)
-
-    def setState(self, new_state):
-        self._turn_number = 0
-        self._state = DEFAULT_STATE
-        for position in range(min(9, len(new_state))):
-            mark = new_state[position]
-            if mark == CROSS or mark == NOUGHT:
-                self._turn_number += 1
-                self._change_state_at(position, mark)
-            position += 1
-        self.update()
-
-    def state(self):
-        return self._state
-
-    @Slot()
-    def clear_board(self):
-        self._state = DEFAULT_STATE
-        self._turn_number = 0
-        self.update()
-
-    def _change_state_at(self, pos, new_state):
-        self._state = self._state[:pos] + new_state + self._state[pos + 1 :]
-
-    def mousePressEvent(self, event):
-        if self._turn_number == 9:
-            self.clear_board()
-            return
-        for position in range(9):
-            cell = self._cell_rect(position)
-            if cell.contains(event.position().toPoint()):
-                if self._state[position] == EMPTY:
-                    new_state = CROSS if self._turn_number % 2 == 0 else NOUGHT
-                    self._change_state_at(position, new_state)
-                    self._turn_number += 1
-                    self.update()
-
-    def paintEvent(self, event):
-        with QPainter(self) as painter:
-            painter.setRenderHint(QPainter.Antialiasing)
-
-            painter.setPen(QPen(Qt.darkGreen, 1))
-            painter.drawLine(self._cell_width(), 0, self._cell_width(), self.height())
-            painter.drawLine(2 * self._cell_width(), 0, 2 * self._cell_width(), self.height())
-            painter.drawLine(0, self._cell_height(), self.width(), self._cell_height())
-            painter.drawLine(0, 2 * self._cell_height(), self.width(), 2 * self._cell_height())
-
-            painter.setPen(QPen(Qt.darkBlue, 2))
-
-            for position in range(9):
-                cell = self._cell_rect(position)
-                if self._state[position] == CROSS:
-                    painter.drawLine(cell.topLeft(), cell.bottomRight())
-                    painter.drawLine(cell.topRight(), cell.bottomLeft())
-                elif self._state[position] == NOUGHT:
-                    painter.drawEllipse(cell)
-
-            painter.setPen(QPen(Qt.yellow, 3))
-
-            for position in range(0, 8, 3):
-                if (
-                    self._state[position] != EMPTY
-                    and self._state[position + 1] == self._state[position]
-                    and self._state[position + 2] == self._state[position]
-                ):
-                    y = self._cell_rect(position).center().y()
-                    painter.drawLine(0, y, self.width(), y)
-                    self._turn_number = 9
-
-            for position in range(3):
-                if (
-                    self._state[position] != EMPTY
-                    and self._state[position + 3] == self._state[position]
-                    and self._state[position + 6] == self._state[position]
-                ):
-                    x = self._cell_rect(position).center().x()
-                    painter.drawLine(x, 0, x, self.height())
-                    self._turn_number = 9
-
-            if (
-                self._state[0] != EMPTY
-                and self._state[4] == self._state[0]
-                and self._state[8] == self._state[0]
-            ):
-                painter.drawLine(0, 0, self.width(), self.height())
-                self._turn_number = 9
-
-            if (
-                self._state[2] != EMPTY
-                and self._state[4] == self._state[2]
-                and self._state[6] == self._state[2]
-            ):
-                painter.drawLine(0, self.height(), self.width(), 0)
-                self._turn_number = 9
-
-    def _cell_rect(self, position):
-        h_margin = self.width() / 30
-        v_margin = self.height() / 30
-        row = int(position / 3)
-        column = position - 3 * row
-        pos = QPoint(column * self._cell_width() + h_margin, row * self._cell_height() + v_margin)
-        size = QSize(self._cell_width() - 2 * h_margin, self._cell_height() - 2 * v_margin)
-        return QRect(pos, size)
-
-    def _cell_width(self):
-        return self.width() / 3
-
-    def _cell_height(self):
-        return self.height() / 3
-
-    state = Property(str, state, setState)

bec_widgets/examples/plugin_example_pyside/tictactoeplugin.py

@@ -1,68 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtGui import QIcon
-from tictactoe import TicTacToe
-from tictactoetaskmenu import TicTacToeTaskMenuFactory
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='TicTacToe' name='ticTacToe'>
-        <property name='geometry'>
-            <rect>
-                <x>0</x>
-                <y>0</y>
-                <width>200</width>
-                <height>200</height>
-            </rect>
-        </property>
-        <property name='state'>
-            <string>-X-XO----</string>
-        </property>
-    </widget>
-</ui>
-"""
-
-
-class TicTacToePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        t = TicTacToe(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return ""
-
-    def icon(self):
-        return QIcon()
-
-    def includeFile(self):
-        return "tictactoe"
-
-    def initialize(self, form_editor):
-        self._form_editor = form_editor
-        manager = form_editor.extensionManager()
-        iid = TicTacToeTaskMenuFactory.task_menu_iid()
-        manager.registerExtensions(TicTacToeTaskMenuFactory(manager), iid)
-
-    def isContainer(self):
-        return False
-
-    def isInitialized(self):
-        return self._form_editor is not None
-
-    def name(self):
-        return "TicTacToe"
-
-    def toolTip(self):
-        return "Tic Tac Toe Example, demonstrating class QDesignerTaskMenuExtension (Python)"
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/examples/plugin_example_pyside/tictactoetaskmenu.py

@@ -1,67 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtCore import Slot
-from qtpy.QtDesigner import QExtensionFactory, QPyDesignerTaskMenuExtension
-from qtpy.QtGui import QAction
-from qtpy.QtWidgets import QDialog, QDialogButtonBox, QVBoxLayout
-from tictactoe import TicTacToe
-
-
-class TicTacToeDialog(QDialog):  # pragma: no cover
-    def __init__(self, parent):
-        super().__init__(parent)
-        layout = QVBoxLayout(self)
-        self._ticTacToe = TicTacToe(self)
-        layout.addWidget(self._ticTacToe)
-        button_box = QDialogButtonBox(
-            QDialogButtonBox.Ok | QDialogButtonBox.Cancel | QDialogButtonBox.Reset
-        )
-        button_box.accepted.connect(self.accept)
-        button_box.rejected.connect(self.reject)
-        reset_button = button_box.button(QDialogButtonBox.Reset)
-        reset_button.clicked.connect(self._ticTacToe.clear_board)
-        layout.addWidget(button_box)
-
-    def set_state(self, new_state):
-        self._ticTacToe.setState(new_state)
-
-    def state(self):
-        return self._ticTacToe.state
-
-
-class TicTacToeTaskMenu(QPyDesignerTaskMenuExtension):
-    def __init__(self, ticTacToe, parent):
-        super().__init__(parent)
-        self._ticTacToe = ticTacToe
-        self._edit_state_action = QAction("Edit State...", None)
-        self._edit_state_action.triggered.connect(self._edit_state)
-
-    def taskActions(self):
-        return [self._edit_state_action]
-
-    def preferredEditAction(self):
-        return self._edit_state_action
-
-    @Slot()
-    def _edit_state(self):
-        dialog = TicTacToeDialog(self._ticTacToe)
-        dialog.set_state(self._ticTacToe.state)
-        if dialog.exec() == QDialog.Accepted:
-            self._ticTacToe.state = dialog.state()
-
-
-class TicTacToeTaskMenuFactory(QExtensionFactory):
-    def __init__(self, extension_manager):
-        super().__init__(extension_manager)
-
-    @staticmethod
-    def task_menu_iid():
-        return "org.qt-project.Qt.Designer.TaskMenu"
-
-    def createExtension(self, object, iid, parent):
-        if iid != TicTacToeTaskMenuFactory.task_menu_iid():
-            return None
-        if object.__class__.__name__ != "TicTacToe":
-            return None
-        return TicTacToeTaskMenu(object, parent)

bec_widgets/readme.md

@@ -0,0 +1,4 @@
+Add/modify the path in the following variable to make the plugin avaiable in Qt Designer:
+```
+$ export PYQTDESIGNERPATH=/<path to repo>/bec/bec_qtplugin:$PYQTDESIGNERPATH
+```

bec_widgets/scan_plot.py

@@ -0,0 +1,106 @@
+import itertools
+
+import pyqtgraph as pg
+from PyQt5.QtCore import pyqtProperty, pyqtSlot
+
+from bec_lib.core.logger import bec_logger
+
+logger = bec_logger.logger
+
+
+pg.setConfigOptions(background="w", foreground="k", antialias=True)
+COLORS = ["#fd7f6f", "#7eb0d5", "#b2e061", "#bd7ebe", "#ffb55a"]
+
+
+class BECScanPlot(pg.PlotWidget):
+    def __init__(self, parent=None, background="default"):
+        super().__init__(parent, background)
+
+        self._x_channel = ""
+        self._y_channel_list = []
+
+        self.scan_curves = {}
+        self.dap_curves = {}
+
+    def initialize(self):
+        plot_item = self.getPlotItem()
+        plot_item.addLegend()
+        colors = itertools.cycle(COLORS)
+
+        for y_chan in self.y_channel_list:
+            if y_chan.startswith("dap."):
+                y_chan = y_chan.partition("dap.")[-1]
+                curves = self.dap_curves
+            else:
+                curves = self.scan_curves
+
+            curves[y_chan] = plot_item.plot(
+                x=[], y=[], pen=pg.mkPen(color=next(colors), width=2), name=y_chan
+            )
+
+        plot_item.setLabel("bottom", self._x_channel)
+        if len(self.scan_curves) == 1:
+            plot_item.setLabel("left", next(iter(self.scan_curves)))
+
+    @pyqtSlot()
+    def clearData(self):
+        for plot_curve in {**self.scan_curves, **self.dap_curves}.values():
+            plot_curve.setData(x=[], y=[])
+
+    @pyqtSlot(dict)
+    def redraw_scan(self, data):
+        if not self.x_channel:
+            return
+
+        if self.x_channel not in data:
+            logger.warning(f"Unknown channel `{self.x_channel}` for X data in {self.objectName()}")
+            return
+
+        x_new = data[self.x_channel][self.x_channel]["value"]
+        for chan, plot_curve in self.scan_curves.items():
+            if not chan:
+                continue
+
+            if chan not in data:
+                logger.warning(f"Unknown channel `{chan}` for Y data in {self.objectName()}")
+                continue
+
+            y_new = data[chan][chan]["value"]
+            x, y = plot_curve.getData()  # TODO: is it a good approach?
+            if x is None:
+                x = []
+            if y is None:
+                y = []
+
+            plot_curve.setData(x=[*x, x_new], y=[*y, y_new])
+
+    @pyqtSlot(dict)
+    def redraw_dap(self, data):
+        for chan, plot_curve in self.dap_curves.items():
+            if not chan:
+                continue
+
+            if chan not in data:
+                logger.warning(f"Unknown channel `{chan}` for DAP data in {self.objectName()}")
+                continue
+
+            x_new = data[chan]["x"]
+            y_new = data[chan]["y"]
+
+            plot_curve.setData(x=x_new, y=y_new)
+
+    @pyqtProperty("QStringList")
+    def y_channel_list(self):
+        return self._y_channel_list
+
+    @y_channel_list.setter
+    def y_channel_list(self, new_list):
+        self._y_channel_list = new_list
+
+    @pyqtProperty(str)
+    def x_channel(self):
+        return self._x_channel
+
+    @x_channel.setter
+    def x_channel(self, new_val):
+        self._x_channel = new_val

bec_widgets/scan_plot_plugin.py

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

bec_widgets/utils/__init__.py

@@ -1,13 +0,0 @@
-from qtpy.QtWebEngineWidgets import QWebEngineView
-
-from .bec_connector import BECConnector, ConnectionConfig
-from .bec_dispatcher import BECDispatcher
-from .bec_table import BECTable
-from .colors import Colors
-from .container_utils import WidgetContainerUtils
-from .crosshair import Crosshair
-from .entry_validator import EntryValidator
-from .layout_manager import GridLayoutManager
-from .rpc_decorator import register_rpc_methods, rpc_public
-from .ui_loader import UILoader
-from .validator_delegate import DoubleValidationDelegate

bec_widgets/utils/bec_connector.py

@@ -1,295 +0,0 @@
-# pylint: disable = no-name-in-module,missing-module-docstring
-from __future__ import annotations
-
-import os
-import time
-import uuid
-from typing import Optional
-
-import yaml
-from bec_lib.utils.import_utils import lazy_import_from
-from pydantic import BaseModel, Field, field_validator
-from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
-from qtpy.QtCore import Slot as pyqtSlot
-
-from bec_widgets.cli.rpc_register import RPCRegister
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui
-
-BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("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."
-    )
-    model_config: dict = {"validate_assignment": True}
-
-    @field_validator("gui_id")
-    @classmethod
-    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 WorkerSignals(QObject):
-    progress = Signal(dict)
-    completed = Signal()
-
-
-class Worker(QRunnable):
-    """
-    Worker class to run a function in a separate thread.
-    """
-
-    def __init__(self, func, *args, **kwargs):
-        super().__init__()
-        self.signals = WorkerSignals()
-        self.func = func
-        self.args = args
-        self.kwargs = kwargs
-
-    def run(self):
-        """
-        Run the specified function in the thread.
-        """
-        self.func(*self.args, **self.kwargs)
-        self.signals.completed.emit()
-
-
-class BECConnector(BECWidget):
-    """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
-
-    USER_ACCESS = ["_config_dict", "_get_all_rpc"]
-
-    def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
-        # BEC related connections
-        self.bec_dispatcher = BECDispatcher(client=client)
-        self.client = self.bec_dispatcher.client if client is None else client
-
-        if config:
-            self.config = config
-            self.config.widget_class = self.__class__.__name__
-        else:
-            print(
-                f"No initial config found for {self.__class__.__name__}.\n"
-                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
-
-        # register widget to rpc register
-        self.rpc_register = RPCRegister()
-        self.rpc_register.add_rpc(self)
-
-        self._thread_pool = QThreadPool.globalInstance()
-
-    def submit_task(self, fn, *args, on_complete: pyqtSlot = None, **kwargs) -> Worker:
-        """
-        Submit a task to run in a separate thread. The task will run the specified
-        function with the provided arguments and emit the completed signal when done.
-
-        Use this method if you want to wait for a task to complete without blocking the
-        main thread.
-
-        Args:
-            fn: Function to run in a separate thread.
-            *args: Arguments for the function.
-            on_complete: Slot to run when the task is complete.
-            **kwargs: Keyword arguments for the function.
-
-        Returns:
-            worker: The worker object that will run the task.
-
-        Examples:
-            >>> def my_function(a, b):
-            >>>     print(a + b)
-            >>> self.submit_task(my_function, 1, 2)
-
-            >>> def my_function(a, b):
-            >>>     print(a + b)
-            >>> def on_complete():
-            >>>     print("Task complete")
-            >>> self.submit_task(my_function, 1, 2, on_complete=on_complete)
-
-        """
-        worker = Worker(fn, *args, **kwargs)
-        if on_complete:
-            worker.signals.completed.connect(on_complete)
-        self._thread_pool.start(worker)
-        return worker
-
-    def _get_all_rpc(self) -> dict:
-        """Get all registered RPC objects."""
-        all_connections = self.rpc_register.list_all_connections()
-        return dict(all_connections)
-
-    @property
-    def _rpc_id(self) -> str:
-        """Get the RPC ID of the widget."""
-        return self.gui_id
-
-    @_rpc_id.setter
-    def _rpc_id(self, rpc_id: str) -> None:
-        """Set the RPC ID of the widget."""
-        self.gui_id = rpc_id
-
-    @property
-    def _config_dict(self) -> dict:
-        """
-        Get the configuration of the widget.
-
-        Returns:
-            dict: The configuration of the widget.
-        """
-        return self.config.model_dump()
-
-    @_config_dict.setter
-    def _config_dict(self, config: BaseModel) -> None:
-        """
-        Get the configuration of the widget.
-
-        Returns:
-            dict: The configuration of the widget.
-        """
-        self.config = config
-
-    def apply_config(self, config: dict, generate_new_id: bool = True) -> None:
-        """
-        Apply the configuration to the widget.
-
-        Args:
-            config(dict): Configuration settings.
-            generate_new_id(bool): If True, generate a new GUI ID for the widget.
-        """
-        self.config = ConnectionConfig(**config)
-        if generate_new_id is True:
-            gui_id = str(uuid.uuid4())
-            self.rpc_register.remove_rpc(self)
-            self.set_gui_id(gui_id)
-            self.rpc_register.add_rpc(self)
-        else:
-            self.gui_id = self.config.gui_id
-
-    def load_config(self, path: str | None = None, gui: bool = False):
-        """
-        Load the configuration of the widget from YAML.
-
-        Args:
-            path(str): Path to the configuration file for non-GUI dialog mode.
-            gui(bool): If True, use the GUI dialog to load the configuration file.
-        """
-        if gui is True:
-            config = load_yaml_gui(self)
-        else:
-            config = load_yaml(path)
-
-        if config is not None:
-            if config.get("widget_class") != self.__class__.__name__:
-                raise ValueError(
-                    f"Configuration file is not for {self.__class__.__name__}. Got configuration for {config.get('widget_class')}."
-                )
-            self.apply_config(config)
-
-    def save_config(self, path: str | None = None, gui: bool = False):
-        """
-        Save the configuration of the widget to YAML.
-
-        Args:
-            path(str): Path to save the configuration file for non-GUI dialog mode.
-            gui(bool): If True, use the GUI dialog to save the configuration file.
-        """
-        if gui is True:
-            save_yaml_gui(self, self._config_dict)
-        else:
-            if path is None:
-                path = os.getcwd()
-            file_path = os.path.join(path, f"{self.__class__.__name__}_config.yaml")
-
-            save_yaml(file_path, self._config_dict)
-
-    @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
-
-    def cleanup(self):
-        """Cleanup the widget."""
-        self.rpc_register.remove_rpc(self)
-        all_connections = self.rpc_register.list_all_connections()
-        if len(all_connections) == 0:
-            print("No more connections. Shutting down GUI BEC client.")
-            self.bec_dispatcher.disconnect_all()
-            self.client.shutdown()
-
-    # def closeEvent(self, event):
-    #     self.cleanup()
-    #     super().closeEvent(event)

bec_widgets/utils/bec_designer.py

@@ -1,138 +0,0 @@
-import importlib.metadata
-import json
-import os
-import site
-import sys
-import sysconfig
-from pathlib import Path
-
-from qtpy import PYSIDE6
-
-if PYSIDE6:
-    from PySide6.scripts.pyside_tool import (
-        _extend_path_var,
-        init_virtual_env,
-        qt_tool_wrapper,
-        is_pyenv_python,
-        is_virtual_env,
-        ui_tool_binary,
-    )
-
-import bec_widgets
-
-
-def list_editable_packages() -> set[str]:
-    """
-    List all editable packages in the environment.
-
-    Returns:
-        set: A set of paths to editable packages.
-    """
-
-    editable_packages = set()
-
-    # Get site-packages directories
-    site_packages = site.getsitepackages()
-    if hasattr(site, "getusersitepackages"):
-        site_packages.append(site.getusersitepackages())
-
-    for dist in importlib.metadata.distributions():
-        location = dist.locate_file("").resolve()
-        is_editable = all(not str(location).startswith(site_pkg) for site_pkg in site_packages)
-
-        if is_editable:
-            editable_packages.add(str(location))
-
-    for packages in site_packages:
-        # all dist-info directories in site-packages that contain a direct_url.json file
-        dist_info_dirs = Path(packages).rglob("*.dist-info")
-        for dist_info_dir in dist_info_dirs:
-            direct_url = dist_info_dir / "direct_url.json"
-            if not direct_url.exists():
-                continue
-            # load the json file and get the path to the package
-            with open(direct_url, "r", encoding="utf-8") as f:
-                data = json.load(f)
-                path = data.get("url", "")
-                if path.startswith("file://"):
-                    path = path[7:]
-                    editable_packages.add(path)
-
-    return editable_packages
-
-
-def patch_designer():  # pragma: no cover
-    if not PYSIDE6:
-        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
-        return
-
-    init_virtual_env()
-
-    major_version = sys.version_info[0]
-    minor_version = sys.version_info[1]
-    os.environ["PY_MAJOR_VERSION"] = str(major_version)
-    os.environ["PY_MINOR_VERSION"] = str(minor_version)
-
-    if sys.platform == "win32":
-        if is_virtual_env():
-            _extend_path_var("PATH", os.fspath(Path(sys._base_executable).parent), True)
-    else:
-        if sys.platform == "linux":
-            suffix = f"{sys.abiflags}.so"
-            env_var = "LD_PRELOAD"
-        elif sys.platform == "darwin":
-            suffix = ".dylib"
-            env_var = "DYLD_INSERT_LIBRARIES"
-        else:
-            raise RuntimeError(f"Unsupported platform: {sys.platform}")
-        version = f"{major_version}.{minor_version}"
-        library_name = f"libpython{version}{suffix}"
-        lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
-        os.environ[env_var] = lib_path
-
-        if is_pyenv_python() or is_virtual_env():
-            # append all editable packages to the PYTHONPATH
-            editable_packages = list_editable_packages()
-            for pckg in editable_packages:
-                _extend_path_var("PYTHONPATH", pckg, True)
-    qt_tool_wrapper(ui_tool_binary("designer"), sys.argv[1:])
-
-
-def find_plugin_paths(base_path: Path):
-    """
-    Recursively find all directories containing a .pyproject file.
-    """
-    plugin_paths = []
-    for path in base_path.rglob("*.pyproject"):
-        plugin_paths.append(str(path.parent))
-    return plugin_paths
-
-
-def set_plugin_environment_variable(plugin_paths):
-    """
-    Set the PYSIDE_DESIGNER_PLUGINS environment variable with the given plugin paths.
-    """
-    current_paths = os.environ.get("PYSIDE_DESIGNER_PLUGINS", "")
-    if current_paths:
-        current_paths = current_paths.split(os.pathsep)
-    else:
-        current_paths = []
-
-    current_paths.extend(plugin_paths)
-    os.environ["PYSIDE_DESIGNER_PLUGINS"] = os.pathsep.join(current_paths)
-
-
-# Patch the designer function
-def main():  # pragma: no cover
-    if not PYSIDE6:
-        print("PYSIDE6 is not available in the environment. Exiting...")
-        return
-    base_dir = Path(os.path.dirname(bec_widgets.__file__)).resolve()
-    plugin_paths = find_plugin_paths(base_dir)
-    set_plugin_environment_variable(plugin_paths)
-
-    patch_designer()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/utils/bec_dispatcher.py

@@ -1,176 +0,0 @@
-from __future__ import annotations
-
-import collections
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Union
-
-import redis
-from bec_lib.client import BECClient
-from bec_lib.redis_connector import MessageObject, RedisConnector
-from bec_lib.service_config import ServiceConfig
-from qtpy.QtCore import PYQT6, PYSIDE6, QCoreApplication, QObject
-from qtpy.QtCore import Signal as pyqtSignal
-
-if TYPE_CHECKING:
-    from bec_lib.endpoints import EndpointInfo
-
-
-class QtThreadSafeCallback(QObject):
-    cb_signal = pyqtSignal(dict, dict)
-
-    def __init__(self, cb):
-        super().__init__()
-
-        self.cb = cb
-        self.cb_signal.connect(self.cb)
-
-    def __hash__(self):
-        # make 2 differents QtThreadSafeCallback to look
-        # identical when used as dictionary keys, if the
-        # callback is the same
-        return id(self.cb)
-
-    def __call__(self, msg_content, metadata):
-        self.cb_signal.emit(msg_content, metadata)
-
-
-class QtRedisConnector(RedisConnector):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def _execute_callback(self, cb, msg, kwargs):
-        if not isinstance(cb, QtThreadSafeCallback):
-            return super()._execute_callback(cb, msg, kwargs)
-        # if msg.msg_type == "bundle_message":
-        #    # big warning: how to handle bundle messages?
-        #    # message with messages inside ; which slot to call?
-        #    # bundle_msg = msg
-        #    # for msg in bundle_msg:
-        #    #    ...
-        #    # for now, only consider the 1st message
-        #    msg = msg[0]
-        #    raise RuntimeError(f"
-        if isinstance(msg, MessageObject):
-            if isinstance(msg.value, list):
-                msg = msg.value[0]
-            else:
-                msg = msg.value
-
-            # we can notice kwargs are lost when passed to Qt slot
-            metadata = msg.metadata
-            cb(msg.content, metadata)
-        else:
-            # from stream
-            msg = msg["data"]
-            cb(msg.content, msg.metadata)
-
-
-class BECClientWithoutLoggerInit(BECClient):
-    def _initialize_logger(self):
-        return
-
-
-class BECDispatcher:
-    """Utility class to keep track of slots connected to a particular redis connector"""
-
-    _instance = None
-    _initialized = False
-    qapp = None
-
-    def __new__(cls, client=None, config: str = None, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super(BECDispatcher, cls).__new__(cls)
-            cls._initialized = False
-        return cls._instance
-
-    def __init__(self, client=None, config: str | ServiceConfig = None):
-        if self._initialized:
-            return
-
-        if not QCoreApplication.instance():
-            BECDispatcher.qapp = QCoreApplication([])
-
-        self._slots = collections.defaultdict(set)
-        self.client = client
-
-        if self.client is None:
-            if config is not None:
-                if not isinstance(config, ServiceConfig):
-                    # config is supposed to be a path
-                    config = ServiceConfig(config)
-                self.client = BECClientWithoutLoggerInit(
-                    config=config, connector_cls=QtRedisConnector
-                )  # , forced=True)
-            else:
-                self.client = BECClientWithoutLoggerInit(
-                    connector_cls=QtRedisConnector
-                )  # , forced=True)
-        else:
-            if self.client.started:
-                # have to reinitialize client to use proper connector
-                self.client.shutdown()
-            self.client._BECClient__init_params["connector_cls"] = QtRedisConnector
-
-        try:
-            self.client.start()
-        except redis.exceptions.ConnectionError:
-            print("Could not connect to Redis, skipping start of BECClient.")
-
-        self._initialized = True
-
-    @classmethod
-    def reset_singleton(cls):
-        cls._instance = None
-        cls._initialized = False
-
-        if not cls.qapp:
-            return
-
-        # shutdown QCoreApp if it exists
-        if PYQT6:
-            cls.qapp.exit()
-        elif PYSIDE6:
-            cls.qapp.shutdown()
-        cls.qapp = None
-
-    def connect_slot(
-        self, slot: Callable, topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]]
-    ) -> None:
-        """Connect widget's pyqt slot, so that it is called on new pub/sub topic message.
-
-        Args:
-            slot (Callable): A slot method/function that accepts two inputs: content and metadata of
-                the corresponding pub/sub message
-            topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
-        """
-        slot = QtThreadSafeCallback(slot)
-        self.client.connector.register(topics, cb=slot)
-        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        self._slots[slot].update(set(topics_str))
-
-    def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
-        # find the right slot to disconnect from ;
-        # slot callbacks are wrapped in QtThreadSafeCallback objects,
-        # but the slot we receive here is the original callable
-        for connected_slot in self._slots:
-            if connected_slot.cb == slot:
-                break
-        else:
-            return
-        self.client.connector.unregister(topics, cb=connected_slot)
-        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        self._slots[slot].difference_update(set(topics_str))
-        if not self._slots[slot]:
-            del self._slots[slot]
-
-    def disconnect_topics(self, topics: Union[str, list]):
-        self.client.connector.unregister(topics)
-        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        for slot in list(self._slots.keys()):
-            slot_topics = self._slots[slot]
-            slot_topics.difference_update(set(topics_str))
-            if not slot_topics:
-                del self._slots[slot]
-
-    def disconnect_all(self, *args, **kwargs):
-        self.disconnect_topics(self.client.connector._topics_cb)

bec_widgets/utils/bec_table.py

@@ -1,21 +0,0 @@
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import QTableWidget
-
-
-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/bec_widget.py

@@ -1,2 +0,0 @@
-class BECWidget:
-    """Base class for all BEC widgets."""

bec_widgets/utils/colors.py

@@ -1,314 +0,0 @@
-import re
-from typing import Literal
-
-import numpy as np
-import pyqtgraph as pg
-from pydantic_core import PydanticCustomError
-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
-
-    @staticmethod
-    def hex_to_rgba(hex_color: str, alpha=255) -> tuple:
-        """
-        Convert HEX color to RGBA.
-
-        Args:
-            hex_color(str): HEX color string.
-            alpha(int): Alpha value (0-255). Default is 255 (opaque).
-
-        Returns:
-            tuple: RGBA color tuple (r, g, b, a).
-        """
-        hex_color = hex_color.lstrip("#")
-        if len(hex_color) == 6:
-            r, g, b = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
-        elif len(hex_color) == 8:
-            r, g, b, a = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4, 6))
-            return (r, g, b, a)
-        else:
-            raise ValueError("HEX color must be 6 or 8 characters long.")
-        return (r, g, b, alpha)
-
-    @staticmethod
-    def rgba_to_hex(r: int, g: int, b: int, a: int = 255) -> str:
-        """
-        Convert RGBA color to HEX.
-
-        Args:
-            r(int): Red value (0-255).
-            g(int): Green value (0-255).
-            b(int): Blue value (0-255).
-            a(int): Alpha value (0-255). Default is 255 (opaque).
-
-        Returns:
-            hec_color(str): HEX color string.
-        """
-        return "#{:02X}{:02X}{:02X}{:02X}".format(r, g, b, a)
-
-    @staticmethod
-    def validate_color(color: tuple | str) -> tuple | str:
-        """
-        Validate the color input if it is HEX or RGBA compatible. Can be used in any pydantic model as a field validator.
-
-        Args:
-            color(tuple|str): The color to be validated. Can be a tuple of RGBA values or a HEX string.
-
-        Returns:
-            tuple|str: The validated color.
-        """
-        CSS_COLOR_NAMES = {
-            "aliceblue",
-            "antiquewhite",
-            "aqua",
-            "aquamarine",
-            "azure",
-            "beige",
-            "bisque",
-            "black",
-            "blanchedalmond",
-            "blue",
-            "blueviolet",
-            "brown",
-            "burlywood",
-            "cadetblue",
-            "chartreuse",
-            "chocolate",
-            "coral",
-            "cornflowerblue",
-            "cornsilk",
-            "crimson",
-            "cyan",
-            "darkblue",
-            "darkcyan",
-            "darkgoldenrod",
-            "darkgray",
-            "darkgreen",
-            "darkgrey",
-            "darkkhaki",
-            "darkmagenta",
-            "darkolivegreen",
-            "darkorange",
-            "darkorchid",
-            "darkred",
-            "darksalmon",
-            "darkseagreen",
-            "darkslateblue",
-            "darkslategray",
-            "darkslategrey",
-            "darkturquoise",
-            "darkviolet",
-            "deeppink",
-            "deepskyblue",
-            "dimgray",
-            "dimgrey",
-            "dodgerblue",
-            "firebrick",
-            "floralwhite",
-            "forestgreen",
-            "fuchsia",
-            "gainsboro",
-            "ghostwhite",
-            "gold",
-            "goldenrod",
-            "gray",
-            "green",
-            "greenyellow",
-            "grey",
-            "honeydew",
-            "hotpink",
-            "indianred",
-            "indigo",
-            "ivory",
-            "khaki",
-            "lavender",
-            "lavenderblush",
-            "lawngreen",
-            "lemonchiffon",
-            "lightblue",
-            "lightcoral",
-            "lightcyan",
-            "lightgoldenrodyellow",
-            "lightgray",
-            "lightgreen",
-            "lightgrey",
-            "lightpink",
-            "lightsalmon",
-            "lightseagreen",
-            "lightskyblue",
-            "lightslategray",
-            "lightslategrey",
-            "lightsteelblue",
-            "lightyellow",
-            "lime",
-            "limegreen",
-            "linen",
-            "magenta",
-            "maroon",
-            "mediumaquamarine",
-            "mediumblue",
-            "mediumorchid",
-            "mediumpurple",
-            "mediumseagreen",
-            "mediumslateblue",
-            "mediumspringgreen",
-            "mediumturquoise",
-            "mediumvioletred",
-            "midnightblue",
-            "mintcream",
-            "mistyrose",
-            "moccasin",
-            "navajowhite",
-            "navy",
-            "oldlace",
-            "olive",
-            "olivedrab",
-            "orange",
-            "orangered",
-            "orchid",
-            "palegoldenrod",
-            "palegreen",
-            "paleturquoise",
-            "palevioletred",
-            "papayawhip",
-            "peachpuff",
-            "peru",
-            "pink",
-            "plum",
-            "powderblue",
-            "purple",
-            "red",
-            "rosybrown",
-            "royalblue",
-            "saddlebrown",
-            "salmon",
-            "sandybrown",
-            "seagreen",
-            "seashell",
-            "sienna",
-            "silver",
-            "skyblue",
-            "slateblue",
-            "slategray",
-            "slategrey",
-            "snow",
-            "springgreen",
-            "steelblue",
-            "tan",
-            "teal",
-            "thistle",
-            "tomato",
-            "turquoise",
-            "violet",
-            "wheat",
-            "white",
-            "whitesmoke",
-            "yellow",
-            "yellowgreen",
-        }
-        if isinstance(color, str):
-            hex_pattern = re.compile(r"^#(?:[0-9a-fA-F]{3}){1,2}$")
-            if hex_pattern.match(color):
-                return color
-            elif color.lower() in CSS_COLOR_NAMES:
-                return color
-            else:
-                raise PydanticCustomError(
-                    "unsupported color",
-                    "The color must be a valid HEX string or CSS Color.",
-                    {"wrong_value": color},
-                )
-        elif isinstance(color, tuple):
-            if len(color) != 4:
-                raise PydanticCustomError(
-                    "unsupported color",
-                    "The color must be a tuple of 4 elements (R, G, B, A).",
-                    {"wrong_value": color},
-                )
-            for value in color:
-                if not 0 <= value <= 255:
-                    raise PydanticCustomError(
-                        "unsupported color",
-                        f"The color values must be between 0 and 255 in RGBA format (R,G,B,A)",
-                        {"wrong_value": color},
-                    )
-            return color
-
-    @staticmethod
-    def validate_color_map(color_map: str) -> str:
-        """
-        Validate the colormap input if it is supported by pyqtgraph. Can be used in any pydantic model as a field validator. If validation fails it prints all available colormaps from pyqtgraph instance.
-
-        Args:
-            color_map(str): The colormap to be validated.
-
-        Returns:
-            str: The validated colormap.
-        """
-        available_colormaps = pg.colormap.listMaps()
-        if color_map not in available_colormaps:
-            raise PydanticCustomError(
-                "unsupported colormap",
-                f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
-                {"wrong_value": color_map},
-            )
-        return color_map

bec_widgets/utils/container_utils.py

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

bec_widgets/utils/crosshair.py

@@ -1,235 +0,0 @@
-import numpy as np
-import pyqtgraph as pg
-
-# from qtpy.QtCore import QObject, pyqtSignal
-from qtpy.QtCore import QObject
-from qtpy.QtCore import Signal as pyqtSignal
-
-
-class Crosshair(QObject):
-    # Signal for 1D plot
-    coordinatesChanged1D = pyqtSignal(tuple)
-    coordinatesClicked1D = pyqtSignal(tuple)
-    # Signal for 2D plot
-    coordinatesChanged2D = pyqtSignal(tuple)
-    coordinatesClicked2D = pyqtSignal(tuple)
-
-    def __init__(self, plot_item: pg.PlotItem, precision: int = 3, parent=None):
-        """
-        Crosshair for 1D and 2D plots.
-
-        Args:
-            plot_item (pyqtgraph.PlotItem): The plot item to which the crosshair will be attached.
-            precision (int, optional): Number of decimal places to round the coordinates to. Defaults to None.
-            parent (QObject, optional): Parent object for the QObject. Defaults to None.
-        """
-        super().__init__(parent)
-        self.is_log_y = None
-        self.is_log_x = None
-        self.plot_item = plot_item
-        self.precision = precision
-        self.v_line = pg.InfiniteLine(angle=90, movable=False)
-        self.h_line = pg.InfiniteLine(angle=0, movable=False)
-        self.plot_item.addItem(self.v_line, ignoreBounds=True)
-        self.plot_item.addItem(self.h_line, ignoreBounds=True)
-        self.proxy = pg.SignalProxy(
-            self.plot_item.scene().sigMouseMoved, rateLimit=60, slot=self.mouse_moved
-        )
-        self.plot_item.scene().sigMouseClicked.connect(self.mouse_clicked)
-
-        # Initialize markers
-        self.marker_moved_1d = []
-        self.marker_clicked_1d = []
-        self.marker_2d = None
-        self.update_markers()
-
-    def update_markers(self):
-        """Update the markers for the crosshair, creating new ones if necessary."""
-
-        # Clear existing markers
-        for marker in self.marker_moved_1d + self.marker_clicked_1d:
-            self.plot_item.removeItem(marker)
-        if self.marker_2d:
-            self.plot_item.removeItem(self.marker_2d)
-
-        # Create new markers
-        self.marker_moved_1d = []
-        self.marker_clicked_1d = []
-        self.marker_2d = None
-        for item in self.plot_item.items:
-            if isinstance(item, pg.PlotDataItem):  # 1D plot
-                pen = item.opts["pen"]
-                color = pen.color() if hasattr(pen, "color") else pg.mkColor(pen)
-                marker_moved = pg.ScatterPlotItem(
-                    size=10, pen=pg.mkPen(color), brush=pg.mkBrush(None)
-                )
-                marker_clicked = pg.ScatterPlotItem(
-                    size=10, pen=pg.mkPen(None), brush=pg.mkBrush(color)
-                )
-                self.marker_moved_1d.append(marker_moved)
-                self.plot_item.addItem(marker_moved)
-                # Create glowing effect markers for clicked events
-                marker_clicked_list = []
-                for size, alpha in [(18, 64), (14, 128), (10, 255)]:
-                    marker_clicked = pg.ScatterPlotItem(
-                        size=size,
-                        pen=pg.mkPen(None),
-                        brush=pg.mkBrush(color.red(), color.green(), color.blue(), alpha),
-                    )
-                    marker_clicked_list.append(marker_clicked)
-                    self.plot_item.addItem(marker_clicked)
-
-                self.marker_clicked_1d.append(marker_clicked_list)
-            elif isinstance(item, pg.ImageItem):  # 2D plot
-                self.marker_2d = pg.ROI(
-                    [0, 0], size=[1, 1], pen=pg.mkPen("r", width=2), movable=False
-                )
-                self.plot_item.addItem(self.marker_2d)
-
-    def snap_to_data(self, x, y) -> tuple:
-        """
-        Finds the nearest data points to the given x and y coordinates.
-
-        Args:
-            x: The x-coordinate
-            y: The y-coordinate
-
-        Returns:
-            tuple: The nearest x and y values
-        """
-        y_values_1d = []
-        x_values_1d = []
-        image_2d = None
-
-        # Iterate through items in the plot
-        for item in self.plot_item.items:
-            if isinstance(item, pg.PlotDataItem):  # 1D plot
-                x_data, y_data = item.xData, item.yData
-                if x_data is not None and y_data is not None:
-                    if self.is_log_x:
-                        min_x_data = np.min(x_data[x_data > 0])
-                    else:
-                        min_x_data = np.min(x_data)
-                    max_x_data = np.max(x_data)
-                    if x < min_x_data or x > max_x_data:
-                        return None, None
-                    closest_x, closest_y = self.closest_x_y_value(x, x_data, y_data)
-                    y_values_1d.append(closest_y)
-                    x_values_1d.append(closest_x)
-            elif isinstance(item, pg.ImageItem):  # 2D plot
-                image_2d = item.image
-
-        # Handle 1D plot
-        if y_values_1d:
-            if all(v is None for v in x_values_1d) or all(v is None for v in y_values_1d):
-                return None, None
-            closest_x = min(x_values_1d, key=lambda xi: abs(xi - x))  # Snap x to closest data point
-            return closest_x, y_values_1d
-
-        # Handle 2D plot
-        if image_2d is not None:
-            x_idx = int(np.clip(x, 0, image_2d.shape[0] - 1))
-            y_idx = int(np.clip(y, 0, image_2d.shape[1] - 1))
-            return x_idx, y_idx
-
-        return None, None
-
-    def closest_x_y_value(self, input_value: float, list_x: list, list_y: list) -> tuple:
-        """
-        Find the closest x and y value to the input value.
-
-        Args:
-            input_value (float): Input value
-            list_x (list): List of x values
-            list_y (list): List of y values
-
-        Returns:
-            tuple: Closest x and y value
-        """
-        arr = np.asarray(list_x)
-        i = (np.abs(arr - input_value)).argmin()
-        return list_x[i], list_y[i]
-
-    def mouse_moved(self, event):
-        """Handles the mouse moved event, updating the crosshair position and emitting signals.
-
-        Args:
-            event: The mouse moved event
-        """
-        self.check_log()
-        pos = event[0]
-        if self.plot_item.vb.sceneBoundingRect().contains(pos):
-            mouse_point = self.plot_item.vb.mapSceneToView(pos)
-            self.v_line.setPos(mouse_point.x())
-            self.h_line.setPos(mouse_point.y())
-
-            x, y = mouse_point.x(), mouse_point.y()
-            if self.is_log_x:
-                x = 10**x
-            if self.is_log_y:
-                y = 10**y
-            x, y_values = self.snap_to_data(x, y)
-
-            for item in self.plot_item.items:
-                if isinstance(item, pg.PlotDataItem):
-                    if x is None or all(v is None for v in y_values):
-                        return
-                    coordinate_to_emit = (
-                        round(x, self.precision),
-                        [round(y_val, self.precision) for y_val in y_values],
-                    )
-                    self.coordinatesChanged1D.emit(coordinate_to_emit)
-                    for i, y_val in enumerate(y_values):
-                        self.marker_moved_1d[i].setData(
-                            [x if not self.is_log_x else np.log10(x)],
-                            [y_val if not self.is_log_y else np.log10(y_val)],
-                        )
-                elif isinstance(item, pg.ImageItem):
-                    if x is None or y_values is None:
-                        return
-                    coordinate_to_emit = (x, y_values)
-                    self.coordinatesChanged2D.emit(coordinate_to_emit)
-
-    def mouse_clicked(self, event):
-        """Handles the mouse clicked event, updating the crosshair position and emitting signals.
-
-        Args:
-            event: The mouse clicked event
-        """
-        self.check_log()
-        if self.plot_item.vb.sceneBoundingRect().contains(event._scenePos):
-            mouse_point = self.plot_item.vb.mapSceneToView(event._scenePos)
-            x, y = mouse_point.x(), mouse_point.y()
-
-            if self.is_log_x:
-                x = 10**x
-            if self.is_log_y:
-                y = 10**y
-            x, y_values = self.snap_to_data(x, y)
-
-            for item in self.plot_item.items:
-                if isinstance(item, pg.PlotDataItem):
-                    if x is None or all(v is None for v in y_values):
-                        return
-                    coordinate_to_emit = (
-                        round(x, self.precision),
-                        [round(y_val, self.precision) for y_val in y_values],
-                    )
-                    self.coordinatesClicked1D.emit(coordinate_to_emit)
-                    for i, y_val in enumerate(y_values):
-                        for marker in self.marker_clicked_1d[i]:
-                            marker.setData(
-                                [x if not self.is_log_x else np.log10(x)],
-                                [y_val if not self.is_log_y else np.log10(y_val)],
-                            )
-                elif isinstance(item, pg.ImageItem):
-                    if x is None or y_values is None:
-                        return
-                    coordinate_to_emit = (x, y_values)
-                    self.coordinatesClicked2D.emit(coordinate_to_emit)
-                    self.marker_2d.setPos([x, y_values])
-
-    def check_log(self):
-        """Checks if the x or y axis is in log scale and updates the internal state accordingly."""
-        self.is_log_x = self.plot_item.ctrl.logXCheck.isChecked()
-        self.is_log_y = self.plot_item.ctrl.logYCheck.isChecked()

bec_widgets/utils/entry_validator.py

@@ -1,42 +0,0 @@
-class EntryValidator:
-    def __init__(self, devices):
-        self.devices = devices
-
-    def validate_signal(self, name: str, entry: str = None) -> str:
-        """
-        Validate a signal entry for a given device. If the entry is not provided, the first signal entry will be used from the device hints.
-
-        Args:
-            name(str): Device name
-            entry(str): Signal entry
-
-        Returns:
-            str: Signal entry
-        """
-        if name not in self.devices:
-            raise ValueError(f"Device '{name}' not found in current BEC session")
-
-        device = self.devices[name]
-        description = device.describe()
-
-        if entry is None or entry == "":
-            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
-
-    def validate_monitor(self, monitor: str) -> str:
-        """
-        Validate a monitor entry for a given device.
-
-        Args:
-            monitor(str): Monitor entry
-
-        Returns:
-            str: Monitor entry
-        """
-        if monitor not in self.devices:
-            raise ValueError(f"Device '{monitor}' not found in current BEC session")
-
-        return monitor

bec_widgets/utils/generate_designer_plugin.py

@@ -1,148 +0,0 @@
-import inspect
-import os
-import re
-
-from qtpy.QtCore import QObject
-
-EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock"]
-
-
-class DesignerPluginInfo:
-    def __init__(self, plugin_class):
-        self.plugin_class = plugin_class
-        self.plugin_name_pascal = plugin_class.__name__
-        self.plugin_name_snake = self.pascal_to_snake(self.plugin_name_pascal)
-        self.widget_import = f"from {plugin_class.__module__} import {self.plugin_name_pascal}"
-        plugin_module = (
-            ".".join(plugin_class.__module__.split(".")[:-1]) + f".{self.plugin_name_snake}_plugin"
-        )
-        self.plugin_import = f"from {plugin_module} import {self.plugin_name_pascal}Plugin"
-
-        # first sentence / line of the docstring is used as tooltip
-        self.plugin_tooltip = (
-            plugin_class.__doc__.split("\n")[0].strip().replace('"', "'")
-            if plugin_class.__doc__
-            else self.plugin_name_pascal
-        )
-
-        self.base_path = os.path.dirname(inspect.getfile(plugin_class))
-
-    @staticmethod
-    def pascal_to_snake(name: str) -> str:
-        """
-        Convert PascalCase to snake_case.
-
-        Args:
-            name (str): The name to be converted.
-
-        Returns:
-            str: The converted name.
-        """
-        s1 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
-        s2 = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s1)
-        return s2.lower()
-
-
-class DesignerPluginGenerator:
-    def __init__(self, widget: type):
-        self._excluded = False
-        self.widget = widget
-        self.info = DesignerPluginInfo(widget)
-        if widget.__name__ in EXCLUDED_PLUGINS:
-
-            self._excluded = True
-            return
-
-        self.templates = {}
-        self.template_path = os.path.join(
-            os.path.dirname(os.path.abspath(__file__)), "plugin_templates"
-        )
-
-    def run(self):
-        if self._excluded:
-            print(f"Plugin {self.widget.__name__} is excluded from generation.")
-            return
-        self._check_class_validity()
-        self._load_templates()
-        self._write_templates()
-
-    def _check_class_validity(self):
-
-        # Check if the widget is a QWidget subclass
-        if not issubclass(self.widget, QObject):
-            return
-
-        # Check if the widget class has parent as the first argument. This is a strict requirement of Qt!
-        signature = list(inspect.signature(self.widget.__init__).parameters.values())
-        if len(signature) == 1 or signature[1].name != "parent":
-            raise ValueError(
-                f"Widget class {self.widget.__name__} must have parent as the first argument."
-            )
-
-        base_cls = [val for val in self.widget.__bases__ if issubclass(val, QObject)]
-        if not base_cls:
-            raise ValueError(
-                f"Widget class {self.widget.__name__} must inherit from a QObject subclass."
-            )
-
-        # Check if the widget class calls the super constructor with parent argument
-        init_source = inspect.getsource(self.widget.__init__)
-        cls_init_found = (
-            bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent=parent") > 0)
-            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent)") > 0)
-            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent,") > 0)
-        )
-        super_init_found = (
-            bool(
-                init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent=parent") > 0
-            )
-            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent,") > 0)
-            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent)") > 0)
-        )
-        if issubclass(self.widget.__bases__[0], QObject) and not super_init_found:
-            super_init_found = (
-                bool(init_source.find("super().__init__(parent=parent") > 0)
-                or bool(init_source.find("super().__init__(parent,") > 0)
-                or bool(init_source.find("super().__init__(parent)") > 0)
-            )
-
-        if not cls_init_found and not super_init_found:
-            raise ValueError(
-                f"Widget class {self.widget.__name__} must call the super constructor with parent."
-            )
-
-    def _write_templates(self):
-        self._write_register()
-        self._write_plugin()
-        self._write_pyproject()
-
-    def _write_register(self):
-        file_path = os.path.join(self.info.base_path, f"register_{self.info.plugin_name_snake}.py")
-        with open(file_path, "w", encoding="utf-8") as f:
-            f.write(self.templates["register"].format(**self.info.__dict__))
-
-    def _write_plugin(self):
-        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}_plugin.py")
-        with open(file_path, "w", encoding="utf-8") as f:
-            f.write(self.templates["plugin"].format(**self.info.__dict__))
-
-    def _write_pyproject(self):
-        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}.pyproject")
-        out = {"files": [f"{self.info.plugin_class.__module__.split('.')[-1]}.py"]}
-        with open(file_path, "w", encoding="utf-8") as f:
-            f.write(str(out))
-
-    def _load_templates(self):
-        for file in os.listdir(self.template_path):
-            if not file.endswith(".template"):
-                continue
-            with open(os.path.join(self.template_path, file), "r", encoding="utf-8") as f:
-                self.templates[file.split(".")[0]] = f.read()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    # from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
-    from bec_widgets.widgets.dock import BECDockArea
-
-    generator = DesignerPluginGenerator(BECDockArea)
-    generator.run()

bec_widgets/utils/layout_manager.py

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

bec_widgets/utils/plugin_templates/plugin.template

@@ -1,54 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtGui import QIcon
-
-{widget_import}
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='{plugin_name_pascal}' name='{plugin_name_snake}'>
-    </widget>
-</ui>
-"""
-
-
-class {plugin_name_pascal}Plugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        t = {plugin_name_pascal}(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return ""
-
-    def icon(self):
-        return QIcon()
-
-    def includeFile(self):
-        return "{plugin_name_snake}"
-
-    def initialize(self, form_editor):
-        self._form_editor = form_editor
-
-    def isContainer(self):
-        return False
-
-    def isInitialized(self):
-        return self._form_editor is not None
-
-    def name(self):
-        return "{plugin_name_pascal}"
-
-    def toolTip(self):
-        return "{plugin_tooltip}"
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/utils/plugin_templates/register.template

@@ -1,15 +0,0 @@
-def main():  # pragma: no cover
-    from qtpy import PYSIDE6
-
-    if not PYSIDE6:
-        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
-        return
-    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
-
-    {plugin_import}
-
-    QPyDesignerCustomWidgetCollection.addCustomWidget({plugin_name_pascal}Plugin())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/utils/plugin_utils.py

@@ -1,158 +0,0 @@
-import importlib
-import inspect
-import os
-from dataclasses import dataclass
-
-from bec_lib.plugin_helper import _get_available_plugins
-from qtpy.QtWidgets import QGraphicsWidget, QWidget
-
-from bec_widgets.utils import BECConnector
-from bec_widgets.utils.bec_widget import BECWidget
-
-
-def get_plugin_widgets() -> dict[str, BECConnector]:
-    """
-    Get all available widgets from the plugin directory. Widgets are classes that inherit from BECConnector.
-    The plugins are provided through python plugins and specified in the respective pyproject.toml file using
-    the following key:
-
-        [project.entry-points."bec.widgets.user_widgets"]
-        plugin_widgets = "path.to.plugin.module"
-
-    e.g.
-        [project.entry-points."bec.widgets.user_widgets"]
-        plugin_widgets = "pxiii_bec.bec_widgets.widgets"
-
-        assuming that the widgets module for the package pxiii_bec is located at pxiii_bec/bec_widgets/widgets and
-        contains the widgets to be loaded within the pxiii_bec/bec_widgets/widgets/__init__.py file.
-
-    Returns:
-        dict[str, BECConnector]: A dictionary of widget names and their respective classes.
-    """
-    modules = _get_available_plugins("bec.widgets.user_widgets")
-    loaded_plugins = {}
-    print(modules)
-    for module in modules:
-        mods = inspect.getmembers(module, predicate=_filter_plugins)
-        for name, mod_cls in mods:
-            if name in loaded_plugins:
-                print(f"Duplicated widgets plugin {name}.")
-            loaded_plugins[name] = mod_cls
-    return loaded_plugins
-
-
-def _filter_plugins(obj):
-    return inspect.isclass(obj) and issubclass(obj, BECConnector)
-
-
-@dataclass
-class BECClassInfo:
-    name: str
-    module: str
-    file: str
-    obj: type
-    is_connector: bool = False
-    is_widget: bool = False
-    is_top_level: bool = False
-
-
-class BECClassContainer:
-    def __init__(self):
-        self._collection = []
-
-    def add_class(self, class_info: BECClassInfo):
-        """
-        Add a class to the collection.
-
-        Args:
-            class_info(BECClassInfo): The class information
-        """
-        self.collection.append(class_info)
-
-    @property
-    def collection(self):
-        """
-        Get the collection of classes.
-        """
-        return self._collection
-
-    @property
-    def connector_classes(self):
-        """
-        Get all connector classes.
-        """
-        return [info.obj for info in self.collection if info.is_connector]
-
-    @property
-    def top_level_classes(self):
-        """
-        Get all top-level classes.
-        """
-        return [info.obj for info in self.collection if info.is_top_level]
-
-    @property
-    def plugins(self):
-        """
-        Get all plugins. These are all classes that are on the top level and are widgets.
-        """
-        return [info.obj for info in self.collection if info.is_widget and info.is_top_level]
-
-    @property
-    def widgets(self):
-        """
-        Get all widgets. These are all classes inheriting from BECWidget.
-        """
-        return [info.obj for info in self.collection if info.is_widget]
-
-    @property
-    def rpc_top_level_classes(self):
-        """
-        Get all top-level classes that are RPC-enabled. These are all classes that users can choose from.
-        """
-        return [info.obj for info in self.collection if info.is_top_level and info.is_connector]
-
-
-def get_rpc_classes(repo_name: str) -> BECClassContainer:
-    """
-    Get all RPC-enabled classes in the specified repository.
-
-    Args:
-        repo_name(str): The name of the repository.
-
-    Returns:
-        dict: A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
-    """
-    collection = BECClassContainer()
-    anchor_module = importlib.import_module(f"{repo_name}.widgets")
-    directory = os.path.dirname(anchor_module.__file__)
-    for root, _, files in sorted(os.walk(directory)):
-        for file in files:
-            if not file.endswith(".py") or file.startswith("__"):
-                continue
-
-            path = os.path.join(root, file)
-            subs = os.path.dirname(os.path.relpath(path, directory)).split("/")
-            if len(subs) == 1 and not subs[0]:
-                module_name = file.split(".")[0]
-            else:
-                module_name = ".".join(subs + [file.split(".")[0]])
-
-            module = importlib.import_module(f"{repo_name}.widgets.{module_name}")
-
-            for name in dir(module):
-                obj = getattr(module, name)
-                if not hasattr(obj, "__module__") or obj.__module__ != module.__name__:
-                    continue
-                if isinstance(obj, type):
-                    class_info = BECClassInfo(name=name, module=module_name, file=path, obj=obj)
-                    if issubclass(obj, BECConnector):
-                        class_info.is_connector = True
-                    if issubclass(obj, BECWidget):
-                        class_info.is_widget = True
-                    if len(subs) == 1 and (
-                        issubclass(obj, QWidget) or issubclass(obj, QGraphicsWidget)
-                    ):
-                        class_info.is_top_level = True
-                    collection.add_class(class_info)
-
-    return collection

bec_widgets/utils/rpc_decorator.py

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

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

bec_widgets/utils/ui_loader.py

@@ -1,140 +0,0 @@
-import os
-
-from qtpy import PYQT6, PYSIDE6, QT_VERSION
-from qtpy.QtCore import QFile, QIODevice
-
-from bec_widgets.utils.generate_designer_plugin import DesignerPluginInfo
-from bec_widgets.utils.plugin_utils import get_rpc_classes
-
-if PYSIDE6:
-    from PySide6.QtUiTools import QUiLoader
-
-    class CustomUiLoader(QUiLoader):
-        def __init__(self, baseinstance, custom_widgets: dict = None):
-            super().__init__(baseinstance)
-            self.custom_widgets = custom_widgets or {}
-
-            self.baseinstance = baseinstance
-
-        def createWidget(self, class_name, parent=None, name=""):
-            if class_name in self.custom_widgets:
-                widget = self.custom_widgets[class_name](parent)
-                widget.setObjectName(name)
-                return widget
-            return super().createWidget(class_name, parent, name)
-
-
-class UILoader:
-    """Universal UI loader for PyQt6 and PySide6."""
-
-    def __init__(self, parent=None):
-        self.parent = parent
-
-        widgets = get_rpc_classes("bec_widgets").top_level_classes
-
-        self.custom_widgets = {widget.__name__: widget for widget in widgets}
-
-        if PYSIDE6:
-            self.loader = self.load_ui_pyside6
-        elif PYQT6:
-            self.loader = self.load_ui_pyqt6
-        else:
-            raise ImportError("No compatible Qt bindings found.")
-
-    def load_ui_pyside6(self, ui_file, parent=None):
-        """
-        Specific loader for PySide6 using QUiLoader.
-        Args:
-            ui_file(str): Path to the .ui file.
-            parent(QWidget): Parent widget.
-
-        Returns:
-            QWidget: The loaded widget.
-        """
-
-        loader = CustomUiLoader(parent, self.custom_widgets)
-        file = QFile(ui_file)
-        if not file.open(QIODevice.ReadOnly):
-            raise IOError(f"Cannot open file: {ui_file}")
-        widget = loader.load(file, parent)
-        file.close()
-        return widget
-
-    def load_ui_pyqt6(self, ui_file, parent=None):
-        """
-        Specific loader for PyQt6 using loadUi.
-        Args:
-            ui_file(str): Path to the .ui file.
-            parent(QWidget): Parent widget.
-
-        Returns:
-            QWidget: The loaded widget.
-        """
-        from PyQt6.uic.Loader.loader import DynamicUILoader
-
-        class CustomDynamicUILoader(DynamicUILoader):
-            def __init__(self, package, custom_widgets: dict = None):
-                super().__init__(package)
-                self.custom_widgets = custom_widgets or {}
-
-            def _handle_custom_widgets(self, el):
-                """Handle the <customwidgets> element."""
-
-                def header2module(header):
-                    """header2module(header) -> string
-
-                    Convert paths to C++ header files to according Python modules
-                    >>> header2module("foo/bar/baz.h")
-                    'foo.bar.baz'
-                    """
-
-                    if header.endswith(".h"):
-                        header = header[:-2]
-
-                    mpath = []
-                    for part in header.split("/"):
-                        # Ignore any empty parts or those that refer to the current
-                        # directory.
-                        if part not in ("", "."):
-                            if part == "..":
-                                # We should allow this for Python3.
-                                raise SyntaxError(
-                                    "custom widget header file name may not contain '..'."
-                                )
-
-                            mpath.append(part)
-
-                    return ".".join(mpath)
-
-                for custom_widget in el:
-                    classname = custom_widget.findtext("class")
-                    header = custom_widget.findtext("header")
-                    if header:
-                        header = self._translate_bec_widgets_header(header)
-                    self.factory.addCustomWidget(
-                        classname,
-                        custom_widget.findtext("extends") or "QWidget",
-                        header2module(header),
-                    )
-
-            def _translate_bec_widgets_header(self, header):
-                for name, value in self.custom_widgets.items():
-                    if header == DesignerPluginInfo.pascal_to_snake(name):
-                        return value.__module__
-                return header
-
-        return CustomDynamicUILoader("", self.custom_widgets).loadUi(ui_file, parent)
-
-    def load_ui(self, ui_file, parent=None):
-        """
-        Universal UI loader method.
-        Args:
-            ui_file(str): Path to the .ui file.
-            parent(QWidget): Parent widget.
-
-        Returns:
-            QWidget: The loaded widget.
-        """
-        if parent is None:
-            parent = self.parent
-        return self.loader(ui_file, parent)

bec_widgets/utils/validator_delegate.py

@@ -1,13 +0,0 @@
-# from qtpy.QtGui import QDoubleValidator
-# from qtpy.QtWidgets import QStyledItemDelegate, QLineEdit
-
-from qtpy.QtGui import QDoubleValidator
-from qtpy.QtWidgets import QLineEdit, QStyledItemDelegate
-
-
-class DoubleValidationDelegate(QStyledItemDelegate):
-    def createEditor(self, parent, option, index):
-        editor = QLineEdit(parent)
-        validator = QDoubleValidator()
-        editor.setValidator(validator)
-        return editor

bec_widgets/utils/widget_io.py

@@ -1,364 +0,0 @@
-# pylint: disable=no-name-in-module
-from abc import ABC, abstractmethod
-
-from qtpy.QtWidgets import (
-    QApplication,
-    QCheckBox,
-    QComboBox,
-    QDoubleSpinBox,
-    QLabel,
-    QLineEdit,
-    QSpinBox,
-    QTableWidget,
-    QTableWidgetItem,
-    QVBoxLayout,
-    QWidget,
-)
-
-
-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 | str) -> None:
-        if isinstance(value, str):
-            value = widget.findText(value)
-        if isinstance(value, int):
-            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._find_handler(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._find_handler(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)}")
-
-    @staticmethod
-    def check_and_adjust_limits(spin_box: QDoubleSpinBox, number: float):
-        """
-        Check if the new limits are within the current limits, if not adjust the limits.
-
-        Args:
-            number(float): The new value to check against the limits.
-        """
-
-        min_value = spin_box.minimum()
-        max_value = spin_box.maximum()
-
-        # Calculate the new limits
-        new_limit = number + 5 * number
-
-        if number < min_value:
-            spin_box.setMinimum(new_limit)
-        elif number > max_value:
-            spin_box.setMaximum(new_limit)
-
-    @staticmethod
-    def _find_handler(widget):
-        """
-        Find the appropriate handler for the widget by checking its base classes.
-
-        Args:
-            widget: Widget instance.
-
-        Returns:
-            handler_class: The handler class if found, otherwise None.
-        """
-        for base in type(widget).__mro__:
-            if base in WidgetIO._handlers:
-                return WidgetIO._handlers[base]
-        return None
-
-
-################## 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

@@ -1,88 +0,0 @@
-# pylint: disable=no-name-in-module
-
-from typing import Union
-
-import yaml
-from qtpy.QtWidgets import QFileDialog
-
-
-def load_yaml_gui(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
-    )
-    config = load_yaml(file_path)
-    return config
-
-
-def load_yaml(file_path: str) -> Union[dict, None]:
-    """
-    Load YAML file from disk.
-
-    Args:
-        file_path(str): Path to the YAML file.
-
-    Returns:
-        dict: Configuration data loaded from the YAML file.
-    """
-    if not file_path:
-        return None
-    try:
-        with open(file_path, "r") as file:
-            config = yaml.load(file, Loader=yaml.FullLoader)
-        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_gui(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
-    )
-
-    save_yaml(file_path, config)
-
-
-def save_yaml(file_path: str, config: dict) -> None:
-    """
-    Save YAML file to disk.
-
-    Args:
-        file_path(str): Path to the YAML file.
-        config(dict): Configuration data to be saved.
-    """
-    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/widgets/__init__.py

@@ -1 +0,0 @@
-

bec_widgets/widgets/bec_queue/bec_queue.py

@@ -1,111 +0,0 @@
-from bec_lib.endpoints import MessageEndpoints
-from qtpy.QtCore import Qt, Slot
-from qtpy.QtWidgets import QHeaderView, QTableWidget, QTableWidgetItem, QWidget
-
-from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
-
-
-class BECQueue(BECConnector, QTableWidget):
-    """
-    Widget to display the BEC queue.
-    """
-
-    def __init__(
-        self,
-        parent: QWidget | None = None,
-        client=None,
-        config: ConnectionConfig = None,
-        gui_id: str = None,
-    ):
-        super().__init__(client, config, gui_id)
-        QTableWidget.__init__(self, parent=parent)
-        self.setColumnCount(3)
-        self.setHorizontalHeaderLabels(["Scan Number", "Type", "Status"])
-        header = self.horizontalHeader()
-        header.setSectionResizeMode(QHeaderView.Stretch)
-        self.bec_dispatcher.connect_slot(self.update_queue, MessageEndpoints.scan_queue_status())
-        self.reset_content()
-
-    @Slot(dict, dict)
-    def update_queue(self, content, _metadata):
-        """
-        Update the queue table with the latest queue information.
-
-        Args:
-            content (dict): The queue content.
-            _metadata (dict): The metadata.
-        """
-        # only show the primary queue for now
-        queue_info = content.get("queue", {}).get("primary", {}).get("info", [])
-        self.setRowCount(len(queue_info))
-        self.clearContents()
-
-        if not queue_info:
-            self.reset_content()
-            return
-
-        for index, item in enumerate(queue_info):
-            blocks = item.get("request_blocks", [])
-            scan_types = []
-            scan_numbers = []
-            status = item.get("status", "")
-            for request_block in blocks:
-                scan_type = request_block.get("content", {}).get("scan_type", "")
-                if scan_type:
-                    scan_types.append(scan_type)
-                scan_number = request_block.get("scan_number", "")
-                if scan_number:
-                    scan_numbers.append(str(scan_number))
-            if scan_types:
-                scan_types = ", ".join(scan_types)
-            if scan_numbers:
-                scan_numbers = ", ".join(scan_numbers)
-            self.set_row(index, scan_numbers, scan_types, status)
-
-    def format_item(self, content: str) -> QTableWidgetItem:
-        """
-        Format the content of the table item.
-
-        Args:
-            content (str): The content to be formatted.
-
-        Returns:
-            QTableWidgetItem: The formatted item.
-        """
-        item = QTableWidgetItem(content)
-        item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
-        return item
-
-    def set_row(self, index: int, scan_number: str, scan_type: str, status: str):
-        """
-        Set the row of the table.
-
-        Args:
-            index (int): The index of the row.
-            scan_number (str): The scan number.
-            scan_type (str): The scan type.
-            status (str): The status.
-        """
-
-        self.setItem(index, 0, self.format_item(scan_number))
-        self.setItem(index, 1, self.format_item(scan_type))
-        self.setItem(index, 2, self.format_item(status))
-
-    def reset_content(self):
-        """
-        Reset the content of the table.
-        """
-
-        self.setRowCount(1)
-        self.set_row(0, "", "", "")
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    widget = BECQueue()
-    widget.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/bec_queue/bec_queue.pyproject

@@ -1 +0,0 @@
-{'files': ['bec_queue.py']}

bec_widgets/widgets/bec_queue/bec_queue_plugin.py

@@ -1,54 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtGui import QIcon
-
-from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='BECQueue' name='bec_queue'>
-    </widget>
-</ui>
-"""
-
-
-class BECQueuePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        t = BECQueue(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return ""
-
-    def icon(self):
-        return QIcon()
-
-    def includeFile(self):
-        return "bec_queue"
-
-    def initialize(self, form_editor):
-        self._form_editor = form_editor
-
-    def isContainer(self):
-        return False
-
-    def isInitialized(self):
-        return self._form_editor is not None
-
-    def name(self):
-        return "BECQueue"
-
-    def toolTip(self):
-        return "Widget to display the BEC queue."
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/widgets/bec_queue/register_bec_queue.py

@@ -1,15 +0,0 @@
-def main():  # pragma: no cover
-    from qtpy import PYSIDE6
-
-    if not PYSIDE6:
-        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
-        return
-    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
-
-    from bec_widgets.widgets.bec_queue.bec_queue_plugin import BECQueuePlugin
-
-    QPyDesignerCustomWidgetCollection.addCustomWidget(BECQueuePlugin())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/widgets/bec_status_box/bec_status_box.py

@@ -1,316 +0,0 @@
-"""This module contains the BECStatusBox widget, which displays the status of different BEC services in a collapsible tree widget.
-The widget automatically updates the status of all running BEC services, and displays their status.
-"""
-
-from __future__ import annotations
-
-import sys
-from collections import defaultdict
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-import qdarktheme
-from bec_lib.utils.import_utils import lazy_import_from
-from qtpy.QtCore import QObject, QTimer, Signal, Slot
-from qtpy.QtWidgets import QHBoxLayout, QTreeWidget, QTreeWidgetItem, QWidget
-
-from bec_widgets.utils.bec_connector import BECConnector
-from bec_widgets.widgets.bec_status_box.status_item import StatusItem
-
-if TYPE_CHECKING:
-    from bec_lib.client import BECClient
-
-# TODO : Put normal imports back when Pydantic gets faster
-BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
-
-
-@dataclass
-class BECServiceInfoContainer:
-    """Container to store information about the BEC services."""
-
-    service_name: str
-    status: str
-    info: dict
-    metrics: dict | None
-
-
-class BECServiceStatusMixin(QObject):
-    """Mixin to receive the latest service status from the BEC server and emit it via services_update signal.
-
-    Args:
-        client (BECClient): The client object to connect to the BEC server.
-    """
-
-    services_update = Signal(dict, dict)
-
-    def __init__(self, parent, client: BECClient):
-        super().__init__(parent)
-        self.client = client
-        self._service_update_timer = QTimer()
-        self._service_update_timer.timeout.connect(self._get_service_status)
-        self._service_update_timer.start(1000)
-
-    def _get_service_status(self):
-        """Get the latest service status from the BEC server."""
-        # pylint: disable=protected-access
-        self.client._update_existing_services()
-        self.services_update.emit(self.client._services_info, self.client._services_metric)
-
-
-class BECStatusBox(BECConnector, QWidget):
-    """An autonomous widget to display the status of BEC services.
-
-    Args:
-        parent Optional : The parent widget for the BECStatusBox. Defaults to None.
-        box_name Optional(str): The name of the top service label. Defaults to "BEC Server".
-        client Optional(BECClient): The client object to connect to the BEC server. Defaults to None
-        config Optional(BECStatusBoxConfig | dict): The configuration for the status box. Defaults to None.
-        gui_id Optional(str): The unique id for the widget. Defaults to None.
-    """
-
-    CORE_SERVICES = ["DeviceServer", "ScanServer", "SciHub", "ScanBundler", "FileWriterManager"]
-
-    service_update = Signal(BECServiceInfoContainer)
-    bec_core_state = Signal(str)
-
-    def __init__(
-        self,
-        parent=None,
-        box_name: str = "BEC Server",
-        client: BECClient = None,
-        bec_service_status_mixin: BECServiceStatusMixin = None,
-        gui_id: str = None,
-    ):
-        super().__init__(client=client, gui_id=gui_id)
-        QWidget.__init__(self, parent=parent)
-        self.tree = QTreeWidget(self)
-        self.layout = QHBoxLayout(self)
-
-        self.box_name = box_name
-        self.status_container = defaultdict(lambda: {"info": None, "item": None, "widget": None})
-
-        if not bec_service_status_mixin:
-            bec_service_status_mixin = BECServiceStatusMixin(self, client=self.client)
-        self.bec_service_status = bec_service_status_mixin
-
-        self.init_ui()
-        self.bec_service_status.services_update.connect(self.update_service_status)
-        self.bec_core_state.connect(self.update_top_item_status)
-        self.tree.itemDoubleClicked.connect(self.on_tree_item_double_clicked)
-        self.layout.addWidget(self.tree)
-
-    def init_ui(self) -> None:
-        """Init the UI for the BECStatusBox widget, should only take place once."""
-        self.init_ui_tree_widget()
-        top_label = self._create_status_widget(self.box_name, status=BECStatus.IDLE)
-        tree_item = QTreeWidgetItem()
-        tree_item.setExpanded(True)
-        tree_item.setDisabled(True)
-        self.status_container[self.box_name].update({"item": tree_item, "widget": top_label})
-        self.tree.addTopLevelItem(tree_item)
-        self.tree.setItemWidget(tree_item, 0, top_label)
-        self.service_update.connect(top_label.update_config)
-        self._initialized = True
-
-    def init_ui_tree_widget(self) -> None:
-        """Initialise the tree widget for the status box."""
-        self.tree.setHeaderHidden(True)
-        # TODO probably here is a problem still with setting the stylesheet
-        self.tree.setStyleSheet(
-            "QTreeWidget::item:!selected "
-            "{ "
-            "border: 1px solid gainsboro; "
-            "border-left: none; "
-            "border-top: none; "
-            "}"
-            "QTreeWidget::item:selected {}"
-        )
-
-    def _create_status_widget(
-        self, service_name: str, status=BECStatus, info: dict = None, metrics: dict = None
-    ) -> StatusItem:
-        """Creates a StatusItem (QWidget) for the given service, and stores all relevant
-        information about the service in the status_container.
-
-        Args:
-            service_name (str): The name of the service.
-            status (BECStatus): The status of the service.
-            info Optional(dict): The information about the service. Default is {}
-            metric Optional(dict): Metrics for the respective service. Default is None
-
-        Returns:
-            StatusItem: The status item widget.
-        """
-        if info is None:
-            info = {}
-        self._update_status_container(service_name, status, info, metrics)
-        item = StatusItem(parent=self, config=self.status_container[service_name]["info"])
-        return item
-
-    @Slot(str)
-    def update_top_item_status(self, status: BECStatus) -> None:
-        """Method to update the status of the top item in the tree widget.
-        Gets the status from the Signal 'bec_core_state' and updates the StatusItem via the signal 'service_update'.
-
-        Args:
-            status (BECStatus): The state of the core services.
-        """
-        self.status_container[self.box_name]["info"].status = status
-        self.service_update.emit(self.status_container[self.box_name]["info"])
-
-    def _update_status_container(
-        self, service_name: str, status: BECStatus, info: dict, metrics: dict = None
-    ) -> None:
-        """Update the status_container with the newest status and metrics for the BEC service.
-        If information about the service already exists, it will create a new entry.
-
-        Args:
-            service_name (str): The name of the service.
-            status (BECStatus): The status of the service.
-            info (dict): The information about the service.
-            metrics (dict): The metrics of the service.
-        """
-        container = self.status_container[service_name].get("info", None)
-
-        if container:
-            container.status = status.name
-            container.info = info
-            container.metrics = metrics
-            return
-        service_info_item = BECServiceInfoContainer(
-            service_name=service_name,
-            status=status.name if isinstance(status, BECStatus) else status,
-            info=info,
-            metrics=metrics,
-        )
-        self.status_container[service_name].update({"info": service_info_item})
-
-    @Slot(dict, dict)
-    def update_service_status(self, services_info: dict, services_metric: dict) -> None:
-        """Callback function services_metric from BECServiceStatusMixin.
-        It updates the status of all services.
-
-        Args:
-            services_info (dict): A dictionary containing the service status for all running BEC services.
-            services_metric (dict): A dictionary containing the service metrics for all running BEC services.
-        """
-        checked = [self.box_name]
-        services_info = self.update_core_services(services_info, services_metric)
-        checked.extend(self.CORE_SERVICES)
-
-        for service_name, msg in sorted(services_info.items()):
-            checked.append(service_name)
-            metric_msg = services_metric.get(service_name, None)
-            metrics = metric_msg.metrics if metric_msg else None
-            if service_name in self.status_container:
-                if not msg:
-                    self.add_tree_item(service_name, "NOTCONNECTED", {}, metrics)
-                    continue
-                self._update_status_container(service_name, msg.status, msg.info, metrics)
-                self.service_update.emit(self.status_container[service_name]["info"])
-                continue
-
-            self.add_tree_item(service_name, msg.status, msg.info, metrics)
-        self.check_redundant_tree_items(checked)
-
-    def update_core_services(self, services_info: dict, services_metric: dict) -> dict:
-        """Update the core services of BEC, and emit the updated status to the BECStatusBox.
-
-        Args:
-            services_info (dict): A dictionary containing the service status of different services.
-            services_metric (dict): A dictionary containing the service metrics of different services.
-
-        Returns:
-            dict: The services_info dictionary after removing the info updates related to the CORE_SERVICES
-        """
-        core_state = BECStatus.RUNNING
-        for service_name in sorted(self.CORE_SERVICES):
-            metric_msg = services_metric.get(service_name, None)
-            metrics = metric_msg.metrics if metric_msg else None
-            msg = services_info.pop(service_name, None)
-            if service_name not in self.status_container:
-                if not msg:
-                    self.add_tree_item(service_name, "NOTCONNECTED", {}, metrics)
-                    continue
-                self.add_tree_item(service_name, msg.status, msg.info, metrics)
-                continue
-            if not msg:
-                self.status_container[service_name]["info"].status = "NOTCONNECTED"
-                core_state = None
-            else:
-                self._update_status_container(service_name, msg.status, msg.info, metrics)
-                if core_state:
-                    core_state = msg.status if msg.status.value < core_state.value else core_state
-
-            self.service_update.emit(self.status_container[service_name]["info"])
-
-        self.bec_core_state.emit(core_state.name if core_state else "NOTCONNECTED")
-        return services_info
-
-    def check_redundant_tree_items(self, checked: list) -> None:
-        """Utility method to check and remove redundant objects from the BECStatusBox.
-
-        Args:
-            checked (list): A list of services that are currently running.
-        """
-        to_be_deleted = [key for key in self.status_container if key not in checked]
-
-        for key in to_be_deleted:
-            obj = self.status_container.pop(key)
-            item = obj["item"]
-            self.status_container[self.box_name]["item"].removeChild(item)
-
-    def add_tree_item(
-        self, service_name: str, status: BECStatus, info: dict = None, metrics: dict = None
-    ) -> None:
-        """Method to add a new QTreeWidgetItem together with a StatusItem to the tree widget.
-
-        Args:
-            service_name (str): The name of the service.
-            status (BECStatus): The status of the service.
-            info (dict): The information about the service.
-            metrics (dict): The metrics of the service.
-        """
-        item_widget = self._create_status_widget(service_name, status, info, metrics)
-        item = QTreeWidgetItem()
-        self.service_update.connect(item_widget.update_config)
-        self.status_container[self.box_name]["item"].addChild(item)
-        self.tree.setItemWidget(item, 0, item_widget)
-        self.status_container[service_name].update({"item": item, "widget": item_widget})
-
-    @Slot(QTreeWidgetItem, int)
-    def on_tree_item_double_clicked(self, item: QTreeWidgetItem, column: int) -> None:
-        """Callback function for double clicks on individual QTreeWidgetItems in the collapsed section.
-
-        Args:
-            item (QTreeWidgetItem): The item that was double clicked.
-            column (int): The column that was double clicked.
-        """
-        for _, objects in self.status_container.items():
-            if objects["item"] == item:
-                objects["widget"].show_popup()
-
-    def closeEvent(self, event):
-        """Upon closing the widget, clean up the BECStatusBox and the QWidget.
-
-        Args:
-            event: The close event.
-        """
-        super().cleanup()
-        super().closeEvent(event)
-
-
-def main():
-    """Main method to run the BECStatusBox widget."""
-    # pylint: disable=import-outside-toplevel
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    qdarktheme.setup_theme("auto")
-    main_window = BECStatusBox()
-    main_window.show()
-    sys.exit(app.exec())
-
-
-if __name__ == "__main__":
-    main()

bec_widgets/widgets/bec_status_box/bec_status_box.pyproject

@@ -1 +0,0 @@
-{'files': ['bec_status_box.py']}

bec_widgets/widgets/bec_status_box/bec_status_box_plugin.py

@@ -1,54 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtGui import QIcon
-
-from bec_widgets.widgets.bec_status_box.bec_status_box import BECStatusBox
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='BECStatusBox' name='bec_status_box'>
-    </widget>
-</ui>
-"""
-
-
-class BECStatusBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        t = BECStatusBox(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return ""
-
-    def icon(self):
-        return QIcon()
-
-    def includeFile(self):
-        return "bec_status_box"
-
-    def initialize(self, form_editor):
-        self._form_editor = form_editor
-
-    def isContainer(self):
-        return False
-
-    def isInitialized(self):
-        return self._form_editor is not None
-
-    def name(self):
-        return "BECStatusBox"
-
-    def toolTip(self):
-        return "An autonomous widget to display the status of BEC services."
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/widgets/bec_status_box/register_bec_status_box.py

@@ -1,15 +0,0 @@
-def main():  # pragma: no cover
-    from qtpy import PYSIDE6
-
-    if not PYSIDE6:
-        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
-        return
-    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
-
-    from bec_widgets.widgets.bec_status_box.bec_status_box_plugin import BECStatusBoxPlugin
-
-    QPyDesignerCustomWidgetCollection.addCustomWidget(BECStatusBoxPlugin())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/widgets/bec_status_box/status_item.py

@@ -1,138 +0,0 @@
-""" Module for a StatusItem widget to display status and metrics for a BEC service.
-The widget is bound to be used with the BECStatusBox widget."""
-
-import enum
-from datetime import datetime
-
-from bec_lib.utils.import_utils import lazy_import_from
-from qtpy.QtCore import Qt, Slot
-from qtpy.QtWidgets import QDialog, QHBoxLayout, QLabel, QStyle, QVBoxLayout, QWidget
-
-# TODO : Put normal imports back when Pydantic gets faster
-BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
-
-
-class IconsEnum(enum.Enum):
-    """Enum class for icons in the status item widget."""
-
-    RUNNING = "SP_DialogApplyButton"
-    BUSY = "SP_BrowserReload"
-    IDLE = "SP_MessageBoxWarning"
-    ERROR = "SP_DialogCancelButton"
-    NOTCONNECTED = "SP_TitleBarContextHelpButton"
-
-
-class StatusItem(QWidget):
-    """A widget to display the status of a service.
-
-    Args:
-        parent: The parent widget.
-        config (dict): The configuration for the service, must be a BECServiceInfoContainer.
-    """
-
-    def __init__(self, parent: QWidget = None, config=None):
-        QWidget.__init__(self, parent=parent)
-        if config is None:
-            # needed because we need parent to be the first argument for QT Designer
-            raise ValueError(
-                "Please initialize the StatusItem with a BECServiceInfoContainer for config, received None."
-            )
-        self.config = config
-        self.parent = parent
-        self.layout = None
-        self._label = None
-        self._icon = None
-        self.icon_size = (24, 24)
-
-        self._popup_label_ref = {}
-        self.init_ui()
-
-    def init_ui(self) -> None:
-        """Init the UI for the status item widget."""
-        self.layout = QHBoxLayout()
-        self.layout.setContentsMargins(5, 5, 5, 5)
-        self.setLayout(self.layout)
-        self._label = QLabel()
-        self._icon = QLabel()
-        self.layout.addWidget(self._label)
-        self.layout.addWidget(self._icon)
-        self.update_ui()
-
-    @Slot(dict)
-    def update_config(self, config) -> None:
-        """Update the config of the status item widget.
-
-        Args:
-            config (dict): Config updates from parent widget, must be a BECServiceInfoContainer.
-        """
-        if self.config is None or config.service_name != self.config.service_name:
-            return
-        self.config = config
-        self.update_ui()
-
-    def update_ui(self) -> None:
-        """Update the UI of the labels, and popup dialog."""
-        if self.config is None:
-            return
-        self.set_text()
-        self.set_status()
-        self._set_popup_text()
-
-    def set_text(self) -> None:
-        """Set the text of the QLabel basae on the config."""
-        service = self.config.service_name
-        status = self.config.status
-        if len(service.split("/")) > 1 and service.split("/")[0].startswith("BEC"):
-            service = service.split("/", maxsplit=1)[0] + "/..." + service.split("/")[1][-4:]
-        if status == "NOTCONNECTED":
-            status = "NOT CONNECTED"
-        text = f"{service} is {status}"
-        self._label.setText(text)
-
-    def set_status(self) -> None:
-        """Set the status icon for the status item widget."""
-        icon_name = IconsEnum[self.config.status].value
-        icon = self.style().standardIcon(getattr(QStyle.StandardPixmap, icon_name))
-        self._icon.setPixmap(icon.pixmap(*self.icon_size))
-        self._icon.setAlignment(Qt.AlignmentFlag.AlignRight)
-
-    def show_popup(self) -> None:
-        """Method that is invoked when the user double clicks on the StatusItem widget."""
-        dialog = QDialog(self)
-        dialog.setWindowTitle(f"{self.config.service_name} Details")
-        layout = QVBoxLayout()
-        popup_label = self._make_popup_label()
-        self._set_popup_text()
-        layout.addWidget(popup_label)
-        dialog.setLayout(layout)
-        dialog.finished.connect(self._cleanup_popup_label)
-        dialog.exec()
-
-    def _make_popup_label(self) -> QLabel:
-        """Create a QLabel for the popup dialog.
-
-        Returns:
-            QLabel: The label for the popup dialog.
-        """
-        label = QLabel()
-        label.setWordWrap(True)
-        self._popup_label_ref.update({"label": label})
-        return label
-
-    def _set_popup_text(self) -> None:
-        """Compile the metrics text for the status item widget."""
-        if self._popup_label_ref.get("label") is None:
-            return
-        metrics_text = (
-            f"<b>SERVICE:</b> {self.config.service_name}<br><b>STATUS:</b> {self.config.status}<br>"
-        )
-        if self.config.metrics:
-            for key, value in self.config.metrics.items():
-                if key == "create_time":
-                    value = datetime.fromtimestamp(value).strftime("%Y-%m-%d %H:%M:%S")
-                metrics_text += f"<b>{key.upper()}:</b> {value}<br>"
-        self._popup_label_ref["label"].setText(metrics_text)
-
-    def _cleanup_popup_label(self) -> None:
-        """Cleanup the popup label."""
-        self._popup_label_ref.clear()

bec_widgets/widgets/buttons/__init__.py

@@ -1 +0,0 @@
-from .stop_button.stop_button import StopButton

bec_widgets/widgets/buttons/color_button/color_button.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal
-
-import pyqtgraph as pg
-
-
-class ColorButton(pg.ColorButton):
-    """
-    A ColorButton that opens a dialog to select a color. Inherits from pyqtgraph.ColorButton.
-    Patches event loop of the ColorDialog, if opened in another QDialog.
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def selectColor(self):
-        self.origColor = self.color()
-        self.colorDialog.setCurrentColor(self.color())
-        self.colorDialog.open()
-        self.colorDialog.exec()
-
-    def get_color(self, format: Literal["RGBA", "HEX"] = "RGBA") -> tuple | str:
-        """
-        Get the color of the button in the specified format.
-
-        Args:
-            format(Literal["RGBA", "HEX"]): The format of the returned color.
-
-        Returns:
-            tuple|str: The color in the specified format.
-        """
-        if format == "RGBA":
-            return self.color().getRgb()
-        if format == "HEX":
-            return self.color().name()

bec_widgets/widgets/buttons/color_button/color_button.pyproject

@@ -1 +0,0 @@
-{'files': ['color_button.py']}

bec_widgets/widgets/buttons/color_button/color_button_plugin.py

@@ -1,55 +0,0 @@
-import os
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtGui import QIcon
-
-from bec_widgets.widgets.buttons.color_button.color_button import ColorButton
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='ColorButton' name='color_button'>
-    </widget>
-</ui>
-"""
-
-
-class ColorButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        t = ColorButton(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return "BEC Buttons"
-
-    def icon(self):
-        current_path = os.path.dirname(__file__)
-        icon_path = os.path.join(current_path, "assets", "color_button.png")
-        return QIcon(icon_path)
-
-    def includeFile(self):
-        return "color_button"
-
-    def initialize(self, form_editor):
-        self._form_editor = form_editor
-
-    def isContainer(self):
-        return False
-
-    def isInitialized(self):
-        return self._form_editor is not None
-
-    def name(self):
-        return "ColorButton"
-
-    def toolTip(self):
-        return "ColorButton which opens a color dialog."
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/widgets/buttons/color_button/register_color_button.py

@@ -1,15 +0,0 @@
-def main():  # pragma: no cover
-    from qtpy import PYSIDE6
-
-    if not PYSIDE6:
-        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
-        return
-    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
-
-    from bec_widgets.widgets.buttons.color_button.color_button_plugin import ColorButtonPlugin
-
-    QPyDesignerCustomWidgetCollection.addCustomWidget(ColorButtonPlugin())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/widgets/buttons/stop_button/stop_button.py

@@ -1,32 +0,0 @@
-from qtpy.QtWidgets import QPushButton
-
-from bec_widgets.utils import BECConnector
-
-
-class StopButton(BECConnector, QPushButton):
-    """A button that stops the current scan."""
-
-    def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QPushButton.__init__(self, parent=parent)
-
-        self.get_bec_shortcuts()
-        self.setText("Stop")
-        self.setStyleSheet("background-color:  #cc181e; color: white")
-        self.clicked.connect(self.stop_scan)
-
-    def stop_scan(self):
-        """Stop the scan."""
-        self.queue.request_scan_abortion()
-        self.queue.request_queue_reset()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    widget = StopButton()
-    widget.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/console/console.py

@@ -1,496 +0,0 @@
-"""
-BECConsole is a Qt widget that runs a Bash shell. The widget can be used and
-embedded like any other Qt widget.
-
-BECConsole is powered by Pyte, a Python based terminal emulator
-(https://github.com/selectel/pyte).
-"""
-
-import fcntl
-import html
-import os
-import pty
-import subprocess
-import sys
-import threading
-
-import pyte
-from qtpy import QtCore, QtGui, QtWidgets
-from qtpy.QtCore import QSize, QSocketNotifier, Qt
-from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtCore import Slot as pyqtSlot
-from qtpy.QtGui import QClipboard, QTextCursor
-from qtpy.QtWidgets import QApplication, QHBoxLayout, QScrollBar, QSizePolicy
-
-ansi_colors = {
-    "black": "#000000",
-    "red": "#CD0000",
-    "green": "#00CD00",
-    "brown": "#996633",  # Brown, replacing the yellow
-    "blue": "#0000EE",
-    "magenta": "#CD00CD",
-    "cyan": "#00CDCD",
-    "white": "#E5E5E5",
-    "brightblack": "#7F7F7F",
-    "brightred": "#FF0000",
-    "brightgreen": "#00FF00",
-    "brightyellow": "#FFFF00",
-    "brightblue": "#5C5CFF",
-    "brightmagenta": "#FF00FF",
-    "brightcyan": "#00FFFF",
-    "brightwhite": "#FFFFFF",
-}
-
-control_keys_mapping = {
-    QtCore.Qt.Key_A: b"\x01",  # Ctrl-A
-    QtCore.Qt.Key_B: b"\x02",  # Ctrl-B
-    QtCore.Qt.Key_C: b"\x03",  # Ctrl-C
-    QtCore.Qt.Key_D: b"\x04",  # Ctrl-D
-    QtCore.Qt.Key_E: b"\x05",  # Ctrl-E
-    QtCore.Qt.Key_F: b"\x06",  # Ctrl-F
-    QtCore.Qt.Key_G: b"\x07",  # Ctrl-G (Bell)
-    QtCore.Qt.Key_H: b"\x08",  # Ctrl-H (Backspace)
-    QtCore.Qt.Key_I: b"\x09",  # Ctrl-I (Tab)
-    QtCore.Qt.Key_J: b"\x0A",  # Ctrl-J (Line Feed)
-    QtCore.Qt.Key_K: b"\x0B",  # Ctrl-K (Vertical Tab)
-    QtCore.Qt.Key_L: b"\x0C",  # Ctrl-L (Form Feed)
-    QtCore.Qt.Key_M: b"\x0D",  # Ctrl-M (Carriage Return)
-    QtCore.Qt.Key_N: b"\x0E",  # Ctrl-N
-    QtCore.Qt.Key_O: b"\x0F",  # Ctrl-O
-    QtCore.Qt.Key_P: b"\x10",  # Ctrl-P
-    QtCore.Qt.Key_Q: b"\x11",  # Ctrl-Q
-    QtCore.Qt.Key_R: b"\x12",  # Ctrl-R
-    QtCore.Qt.Key_S: b"\x13",  # Ctrl-S
-    QtCore.Qt.Key_T: b"\x14",  # Ctrl-T
-    QtCore.Qt.Key_U: b"\x15",  # Ctrl-U
-    QtCore.Qt.Key_V: b"\x16",  # Ctrl-V
-    QtCore.Qt.Key_W: b"\x17",  # Ctrl-W
-    QtCore.Qt.Key_X: b"\x18",  # Ctrl-X
-    QtCore.Qt.Key_Y: b"\x19",  # Ctrl-Y
-    QtCore.Qt.Key_Z: b"\x1A",  # Ctrl-Z
-    QtCore.Qt.Key_Escape: b"\x1B",  # Ctrl-Escape
-    QtCore.Qt.Key_Backslash: b"\x1C",  # Ctrl-\
-    QtCore.Qt.Key_Underscore: b"\x1F",  # Ctrl-_
-}
-
-normal_keys_mapping = {
-    QtCore.Qt.Key_Return: b"\n",
-    QtCore.Qt.Key_Space: b" ",
-    QtCore.Qt.Key_Enter: b"\n",
-    QtCore.Qt.Key_Tab: b"\t",
-    QtCore.Qt.Key_Backspace: b"\x08",
-    QtCore.Qt.Key_Home: b"\x47",
-    QtCore.Qt.Key_End: b"\x4f",
-    QtCore.Qt.Key_Left: b"\x02",
-    QtCore.Qt.Key_Up: b"\x10",
-    QtCore.Qt.Key_Right: b"\x06",
-    QtCore.Qt.Key_Down: b"\x0E",
-    QtCore.Qt.Key_PageUp: b"\x49",
-    QtCore.Qt.Key_PageDown: b"\x51",
-    QtCore.Qt.Key_F1: b"\x1b\x31",
-    QtCore.Qt.Key_F2: b"\x1b\x32",
-    QtCore.Qt.Key_F3: b"\x1b\x33",
-    QtCore.Qt.Key_F4: b"\x1b\x34",
-    QtCore.Qt.Key_F5: b"\x1b\x35",
-    QtCore.Qt.Key_F6: b"\x1b\x36",
-    QtCore.Qt.Key_F7: b"\x1b\x37",
-    QtCore.Qt.Key_F8: b"\x1b\x38",
-    QtCore.Qt.Key_F9: b"\x1b\x39",
-    QtCore.Qt.Key_F10: b"\x1b\x30",
-    QtCore.Qt.Key_F11: b"\x45",
-    QtCore.Qt.Key_F12: b"\x46",
-}
-
-
-def QtKeyToAscii(event):
-    """
-    Convert the Qt key event to the corresponding ASCII sequence for
-    the terminal. This works fine for standard alphanumerical characters, but
-    most other characters require terminal specific control sequences.
-
-    The conversion below works for TERM="linux" terminals.
-    """
-    if sys.platform == "darwin":
-        # special case for MacOS
-        # /!\ Qt maps ControlModifier to CMD
-        # CMD-C, CMD-V for copy/paste
-        # CTRL-C and other modifiers -> key mapping
-        if event.modifiers() == QtCore.Qt.MetaModifier:
-            if event.key() == Qt.Key_Backspace:
-                return control_keys_mapping.get(Qt.Key_W)
-            return control_keys_mapping.get(event.key())
-        elif event.modifiers() == QtCore.Qt.ControlModifier:
-            if event.key() == Qt.Key_C:
-                # copy
-                return "copy"
-            elif event.key() == Qt.Key_V:
-                # paste
-                return "paste"
-            return None
-        else:
-            return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
-    if event.modifiers() == QtCore.Qt.ControlModifier:
-        return control_keys_mapping.get(event.key())
-    else:
-        return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
-
-
-class Screen(pyte.HistoryScreen):
-    def __init__(self, stdin_fd, numColumns, numLines, historyLength):
-        super().__init__(numColumns, numLines, historyLength, ratio=1 / numLines)
-        self._fd = stdin_fd
-
-    def write_process_input(self, data):
-        """Response to CPR request for example"""
-        os.write(self._fd, data.encode("utf-8"))
-
-
-class Backend(QtCore.QObject):
-    """
-    Poll Bash.
-
-    This class will run as a qsocketnotifier (started in ``_TerminalWidget``) and poll the
-    file descriptor of the Bash terminal.
-    """
-
-    # Signals to communicate with ``_TerminalWidget``.
-    startWork = pyqtSignal()
-    dataReady = pyqtSignal(object)
-
-    def __init__(self, fd, numColumns, numLines):
-        super().__init__()
-
-        # File descriptor that connects to Bash process.
-        self.fd = fd
-
-        # Setup Pyte (hard coded display size for now).
-        self.screen = Screen(self.fd, numColumns, numLines, 10000)
-        self.stream = pyte.ByteStream()
-        self.stream.attach(self.screen)
-
-        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
-        self.notifier.activated.connect(self._fd_readable)
-
-    def _fd_readable(self):
-        """
-        Poll the Bash output, run it through Pyte, and notify the main applet.
-        """
-        # Read the shell output until the file descriptor is closed.
-        try:
-            out = os.read(self.fd, 2**16)
-        except OSError:
-            return
-
-        # Feed output into Pyte's state machine and send the new screen
-        # output to the GUI
-        self.stream.feed(out)
-        self.dataReady.emit(self.screen)
-
-
-class BECConsole(QtWidgets.QScrollArea):
-    """Container widget for the terminal text area"""
-
-    def __init__(self, parent=None, numLines=50, numColumns=125):
-        super().__init__(parent)
-
-        self.innerWidget = QtWidgets.QWidget(self)
-        QHBoxLayout(self.innerWidget)
-        self.innerWidget.layout().setContentsMargins(0, 0, 0, 0)
-
-        self.term = _TerminalWidget(self.innerWidget, numLines, numColumns)
-        self.term.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-        self.innerWidget.layout().addWidget(self.term)
-
-        self.scroll_bar = QScrollBar(Qt.Vertical, self.term)
-        self.innerWidget.layout().addWidget(self.scroll_bar)
-
-        self.term.set_scroll(self.scroll_bar)
-
-        self.setWidget(self.innerWidget)
-
-    def start(self, cmd=["bec", "--nogui"], deactivate_ctrl_d=True):
-        self.term._cmd = cmd
-        self.term.start(deactivate_ctrl_d=deactivate_ctrl_d)
-
-    def push(self, text):
-        """Push some text to the terminal"""
-        return self.term.push(text)
-
-
-class _TerminalWidget(QtWidgets.QPlainTextEdit):
-    """
-    Start ``Backend`` process and render Pyte output as text.
-    """
-
-    def __init__(self, parent, numColumns, numLines, **kwargs):
-        super().__init__(parent)
-
-        # file descriptor to communicate with the subprocess
-        self.fd = None
-        self.backend = None
-        self.lock = threading.Lock()
-        # command to execute
-        self._cmd = None
-        # should ctrl-d be deactivated ? (prevent Python exit)
-        self._deactivate_ctrl_d = False
-
-        # Specify the terminal size in terms of lines and columns.
-        self.numLines = numLines
-        self.numColumns = numColumns
-        self.output = [""] * numLines
-
-        # Use Monospace fonts and disable line wrapping.
-        self.setFont(QtGui.QFont("Courier", 9))
-        self.setFont(QtGui.QFont("Monospace"))
-        self.setLineWrapMode(QtWidgets.QPlainTextEdit.NoWrap)
-
-        # Disable vertical scrollbar (we use our own, to be set via .set_scroll())
-        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-
-        fmt = QtGui.QFontMetrics(self.font())
-        self._char_width = fmt.width("w")
-        self._char_height = fmt.height()
-        self.setCursorWidth(self._char_width)
-        # self.setStyleSheet("QPlainTextEdit { color: #ffff00; background-color: #303030; } ");
-
-    def start(self, deactivate_ctrl_d=False):
-        self._deactivate_ctrl_d = deactivate_ctrl_d
-
-        # Start the Bash process
-        self.fd = self.forkShell()
-
-        # Create the ``Backend`` object
-        self.backend = Backend(self.fd, self.numColumns, self.numLines)
-        self.backend.dataReady.connect(self.dataReady)
-
-    def minimumSizeHint(self):
-        width = self._char_width * self.numColumns
-        height = self._char_height * self.numLines
-        return QSize(width, height + 20)
-
-    def set_scroll(self, scroll):
-        self.scroll = scroll
-        self.scroll.setMinimum(0)
-        self.scroll.valueChanged.connect(self.scroll_value_change)
-
-    def scroll_value_change(self, value, old={"value": 0}):
-        if value <= old["value"]:
-            # scroll up
-            # value is number of lines from the start
-            nlines = old["value"] - value
-            # history ratio gives prev_page == 1 line
-            for i in range(nlines):
-                self.backend.screen.prev_page()
-        else:
-            # scroll down
-            nlines = value - old["value"]
-            for i in range(nlines):
-                self.backend.screen.next_page()
-        old["value"] = value
-        self.dataReady(self.backend.screen, reset_scroll=False)
-
-    @pyqtSlot(object)
-    def keyPressEvent(self, event):
-        """
-        Redirect all keystrokes to the terminal process.
-        """
-        # Convert the Qt key to the correct ASCII code.
-        if (
-            self._deactivate_ctrl_d
-            and event.modifiers() == QtCore.Qt.ControlModifier
-            and event.key() == QtCore.Qt.Key_D
-        ):
-            return None
-
-        code = QtKeyToAscii(event)
-        if code == "copy":
-            # MacOS only: CMD-C handling
-            self.copy()
-        elif code == "paste":
-            # MacOS only: CMD-V handling
-            self._push_clipboard()
-        elif code is not None:
-            os.write(self.fd, code)
-
-    def push(self, text):
-        """
-        Write 'text' to terminal
-        """
-        os.write(self.fd, text.encode("utf-8"))
-
-    def contextMenuEvent(self, event):
-        menu = self.createStandardContextMenu()
-        for action in menu.actions():
-            # remove all actions except copy and paste
-            if "opy" in action.text():
-                # redefine text without shortcut
-                # since it probably clashes with control codes (like CTRL-C etc)
-                action.setText("Copy")
-                continue
-            if "aste" in action.text():
-                # redefine text without shortcut
-                action.setText("Paste")
-                # paste -> have to insert with self.push
-                action.triggered.connect(self._push_clipboard)
-                continue
-            menu.removeAction(action)
-        menu.exec_(event.globalPos())
-
-    def _push_clipboard(self):
-        clipboard = QApplication.instance().clipboard()
-        self.push(clipboard.text())
-
-    def mouseReleaseEvent(self, event):
-        if event.button() == Qt.MiddleButton:
-            # push primary selection buffer ("mouse clipboard") to terminal
-            clipboard = QApplication.instance().clipboard()
-            if clipboard.supportsSelection():
-                self.push(clipboard.text(QClipboard.Selection))
-            return None
-        elif event.button() == Qt.LeftButton:
-            # left button click
-            textCursor = self.textCursor()
-            if textCursor.selectedText():
-                # mouse was used to select text -> nothing to do
-                pass
-            else:
-                # a simple 'click', make cursor going to end
-                textCursor.setPosition(0)
-                textCursor.movePosition(
-                    QTextCursor.Down, QTextCursor.MoveAnchor, self.backend.screen.cursor.y
-                )
-                textCursor.movePosition(
-                    QTextCursor.Right, QTextCursor.MoveAnchor, self.backend.screen.cursor.x
-                )
-                self.setTextCursor(textCursor)
-                self.ensureCursorVisible()
-                return None
-        return super().mouseReleaseEvent(event)
-
-    def dataReady(self, screenData, reset_scroll=True):
-        """
-        Render the new screen as text into the widget.
-
-        This method is triggered via a signal from ``Backend``.
-        """
-        with self.lock:
-            # Clear the widget
-            self.clear()
-
-            # Prepare the HTML output
-            for line_no in screenData.dirty:
-                line = text = ""
-                style = old_style = ""
-                for ch in screenData.buffer[line_no].values():
-                    style = f"{'background-color:%s;' % ansi_colors.get(ch.bg, ansi_colors['black']) if ch.bg!='default' else ''}{'color:%s;' % ansi_colors.get(ch.fg, ansi_colors['white']) if ch.fg!='default' else ''}{'font-weight:bold;' if ch.bold else ''}{'font-style:italic;' if ch.italics else ''}"
-                    if style != old_style:
-                        if old_style:
-                            line += f"<span style={repr(old_style)}>{html.escape(text, quote=True)}</span>"
-                        else:
-                            line += html.escape(text, quote=True)
-                        text = ""
-                        old_style = style
-                    text += ch.data
-                if style:
-                    line += f"<span style={repr(style)}>{html.escape(text, quote=True)}</span>"
-                else:
-                    line += html.escape(text, quote=True)
-                self.output[line_no] = line
-            # fill the text area with HTML contents in one go
-            self.appendHtml(f"<pre>{chr(10).join(self.output)}</pre>")
-            # done updates, all clean
-            screenData.dirty.clear()
-
-            # Activate cursor
-            textCursor = self.textCursor()
-            textCursor.setPosition(0)
-            textCursor.movePosition(QTextCursor.Down, QTextCursor.MoveAnchor, screenData.cursor.y)
-            textCursor.movePosition(QTextCursor.Right, QTextCursor.MoveAnchor, screenData.cursor.x)
-            self.setTextCursor(textCursor)
-            self.ensureCursorVisible()
-
-            # manage scroll
-            if reset_scroll:
-                self.scroll.valueChanged.disconnect(self.scroll_value_change)
-                tmp = len(self.backend.screen.history.top) + len(self.backend.screen.history.bottom)
-                self.scroll.setMaximum(tmp if tmp > 0 else 0)
-                self.scroll.setSliderPosition(len(self.backend.screen.history.top))
-                self.scroll.valueChanged.connect(self.scroll_value_change)
-
-    # def resizeEvent(self, event):
-    #    with self.lock:
-    #        self.numColumns = int(self.width() / self._char_width)
-    #        self.numLines = int(self.height() / self._char_height)
-    #        self.output = [""] * self.numLines
-    #        print("RESIZING TO", self.numColumns, "x", self.numLines)
-    #        self.backend.screen.resize(self.numLines, self.numColumns)
-
-    def wheelEvent(self, event):
-        y = event.angleDelta().y()
-        if y > 0:
-            self.backend.screen.prev_page()
-        else:
-            self.backend.screen.next_page()
-        self.dataReady(self.backend.screen, reset_scroll=False)
-
-    def forkShell(self):
-        """
-        Fork the current process and execute bec in shell.
-        """
-        try:
-            pid, fd = pty.fork()
-        except (IOError, OSError):
-            return False
-        if pid == 0:
-            # Safe way to make it work under BSD and Linux
-            try:
-                ls = os.environ["LANG"].split(".")
-            except KeyError:
-                ls = []
-            if len(ls) < 2:
-                ls = ["en_US", "UTF-8"]
-            try:
-                os.putenv("COLUMNS", str(self.numColumns))
-                os.putenv("LINES", str(self.numLines))
-                os.putenv("TERM", "linux")
-                os.putenv("LANG", ls[0] + ".UTF-8")
-                if isinstance(self._cmd, str):
-                    os.execvp(self._cmd, self._cmd)
-                else:
-                    os.execvp(self._cmd[0], self._cmd)
-                # print "child_pid", child_pid, sts
-            except (IOError, OSError):
-                pass
-            # self.proc_finish(sid)
-            os._exit(0)
-        else:
-            # We are in the parent process.
-            # Set file control
-            fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)
-            print("Spawned Bash shell (PID {})".format(pid))
-            return fd
-
-
-if __name__ == "__main__":
-    import os
-    import sys
-
-    from qtpy import QtGui, QtWidgets
-
-    # Terminal size in characters.
-    numLines = 25
-    numColumns = 100
-
-    # Create the Qt application and QBash instance.
-    app = QtWidgets.QApplication([])
-    mainwin = QtWidgets.QMainWindow()
-    title = "BECConsole ({}x{})".format(numColumns, numLines)
-    mainwin.setWindowTitle(title)
-
-    console = BECConsole(mainwin, numColumns, numLines)
-    mainwin.setCentralWidget(console)
-    console.start()
-
-    # Show widget and launch Qt's event loop.
-    mainwin.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/device_inputs/__init__.py

@@ -1,2 +0,0 @@
-from .device_combobox.device_combobox import DeviceComboBox
-from .device_line_edit.device_line_edit import DeviceLineEdit

bec_widgets/widgets/device_inputs/device_combobox/device_combobox.py

@@ -1,92 +0,0 @@
-from typing import TYPE_CHECKING
-
-from qtpy.QtWidgets import QComboBox
-
-from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputBase, DeviceInputConfig
-
-if TYPE_CHECKING:
-    from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputConfig
-
-
-class DeviceComboBox(DeviceInputBase, QComboBox):
-    """
-    Line edit widget for device input with autocomplete for device names.
-
-    Args:
-        parent: Parent widget.
-        client: BEC client object.
-        config: Device input configuration.
-        gui_id: GUI ID.
-        device_filter: Device filter, name of the device class.
-        default: Default device name.
-        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
-    """
-
-    def __init__(
-        self,
-        parent=None,
-        client=None,
-        config: DeviceInputConfig = None,
-        gui_id: str | None = None,
-        device_filter: str | None = None,
-        default: str | None = None,
-        arg_name: str | None = None,
-    ):
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QComboBox.__init__(self, parent=parent)
-
-        self.populate_combobox()
-
-        if arg_name is not None:
-            self.config.arg_name = arg_name
-        if device_filter is not None:
-            self.set_device_filter(device_filter)
-        if default is not None:
-            self.set_default_device(default)
-
-    def set_device_filter(self, device_filter: str):
-        """
-        Set the device filter.
-
-        Args:
-            device_filter(str): Device filter, name of the device class.
-        """
-        super().set_device_filter(device_filter)
-        self.populate_combobox()
-
-    def set_default_device(self, default_device: str):
-        """
-        Set the default device.
-
-        Args:
-            default_device(str): Default device name.
-        """
-        super().set_default_device(default_device)
-        self.setCurrentText(default_device)
-
-    def populate_combobox(self):
-        """Populate the combobox with the devices."""
-        self.devices = self.get_device_list(self.config.device_filter)
-        self.clear()
-        self.addItems(self.devices)
-
-    def get_device(self) -> object:
-        """
-        Get the selected device object.
-
-        Returns:
-            object: Device object.
-        """
-        device_name = self.currentText()
-        device_obj = getattr(self.dev, device_name.lower(), None)
-        if device_obj is None:
-            raise ValueError(f"Device {device_name} is not found.")
-        return device_obj
-
-    def cleanup(self):
-        """Cleanup the widget."""
-        super().cleanup()
-
-    def closeEvent(self, event):
-        super().cleanup()
-        return QComboBox.closeEvent(self, event)

bec_widgets/widgets/device_inputs/device_combobox/device_combobox.pyproject

@@ -1,4 +0,0 @@
-{
-    "files": ["device_combobox.py", "launch_device_combobox.py",
-    ]
-}

bec_widgets/widgets/device_inputs/device_combobox/device_combobox_plugin.py

@@ -1,54 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtGui import QIcon
-
-from bec_widgets.widgets.device_inputs import DeviceComboBox
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='DeviceComboBox' name='device_combobox'>
-    </widget>
-</ui>
-"""
-
-
-class DeviceComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        t = DeviceComboBox(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return ""
-
-    def icon(self):
-        return QIcon()
-
-    def includeFile(self):
-        return "device_combobox"
-
-    def initialize(self, form_editor):
-        self._form_editor = form_editor
-
-    def isContainer(self):
-        return False
-
-    def isInitialized(self):
-        return self._form_editor is not None
-
-    def name(self):
-        return "DeviceComboBox"
-
-    def toolTip(self):
-        return "Device ComboBox Example for BEC Widgets"
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/widgets/device_inputs/device_combobox/launch_device_combobox.py

@@ -1,11 +0,0 @@
-from bec_widgets.widgets.device_inputs import DeviceComboBox
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    w = DeviceComboBox()
-    w.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/device_inputs/device_combobox/register_device_combobox.py

@@ -1,17 +0,0 @@
-def main():  # pragma: no cover
-    from qtpy import PYSIDE6
-
-    if not PYSIDE6:
-        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
-        return
-    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
-
-    from bec_widgets.widgets.device_inputs.device_combobox.device_combobox_plugin import (
-        DeviceComboBoxPlugin,
-    )
-
-    QPyDesignerCustomWidgetCollection.addCustomWidget(DeviceComboBoxPlugin())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/widgets/device_inputs/device_input_base.py

@@ -1,123 +0,0 @@
-from __future__ import annotations
-
-from bec_widgets.utils import BECConnector, ConnectionConfig
-
-
-class DeviceInputConfig(ConnectionConfig):
-    device_filter: str | list[str] | None = None
-    default: str | None = None
-    arg_name: str | None = None
-
-
-class DeviceInputBase(BECConnector):
-    """
-    Mixin class for device input widgets. This class provides methods to get the device list and device object based
-    on the current text of the widget.
-    """
-
-    def __init__(self, client=None, config=None, gui_id=None):
-        if config is None:
-            config = DeviceInputConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = DeviceInputConfig(**config)
-            self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id)
-
-        self.get_bec_shortcuts()
-        self._devices = []
-
-    @property
-    def devices(self) -> list[str]:
-        """
-        Get the list of devices.
-
-        Returns:
-            list[str]: List of devices.
-        """
-        return self._devices
-
-    @devices.setter
-    def devices(self, value: list[str]):
-        """
-        Set the list of devices.
-
-        Args:
-            value: List of devices.
-        """
-        self._devices = value
-
-    def set_device_filter(self, device_filter: str | list[str]):
-        """
-        Set the device filter.
-
-        Args:
-            device_filter(str): Device filter, name of the device class.
-        """
-        self.validate_device_filter(device_filter)
-        self.config.device_filter = device_filter
-
-    def set_default_device(self, default_device: str):
-        """
-        Set the default device.
-
-        Args:
-            default_device(str): Default device name.
-        """
-        self.validate_device(default_device)
-        self.config.default = default_device
-
-    def get_device_list(self, filter: str | list[str] | None = None) -> list[str]:
-        """
-        Get the list of device names based on the filter of current BEC client.
-
-        Args:
-            filter(str|None): Class name filter to apply on the device list.
-
-        Returns:
-            devices(list[str]): List of device names.
-        """
-        all_devices = self.dev.enabled_devices
-        if filter is not None:
-            self.validate_device_filter(filter)
-            if isinstance(filter, str):
-                filter = [filter]
-            devices = [device.name for device in all_devices if device.__class__.__name__ in filter]
-        else:
-            devices = [device.name for device in all_devices]
-        return devices
-
-    def get_available_filters(self):
-        """
-        Get the available device classes which can be used as filters.
-        """
-        all_devices = self.dev.enabled_devices
-        filters = {device.__class__.__name__ for device in all_devices}
-        return filters
-
-    def validate_device_filter(self, filter: str | list[str]) -> None:
-        """
-        Validate the device filter if the class name is present in the current BEC instance.
-
-        Args:
-            filter(str|list[str]): Class name to use as a device filter.
-        """
-        if isinstance(filter, str):
-            filter = [filter]
-        available_filters = self.get_available_filters()
-        for f in filter:
-            if f not in available_filters:
-                raise ValueError(f"Device filter {f} is not valid.")
-
-    def validate_device(self, device: str) -> None:
-        """
-        Validate the device if it is present in current BEC instance.
-
-        Args:
-            device(str): Device to validate.
-        """
-        if device not in self.get_device_list(self.config.device_filter):
-            raise ValueError(f"Device {device} is not valid.")
-
-    def cleanup(self):
-        super().cleanup()

bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit.py

@@ -1,104 +0,0 @@
-from typing import TYPE_CHECKING
-
-from qtpy.QtCore import QSize
-from qtpy.QtWidgets import QCompleter, QLineEdit, QSizePolicy
-
-from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputBase, DeviceInputConfig
-
-if TYPE_CHECKING:
-    from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputConfig
-
-
-class DeviceLineEdit(DeviceInputBase, QLineEdit):
-    """
-    Line edit widget for device input with autocomplete for device names.
-
-    Args:
-        parent: Parent widget.
-        client: BEC client object.
-        config: Device input configuration.
-        gui_id: GUI ID.
-        device_filter: Device filter, name of the device class.
-        default: Default device name.
-        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
-    """
-
-    def __init__(
-        self,
-        parent=None,
-        client=None,
-        config: DeviceInputConfig = None,
-        gui_id: str | None = None,
-        device_filter: str | list[str] | None = None,
-        default: str | None = None,
-        arg_name: str | None = None,
-    ):
-        QLineEdit.__init__(self, parent=parent)
-        DeviceInputBase.__init__(self, client=client, config=config, gui_id=gui_id)
-
-        self.completer = QCompleter(self)
-        self.setCompleter(self.completer)
-        self.populate_completer()
-
-        if arg_name is not None:
-            self.config.arg_name = arg_name
-            self.arg_name = arg_name
-        if device_filter is not None:
-            self.set_device_filter(device_filter)
-        if default is not None:
-            self.set_default_device(default)
-
-        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
-        self.setMinimumSize(QSize(100, 0))
-
-    def set_device_filter(self, device_filter: str | list[str]):
-        """
-        Set the device filter.
-
-        Args:
-            device_filter (str | list[str]): Device filter, name of the device class.
-        """
-        super().set_device_filter(device_filter)
-        self.populate_completer()
-
-    def set_default_device(self, default_device: str):
-        """
-        Set the default device.
-
-        Args:
-            default_device (str): Default device name.
-        """
-        super().set_default_device(default_device)
-        self.setText(default_device)
-
-    def populate_completer(self):
-        """Populate the completer with the devices."""
-        self.devices = self.get_device_list(self.config.device_filter)
-        self.completer.setModel(self.create_completer_model(self.devices))
-
-    def create_completer_model(self, devices: list[str]):
-        """Create a model for the completer."""
-        from qtpy.QtCore import QStringListModel
-
-        return QStringListModel(devices, self)
-
-    def get_device(self) -> object:
-        """
-        Get the selected device object.
-
-        Returns:
-            object: Device object.
-        """
-        device_name = self.text()
-        device_obj = getattr(self.dev, device_name.lower(), None)
-        if device_obj is None:
-            raise ValueError(f"Device {device_name} is not found.")
-        return device_obj
-
-    def cleanup(self):
-        """Cleanup the widget."""
-        super().cleanup()
-
-    def closeEvent(self, event):
-        super().cleanup()
-        return QLineEdit.closeEvent(self, event)

bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit.pyproject

@@ -1,4 +0,0 @@
-{
-    "files": ["device_line_edit.py", "launch_device_line_edit.py",
-    ]
-}

bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit_plugin.py

@@ -1,54 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtGui import QIcon
-
-from bec_widgets.widgets.device_inputs import DeviceLineEdit
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='DeviceLineEdit' name='device_line_edit'>
-    </widget>
-</ui>
-"""
-
-
-class DeviceLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        t = DeviceLineEdit(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return ""
-
-    def icon(self):
-        return QIcon()
-
-    def includeFile(self):
-        return "device_line_edit"
-
-    def initialize(self, form_editor):
-        self._form_editor = form_editor
-
-    def isContainer(self):
-        return False
-
-    def isInitialized(self):
-        return self._form_editor is not None
-
-    def name(self):
-        return "DeviceLineEdit"
-
-    def toolTip(self):
-        return "Device LineEdit Example for BEC Widgets with autocomplete."
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/widgets/device_inputs/device_line_edit/launch_device_line_edit.py

@@ -1,11 +0,0 @@
-from bec_widgets.widgets.device_inputs import DeviceLineEdit
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    w = DeviceLineEdit()
-    w.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/device_inputs/device_line_edit/register_device_line_edit.py

@@ -1,17 +0,0 @@
-def main():  # pragma: no cover
-    from qtpy import PYSIDE6
-
-    if not PYSIDE6:
-        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
-        return
-    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
-
-    from bec_widgets.widgets.device_inputs.device_line_edit.device_line_edit_plugin import (
-        DeviceLineEditPlugin,
-    )
-
-    QPyDesignerCustomWidgetCollection.addCustomWidget(DeviceLineEditPlugin())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/widgets/dock/__init__.py

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

bec_widgets/widgets/dock/dock.py

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

bec_widgets/widgets/dock/dock_area.py

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

bec_widgets/widgets/figure/__init__.py

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

bec_widgets/widgets/figure/figure.py

@@ -1,835 +0,0 @@
-# pylint: disable = no-name-in-module,missing-module-docstring
-from __future__ import annotations
-
-import uuid
-from collections import defaultdict
-from typing import Literal, Optional
-
-import numpy as np
-import pyqtgraph as pg
-import qdarktheme
-from pydantic import Field, ValidationError, field_validator
-from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtWidgets import QWidget
-from typeguard import typechecked
-
-from bec_widgets.utils import BECConnector, ConnectionConfig, WidgetContainerUtils
-from bec_widgets.widgets.figure.plots.image.image import BECImageShow, ImageConfig
-from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap, MotorMapConfig
-from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
-from bec_widgets.widgets.figure.plots.waveform.waveform import BECWaveform, Waveform1DConfig
-
-
-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, Waveform1DConfig | ImageConfig | MotorMapConfig | SubplotConfig] = Field(
-        {}, description="The list of widgets to be added to the figure widget."
-    )
-
-    @field_validator("widgets", mode="before")
-    @classmethod
-    def validate_widgets(cls, v):
-        """Validate the widgets configuration."""
-        widget_class_map = {
-            "BECWaveform": Waveform1DConfig,
-            "BECImageShow": ImageConfig,
-            "BECMotorMap": MotorMapConfig,
-        }
-        validated_widgets = {}
-        for key, widget_config in v.items():
-            if "widget_class" not in widget_config:
-                raise ValueError(f"Widget config for {key} does not contain 'widget_class'.")
-            widget_class = widget_config["widget_class"]
-            if widget_class not in widget_class_map:
-                raise ValueError(f"Unknown widget_class '{widget_class}' for widget '{key}'.")
-            config_class = widget_class_map[widget_class]
-            validated_widgets[key] = config_class(**widget_config)
-        return validated_widgets
-
-
-class WidgetHandler:
-    """Factory for creating and configuring BEC widgets for BECFigure."""
-
-    def __init__(self):
-        self.widget_factory = {
-            "BECPlotBase": (BECPlotBase, SubplotConfig),
-            "BECWaveform": (BECWaveform, Waveform1DConfig),
-            "BECImageShow": (BECImageShow, ImageConfig),
-            "BECMotorMap": (BECMotorMap, MotorMapConfig),
-        }
-
-    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
-        if config is not None and isinstance(config, config_class):
-            config = config.model_dump()
-        widget_config_dict = {
-            "widget_class": widget_class.__name__,
-            "parent_id": parent_id,
-            "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 = [
-        "_rpc_id",
-        "_config_dict",
-        "_get_all_rpc",
-        "axes",
-        "widgets",
-        "plot",
-        "image",
-        "motor_map",
-        "remove",
-        "change_layout",
-        "change_theme",
-        "clear_all",
-        "widget_list",
-    ]
-    subplot_map = {
-        "PlotBase": BECPlotBase,
-        "BECWaveform": BECWaveform,
-        "BECImageShow": BECImageShow,
-        "BECMotorMap": BECMotorMap,
-    }
-    widget_method_map = {"BECWaveform": "plot", "BECImageShow": "image", "BECMotorMap": "motor_map"}
-
-    clean_signal = pyqtSignal()
-
-    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)
-        super().__init__(client=client, 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 = []
-        # Create config and apply it
-        self.apply_config(config)
-
-    def __getitem__(self, key: tuple | str):
-        if isinstance(key, tuple) and len(key) == 2:
-            return self.axes(*key)
-        elif isinstance(key, str):
-            widget = self._widgets.get(key)
-            if widget is None:
-                raise KeyError(f"No widget with ID {key}")
-            return self._widgets.get(key)
-        else:
-            raise TypeError(
-                "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
-            )
-
-    def apply_config(self, config: dict | FigureConfig):  # ,generate_new_id: bool = False):
-        if isinstance(config, dict):
-            try:
-                config = FigureConfig(**config)
-            except ValidationError as e:
-                print(f"Error in applying config: {e}")
-                return
-        self.config = config
-        self.change_theme(self.config.theme)
-
-        # widget_config has to be reset for not have each widget config twice when added to the figure
-        widget_configs = [config for config in self.config.widgets.values()]
-        self.config.widgets = {}
-        for widget_config in widget_configs:
-            getattr(self, self.widget_method_map[widget_config.widget_class])(
-                config=widget_config.model_dump(), row=widget_config.row, col=widget_config.col
-            )
-
-    @property
-    def widget_list(self) -> list[BECPlotBase]:
-        """
-        Access all widget in BECFigure as a list
-        Returns:
-            list[BECPlotBase]: List of all widgets in the figure.
-        """
-        axes = [value for value in self._widgets.values() if isinstance(value, BECPlotBase)]
-        return axes
-
-    @widget_list.setter
-    def widget_list(self, value: list[BECPlotBase]):
-        """
-        Access all widget in BECFigure as a list
-        Returns:
-            list[BECPlotBase]: List of all widgets in the figure.
-        """
-        self._axes = value
-
-    @property
-    def widgets(self) -> dict:
-        """
-        All widgets within the figure with gui ids as keys.
-        Returns:
-            dict: All widgets within the figure.
-        """
-        return self._widgets
-
-    @widgets.setter
-    def widgets(self, value: dict):
-        """
-        All widgets within the figure with gui ids as keys.
-        Returns:
-            dict: All widgets within the figure.
-        """
-        self._widgets = value
-
-    def _init_waveform(
-        self,
-        waveform,
-        x_name: str = None,
-        y_name: str = None,
-        z_name: str = None,
-        x_entry: str = None,
-        y_entry: str = None,
-        z_entry: str = None,
-        x: list | np.ndarray = None,
-        y: list | np.ndarray = None,
-        color: str | None = None,
-        color_map_z: str | None = "plasma",
-        label: str | None = None,
-        validate: bool = True,
-        dap: str | None = None,
-    ) -> BECWaveform:
-        """
-        Configure the waveform based on the provided parameters.
-
-        Args:
-            waveform (BECWaveform): The waveform to configure.
-            x (list | np.ndarray): Custom x data to plot.
-            y (list | np.ndarray): Custom y data to plot.
-            x_name (str): The name of the device for the x-axis.
-            y_name (str): The name of the device for the y-axis.
-            z_name (str): The name of the device for the z-axis.
-            x_entry (str): The name of the entry for the x-axis.
-            y_entry (str): The name of the entry for the y-axis.
-            z_entry (str): The name of the entry for the z-axis.
-            color (str): The color of the curve.
-            color_map_z (str): The color map to use for the z-axis.
-            label (str): The label of the curve.
-            validate (bool): If True, validate the device names and entries.
-            dap (str): The DAP model to use for the curve.
-        """
-        if x is not None and y is None:
-            if isinstance(x, np.ndarray):
-                if x.ndim == 1:
-                    y = np.arange(x.size)
-                    waveform.add_curve_custom(x=np.arange(x.size), y=x, color=color, label=label)
-                    return waveform
-                if x.ndim == 2:
-                    waveform.add_curve_custom(x=x[:, 0], y=x[:, 1], color=color, label=label)
-                    return waveform
-            elif isinstance(x, list):
-                y = np.arange(len(x))
-                waveform.add_curve_custom(x=np.arange(len(x)), y=x, color=color, label=label)
-                return waveform
-            else:
-                raise ValueError(
-                    "Invalid input. Provide either device names (x_name, y_name) or custom data."
-                )
-        if x is not None and y is not None:
-            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
-            return waveform
-        # User wants to add scan curve -> 1D Waveform
-        if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
-            waveform.plot(
-                x_name=x_name,
-                y_name=y_name,
-                x_entry=x_entry,
-                y_entry=y_entry,
-                validate=validate,
-                color=color,
-                label=label,
-                dap=dap,
-            )
-        # User wants to add scan curve -> 2D Waveform Scatter
-        if (
-            x_name is not None
-            and y_name is not None
-            and z_name is not None
-            and x is None
-            and y is None
-        ):
-            waveform.plot(
-                x_name=x_name,
-                y_name=y_name,
-                z_name=z_name,
-                x_entry=x_entry,
-                y_entry=y_entry,
-                z_entry=z_entry,
-                color=color,
-                color_map_z=color_map_z,
-                label=label,
-                validate=validate,
-                dap=dap,
-            )
-        # User wants to add custom curve
-        elif x is not None and y is not None and x_name is None and y_name is None:
-            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
-
-        return waveform
-
-    @typechecked
-    def plot(
-        self,
-        x: list | np.ndarray | None = None,
-        y: list | np.ndarray | None = None,
-        x_name: str | None = None,
-        y_name: str | None = None,
-        z_name: str | None = None,
-        x_entry: str | None = None,
-        y_entry: str | None = None,
-        z_entry: str | None = None,
-        color: str | None = None,
-        color_map_z: str | None = "plasma",
-        label: str | None = None,
-        validate: bool = True,
-        new: bool = False,
-        row: int | None = None,
-        col: int | None = None,
-        dap: str | None = None,
-        config: dict | None = None,  # TODO make logic more transparent
-        **axis_kwargs,
-    ) -> BECWaveform:
-        """
-        Add a 1D waveform plot to the figure. Always access the first waveform widget in the figure.
-
-        Args:
-            x(list | np.ndarray): Custom x data to plot.
-            y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
-            y_name(str): The name of the device for the y-axis.
-            z_name(str): The name of the device for the z-axis.
-            x_entry(str): The name of the entry for the x-axis.
-            y_entry(str): The name of the entry for the y-axis.
-            z_entry(str): The name of the entry for the z-axis.
-            color(str): The color of the curve.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str): The label of the curve.
-            validate(bool): If True, validate the device names and entries.
-            new(bool): If True, create a new plot instead of using the first plot.
-            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.
-            dap(str): The DAP model to use for the curve.
-            config(dict): Recreates the whole BECWaveform widget from provided configuration.
-            **axis_kwargs: Additional axis properties to set on the widget after creation.
-
-        Returns:
-            BECWaveform: The waveform plot widget.
-        """
-        waveform = self.subplot_factory(
-            widget_type="BECWaveform", config=config, row=row, col=col, new=new, **axis_kwargs
-        )
-        if config is not None:
-            return waveform
-
-        # Passing args to init_waveform
-        waveform = self._init_waveform(
-            waveform=waveform,
-            x=x,
-            y=y,
-            x_name=x_name,
-            y_name=y_name,
-            z_name=z_name,
-            x_entry=x_entry,
-            y_entry=y_entry,
-            z_entry=z_entry,
-            color=color,
-            color_map_z=color_map_z,
-            label=label,
-            validate=validate,
-            dap=dap,
-        )
-        return waveform
-
-    def _init_image(
-        self,
-        image,
-        monitor: str = None,
-        color_bar: Literal["simple", "full"] = "full",
-        color_map: str = "magma",
-        data: np.ndarray = None,
-        vrange: tuple[float, float] = None,
-    ) -> BECImageShow:
-        """
-        Configure the image based on the provided parameters.
-
-        Args:
-            image (BECImageShow): The image to configure.
-            monitor (str): The name of the monitor to display.
-            color_bar (Literal["simple","full"]): The type of color bar to display.
-            color_map (str): The color map to use for the image.
-            data (np.ndarray): Custom data to display.
-        """
-        if monitor is not None and data is None:
-            image.add_monitor_image(
-                monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar
-            )
-        elif data is not None and monitor is None:
-            image.add_custom_image(
-                name="custom", data=data, color_map=color_map, vrange=vrange, color_bar=color_bar
-            )
-        elif data is None and monitor is None:
-            # Setting appearance
-            if vrange is not None:
-                image.set_vrange(vmin=vrange[0], vmax=vrange[1])
-            if color_map is not None:
-                image.set_color_map(color_map)
-        else:
-            raise ValueError("Invalid input. Provide either monitor name or custom data.")
-        return image
-
-    def image(
-        self,
-        monitor: str = None,
-        color_bar: Literal["simple", "full"] = "full",
-        color_map: str = "magma",
-        data: np.ndarray = None,
-        vrange: tuple[float, float] = None,
-        new: bool = False,
-        row: int | None = None,
-        col: int | None = None,
-        config: dict | None = None,
-        **axis_kwargs,
-    ) -> BECImageShow:
-        """
-        Add an image to the figure. Always access the first image widget in the figure.
-
-        Args:
-            monitor(str): The name of the monitor to display.
-            color_bar(Literal["simple","full"]): The type of color bar to display.
-            color_map(str): The color map to use for the image.
-            data(np.ndarray): Custom data to display.
-            vrange(tuple[float, float]): The range of values to display.
-            new(bool): If True, create a new plot instead of using the first plot.
-            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): Recreates the whole BECImageShow widget from provided configuration.
-            **axis_kwargs: Additional axis properties to set on the widget after creation.
-
-        Returns:
-            BECImageShow: The image widget.
-        """
-
-        image = self.subplot_factory(
-            widget_type="BECImageShow", config=config, row=row, col=col, new=new, **axis_kwargs
-        )
-        if config is not None:
-            return image
-
-        image = self._init_image(
-            image=image,
-            monitor=monitor,
-            color_bar=color_bar,
-            color_map=color_map,
-            data=data,
-            vrange=vrange,
-        )
-        return image
-
-    def motor_map(
-        self,
-        motor_x: str = None,
-        motor_y: str = None,
-        new: bool = False,
-        row: int | None = None,
-        col: int | None = None,
-        config: dict | None = None,
-        **axis_kwargs,
-    ) -> BECMotorMap:
-        """
-        Add a motor map to the figure. Always access the first motor map widget in the figure.
-
-        Args:
-            motor_x(str): The name of the motor for the X axis.
-            motor_y(str): The name of the motor for the Y axis.
-            new(bool): If True, create a new plot instead of using the first plot.
-            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): Recreates the whole BECImageShow widget from provided configuration.
-            **axis_kwargs: Additional axis properties to set on the widget after creation.
-
-        Returns:
-            BECMotorMap: The motor map widget.
-        """
-        motor_map = self.subplot_factory(
-            widget_type="BECMotorMap", config=config, row=row, col=col, new=new, **axis_kwargs
-        )
-        if config is not None:
-            return motor_map
-
-        if motor_x is not None and motor_y is not None:
-            motor_map.change_motors(motor_x, motor_y)
-
-        return motor_map
-
-    def subplot_factory(
-        self,
-        widget_type: Literal[
-            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
-        ] = "BECPlotBase",
-        row: int = None,
-        col: int = None,
-        config=None,
-        new: bool = False,
-        **axis_kwargs,
-    ) -> BECPlotBase:
-        # Case 1 - config provided, new plot, possible to define coordinates
-        if config is not None:
-            widget_cls = config["widget_class"]
-            if widget_cls != widget_type:
-                raise ValueError(
-                    f"Widget type '{widget_type}' does not match the provided configuration ({widget_cls})."
-                )
-            widget = self.add_widget(
-                widget_type=widget_type, config=config, row=row, col=col, **axis_kwargs
-            )
-            return widget
-
-        # Case 2 - find first plot or create first plot if no plot available, no config provided, no coordinates
-        if new is False and (row is None or col is None):
-            widget = WidgetContainerUtils.find_first_widget_by_class(
-                self._widgets, self.subplot_map[widget_type], can_fail=True
-            )
-            if widget is not None:
-                if axis_kwargs:
-                    widget.set(**axis_kwargs)
-            else:
-                widget = self.add_widget(widget_type=widget_type, **axis_kwargs)
-            return widget
-
-        # Case 3 - modifying existing plot wit coordinates provided
-        if new is False and (row is not None and col is not None):
-            try:
-                widget = self.axes(row, col)
-            except ValueError:
-                widget = None
-            if widget is not None:
-                if axis_kwargs:
-                    widget.set(**axis_kwargs)
-            else:
-                widget = self.add_widget(widget_type=widget_type, row=row, col=col, **axis_kwargs)
-            return widget
-
-        # Case 4 - no previous plot or new plot, no config provided, possible to define coordinates
-        widget = self.add_widget(widget_type=widget_type, row=row, col=col, **axis_kwargs)
-        return widget
-
-    def add_widget(
-        self,
-        widget_type: Literal[
-            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
-        ] = "BECPlotBase",
-        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 = str(uuid.uuid4())
-        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,
-        )
-        # has to be changed manually to ensure unique id, if config is copied from existing widget, the id could be
-        # used otherwise multiple times
-        widget.set_gui_id(widget_id)
-
-        # 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 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
-        for plot in self.widget_list:
-            plot.set_x_label(plot.plot_item.getAxis("bottom").label.toPlainText())
-            plot.set_y_label(plot.plot_item.getAxis("left").label.toPlainText())
-            if plot.plot_item.titleLabel.text:
-                plot.set_title(plot.plot_item.titleLabel.text)
-            plot.set_legend_label_size()
-
-    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.axes(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)
-            widget.deleteLater()
-        else:
-            raise ValueError(f"Widget with ID '{widget_id}' does not exist.")
-
-    def axes(self, row: int, col: int) -> BECPlotBase:
-        """
-        Get widget by its coordinates in the figure.
-
-        Args:
-            row(int): the row coordinate
-            col(int): the column coordinate
-
-        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 _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."""
-        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"""
-        for widget in list(self._widgets.values()):
-            widget.remove()
-        # self.clear()
-        self._widgets = defaultdict(dict)
-        self.grid = []
-        theme = self.config.theme
-        self.config = FigureConfig(
-            widget_class=self.__class__.__name__, gui_id=self.gui_id, theme=theme
-        )
-
-    def cleanup(self):
-        self.clear_all()
-        super().cleanup()